sctk: WIP session lock surface support

core/src/event/wayland/mod.rs

@@ -3,6 +3,7 @@ mod layer;
 mod output;
 mod popup;
 mod seat;
+mod session_lock;
 mod window;
 
 use crate::{time::Instant, window::Id};
@@ -15,6 +16,7 @@ pub use layer::*;
 pub use output::*;
 pub use popup::*;
 pub use seat::*;
+pub use session_lock::*;
 pub use window::*;
 
 /// wayland events
@@ -36,6 +38,8 @@ pub enum Event {
     DndOffer(DndOfferEvent),
     /// Selection Offer events
     SelectionOffer(SelectionOfferEvent),
+    /// Session lock events
+    SessionLock(SessionLockEvent),
     /// Frame events
     Frame(Instant, WlSurface, Id),
 }

core/src/event/wayland/session_lock.rs

@@ -0,0 +1,19 @@
+use crate::window::Id;
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+
+/// session lock events
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum SessionLockEvent {
+    /// Compositor has activated lock
+    Locked,
+    /// Lock rejected / canceled by compositor
+    Finished,
+    /// Session lock protocol not supported
+    NotSupported,
+    /// Session lock surface focused
+    Focused(WlSurface, Id),
+    /// Session lock surface unfocused
+    Unfocused(WlSurface, Id),
+    /// Session unlock has been processed by server
+    Unlocked,
+}

examples/sctk_session_lock/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "sctk_session_lock"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+sctk = { package = "smithay-client-toolkit", git = "https://github.com/smithay/client-toolkit", rev = "828b1eb" }
+iced = { path = "../..", default-features = false,  features = ["wayland", "debug", "a11y"] }
+iced_runtime = { path = "../../runtime" }
+env_logger = "0.10"

examples/sctk_session_lock/src/main.rs

@@ -0,0 +1,101 @@
+use iced::wayland::session_lock;
+use iced::{
+    event::wayland::{Event as WaylandEvent, OutputEvent, SessionLockEvent},
+    subscription,
+    wayland::InitialSurface,
+    widget::{column, container, text},
+    window, Application, Color, Command, Element, Length, Subscription, Theme,
+};
+use iced_runtime::window::Id as SurfaceId;
+
+fn main() {
+    let mut settings = iced::Settings::default();
+    settings.initial_surface = InitialSurface::None;
+    Locker::run(settings).unwrap();
+}
+
+#[derive(Debug, Clone, Default)]
+struct Locker {
+    max_surface_id: u128,
+}
+
+#[derive(Debug, Clone)]
+pub enum Message {
+    WaylandEvent(WaylandEvent),
+    Ignore,
+}
+
+impl Locker {
+    fn next_surface_id(&mut self) -> SurfaceId {
+        self.max_surface_id += 1;
+        SurfaceId(self.max_surface_id)
+    }
+}
+
+impl Application for Locker {
+    type Executor = iced::executor::Default;
+    type Message = Message;
+    type Flags = ();
+    type Theme = Theme;
+
+    fn new(_flags: ()) -> (Locker, Command<Self::Message>) {
+        (
+            Locker {
+                ..Locker::default()
+            },
+            session_lock::lock(),
+        )
+    }
+
+    fn title(&self) -> String {
+        String::from("Locker")
+    }
+
+    fn update(&mut self, message: Self::Message) -> Command<Self::Message> {
+        match message {
+            Message::WaylandEvent(evt) => {
+                match evt {
+                    // TODO handle creation/removal after lock
+                    WaylandEvent::Output(evt, output) => match evt {
+                        OutputEvent::Created(_) => {
+                            return session_lock::get_lock_surface(
+                                self.next_surface_id(),
+                                output,
+                            );
+                        }
+                        OutputEvent::Removed => {}
+                        _ => {}
+                    },
+                    WaylandEvent::SessionLock(evt) => match evt {
+                        SessionLockEvent::Locked => {}
+                        _ => {} // TODO
+                    },
+                    _ => {}
+                }
+            }
+            Message::Ignore => {}
+        }
+        Command::none()
+    }
+
+    fn view(&self, id: window::Id) -> Element<Self::Message> {
+        text("Lock").into()
+    }
+
+    fn subscription(&self) -> Subscription<Self::Message> {
+        iced::subscription::events_with(|evt, _| {
+            if let iced::Event::PlatformSpecific(
+                iced::event::PlatformSpecific::Wayland(evt),
+            ) = evt
+            {
+                Some(Message::WaylandEvent(evt))
+            } else {
+                None
+            }
+        })
+    }
+
+    fn close_requested(&self, _id: window::Id) -> Self::Message {
+        Message::Ignore
+    }
+}

