refactor(wayland): update to 0.30.0

This is pretty much a rewrite of the Wayland client code for `wayland-client` and `wayland-protocols` v0.30.0, and `smithay-client-toolkit` v0.17.0

src/clients/wayland/wlr_foreign_toplevel/handle.rs

@@ -1,13 +1,15 @@
+use super::manager::ToplevelManagerState;
+use crate::lock;
 use std::collections::HashSet;
-use std::sync::{Arc, RwLock};
 use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::{Arc, Mutex};
 use tracing::trace;
-use wayland_client::{DispatchData, Main};
-use wayland_protocols::wlr::unstable::foreign_toplevel::v1::client::zwlr_foreign_toplevel_handle_v1::{Event, ZwlrForeignToplevelHandleV1};
-use crate::write_lock;
-
-const STATE_ACTIVE: u32 = 2;
-const STATE_FULLSCREEN: u32 = 3;
+use wayland_client::protocol::wl_output::WlOutput;
+use wayland_client::protocol::wl_seat::WlSeat;
+use wayland_client::{Connection, Dispatch, Proxy, QueueHandle};
+use wayland_protocols_wlr::foreign_toplevel::v1::client::zwlr_foreign_toplevel_handle_v1::{
+    Event, ZwlrForeignToplevelHandleV1,
+};
 
 static COUNTER: AtomicUsize = AtomicUsize::new(1);
 
