implement screen for wayland. (#2076)

- refactors some of the wayland connection code out of the
  application startup.

Author: james-lawrence

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

@@ -0,0 +1,225 @@
+use super::error;
+use std::collections::BTreeMap;
+use wayland_client as wlc;
+use wayland_client::protocol::wl_registry;
+use wayland_protocols::xdg_shell::client::xdg_wm_base;
+
+#[derive(Clone)]
+pub struct GlobalEventSubscription {
+    id: u64,
+    sub: std::sync::Arc<dyn GlobalEventConsumer>,
+}
+
+impl GlobalEventSubscription {
+    fn with_id(mut self, id: u64) -> Self {
+        self.id = id;
+        self
+    }
+}
+
+impl GlobalEventConsumer for GlobalEventSubscription {
+    fn consume<'a>(
+        &self,
+        event: &'a wlc::GlobalEvent,
+        registry: &'a wlc::Attached<wl_registry::WlRegistry>,
+        ctx: &'a wlc::DispatchData,
+    ) {
+        self.sub.consume(event, registry, ctx)
+    }
+}
+
+impl<X> From<X> for GlobalEventSubscription
+where
+    X: Fn(&wlc::GlobalEvent, &wlc::Attached<wl_registry::WlRegistry>, &wlc::DispatchData)
+        + GlobalEventConsumer
+        + 'static,
+{
+    fn from(closure: X) -> Self {
+        Self {
+            id: 0,
+            sub: std::sync::Arc::new(closure),
+        }
+    }
+}
+
+impl<X> GlobalEventConsumer for X
+where
+    X: Fn(&wlc::GlobalEvent, &wlc::Attached<wl_registry::WlRegistry>, &wlc::DispatchData) + 'static,
+{
+    fn consume<'a>(
+        &self,
+        event: &'a wlc::GlobalEvent,
+        registry: &'a wlc::Attached<wl_registry::WlRegistry>,
+        ctx: &'a 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>>,
+}
+
+impl Default for Dispatcher {
+    fn default() -> Self {
+        Self {
+            incr: crate::Counter::new(),
+            subscriptions: std::cell::RefCell::new(BTreeMap::new()),
+        }
+    }
+}
+
+impl GlobalEventConsumer for Dispatcher {
+    fn consume<'a>(
+        &self,
+        event: &'a wlc::GlobalEvent,
+        registry: &'a wlc::Attached<wl_registry::WlRegistry>,
+        ctx: &'a 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);
+    }
+}
+
+impl GlobalEventDispatch for Dispatcher {
+    fn subscribe(&self, sub: impl Into<GlobalEventSubscription>) -> GlobalEventSubscription {
+        let sub = sub.into().with_id(self.incr.next());
+        self.subscriptions.borrow_mut().insert(sub.id, sub.clone());
+        sub
+    }
+
+    fn release(&self, s: &GlobalEventSubscription) {
+        self.subscriptions.borrow_mut().remove(&s.id);
+    }
+}
+
+pub(super) struct Environment {
+    pub(super) display: wlc::Display,
+    pub(super) registry: wlc::GlobalManager,
+    pub(super) xdg_base: wlc::Main<xdg_wm_base::XdgWmBase>,
+    pub(super) queue: std::rc::Rc<std::cell::RefCell<wlc::EventQueue>>,
+    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 std::sync::Arc<Environment> {
+    fn subscribe(&self, sub: impl Into<GlobalEventSubscription>) -> GlobalEventSubscription {
+        self.dispatcher.subscribe(sub)
+    }
+
+    fn release(&self, s: &GlobalEventSubscription) {
+        self.dispatcher.release(s)
+    }
+}
+
+pub(super) fn new(dispatcher: Dispatcher) -> Result<std::sync::Arc<Environment>, error::Error> {
+    let dispatcher = std::sync::Arc::new(dispatcher);
+    let d = wlc::Display::connect_to_env()?;
+
+    let mut queue = d.create_event_queue();
+    let handle = d.clone().attach(queue.token());
+    let registry = wlc::GlobalManager::new_with_cb(&handle, {
+        let dispatcher = dispatcher.clone();
+        move |event, registry, ctx| {
+            dispatcher.consume(&event, &registry, &ctx);
+        }
+    });
+
+    // do a round trip to make sure we have all the globals
+    queue
+        .sync_roundtrip(&mut (), |_, _, _| unreachable!())
+        .map_err(error::Error::fatal)?;
+
+    let xdg_base = registry
+        .instantiate_exact::<xdg_wm_base::XdgWmBase>(2)
+        .map_err(|e| error::Error::global("xdg_wm_base", 2, e))?;
+
+    // We do this to make sure wayland knows we're still responsive.
+    //
+    // NOTE: This means that clients mustn't hold up the event loop, or else wayland might kill
+    // your app's connection. Move *everything* to another thread, including e.g. file i/o,
+    // computation, network, ... This is good practice for all back-ends: it will improve
+    // responsiveness.
+    xdg_base.quick_assign(|xdg_base, event, ctx| {
+        tracing::info!(
+            "global xdg_base events {:?} {:?} {:?}",
+            xdg_base,
+            event,
+            ctx
+        );
+        match event {
+            xdg_wm_base::Event::Ping { serial } => xdg_base.pong(serial),
+            _ => (),
+        }
+    });
+
+    let env = std::sync::Arc::new(Environment {
+        queue: std::rc::Rc::new(std::cell::RefCell::new(queue)),
+        display: d,
+        registry,
+        xdg_base,
+        dispatcher,
+    });
+
+    return Ok(env);
+}
+
+pub(super) fn global() -> Result<std::sync::Arc<Environment>, error::Error> {
+    use lazy_static::lazy_static;
+    lazy_static! {
+        static ref _GLOBAL: std::sync::Mutex<Option<std::sync::Arc<Environment>>> =
+            std::sync::Mutex::new(None,);
+    }
+
+    let mut guard = _GLOBAL.lock().unwrap();
+    if let Some(d) = &*guard {
+        return Ok(d.clone());
+    }
+
+    let env = new(Dispatcher::default())?;
+    guard.replace(env.clone());
+
+    return Ok(env);
+}
+
+#[allow(unused)]
+pub(super) fn print<'a>(reg: &'a wlc::GlobalManager) {
+    let mut globals_list = reg.list();
+    globals_list.sort_by(|(_, name1, version1), (_, name2, version2)| {
+        name1.cmp(name2).then(version1.cmp(version2))
+    });
+
+    for (id, name, version) in globals_list.into_iter() {
+        tracing::debug!("{:?}@{:?} - {:?}", name, version, id);
+    }
+}
+
+pub(super) fn count<'a>(reg: &'a wlc::GlobalManager, i: &str) -> usize {
+    reg.list()
+        .iter()
+        .filter(|(_, name, _)| name == i)
+        .count()
+}

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