runtime/src/command/platform_specific/wayland/mod.rs

@@ -10,6 +10,8 @@ pub mod data_device;
 pub mod layer_surface;
 /// popup actions
 pub mod popup;
+/// session locks
+pub mod session_lock;
 /// window actions
 pub mod window;
 
@@ -25,6 +27,8 @@ pub enum Action<T> {
     DataDevice(data_device::Action<T>),
     /// activation
     Activation(activation::Action<T>),
+    /// session lock
+    SessionLock(session_lock::Action<T>),
 }
 
 impl<T> Action<T> {
@@ -43,6 +47,7 @@ impl<T> Action<T> {
             Action::Popup(a) => Action::Popup(a.map(f)),
             Action::DataDevice(a) => Action::DataDevice(a.map(f)),
             Action::Activation(a) => Action::Activation(a.map(f)),
+            Action::SessionLock(a) => Action::SessionLock(a.map(f)),
         }
     }
 }
@@ -61,6 +66,9 @@ impl<T> Debug for Action<T> {
             Self::Activation(arg0) => {
                 f.debug_tuple("Activation").field(arg0).finish()
             }
+            Self::SessionLock(arg0) => {
+                f.debug_tuple("SessionLock").field(arg0).finish()
+            }
         }
     }
 }

runtime/src/command/platform_specific/wayland/session_lock.rs

@@ -0,0 +1,80 @@
+use std::{fmt, marker::PhantomData};
+
+use iced_core::window::Id;
+use iced_futures::MaybeSend;
+
+use sctk::reexports::client::protocol::wl_output::WlOutput;
+
+/// Session lock action
+#[derive(Clone)]
+pub enum Action<T> {
+    /// Request a session lock
+    Lock,
+    /// Destroy lock
+    Unlock,
+    /// Create lock surface for output
+    LockSurface {
+        /// unique id for surface
+        id: Id,
+        /// output
+        output: WlOutput,
+        /// phantom
+        _phantom: PhantomData<T>,
+    },
+    /// Destroy lock surface
+    DestroyLockSurface {
+        /// unique id for surface
+        id: Id,
+    },
+}
+
+impl<T> Action<T> {
+    /// Maps the output of a window [`Action`] using the provided closure.
+    pub fn map<A>(
+        self,
+        _: impl Fn(T) -> A + 'static + MaybeSend + Sync,
+    ) -> Action<A>
+    where
+        T: 'static,
+    {
+        match self {
+            Action::Lock => Action::Lock,
+            Action::Unlock => Action::Unlock,
+            Action::LockSurface {
+                id,
+                output,
+                _phantom,
+            } => Action::LockSurface {
+                id,
+                output,
+                _phantom: PhantomData,
+            },
+            Action::DestroyLockSurface { id } => {
+                Action::DestroyLockSurface { id }
+            }
+        }
+    }
+}
+
+impl<T> fmt::Debug for Action<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Action::Lock => write!(f, "Action::SessionLock::Lock"),
+            Action::Unlock => write!(f, "Action::SessionLock::Unlock"),
+            Action::LockSurface {
+                id,
+                output,
+                _phantom,
+            } => write!(
+                f,
+                "Action::SessionLock::LockSurface {{ id: {:?}, output: {:?} }}",
+                id, output
+            ),
+            Action::DestroyLockSurface { id } => write!(
+                f,
+                "Action::SessionLock::DestroyLockSurface {{ id: {:?} }}",
+                id
+            ),
+        }
+    }
+}

sctk/src/application.rs

@@ -93,6 +93,8 @@ pub enum Event<Message> {
     DataDevice(platform_specific::wayland::data_device::Action<Message>),
     /// xdg-activation request from the client
     Activation(platform_specific::wayland::activation::Action<Message>),
+    /// data session lock requests from the client
+    SessionLock(platform_specific::wayland::session_lock::Action<Message>),
     /// request sctk to set the cursor of the active pointer
     SetCursor(Interaction),
     /// Application Message
@@ -770,6 +772,46 @@ where
                             }
                         })
                     }
