peer review

Author: james-lawrence

druid-shell/examples/empty_window.rs

@@ -35,11 +35,11 @@ pub use x11::*;
 #[cfg(all(feature = "x11", any(target_os = "linux", target_os = "openbsd")))]
 pub(crate) mod shared;
 
-#[cfg(all(feature = "wayland", target_os = "linux"))]
+#[cfg(all(feature = "wayland", any(target_os = "linux", target_os = "openbsd")))]
 mod wayland;
-#[cfg(all(feature = "wayland", target_os = "linux"))]
+#[cfg(all(feature = "wayland", any(target_os = "linux", target_os = "openbsd")))]
 pub use wayland::*;
-#[cfg(all(feature = "wayland", target_os = "linux"))]
+#[cfg(all(feature = "wayland", any(target_os = "linux", target_os = "openbsd")))]
 pub(crate) mod shared;
 
 #[cfg(all(

druid-shell/src/backend/mod.rs

@@ -18,8 +18,10 @@
 use keyboard_types::{Code, Location};
 
 #[cfg(any(
-    all(feature = "x11", any(target_os = "linux", target_os = "openbsd")),
-    all(feature = "wayland", target_os = "linux"),
+    all(
+        any(feature = "x11", feature = "wayland"),
+        any(target_os = "linux", target_os = "openbsd")
+    ),
     target_os = "macos"
 ))]
 /// Map key code to location.

druid-shell/src/backend/shared/keyboard.rs

@@ -106,10 +106,6 @@ pub(crate) struct ApplicationData {
     /// necessary, but it negligable cost).
     pub(super) outputs: Rc<RefCell<BTreeMap<u32, outputs::Meta>>>,
     pub(super) seats: Rc<RefCell<BTreeMap<u32, Rc<RefCell<Seat>>>>>,
-    /// Handles to any surfaces that have been created.
-    ///
-    /// This is where the window data is owned. Other handles should be weak.
-    // pub(super) surfaces: RefCell<im::OrdMap<u32, std::sync::Arc<surfaces::surface::Data>>>,
 
     /// Handles to any surfaces that have been created.
     pub(super) handles: RefCell<im::OrdMap<u64, WindowHandle>>,
@@ -257,6 +253,10 @@ impl Application {
             wayland: env,
         });
 