@@ -15,138 +17,168 @@ fn get_id() -> usize {
     COUNTER.fetch_add(1, Ordering::Relaxed)
 }
 
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
+pub struct ToplevelHandle {
+    pub handle: ZwlrForeignToplevelHandleV1,
+}
+
+impl PartialEq for ToplevelHandle {
+    fn eq(&self, other: &Self) -> bool {
+        self.handle == other.handle
+    }
+}
+
+impl ToplevelHandle {
+    pub fn info(&self) -> Option<ToplevelInfo> {
+        trace!("Retrieving handle info");
+
+        let data = self.handle.data::<ToplevelHandleData>()?;
+        data.info()
+    }
+
+    pub fn focus(&self, seat: &WlSeat) {
+        trace!("Activating handle");
+        self.handle.activate(seat);
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct ToplevelHandleData {
+    pub inner: Arc<Mutex<ToplevelHandleDataInner>>,
+}
+
+impl ToplevelHandleData {
+    fn info(&self) -> Option<ToplevelInfo> {
+        lock!(self.inner).current_info.clone()
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct ToplevelHandleDataInner {
+    initial_done: bool,
+    output: Option<WlOutput>,
+
+    current_info: Option<ToplevelInfo>,
+    pending_info: ToplevelInfo,
+}
+
+#[derive(Debug, Clone)]
 pub struct ToplevelInfo {
     pub id: usize,
     pub app_id: String,
     pub title: String,
-    pub active: bool,
     pub fullscreen: bool,
-
-    ready: bool,
+    pub focused: bool,
 }
 
-impl ToplevelInfo {
-    fn new() -> Self {
-        let id = get_id();
+impl Default for ToplevelInfo {
+    fn default() -> Self {
         Self {
-            id,
-            ..Default::default()
+            id: get_id(),
+            app_id: String::new(),
+            title: String::new(),
+            fullscreen: false,
+            focused: false,
         }
     }
 }
 
-pub struct Toplevel;
-
-#[derive(Debug, Clone)]
-pub struct ToplevelEvent {
-    pub toplevel: ToplevelInfo,
-    pub change: ToplevelChange,
+pub trait ToplevelHandleDataExt {
+    fn toplevel_handle_data(&self) -> &ToplevelHandleData;
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ToplevelChange {
-    New,
-    Close,
-    Title(String),
-    Focus(bool),
-    Fullscreen(bool),
+impl ToplevelHandleDataExt for ToplevelHandleData {
+    fn toplevel_handle_data(&self) -> &ToplevelHandleData {
+        self
+    }
 }
 
-fn toplevel_implem<F>(event: Event, info: &mut ToplevelInfo, implem: &mut F, ddata: DispatchData)
+pub trait ToplevelHandleHandler: Sized {
+    fn new_handle(&mut self, conn: &Connection, qh: &QueueHandle<Self>, handle: ToplevelHandle);
+
+    fn update_handle(&mut self, conn: &Connection, qh: &QueueHandle<Self>, handle: ToplevelHandle);
+
+    fn remove_handle(&mut self, conn: &Connection, qh: &QueueHandle<Self>, handle: ToplevelHandle);
+}
+
+impl<D, U> Dispatch<ZwlrForeignToplevelHandleV1, U, D> for ToplevelManagerState
 where
-    F: FnMut(ToplevelEvent, DispatchData),
+    D: Dispatch<ZwlrForeignToplevelHandleV1, U> + ToplevelHandleHandler,
+    U: ToplevelHandleDataExt,
 {
-    trace!("event: {event:?} (info: {info:?})");
+    fn event(
+        state: &mut D,
+        handle: &ZwlrForeignToplevelHandleV1,
+        event: Event,
+        data: &U,
+        conn: &Connection,
+        qh: &QueueHandle<D>,
+    ) {
+        const STATE_ACTIVE: u32 = 2;
+        const STATE_FULLSCREEN: u32 = 3;
 
-    let change = match event {
-        Event::AppId { app_id } => {
-            info.app_id = app_id;
-            None
-        }
-        Event::Title { title } => {
-            info.title = title.clone();
+        let data = data.toplevel_handle_data();
 
-            if info.ready {
-                Some(ToplevelChange::Title(title))
-            } else {
-                None
+        trace!("Processing handle event: {event:?}");
+
+        match event {
+            Event::Title { title } => {
+                lock!(data.inner).pending_info.title = title;
             }
-        }
-        Event::State { state } => {
-            // state is received as a `Vec<u8>` where every 4 bytes make up a `u32`
-            // the u32 then represents a value in the `State` enum.
-            assert_eq!(state.len() % 4, 0);
+            Event::AppId { app_id } => lock!(data.inner).pending_info.app_id = app_id,
+            Event::State { state } => {
+                // state is received as a `Vec<u8>` where every 4 bytes make up a `u32`
+                // the u32 then represents a value in the `State` enum.
+                assert_eq!(state.len() % 4, 0);
+                let state = (0..state.len() / 4)
+                    .map(|i| {
+                        let slice: [u8; 4] = state[i * 4..i * 4 + 4]
+                            .try_into()
+                            .expect("Received invalid state length");
+                        u32::from_le_bytes(slice)
+                    })
+                    .collect::<HashSet<_>>();
 
-            let state = (0..state.len() / 4)
-                .map(|i| {
-                    let slice: [u8; 4] = state[i * 4..i * 4 + 4]
-                        .try_into()
-                        .expect("Received invalid state length");
-                    u32::from_le_bytes(slice)
-                })
-                .collect::<HashSet<_>>();
-
-            let new_active = state.contains(&STATE_ACTIVE);
-            let new_fullscreen = state.contains(&STATE_FULLSCREEN);
-
-            let change = if info.ready && new_active != info.active {
-                Some(ToplevelChange::Focus(new_active))
-            } else if info.ready && new_fullscreen != info.fullscreen {
-                Some(ToplevelChange::Fullscreen(new_fullscreen))
-            } else {
-                None
-            };
-
-            info.active = new_active;
-            info.fullscreen = new_fullscreen;
-
-            change
-        }
-        Event::Closed => {
-            if info.ready {
-                Some(ToplevelChange::Close)
-            } else {
-                None
+                lock!(data.inner).pending_info.focused = state.contains(&STATE_ACTIVE);
+                lock!(data.inner).pending_info.fullscreen = state.contains(&STATE_FULLSCREEN);
             }
-        }
-        Event::OutputEnter { output: _ }
-        | Event::OutputLeave { output: _ }
-        | Event::Parent { parent: _ } => None,
-        Event::Done => {
-            if info.ready || info.app_id.is_empty() {
-                None
-            } else {
-                info.ready = true;
-                Some(ToplevelChange::New)
+            Event::OutputEnter { output } => lock!(data.inner).output = Some(output),
+            Event::OutputLeave { output: _ } => lock!(data.inner).output = None,
+            Event::Closed => state.remove_handle(
+                conn,
+                qh,
+                ToplevelHandle {
+                    handle: handle.clone(),
+                },
+            ),
+            Event::Done => {
+                {
+                    let pending_info = lock!(data.inner).pending_info.clone();
+                    lock!(data.inner).current_info = Some(pending_info);
+                }
+
+                if !lock!(data.inner).initial_done {
+                    lock!(data.inner).initial_done = true;
+                    state.new_handle(
+                        conn,
+                        qh,
+                        ToplevelHandle {
+                            handle: handle.clone(),
+                        },
+                    );
+                } else {
+                    state.update_handle(
+                        conn,
+                        qh,
+                        ToplevelHandle {
+                            handle: handle.clone(),
+                        },
+                    );
+                }
             }
+            _ => {}
         }
 
-        _ => unreachable!(),
-    };
-
-    if let Some(change) = change {
-        let event = ToplevelEvent {
-            change,
-            toplevel: info.clone(),
-        };
-
-        implem(event, ddata);
-    }
-}
-
-impl Toplevel {
-    pub fn init<F>(handle: &Main<ZwlrForeignToplevelHandleV1>, mut callback: F) -> Self
-    where
-        F: FnMut(ToplevelEvent, DispatchData) + 'static,
-    {
-        let inner = Arc::new(RwLock::new(ToplevelInfo::new()));
-
-        handle.quick_assign(move |_handle, event, ddata| {
-            let mut inner = write_lock!(inner);
-            toplevel_implem(event, &mut inner, &mut callback, ddata);
-        });
-
-        Self
+        trace!("Event processed");
     }
 }

src/clients/wayland/wlr_foreign_toplevel/manager.rs

@@ -1,163 +1,86 @@
-use super::handle::{Toplevel, ToplevelEvent};
-use crate::wayland::LazyGlobal;
-use smithay_client_toolkit::environment::{Environment, GlobalHandler};
-use std::cell::RefCell;
-use std::rc::{self, Rc};
-use tracing::warn;
-use wayland_client::protocol::wl_registry::WlRegistry;
-use wayland_client::{Attached, DispatchData};
-use wayland_protocols::wlr::unstable::foreign_toplevel::v1::client::{
+use super::handle::{ToplevelHandleData, ToplevelHandleDataExt, ToplevelHandleHandler};
+use smithay_client_toolkit::error::GlobalError;
+use smithay_client_toolkit::globals::{GlobalData, ProvidesBoundGlobal};
+use std::marker::PhantomData;
+use tracing::{debug, warn};
+use wayland_client::globals::{BindError, GlobalList};
+use wayland_client::{event_created_child, Connection, Dispatch, QueueHandle};
+use wayland_protocols_wlr::foreign_toplevel::v1::client::{
     zwlr_foreign_toplevel_handle_v1::ZwlrForeignToplevelHandleV1,
-    zwlr_foreign_toplevel_manager_v1::{self, ZwlrForeignToplevelManagerV1},
+    zwlr_foreign_toplevel_manager_v1::{Event, ZwlrForeignToplevelManagerV1},
 };
 
-struct ToplevelHandlerInner {
-    manager: LazyGlobal<ZwlrForeignToplevelManagerV1>,
-    registry: Option<Attached<WlRegistry>>,
-    toplevels: Vec<Toplevel>,
+pub struct ToplevelManagerState<V = ToplevelHandleData> {
+    manager: ZwlrForeignToplevelManagerV1,
+    _phantom: PhantomData<V>,
 }
 
-impl ToplevelHandlerInner {
-    const fn new() -> Self {
-        let toplevels = vec![];
-
-        Self {
-            registry: None,
-            manager: LazyGlobal::Unknown,
-            toplevels,
-        }
-    }
-}
-
-pub struct ToplevelHandler {
-    inner: Rc<RefCell<ToplevelHandlerInner>>,
-    status_listeners: Rc<RefCell<Vec<rc::Weak<RefCell<ToplevelStatusCallback>>>>>,
-}
-
-impl ToplevelHandler {
-    pub fn init() -> Self {
-        let inner = Rc::new(RefCell::new(ToplevelHandlerInner::new()));
-
-        Self {
-            inner,
-            status_listeners: Rc::new(RefCell::new(Vec::new())),
-        }
-    }
-}
-
-impl GlobalHandler<ZwlrForeignToplevelManagerV1> for ToplevelHandler {
-    fn created(
-        &mut self,
-        registry: Attached<WlRegistry>,
-        id: u32,
-        version: u32,
-        _ddata: DispatchData,
-    ) {
-        let mut inner = RefCell::borrow_mut(&self.inner);
-        if inner.registry.is_none() {
-            inner.registry = Some(registry);
-        }
-        if matches!(inner.manager, LazyGlobal::Unknown) {
-            inner.manager = LazyGlobal::Seen { id, version }
-        } else {
-            warn!(
-                "Compositor advertised zwlr_foreign_toplevel_manager_v1 multiple times, ignoring."
-            );
-        }
-    }
-
-    fn get(&self) -> Option<Attached<ZwlrForeignToplevelManagerV1>> {
-        let mut inner = RefCell::borrow_mut(&self.inner);
-
-        match inner.manager {
-            LazyGlobal::Bound(ref mgr) => Some(mgr.clone()),
-            LazyGlobal::Unknown => None,
-            LazyGlobal::Seen { id, version } => {
-                let registry = inner.registry.as_ref().expect("Failed to get registry");
-                // current max protocol version = 3
-                let version = std::cmp::min(version, 3);
-                let manager = registry.bind::<ZwlrForeignToplevelManagerV1>(version, id);
-
-                {
-                    let inner = self.inner.clone();
-                    let status_listeners = self.status_listeners.clone();
-
-                    manager.quick_assign(move |_, event, _ddata| {
-                        let mut inner = RefCell::borrow_mut(&inner);
-                        let status_listeners = status_listeners.clone();
-
-                        match event {
-                            zwlr_foreign_toplevel_manager_v1::Event::Toplevel {
-                                toplevel: handle,
-                            } => {
-                                let toplevel =
-                                    Toplevel::init(&handle.clone(), move |event, ddata| {
-                                        notify_status_listeners(
-                                            &handle,
-                                            &event,
-                                            ddata,
-                                            &status_listeners,
-                                        );
-                                    });
-
-                                inner.toplevels.push(toplevel);
-                            }
-                            zwlr_foreign_toplevel_manager_v1::Event::Finished => {}
-                            _ => unreachable!(),
-                        }
-                    });
-                }
-
-                inner.manager = LazyGlobal::Bound((*manager).clone());
-                Some((*manager).clone())
-            }
-        }
-    }
-}
-
-type ToplevelStatusCallback =
-    dyn FnMut(ZwlrForeignToplevelHandleV1, ToplevelEvent, DispatchData) + 'static;
-
-/// Notifies the callbacks of an event on the toplevel
-fn notify_status_listeners(
-    toplevel: &ZwlrForeignToplevelHandleV1,
-    event: &ToplevelEvent,
-    mut ddata: DispatchData,
-    listeners: &RefCell<Vec<rc::Weak<RefCell<ToplevelStatusCallback>>>>,
-) {
-    listeners.borrow_mut().retain(|lst| {
-        rc::Weak::upgrade(lst).map_or(false, |cb| {
-            (cb.borrow_mut())(toplevel.clone(), event.clone(), ddata.reborrow());
-            true
-        })
-    });
-}
-
-pub struct ToplevelStatusListener {
-    _cb: Rc<RefCell<ToplevelStatusCallback>>,
-}
-
-pub trait ToplevelHandling {
-    fn listen<F>(&mut self, f: F) -> ToplevelStatusListener
+impl ToplevelManagerState {
+    pub fn bind<State>(globals: &GlobalList, qh: &QueueHandle<State>) -> Result<Self, BindError>
     where
-        F: FnMut(ZwlrForeignToplevelHandleV1, ToplevelEvent, DispatchData) + 'static;
-}
-
-impl ToplevelHandling for ToplevelHandler {
-    fn listen<F>(&mut self, f: F) -> ToplevelStatusListener
-    where
-        F: FnMut(ZwlrForeignToplevelHandleV1, ToplevelEvent, DispatchData) + 'static,
+        State: Dispatch<ZwlrForeignToplevelManagerV1, GlobalData, State> + 'static,
     {
-        let rc = Rc::new(RefCell::new(f)) as Rc<_>;
-        self.status_listeners.borrow_mut().push(Rc::downgrade(&rc));
-        ToplevelStatusListener { _cb: rc }
+        let manager = globals.bind(qh, 1..=3, GlobalData)?;
+        debug!("Bound to ZwlForeignToplevelManagerV1 global");
+        Ok(Self {
+            manager,
+            _phantom: PhantomData,
+        })
     }
 }
 
-pub fn listen_for_toplevels<E, F>(env: &Environment<E>, f: F) -> ToplevelStatusListener
-where
-    E: ToplevelHandling,
-    F: FnMut(ZwlrForeignToplevelHandleV1, ToplevelEvent, DispatchData) + 'static,
-{
-    env.with_inner(move |inner| ToplevelHandling::listen(inner, f))
+pub trait ToplevelManagerHandler: Sized {
+    /// Advertises a new toplevel.
+    fn toplevel(
+        &mut self,
+        conn: &Connection,
+        qh: &QueueHandle<Self>,
+        manager: ToplevelManagerState,
+    );
+}
+
+impl ProvidesBoundGlobal<ZwlrForeignToplevelManagerV1, 3> for ToplevelManagerState {
+    fn bound_global(&self) -> Result<ZwlrForeignToplevelManagerV1, GlobalError> {
+        Ok(self.manager.clone())
+    }
+}
+
+impl<D, V> Dispatch<ZwlrForeignToplevelManagerV1, GlobalData, D> for ToplevelManagerState<V>
+where
+    D: Dispatch<ZwlrForeignToplevelManagerV1, GlobalData>
+        + Dispatch<ZwlrForeignToplevelHandleV1, V>
+        + ToplevelManagerHandler
+        + ToplevelHandleHandler
+        + 'static,
+    V: ToplevelHandleDataExt + Default + 'static + Send + Sync,
+{
+    event_created_child!(D, ZwlrForeignToplevelManagerV1, [
+        0 => (ZwlrForeignToplevelHandleV1, V::default())
+    ]);
+
+    fn event(
+        state: &mut D,
+        toplevel_manager: &ZwlrForeignToplevelManagerV1,
+        event: Event,
+        _data: &GlobalData,
+        conn: &Connection,
+        qhandle: &QueueHandle<D>,
+    ) {
+        match event {
+            Event::Toplevel { toplevel: _ } => {
+                state.toplevel(
+                    conn,
+                    qhandle,
+                    ToplevelManagerState {
+                        manager: toplevel_manager.clone(),
+                        _phantom: PhantomData,
+                    },
+                );
+            }
+            Event::Finished => {
+                warn!("Foreign toplevel manager is no longer valid, but has not been dropped by client. This could cause window tracking issues.");
+            }
+            _ => {}
+        }
+    }
 }

src/clients/wayland/wlr_foreign_toplevel/mod.rs

@@ -1,39 +1,84 @@
-use std::sync::RwLock;
-use indexmap::IndexMap;
-use tokio::sync::broadcast::Sender;
-use tracing::trace;
-use super::Env;
-use handle::{ToplevelEvent, ToplevelChange, ToplevelInfo};
-use manager::{ToplevelHandling, ToplevelStatusListener};
-use wayland_client::DispatchData;
-use wayland_protocols::wlr::unstable::foreign_toplevel::v1::client::zwlr_foreign_toplevel_handle_v1::ZwlrForeignToplevelHandleV1;
-use crate::{send, write_lock};
-
 pub mod handle;
 pub mod manager;
 
-impl ToplevelHandling for Env {
-    fn listen<F>(&mut self, f: F) -> ToplevelStatusListener
-    where
-        F: FnMut(ZwlrForeignToplevelHandleV1, ToplevelEvent, DispatchData) + 'static,
-    {
-        self.toplevel.listen(f)
+use self::handle::ToplevelHandleHandler;
+use self::manager::{ToplevelManagerHandler, ToplevelManagerState};
+use crate::clients::wayland::Environment;
+use tracing::{debug, error, trace};
+use wayland_client::{Connection, QueueHandle};
+
+use crate::send;
+pub use handle::{ToplevelHandle, ToplevelInfo};
+
+#[derive(Debug, Clone)]
+pub enum ToplevelEvent {
+    New(ToplevelHandle),
+    Update(ToplevelHandle),
+    Remove(ToplevelHandle),
+}
+
+impl ToplevelManagerHandler for Environment {
+    fn toplevel(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        _manager: ToplevelManagerState,
+    ) {
+        debug!("Manager received new handle");
     }
 }
 
-pub fn update_toplevels(
-    toplevels: &RwLock<IndexMap<usize, (ToplevelInfo, ZwlrForeignToplevelHandleV1)>>,
-    handle: ZwlrForeignToplevelHandleV1,
-    event: ToplevelEvent,
-    tx: &Sender<ToplevelEvent>,
-) {
-    trace!("Received toplevel event: {:?}", event);
+impl ToplevelHandleHandler for Environment {
+    fn new_handle(&mut self, _conn: &Connection, _qh: &QueueHandle<Self>, handle: ToplevelHandle) {
+        debug!("Handler received new handle");
 
-    if event.change == ToplevelChange::Close {
-        write_lock!(toplevels).remove(&event.toplevel.id);
-    } else {
-        write_lock!(toplevels).insert(event.toplevel.id, (event.toplevel.clone(), handle));
+        match handle.info() {
+            Some(info) => {
+                trace!("Adding new handle: {info:?}");
+                self.handles.insert(info.id, handle.clone());
+                send!(self.toplevel_tx, ToplevelEvent::New(handle));
+            }
+            None => {
+                error!("Handle is missing information!");
+            }
+        }
     }
 
-    send!(tx, event);
+    fn update_handle(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        handle: ToplevelHandle,
+    ) {
+        debug!("Handler received handle update");
+
+        match handle.info() {
+            Some(info) => {
+                trace!("Updating handle: {info:?}");
+                self.handles.insert(info.id, handle.clone());
+                send!(self.toplevel_tx, ToplevelEvent::Update(handle));
+            }
+            None => {
+                error!("Handle is missing information!");
+            }
+        }
+    }
+
+    fn remove_handle(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        handle: ToplevelHandle,
+    ) {
+        debug!("Handler received handle close");
+        match handle.info() {
+            Some(info) => {
+                self.handles.remove(&info.id);
+                send!(self.toplevel_tx, ToplevelEvent::Remove(handle));
+            }
+            None => {
+                error!("Handle is missing information!");
+            }
+        }
+    }
 }