+                    SctkEvent::SessionLockSurfaceCreated { surface, native_id } => {
+                        surface_ids.insert(surface.id(), SurfaceIdWrapper::SessionLock(native_id));
+                        states.insert(native_id, State::new(&application, SurfaceIdWrapper::SessionLock(native_id)));
+                    }
+                    SctkEvent::SessionLockSurfaceConfigure { surface, configure, first } => {
+                        if let Some(id) = surface_ids.get(&surface.id()) {
+                            compositor_surfaces.entry(id.inner()).or_insert_with(|| {
+                                let mut wrapper = SurfaceDisplayWrapper {
+                                     comp_surface: None,
+                                     backend: backend.clone(),
+                                     wl_surface: surface.clone()
+                                };
+                                let c_surface = compositor.create_surface(&wrapper, configure.new_size.0, configure.new_size.1);
+                                wrapper.comp_surface.replace(c_surface);
+                                wrapper
+                            });
+
+                            let Some(state) = states.get_mut(&id.inner()) else {
+                                continue;
+                            };
+
+                            if first {
+                                let user_interface = build_user_interface(
+                                    &application,
+                                    user_interface::Cache::default(),
+                                    &mut renderer,
+                                    state.logical_size(),
+                                    &state.title,
+                                    &mut debug,
+                                    *id,
+                                    &mut auto_size_surfaces,
+                                    &mut ev_proxy
+                                );
+                                interfaces.insert(id.inner(), user_interface);
+                            }
+
+                            state.set_logical_size(configure.new_size.0 as f64 , configure.new_size.1 as f64);
+                        }
+
+                    }
                     _ => {}
                 }
             }
@@ -901,6 +943,9 @@ where
                         SctkEvent::NewOutput { .. }
                             | SctkEvent::UpdateOutput { .. }
                             | SctkEvent::RemovedOutput(_)
+                            | SctkEvent::SessionLocked
+                            | SctkEvent::SessionLockFinished
+                            | SctkEvent::SessionUnlocked
                     );
                     if remove {
                         let event = sctk_events.remove(i);
@@ -1446,6 +1491,7 @@ pub enum SurfaceIdWrapper {
     Window(SurfaceId),
     Popup(SurfaceId),
     Dnd(SurfaceId),
+    SessionLock(SurfaceId),
 }
 
 impl SurfaceIdWrapper {
@@ -1455,6 +1501,7 @@ impl SurfaceIdWrapper {
             SurfaceIdWrapper::Window(id) => *id,
             SurfaceIdWrapper::Popup(id) => *id,
             SurfaceIdWrapper::Dnd(id) => *id,
+            SurfaceIdWrapper::SessionLock(id) => *id,
         }
     }
 }
@@ -1529,6 +1576,7 @@ where
                     );
                 }
                 SurfaceIdWrapper::Dnd(_) => {}
+                SurfaceIdWrapper::SessionLock(_) => {}
             };
         }
 
@@ -2086,6 +2134,9 @@ where
             ) => {
                 proxy.send_event(Event::Activation(activation_action));
             }
+            command::Action::PlatformSpecific(platform_specific::Action::Wayland(platform_specific::wayland::Action::SessionLock(session_lock_action))) => {
+                proxy.send_event(Event::SessionLock(session_lock_action));
+            }
             _ => {}
         };
     None
@@ -2158,5 +2209,14 @@ fn event_is_for_surface(
         SctkEvent::ScaleFactorChanged { id, .. } => &id.id() == object_id,
         SctkEvent::DndOffer { surface, .. } => &surface.id() == object_id,
         SctkEvent::DataSource(_) => true,
+        SctkEvent::SessionLocked => false,
+        SctkEvent::SessionLockFinished => false,
+        SctkEvent::SessionLockSurfaceCreated { surface, .. } => {
+            &surface.id() == object_id
+        }
+        SctkEvent::SessionLockSurfaceConfigure { surface, .. } => {
+            &surface.id() == object_id
+        }
+        SctkEvent::SessionUnlocked => false,
     }
 }

sctk/src/commands/mod.rs

@@ -4,4 +4,5 @@ pub mod activation;
 pub mod data_device;
 pub mod layer_surface;
 pub mod popup;
+pub mod session_lock;
 pub mod window;