Add support for wlr_layer_shell windows

src/platform/wayland.rs

@@ -1,6 +1,9 @@
 use std::os::raw;
 
-use sctk::reexports::client::Proxy;
+use sctk::{
+    reexports::client::Proxy,
+    shell::wlr_layer::{Anchor, KeyboardInteractivity, Layer},
+};
 
 use crate::{
     event_loop::{EventLoopBuilder, EventLoopWindowTarget},
@@ -90,6 +93,16 @@ pub trait WindowExtWayland {
     ///
     /// The pointer will become invalid when the [`Window`] is destroyed.
     fn wayland_display(&self) -> Option<*mut raw::c_void>;
+
+    fn set_anchor(&self, anchor: Anchor);
+
+    fn set_exclusive_zone(&self, exclusive_zone: i32);
+
+    fn set_margin(&self, top: i32, right: i32, bottom: i32, left: i32);
+
+    fn set_keyboard_interactivity(&self, keyboard_interactivity: KeyboardInteractivity);
+
+    fn set_layer(&self, anchor: Layer);
 }
 
 impl WindowExtWayland for Window {
@@ -110,6 +123,46 @@ impl WindowExtWayland for Window {
             _ => None,
         }
     }
+
+    fn set_anchor(&self, anchor: Anchor) {
+        match self.window {
+            LinuxWindow::Wayland(ref w) => w.set_anchor(anchor),
+            #[cfg(x11_platform)]
+            _ => {}
+        }
+    }
+
+    fn set_exclusive_zone(&self, exclusive_zone: i32) {
+        match self.window {
+            LinuxWindow::Wayland(ref w) => w.set_exclusive_zone(exclusive_zone),
+            #[cfg(x11_platform)]
+            _ => {}
+        }
+    }
+
+    fn set_margin(&self, top: i32, right: i32, bottom: i32, left: i32) {
+        match self.window {
+            LinuxWindow::Wayland(ref w) => w.set_margin(top, right, bottom, left),
+            #[cfg(x11_platform)]
+            _ => {}
+        }
+    }
+
+    fn set_keyboard_interactivity(&self, keyboard_interactivity: KeyboardInteractivity) {
+        match self.window {
+            LinuxWindow::Wayland(ref w) => w.set_keyboard_interactivity(keyboard_interactivity),
+            #[cfg(x11_platform)]
+            _ => {}
+        }
+    }
+
+    fn set_layer(&self, layer: Layer) {
+        match self.window {
+            LinuxWindow::Wayland(ref w) => w.set_layer(layer),
+            #[cfg(x11_platform)]
+            _ => {}
+        }
+    }
 }
 
 /// Additional methods on [`WindowBuilder`] that are specific to Wayland.
@@ -122,6 +175,22 @@ pub trait WindowBuilderExtWayland {
     /// For details about application ID conventions, see the
     /// [Desktop Entry Spec](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#desktop-file-id)
     fn with_name(self, general: impl Into<String>, instance: impl Into<String>) -> Self;
+
+    // TODO(theonlymrcat): Users shouldn't need to pull sctk in. Reexport? or Redefine?
+
+    /// Create this window using the WLR Layer Shell protocol.
+    ///
+    /// Building this window will fail if the compositor does not support the `zwlr_layer_shell_v1`
+    /// protocol.
+    fn with_layer_shell(self, layer: Layer) -> Self;
+
+    fn with_anchor(self, anchor: Anchor) -> Self;
+
+    fn with_exclusive_zone(self, exclusive_zone: i32) -> Self;
+
+    fn with_margin(self, top: i32, right: i32, bottom: i32, left: i32) -> Self;
+
+    fn with_keyboard_interactivity(self, keyboard_interactivity: KeyboardInteractivity) -> Self;
 }
 
 impl WindowBuilderExtWayland for WindowBuilder {
@@ -130,6 +199,39 @@ impl WindowBuilderExtWayland for WindowBuilder {
         self.platform_specific.name = Some(ApplicationName::new(general.into(), instance.into()));
         self
     }
+
+    #[inline]
+    fn with_layer_shell(mut self, layer: Layer) -> Self {
+        self.platform_specific.layer_shell = Some(layer);
+        self
+    }
+
+    #[inline]
+    fn with_anchor(mut self, anchor: Anchor) -> Self {
+        self.platform_specific.anchor = Some(anchor);
+        self
+    }
+
+    #[inline]
+    fn with_exclusive_zone(mut self, exclusive_zone: i32) -> Self {
+        self.platform_specific.exclusive_zone = Some(exclusive_zone);
+        self
+    }
+
+    #[inline]
+    fn with_margin(mut self, top: i32, right: i32, bottom: i32, left: i32) -> Self {
+        self.platform_specific.margin = Some((top, right, bottom, left));
+        self
+    }
+
+    #[inline]
+    fn with_keyboard_interactivity(
+        mut self,
+        keyboard_interactivity: KeyboardInteractivity,
+    ) -> Self {
+        self.platform_specific.keyboard_interactivity = Some(keyboard_interactivity);
+        self
+    }
 }
 
 /// Additional methods on `MonitorHandle` that are specific to Wayland.