@@ -32,9 +32,15 @@ pub enum Error {
     Fatal(Arc<dyn StdError + 'static>),
     String(ErrorString),
     InvalidParent(u32),
+    /// general error.
+    Err(Arc<dyn StdError + 'static>),
 }
 
 impl Error {
+    pub fn error(e: impl StdError + 'static) -> Self {
+        Self::Err(Arc::new(e))
+    }
+
     pub fn fatal(e: impl StdError + 'static) -> Self {
         Self::Fatal(Arc::new(e))
     }
@@ -62,6 +68,7 @@ impl fmt::Display for Error {
                 name, version
             ),
             Self::Fatal(e) => write!(f, "an unhandled error occurred: {:?}", e),
+            Self::Err(e) => write!(f, "an unhandled error occurred: {:?}", e),
             Self::String(e) => e.fmt(f),
             Self::InvalidParent(id) => write!(f, "invalid parent window for popup: {:?}", id),
         }
@@ -74,6 +81,7 @@ impl std::error::Error for Error {
             Self::Connect(e) => Some(&**e),
             Self::Global { inner, .. } => Some(&**inner),
             Self::Fatal(e) => Some(&**e),
+            Self::Err(e) => Some(&**e),
             Self::String(e) => Some(e),
             Self::InvalidParent(_) => None,
         }

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

@@ -24,7 +24,7 @@ pub(crate) struct WaylandSource {
 impl WaylandSource {
     /// Wrap an `EventQueue` as a `WaylandSource`.
     pub fn new(appdata: std::sync::Arc<application::ApplicationData>) -> WaylandSource {
-        let queue = appdata.event_queue.clone();
+        let queue = appdata.wayland.queue.clone();
         let fd = queue.borrow().display().get_connection_fd();
         WaylandSource {
             appdata,

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

@@ -16,10 +16,12 @@
 
 pub mod application;
 pub mod clipboard;
+mod display;
 pub mod error;
 mod events;
 pub mod keyboard;
 pub mod menu;
+mod outputs;
 pub mod pointers;
 pub mod screen;
 pub mod surfaces;