+        for m in outputs::current()? {
+            app_data.outputs.borrow_mut().insert(m.id(), m);
+        }
+
         // Collect the supported image formats.
         wl_shm.quick_assign(with_cloned!(app_data; move |d1, event, d3| {
             tracing::debug!("shared memory events {:?} {:?} {:?}", d1, event, d3);

druid-shell/src/backend/wayland/application.rs

@@ -48,10 +48,8 @@ impl Data {
     fn receive(&self, mimetype: &str) -> Option<Offer> {
         for offer in self.current.borrow().iter() {
             if !offer.mimetype.starts_with(mimetype) {
-                // tracing::debug!("compared {:?} {:?}", offer.mimetype, mimetype);
                 continue;
             }
-            // tracing::debug!("retrieving {:?} {:?}", offer.mimetype, mimetype);
             return Some(offer.clone());
         }
         None

druid-shell/src/backend/wayland/clipboard.rs

@@ -5,10 +5,13 @@ use wayland_client as wlc;
 use wayland_client::protocol::wl_registry;
 use wayland_protocols::xdg_shell::client::xdg_wm_base;
 
+type GlobalEventConsumer = dyn Fn(&wlc::GlobalEvent, &wlc::Attached<wl_registry::WlRegistry>, &wlc::DispatchData)
+    + 'static;
+
 #[derive(Clone)]
 pub struct GlobalEventSubscription {
     id: u64,
-    sub: std::sync::Arc<dyn GlobalEventConsumer>,
+    sub: std::sync::Arc<GlobalEventConsumer>,
 }
 
 impl GlobalEventSubscription {
@@ -18,22 +21,20 @@ impl GlobalEventSubscription {
     }
 }
 
-impl GlobalEventConsumer for GlobalEventSubscription {
+impl GlobalEventSubscription {
     fn consume(
         &self,
         event: &wlc::GlobalEvent,
         registry: &wlc::Attached<wl_registry::WlRegistry>,
         ctx: &wlc::DispatchData,
     ) {
-        self.sub.consume(event, registry, ctx)
+        (self.sub)(event, registry, ctx)
     }
 }
 
 impl<X> From<X> for GlobalEventSubscription
 where
-    X: Fn(&wlc::GlobalEvent, &wlc::Attached<wl_registry::WlRegistry>, &wlc::DispatchData)
-        + GlobalEventConsumer
-        + 'static,
+    X: Fn(&wlc::GlobalEvent, &wlc::Attached<wl_registry::WlRegistry>, &wlc::DispatchData) + 'static,
 {
     fn from(closure: X) -> Self {
         Self {
@@ -43,34 +44,11 @@ where
     }
 }
 
-impl<X> GlobalEventConsumer for X
-where
-    X: Fn(&wlc::GlobalEvent, &wlc::Attached<wl_registry::WlRegistry>, &wlc::DispatchData) + 'static,
-{
-    fn consume(
-        &self,
-        event: &wlc::GlobalEvent,
-        registry: &wlc::Attached<wl_registry::WlRegistry>,
-        ctx: &wlc::DispatchData,
-    ) {
-        self(event, registry, ctx)
-    }
-}
-
 pub trait GlobalEventDispatch {
     fn subscribe(&self, sub: impl Into<GlobalEventSubscription>) -> GlobalEventSubscription;
     fn release(&self, s: &GlobalEventSubscription);
 }
 
-pub trait GlobalEventConsumer {
-    fn consume(
-        &self,
-        event: &wlc::GlobalEvent,
-        registry: &wlc::Attached<wl_registry::WlRegistry>,
-        ctx: &wlc::DispatchData,
-    );
-}
-
 pub(super) struct Dispatcher {
     incr: crate::Counter,
     subscriptions: std::cell::RefCell<BTreeMap<u64, GlobalEventSubscription>>,
@@ -85,18 +63,16 @@ impl Default for Dispatcher {
     }
 }
 
-impl GlobalEventConsumer for Dispatcher {
+impl Dispatcher {
     fn consume(
         &self,
         event: &wlc::GlobalEvent,
         registry: &wlc::Attached<wl_registry::WlRegistry>,
         ctx: &wlc::DispatchData,
     ) {
-        // tracing::info!("global event initiated {:?} {:?}", registry, event);
         for (_, sub) in self.subscriptions.borrow().iter() {
             sub.consume(event, registry, ctx);
         }
-        // tracing::info!("global event completed {:?} {:?}", registry, event);
     }
 }
 
@@ -120,12 +96,6 @@ pub(super) struct Environment {
     dispatcher: std::sync::Arc<Dispatcher>,
 }
 
-// because we have the global environment we need to mark these as safe/send.
-// strictly speaking we should probably guard the access to the various fields
-// behind a mutex, but in practice we are not actually accessing across threads.
-unsafe impl Sync for Environment {}
-unsafe impl Send for Environment {}
-
 impl GlobalEventDispatch for Environment {
     fn subscribe(&self, sub: impl Into<GlobalEventSubscription>) -> GlobalEventSubscription {
         self.dispatcher.subscribe(sub)

druid-shell/src/backend/wayland/display.rs

@@ -7,14 +7,6 @@ use wayland_client::protocol::wl_registry;
 use wayland_protocols::unstable::xdg_output::v1::client::zxdg_output_manager_v1;
 use wayland_protocols::unstable::xdg_output::v1::client::zxdg_output_v1;
 
-pub trait Consumer {
-    fn consume(
-        &mut self,
-        obj: &wlc::Main<wl_output::WlOutput>,
-        event: &wl_output::Event,
-    ) -> Option<outputs::Meta>;
-}
-
 pub fn detect(
     env: &impl display::GlobalEventDispatch,
 ) -> Result<calloop::channel::Channel<outputs::Event>, error::Error> {
@@ -155,7 +147,7 @@ struct Meta {
     meta: outputs::Meta,
 }
 
-impl Consumer for Meta {
+impl Meta {
     /// Incorporate update data from the server for this output.
     fn consume(
         &mut self,