src/platform_impl/linux/mod.rs

@@ -40,6 +40,9 @@ use crate::{
     },
 };
 
+#[cfg(wayland_platform)]
+use sctk::shell::wlr_layer::{Anchor, KeyboardInteractivity, Layer};
+
 pub(crate) use crate::icon::RgbaIcon as PlatformIcon;
 pub(self) use crate::platform_impl::Fullscreen;
 
@@ -97,6 +100,16 @@ pub struct PlatformSpecificWindowBuilderAttributes {
     pub override_redirect: bool,
     #[cfg(x11_platform)]
     pub x11_window_types: Vec<XWindowType>,
+    #[cfg(wayland_platform)]
+    pub layer_shell: Option<Layer>,
+    #[cfg(wayland_platform)]
+    pub anchor: Option<Anchor>,
+    #[cfg(wayland_platform)]
+    pub exclusive_zone: Option<i32>,
+    #[cfg(wayland_platform)]
+    pub margin: Option<(i32, i32, i32, i32)>,
+    #[cfg(wayland_platform)]
+    pub keyboard_interactivity: Option<KeyboardInteractivity>,
 }
 
 impl Default for PlatformSpecificWindowBuilderAttributes {
@@ -113,6 +126,16 @@ impl Default for PlatformSpecificWindowBuilderAttributes {
             override_redirect: false,
             #[cfg(x11_platform)]
             x11_window_types: vec![XWindowType::Normal],
+            #[cfg(wayland_platform)]
+            layer_shell: None,
+            #[cfg(wayland_platform)]
+            anchor: None,
+            #[cfg(wayland_platform)]
+            exclusive_zone: None,
+            #[cfg(wayland_platform)]
+            margin: None,
+            #[cfg(wayland_platform)]
+            keyboard_interactivity: None,
         }
     }
 }

src/platform_impl/linux/wayland/state.rs

@@ -16,6 +16,7 @@ use sctk::output::{OutputHandler, OutputState};
 use sctk::registry::{ProvidesRegistryState, RegistryState};
 use sctk::seat::pointer::ThemedPointer;
 use sctk::seat::SeatState;
+use sctk::shell::wlr_layer::{LayerShell, LayerShellHandler, LayerSurface, LayerSurfaceConfigure};
 use sctk::shell::xdg::window::{Window, WindowConfigure, WindowHandler};
 use sctk::shell::xdg::XdgShell;
 use sctk::shell::WaylandSurface;
@@ -59,6 +60,9 @@ pub struct WinitState {
     /// The XDG shell that is used for widnows.
     pub xdg_shell: XdgShell,
 
+    /// The layer shell for layer surfaces
+    pub layer_shell: LayerShell,
+
     /// The currently present windows.
     pub windows: RefCell<FnvHashMap<WindowId, Arc<Mutex<WindowState>>>>,
 
@@ -148,6 +152,8 @@ impl WinitState {
             xdg_shell: XdgShell::bind(globals, queue_handle)?,
             xdg_activation: XdgActivationState::bind(globals, queue_handle).ok(),
 
+            layer_shell: LayerShell::bind(globals, queue_handle)?,
+
             windows: Default::default(),
             window_requests: Default::default(),
             window_compositor_updates: Vec::new(),
@@ -273,7 +279,51 @@ impl WindowHandler for WinitState {
             .expect("got configure for dead window.")
             .lock()
             .unwrap()
-            .configure(configure, &self.shm, &self.subcompositor_state);
+            .configure_xdg(configure, &self.shm, &self.subcompositor_state);
+
+        self.window_compositor_updates[pos].size = Some(new_size);
+    }
+}
+
+impl LayerShellHandler for WinitState {
+    fn closed(&mut self, _: &Connection, _: &QueueHandle<Self>, layer: &LayerSurface) {
+        let window_id = super::make_wid(layer.wl_surface());
+        Self::queue_close(&mut self.window_compositor_updates, window_id);
+    }
+
+    fn configure(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        layer: &LayerSurface,
+        configure: LayerSurfaceConfigure,
+        _serial: u32,
+    ) {
+        let window_id = super::make_wid(layer.wl_surface());
+
+        let pos = if let Some(pos) = self
+            .window_compositor_updates
+            .iter()
+            .position(|update| update.window_id == window_id)
+        {
+            pos
+        } else {
+            self.window_compositor_updates
+                .push(WindowCompositorUpdate::new(window_id));
+            self.window_compositor_updates.len() - 1
+        };
+
+        // Populate the configure to the window.
+        //
+        // XXX the size on the window will be updated right before dispatching the size to the user.
+        let new_size = self
+            .windows
+            .get_mut()
+            .get_mut(&window_id)
+            .expect("got configure for dead window.")
+            .lock()
+            .unwrap()
+            .configure_layer(configure);
 
         self.window_compositor_updates[pos].size = Some(new_size);
     }
@@ -366,3 +416,4 @@ sctk::delegate_registry!(WinitState);
 sctk::delegate_shm!(WinitState);
 sctk::delegate_xdg_shell!(WinitState);
 sctk::delegate_xdg_window!(WinitState);
+sctk::delegate_layer!(WinitState);