wayland: Rework handlers and protocols into separate files

src/wayland/protocols/drm.rs

@@ -0,0 +1,269 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+// Re-export only the actual code, and then only use this re-export
+// The `generated` module below is just some boilerplate to properly isolate stuff
+// and avoid exposing internal details.
+//
+// You can use all the types from my_protocol as if they went from `wayland_client::protocol`.
+pub use generated::wl_drm;
+
+mod generated {
+    use smithay::reexports::wayland_server::{self, protocol::*};
+
+    pub mod __interfaces {
+        use smithay::reexports::wayland_server::protocol::__interfaces::*;
+        use wayland_backend;
+        wayland_scanner::generate_interfaces!("resources/protocols/wayland-drm.xml");
+    }
+    use self::__interfaces::*;
+
+    wayland_scanner::generate_server_code!("resources/protocols/wayland-drm.xml");
+}
+
+use smithay::{
+    backend::allocator::{
+        dmabuf::{Dmabuf, DmabufFlags},
+        Format, Fourcc, Modifier,
+    },
+    reexports::wayland_server::{
+        Client, DataInit, DisplayHandle,
+        DelegateGlobalDispatch, DelegateDispatch,
+        GlobalDispatch, Dispatch, Resource,
+        New, backend::GlobalId,
+        protocol::wl_buffer::WlBuffer,
+    },
+    wayland::{
+        buffer::BufferHandler,
+        dmabuf::{DmabufGlobal, DmabufHandler, ImportError},
+    },
+};
+
+use std::{
+    convert::TryFrom,
+    path::PathBuf,
+    sync::Arc,
+};
+
+pub struct WlDrmState;
+
+/// Data associated with a drm global.
+pub struct DrmGlobalData {
+    filter: Box<dyn for<'a> Fn(&'a Client) -> bool + Send + Sync>,
+    formats: Arc<Vec<Fourcc>>,
+    device_path: PathBuf,
+    _logger: slog::Logger,
+    dmabuf_global: DmabufGlobal,
+}
+
+pub struct DrmInstanceData {
+    formats: Arc<Vec<Fourcc>>,
+    dmabuf_global: DmabufGlobal,
+}
+
+impl<D> DelegateGlobalDispatch<wl_drm::WlDrm, DrmGlobalData, D> for WlDrmState
+where
+    D: GlobalDispatch<wl_drm::WlDrm, DrmGlobalData>
+        + Dispatch<wl_drm::WlDrm, DrmInstanceData>
+        + BufferHandler
+        + DmabufHandler
+        + 'static,
+{
+    fn bind(
+        _state: &mut D,
+        _dh: &DisplayHandle,
+        _client: &Client,
+        resource: New<wl_drm::WlDrm>,
+        global_data: &DrmGlobalData,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        let data = DrmInstanceData {
+            formats: global_data.formats.clone(),
+            dmabuf_global: global_data.dmabuf_global.clone(),
+        };
+        let drm_instance = data_init.init(resource, data);
+
+        drm_instance.device(global_data.device_path.to_string_lossy().into_owned());
+        if drm_instance.version() >= 2 {
+            drm_instance.capabilities(wl_drm::Capability::Prime as u32);
+        }
+        for format in global_data.formats.iter() {
+            if let Ok(converted) = wl_drm::Format::try_from(*format as u32) {
+                drm_instance.format(converted as u32);
+            }
+        }
+    }
+
+    fn can_view(client: Client, global_data: &DrmGlobalData) -> bool {
+        (global_data.filter)(&client)
+    }
+}
+
+impl<D> DelegateDispatch<wl_drm::WlDrm, DrmInstanceData, D> for WlDrmState
+where
+    D: GlobalDispatch<wl_drm::WlDrm, DrmGlobalData>
+        + Dispatch<wl_drm::WlDrm, DrmInstanceData>
+        + Dispatch<WlBuffer, Dmabuf>
+        + BufferHandler
+        + DmabufHandler
+        + 'static,
+{
+    fn request(
+        state: &mut D,
+        _client: &Client,
+        drm: &wl_drm::WlDrm,
+        request: wl_drm::Request,
+        data: &DrmInstanceData,
+        dh: &DisplayHandle,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        match request {
+            wl_drm::Request::Authenticate { .. } => drm.authenticated(),
+            wl_drm::Request::CreateBuffer { .. } => {
+                drm.post_error(
+                    wl_drm::Error::InvalidName,
+                    String::from("Flink handles are unsupported, use PRIME"),
+                )
+            },
+            wl_drm::Request::CreatePlanarBuffer { .. } => {
+                drm.post_error(
+                    wl_drm::Error::InvalidName,
+                    String::from("Flink handles are unsupported, use PRIME"),
+                )
+            },
+            wl_drm::Request::CreatePrimeBuffer {
+                id,
+                name,
+                width,
+                height,
+                format,
+                offset0,
+                stride0,
+                ..
+            } => {
+                let format = match Fourcc::try_from(format) {
+                    Ok(format) => {
+                        if !data.formats.contains(&format) {
+                            drm.post_error(
+                                wl_drm::Error::InvalidFormat,
+                                String::from("Format not advertised by wl_drm"),
+                            );
+                            return;
+                        }
+                        format
+                    },
+                    Err(_) => {
+                        drm.post_error(
+                            wl_drm::Error::InvalidFormat,
+                            String::from("Format unknown / not advertised by wl_drm"),
+                        );
+                        return;
+                    }
+                };
+
+                if width < 1 || height < 1 {
+                    drm.post_error(
+                        wl_drm::Error::InvalidFormat,
+                        String::from("width or height not positive"),
+                    );
+                    return;
+                }
+
+                let mut dma = Dmabuf::builder((width, height), format, DmabufFlags::empty());
+                dma.add_plane(name, 0, offset0 as u32, stride0 as u32, Modifier::Invalid);
+                match dma.build() {
+                    Some(dmabuf) => match state.dmabuf_imported(dh, &data.dmabuf_global, dmabuf.clone()) {
+                        Ok(_) => {
+                            // import was successful
+                            data_init.init(id, dmabuf);
+                            slog_scope::trace!("Created a new validated dma wl_buffer via wl_drm.");
+                        },
+
+                        Err(ImportError::InvalidFormat) => {
+                            drm.post_error(
+                                wl_drm::Error::InvalidFormat,
+                                "format and plane combination are not valid",
+                            );
+                        }
+
+                        Err(ImportError::Failed) => {
+                            // Buffer import failed. The protocol documentation heavily implies killing the
+                            // client is the right thing to do here.
+                            drm.post_error(
+                                wl_drm::Error::InvalidName,
+                                "buffer import failed",
+                            );
+                        }
+                    },
+                    None => {
+                        // Buffer import failed. The protocol documentation heavily implies killing the
+                        // client is the right thing to do here.
+                        drm.post_error(
+                            wl_drm::Error::InvalidName,
+                            "dmabuf global was destroyed on server",
+                        );
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl WlDrmState {
+    pub fn create_global<D>(
+        &mut self,
+        display: &DisplayHandle,
+        device_path: PathBuf,
+        formats: Vec<Format>,
+        dmabuf_global: &DmabufGlobal,
+    ) -> GlobalId
+    where
+        D: GlobalDispatch<wl_drm::WlDrm, DrmGlobalData>
+            + Dispatch<wl_drm::WlDrm, DrmInstanceData>
+            + BufferHandler
+            + DmabufHandler
+            + 'static,
+    {
+        self.create_global_with_filter::<D, _>(display, device_path, formats, dmabuf_global, |_| true)
+    }
+
+    pub fn create_global_with_filter<D, F>(
+        &mut self,
+        display: &DisplayHandle,
+        device_path: PathBuf,
+        formats: Vec<Format>,
+        dmabuf_global: &DmabufGlobal,
+        client_filter: F,
+    ) -> GlobalId
+    where
+        D: GlobalDispatch<wl_drm::WlDrm, DrmGlobalData>
+            + Dispatch<wl_drm::WlDrm, DrmInstanceData>
+            + BufferHandler
+            + DmabufHandler
+            + 'static,
+        F: for<'a> Fn(&'a Client) -> bool + Send + Sync + 'static,
+    {
+        let formats = Arc::new(formats.into_iter().filter(|f| f.modifier == Modifier::Invalid).map(|f| f.code).collect());
+        let data = DrmGlobalData {
+            filter: Box::new(client_filter),
+            formats,
+            device_path,
+            dmabuf_global: dmabuf_global.clone(),
+            _logger: slog_scope::logger().new(slog::o!("cosmic_module" => "wayland_drm")),
+        };
+
+        display.create_global::<D, wl_drm::WlDrm, _>(2, data)
+    }
+}
+
+macro_rules! delegate_wl_drm {
+    ($(@<$( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+>)? $ty: ty) => {
+        smithay::reexports::wayland_server::delegate_global_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            $crate::wayland::protocols::drm::wl_drm::WlDrm: $crate::wayland::protocols::drm::DrmGlobalData
+        ] => $crate::wayland::protocols::drm::WlDrmState);
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            $crate::wayland::protocols::drm::wl_drm::WlDrm: $crate::wayland::protocols::drm::DrmInstanceData
+        ] => $crate::wayland::protocols::drm::WlDrmState);
+    };
+}
+pub(crate) use delegate_wl_drm;
+ 

src/wayland/protocols/mod.rs

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pub mod drm;
+pub mod output_configuration;
+pub mod toplevel_info;
+pub mod workspace;

src/wayland/protocols/output_configuration.rs

@@ -0,0 +1,745 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+use std::{
+    convert::{TryFrom, TryInto},
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicBool, Ordering},
+    },
+};
+use smithay::{
+    reexports::{
+        wayland_protocols_wlr::output_management::v1::server::{
+            zwlr_output_configuration_head_v1::{self, ZwlrOutputConfigurationHeadV1},
+            zwlr_output_configuration_v1::{self, ZwlrOutputConfigurationV1},
+            zwlr_output_head_v1::{self, ZwlrOutputHeadV1},
+            zwlr_output_manager_v1::{self, ZwlrOutputManagerV1},
+            zwlr_output_mode_v1::{self, ZwlrOutputModeV1},
+        },
+        wayland_server::{
+            Client, DisplayHandle,
+            GlobalDispatch, Dispatch,
+            DelegateGlobalDispatch, DelegateDispatch,
+            DataInit, New, Resource,
+            backend::{ClientId, GlobalId, ObjectId},
+            protocol::wl_output::WlOutput,
+        },
+    },
+    wayland::output::{Output, Mode, OutputData},
+    utils::{Logical, Physical, Point, Size, Transform},
+};
+
+pub struct OutputConfigurationState<D> {
+    outputs: Vec<Output>,
+    removed_outputs: Vec<Output>,
+    instances: Vec<OutputMngrInstance>,
+    serial_counter: u32,
+    global: GlobalId,
+    dh: DisplayHandle,
+    _dispatch: std::marker::PhantomData<D>,
+}
+
+pub trait OutputConfigurationHandler: Sized {
+    fn output_configuration_state(&mut self) -> &mut OutputConfigurationState<Self>;
+
+    fn test_configuration(&mut self, conf: Vec<(Output, OutputConfiguration)>) -> bool;
+    fn apply_configuration(&mut self, conf: Vec<(Output, OutputConfiguration)>) -> bool;
+}
+
+pub struct OutputMngrGlobalData {
+    filter: Box<dyn for<'a> Fn(&'a Client) -> bool + Send + Sync>,
+}
+
+struct OutputMngrInstance {
+    obj: ZwlrOutputManagerV1,
+    active: Arc<AtomicBool>,
+    heads: Vec<OutputHeadInstance>,
+}
+
+struct OutputHeadInstance {
+    output: Output,
+    head: ZwlrOutputHeadV1,
+    modes: Vec<ZwlrOutputModeV1>,
+}
+
+pub struct OutputMngrInstanceData {
+    active: Arc<AtomicBool>,
+}
+
+#[derive(Debug, Default)]
+pub struct PendingConfigurationInner {
+    serial: u32,
+    used: bool,
+    heads: Vec<(ZwlrOutputHeadV1, Option<ZwlrOutputConfigurationHeadV1>)>,
+}
+pub type PendingConfiguration = Mutex<PendingConfigurationInner>;
+
+#[derive(Debug, Clone)]
+pub enum ModeConfiguration<M: Clone> {
+    Mode(M),
+    Custom {
+        size: Size<i32, Physical>,
+        refresh: Option<i32>,
+    },
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct PendingOutputConfigurationInner {
+    mode: Option<ModeConfiguration<ZwlrOutputModeV1>>,
+    position: Option<Point<i32, Logical>>,
+    transform: Option<Transform>,
+    scale: Option<f64>,
+}
+pub type PendingOutputConfiguration = Mutex<PendingOutputConfigurationInner>;
+
+#[derive(Debug, Clone)]
+pub enum OutputConfiguration {
+    Enabled {
+        mode: Option<ModeConfiguration<Mode>>,
+        position: Option<Point<i32, Logical>>,
+        transform: Option<Transform>,
+        scale: Option<f64>,
+    },
+    Disabled,
+}
+
+impl<'a> TryFrom<&'a mut PendingOutputConfigurationInner> for OutputConfiguration {
+    type Error = zwlr_output_configuration_head_v1::Error;
+    fn try_from(pending: &'a mut PendingOutputConfigurationInner) -> Result<OutputConfiguration, Self::Error> {
+        let mode = match pending.mode.clone() {
+            Some(ModeConfiguration::Mode(wlr_mode)) => Some(ModeConfiguration::Mode(
+                wlr_mode
+                    .data::<Mode>()
+                    .cloned()
+                    .ok_or_else(|| zwlr_output_configuration_head_v1::Error::InvalidMode)?,
+            )),
+            Some(ModeConfiguration::Custom { size, refresh }) => {
+                Some(ModeConfiguration::Custom { size, refresh })
+            }
+            None => None,
+        };
+        Ok(OutputConfiguration::Enabled {
+            mode,
+            position: pending.position,
+            transform: pending.transform,
+            scale: pending.scale,
+        })
+    }
+}
+
+struct OutputStateInner {
+    enabled: bool,
+    global: Option<GlobalId>,
+}
+type OutputState = Mutex<OutputStateInner>;
+
+impl<D> DelegateGlobalDispatch<ZwlrOutputManagerV1, OutputMngrGlobalData, D> for OutputConfigurationState<D>
+where
+    D: GlobalDispatch<ZwlrOutputManagerV1, OutputMngrGlobalData>
+        + Dispatch<ZwlrOutputManagerV1, OutputMngrInstanceData>
+        + Dispatch<ZwlrOutputHeadV1, Output>
+        + Dispatch<ZwlrOutputModeV1, Mode>
+        + Dispatch<ZwlrOutputConfigurationV1, PendingConfiguration>
+        + Dispatch<ZwlrOutputConfigurationHeadV1, PendingOutputConfiguration>
+        + OutputConfigurationHandler
+        + 'static
+{
+    fn bind(
+        state: &mut D,
+        dh: &DisplayHandle,
+        _client: &Client,
+        resource: New<ZwlrOutputManagerV1>,
+        _global_data: &OutputMngrGlobalData,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        let active = Arc::new(AtomicBool::new(true));
+        let data = OutputMngrInstanceData {
+            active: active.clone(),
+        };
+        let mut instance = OutputMngrInstance {
+            obj: data_init.init(resource, data),
+            heads: Vec::new(),
+            active,
+        };
+        
+        let mngr_state = state.output_configuration_state();
+        for output in &mngr_state.outputs {
+            send_head_to_client::<D>(dh, &mut instance, output);
+        }
+        instance.obj.done(mngr_state.serial_counter);
+        mngr_state.instances.push(instance);
+    }
+
+    fn can_view(client: Client, global_data: &OutputMngrGlobalData) -> bool {
+        (global_data.filter)(&client)
+    }
+}
+
+impl<D> DelegateDispatch<ZwlrOutputManagerV1, OutputMngrInstanceData, D> for OutputConfigurationState<D>
+where
+    D: GlobalDispatch<ZwlrOutputManagerV1, OutputMngrGlobalData>
+        + Dispatch<ZwlrOutputManagerV1, OutputMngrInstanceData>
+        + Dispatch<ZwlrOutputHeadV1, Output>
+        + Dispatch<ZwlrOutputModeV1, Mode>
+        + Dispatch<ZwlrOutputConfigurationV1, PendingConfiguration>
+        + Dispatch<ZwlrOutputConfigurationHeadV1, PendingOutputConfiguration>
+        + OutputConfigurationHandler
+        + 'static
+{
+    fn request(
+        state: &mut D,
+        _client: &Client,
+        _obj: &ZwlrOutputManagerV1,
+        request: zwlr_output_manager_v1::Request,
+        data: &OutputMngrInstanceData,
+        _dh: &DisplayHandle,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        match request {
+            zwlr_output_manager_v1::Request::CreateConfiguration {
+                id,
+                serial,
+            } => {
+                let conf = data_init.init(id, PendingConfiguration::new(PendingConfigurationInner {
+                    serial,
+                    used: false,
+                    heads: Vec::new(),
+                }));
+
+                let state = state.output_configuration_state();
+                if serial != state.serial_counter {
+                    conf.cancelled();
+                }
+            },
+            zwlr_output_manager_v1::Request::Stop => {
+                data.active.store(false, Ordering::SeqCst);
+            },
+            _ => {},
+        }
+    }
+}
+
+impl<D> DelegateDispatch<ZwlrOutputHeadV1, Output, D> for OutputConfigurationState<D>
+where
+    D: GlobalDispatch<ZwlrOutputManagerV1, OutputMngrGlobalData>
+        + Dispatch<ZwlrOutputManagerV1, OutputMngrInstanceData>
+        + Dispatch<ZwlrOutputHeadV1, Output>
+        + Dispatch<ZwlrOutputModeV1, Mode>
+        + Dispatch<ZwlrOutputConfigurationV1, PendingConfiguration>
+        + Dispatch<ZwlrOutputConfigurationHeadV1, PendingOutputConfiguration>
+        + OutputConfigurationHandler
+        + 'static
+{
+    fn request(
+        _state: &mut D,
+        _client: &Client,
+        _obj: &ZwlrOutputHeadV1,
+        request: zwlr_output_head_v1::Request,
+        _data: &Output,
+        _dh: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        match request {
+            _ => {}
+        }
+    }
+
+    fn destroyed(
+        state: &mut D, 
+        _client: ClientId, 
+        resource: ObjectId, 
+        _data: &Output,
+    ) {
+        for instance in &mut state.output_configuration_state().instances {
+            instance.heads.retain(|h| h.head.id() != resource);
+        }
+    }
+}
+
+impl<D> DelegateDispatch<ZwlrOutputModeV1, Mode, D> for OutputConfigurationState<D>
+where
+    D: GlobalDispatch<ZwlrOutputManagerV1, OutputMngrGlobalData>
+        + Dispatch<ZwlrOutputManagerV1, OutputMngrInstanceData>
+        + Dispatch<ZwlrOutputHeadV1, Output>
+        + Dispatch<ZwlrOutputModeV1, Mode>
+        + Dispatch<ZwlrOutputConfigurationV1, PendingConfiguration>
+        + Dispatch<ZwlrOutputConfigurationHeadV1, PendingOutputConfiguration>
+        + OutputConfigurationHandler
+        + 'static
+{
+    fn request(
+        _state: &mut D,
+        _client: &Client,
+        _obj: &ZwlrOutputModeV1,
+        request: zwlr_output_mode_v1::Request,
+        _data: &Mode,
+        _dh: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        match request {
+            _ => {}
+        }
+    }
+}
+
+impl<D> DelegateDispatch<ZwlrOutputConfigurationV1, PendingConfiguration, D> for OutputConfigurationState<D>
+where
+    D: GlobalDispatch<ZwlrOutputManagerV1, OutputMngrGlobalData>
+        + Dispatch<ZwlrOutputManagerV1, OutputMngrInstanceData>
+        + Dispatch<ZwlrOutputHeadV1, Output>
+        + Dispatch<ZwlrOutputModeV1, Mode>
+        + Dispatch<ZwlrOutputConfigurationV1, PendingConfiguration>
+        + Dispatch<ZwlrOutputConfigurationHeadV1, PendingOutputConfiguration>
+        + OutputConfigurationHandler
+        + 'static
+{
+    fn request(
+        state: &mut D,
+        _client: &Client,
+        obj: &ZwlrOutputConfigurationV1,
+        request: zwlr_output_configuration_v1::Request,
+        data: &PendingConfiguration,
+        _dh: &DisplayHandle,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        match request {
+            zwlr_output_configuration_v1::Request::EnableHead { id, head } => {
+                let mut pending = data.lock().unwrap();
+                if pending.heads.iter().any(|(h, _)| *h == head) {
+                    obj.post_error(
+                        zwlr_output_configuration_v1::Error::AlreadyConfiguredHead,
+                        format!("{:?} was already configured", head),
+                    );
+                    return;
+                }
+
+                let conf_head = data_init.init(id, PendingOutputConfiguration::default());
+                pending.heads.push((head, Some(conf_head)));
+            },
+            zwlr_output_configuration_v1::Request::DisableHead { head } => {
+                let mut pending = data.lock().unwrap();
+                if pending.heads.iter().any(|(h, _)| *h == head) {
+                    obj.post_error(
+                        zwlr_output_configuration_v1::Error::AlreadyConfiguredHead,
+                        format!("{:?} was already configured", head),
+                    );
+                    return;
+                }
+                pending.heads.push((head, None));
+            },
+            x @ zwlr_output_configuration_v1::Request::Apply
+            | x @ zwlr_output_configuration_v1::Request::Test => {
+                let mut pending = data.lock().unwrap();
+                
+                if pending.used {
+                    return obj.post_error(
+                        zwlr_output_configuration_v1::Error::AlreadyUsed,
+                        "Configuration object was used already".to_string(),
+                    );
+                }
+                pending.used = true;
+
+                let inner = state.output_configuration_state();
+                if pending.serial != inner.serial_counter {
+                    obj.cancelled();
+                    return;
+                }
+
+                let final_conf = match pending
+                    .heads
+                    .iter_mut()
+                    .map(|(head, conf)| {
+                        let output = match {
+                            inner.instances
+                                .iter()
+                                .find_map(|instance| instance.heads.iter().find(|h| h.head == *head))
+                                .map(|i| i.output.clone())
+                        } {
+                            Some(o) => o,
+                            None => {
+                                return Err(
+                                    zwlr_output_configuration_head_v1::Error::InvalidMode,
+                                );
+                            }
+                        };
+
+                        match conf {
+                            Some(head) => (&mut *head
+                                .data::<PendingOutputConfiguration>()
+                                .unwrap()
+                                .lock()
+                                .unwrap())
+                                .try_into()
+                                .map(|c| (output, c)),
+                            None => Ok((output, OutputConfiguration::Disabled)),
+                        }
+                    })
+                    .collect::<Result<Vec<(Output, OutputConfiguration)>, zwlr_output_configuration_head_v1::Error>>()
+                {
+                    Ok(conf) => conf,
+                    Err(code) => {
+                        return obj.post_error(code, "Incomplete configuration".to_string());
+                    }
+                };
+
+                let result = if matches!(x, zwlr_output_configuration_v1::Request::Test) {
+                    state.test_configuration(final_conf)
+                } else {
+                    state.apply_configuration(final_conf)
+                };
+
+                if result {
+                    obj.succeeded();
+                } else {
+                    obj.failed();
+                }
+            },
+            zwlr_output_configuration_v1::Request::Destroy => {},
+            _ => {},
+        }
+    }
+}
+
+impl<D> DelegateDispatch<ZwlrOutputConfigurationHeadV1, PendingOutputConfiguration, D> for OutputConfigurationState<D>
+where
+    D: GlobalDispatch<ZwlrOutputManagerV1, OutputMngrGlobalData>
+        + Dispatch<ZwlrOutputManagerV1, OutputMngrInstanceData>
+        + Dispatch<ZwlrOutputHeadV1, Output>
+        + Dispatch<ZwlrOutputModeV1, Mode>
+        + Dispatch<ZwlrOutputConfigurationV1, PendingConfiguration>
+        + Dispatch<ZwlrOutputConfigurationHeadV1, PendingOutputConfiguration>
+        + OutputConfigurationHandler
+        + 'static
+{
+    fn request(
+        _state: &mut D,
+        _client: &Client,
+        obj: &ZwlrOutputConfigurationHeadV1,
+        request: zwlr_output_configuration_head_v1::Request,
+        data: &PendingOutputConfiguration,
+        _dh: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        match request {
+            zwlr_output_configuration_head_v1::Request::SetMode { mode } => {
+                let mut pending = data.lock().unwrap();
+                if pending.mode.is_some() {
+                    obj.post_error(
+                        zwlr_output_configuration_head_v1::Error::AlreadySet,
+                        format!("{:?} already had a mode configured", obj),
+                    );
+                    return;
+                }
+                pending.mode = Some(ModeConfiguration::Mode(mode));
+            },
+            zwlr_output_configuration_head_v1::Request::SetCustomMode { width, height, refresh } => {
+                let mut pending = data.lock().unwrap();
+                if pending.mode.is_some() {
+                    obj.post_error(
+                        zwlr_output_configuration_head_v1::Error::AlreadySet,
+                        format!("{:?} already had a mode configured", obj),
+                    );
+                    return;
+                }
+                pending.mode = Some(ModeConfiguration::Custom {
+                    size: Size::from((width, height)),
+                    refresh: if refresh == 0 { None } else { Some(refresh) },
+                });
+            },
+            zwlr_output_configuration_head_v1::Request::SetPosition { x, y } => {
+                let mut pending = data.lock().unwrap();
+                if pending.position.is_some() {
+                    obj.post_error(
+                        zwlr_output_configuration_head_v1::Error::AlreadySet,
+                        format!("{:?} already had a position configured", obj),
+                    );
+                    return;
+                }
+                pending.position = Some(Point::from((x, y)));
+            },
+            zwlr_output_configuration_head_v1::Request::SetScale { scale } => {
+                let mut pending = data.lock().unwrap();
+                if pending.scale.is_some() {
+                    obj.post_error(
+                        zwlr_output_configuration_head_v1::Error::AlreadySet,
+                        format!("{:?} already had a scale configured", obj),
+                    );
+                    return;
+                }
+                pending.scale = Some(scale);
+            },
+            zwlr_output_configuration_head_v1::Request::SetTransform { transform } => {
+                let mut pending = data.lock().unwrap();
+                if pending.transform.is_some() {
+                    obj.post_error(
+                        zwlr_output_configuration_head_v1::Error::AlreadySet,
+                        format!("{:?} already had a transform configured", obj),
+                    );
+                    return;
+                }
+                pending.transform = Some(match transform.into_result() {
+                    Ok(transform) => transform.into(),
+                    Err(err) => {
+                        obj.post_error(
+                            zwlr_output_configuration_head_v1::Error::InvalidTransform,
+                            format!("Invalid transform: {:?}", err),
+                        );
+                        return;
+                    },
+                });
+            },
+            _ => {},
+        }
+    }
+}
+
+impl<D> OutputConfigurationState<D>
+where
+        D: GlobalDispatch<ZwlrOutputManagerV1, OutputMngrGlobalData>
+            + GlobalDispatch<WlOutput, OutputData>
+            + Dispatch<ZwlrOutputManagerV1, OutputMngrInstanceData>
+            + Dispatch<ZwlrOutputHeadV1, Output>
+            + Dispatch<ZwlrOutputModeV1, Mode>
+            + Dispatch<ZwlrOutputConfigurationV1, PendingConfiguration>
+            + Dispatch<ZwlrOutputConfigurationHeadV1, PendingOutputConfiguration>
+            + OutputConfigurationHandler
+            + 'static,
+{
+    pub fn new<F>(
+        dh: &DisplayHandle,
+        client_filter: F,
+    ) -> OutputConfigurationState<D>
+    where
+        F: for<'a> Fn(&'a Client) -> bool + Send + Sync + 'static,
+    {
+        let global = dh.create_global::<D, ZwlrOutputManagerV1, _>(2, OutputMngrGlobalData {
+            filter: Box::new(client_filter),
+        });
+
+        OutputConfigurationState {
+            outputs: Vec::new(),
+            removed_outputs: Vec::new(),
+            instances: Vec::new(),
+            serial_counter: 0,
+            global,
+            dh: dh.clone(),
+            _dispatch: std::marker::PhantomData,
+        }
+    }
+
+    pub fn global_id(&self) -> GlobalId {
+        self.global.clone()
+    }
+    
+    pub fn add_heads<'a>(&mut self, outputs: impl Iterator<Item = &'a Output>) {
+        let new_outputs = outputs.filter(|o| !self.outputs.contains(o)).collect::<Vec<_>>();
+
+        for output in new_outputs {
+            output.user_data().insert_if_missing(|| OutputState::new(OutputStateInner {
+                enabled: true,
+                global: None,
+            }));
+            self.outputs.push(output.clone());
+        }
+    }
+    
+    pub fn remove_heads<'a>(&mut self, outputs: impl Iterator<Item = &'a Output>) {
+        for output in outputs {
+            if self.outputs.contains(output) {
+                self.removed_outputs.push(output.clone());
+                if let Some(inner) = output.user_data().get::<OutputState>() {
+                    let mut inner = inner.lock().unwrap();
+                    // if it gets re-added it should start with being enabled and no global
+                    inner.enabled = true;
+                    if let Some(global) = inner.global.take() {
+                        self.dh.remove_global(global);
+                    }
+                }
+            }
+        }
+        self.outputs.retain(|x| !self.removed_outputs.contains(x));
+    }
+
+    pub fn enable_head(&self, output: &Output) {
+        if let Some(inner) = output.user_data().get::<OutputState>() {
+            let mut inner = inner.lock().unwrap();
+            inner.enabled = true;
+        }
+    }
+
+    pub fn disable_head(&self, output: &Output) {
+        if let Some(inner) = output.user_data().get::<OutputState>() {
+            let mut inner = inner.lock().unwrap();
+            inner.enabled = false;
+        }
+    }
+
+    pub fn update(&mut self) {
+        self.instances.retain(|x| x.active.load(Ordering::SeqCst));
+        self.serial_counter += 1;
+       
+        for output in std::mem::take(&mut self.removed_outputs).into_iter() {
+            for instance in &mut self.instances {
+                instance.heads.retain_mut(|head| if &head.output == &output {
+                    for mode in &head.modes {
+                        mode.finished();
+                    }
+                    head.head.finished();
+                    false
+                } else {
+                    true
+                });
+            }
+        }
+        for output in &self.outputs {
+            {
+                let state = output.user_data().get::<OutputState>().unwrap();
+                let mut inner = state.lock().unwrap();
+                if inner.enabled && inner.global.is_none() {
+                    inner.global = Some(output.create_global::<D>(&self.dh));
+                }
+                if !inner.enabled && inner.global.is_some() {
+                    self.dh.remove_global(inner.global.take().unwrap());
+                }
+            }
+            for manager in self.instances.iter_mut() {
+                send_head_to_client::<D>(&self.dh, manager, output);
+            }
+        }
+        for manager in self.instances.iter() {
+            manager.obj.done(self.serial_counter);
+        }
+    }
+
+    pub fn outputs(&self) -> impl Iterator<Item = Output> {
+        self.outputs.clone().into_iter()
+    }
+}
+
+fn send_head_to_client<D>(dh: &DisplayHandle, mngr: &mut OutputMngrInstance, output: &Output)
+where
+    D: GlobalDispatch<ZwlrOutputManagerV1, OutputMngrGlobalData>
+        + Dispatch<ZwlrOutputManagerV1, OutputMngrInstanceData>
+        + Dispatch<ZwlrOutputHeadV1, Output>
+        + Dispatch<ZwlrOutputModeV1, Mode>
+        + Dispatch<ZwlrOutputConfigurationV1, PendingConfiguration>
+        + OutputConfigurationHandler
+        + 'static
+{
+    let instance = match mngr.heads.iter_mut().find(|i| i.output == *output) {
+        Some(i) => i,
+        None => {
+            if let Ok(client) = dh.get_client(mngr.obj.id()) {
+                if let Ok(head) = client.create_resource::<ZwlrOutputHeadV1, _, D>(dh, mngr.obj.version(), output.clone()) {
+                    mngr.obj.head(&head);
+                    let data = OutputHeadInstance {
+                        head,
+                        modes: Vec::new(),
+                        output: output.clone(),
+                    };
+                    mngr.heads.push(data);
+                    mngr.heads.last_mut().unwrap()
+                } else {
+                    return;
+                }
+            } else {
+                return;
+            }
+        }
+    };
+
+    instance.head.name(output.name());
+    instance.head.description(output.description());
+    let physical = output.physical_properties();
+    if !(physical.size.w == 0 || physical.size.h == 0) {
+        instance.head.physical_size(physical.size.w, physical.size.h);
+    }
+
+    let inner = output
+        .user_data()
+        .get::<OutputState>()
+        .unwrap()
+        .lock()
+        .unwrap();
+
+    let output_modes = output.modes();
+    // remove old modes
+    instance.modes.retain_mut(|m| if !output_modes.contains(m.data::<Mode>().unwrap()) {
+        m.finished();
+        false
+    } else {
+        true
+    });
+    // update other modes
+    for output_mode in output_modes.into_iter() {
+        if let Some(mode) = if let Some(wlr_mode) = instance.modes
+            .iter()
+            .find(|mode| *mode.data::<Mode>().unwrap() == output_mode)
+        {
+            Some(wlr_mode)
+        } else if let Ok(client) = dh.get_client(instance.head.id()) {
+            // create the mode if it does not exist yet
+            if let Ok(mode) = client.create_resource::<ZwlrOutputModeV1, _, D>(dh, instance.head.version(), output_mode) {
+                instance.head.mode(&mode);
+                mode.size(output_mode.size.w, output_mode.size.h);
+                mode.refresh(output_mode.refresh);
+                if output.preferred_mode().map(|p| p == output_mode).unwrap_or(false) {
+                    mode.preferred();
+                }
+                instance.modes.push(mode);
+                instance.modes.last()
+            } else {
+                None
+            }
+        } else {
+            None
+        } {
+            if inner.enabled && output.current_mode().map(|c| c == output_mode).unwrap_or(false) {
+                instance.head.current_mode(&*mode);
+            }
+        }
+    }
+
+    instance.head.enabled(if inner.enabled { 1 } else { 0 });
+    if inner.enabled {
+        let point = output.current_location();
+        instance.head.position(point.x, point.y);
+        instance.head.transform(output.current_transform());
+        instance
+            .head
+            .scale(output.current_scale().fractional_scale());
+    }
+
+    if mngr.obj.version() >= zwlr_output_head_v1::EVT_MAKE_SINCE {
+        if physical.make != "Unknown" {
+            instance.head.make(physical.make.clone());
+        }
+        if physical.model != "Unknown" {
+            instance.head.model(physical.model);
+        }
+    }
+}
+
+macro_rules! delegate_output_configuration {
+    ($(@<$( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+>)? $ty: ty) => {
+        smithay::reexports::wayland_server::delegate_global_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::output_management::v1::server::zwlr_output_manager_v1::ZwlrOutputManagerV1: $crate::wayland::protocols::output_configuration::OutputMngrGlobalData
+        ] => $crate::wayland::protocols::output_configuration::OutputConfigurationState<Self>);
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::output_management::v1::server::zwlr_output_manager_v1::ZwlrOutputManagerV1: $crate::wayland::protocols::output_configuration::OutputMngrInstanceData
+        ] => $crate::wayland::protocols::output_configuration::OutputConfigurationState<Self>);
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::output_management::v1::server::zwlr_output_head_v1::ZwlrOutputHeadV1: smithay::wayland::output::Output
+        ] => $crate::wayland::protocols::output_configuration::OutputConfigurationState<Self>);
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::output_management::v1::server::zwlr_output_mode_v1::ZwlrOutputModeV1: smithay::wayland::output::Mode
+        ] => $crate::wayland::protocols::output_configuration::OutputConfigurationState<Self>);
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::output_management::v1::server::zwlr_output_configuration_v1::ZwlrOutputConfigurationV1: $crate::wayland::protocols::output_configuration::PendingConfiguration
+        ] => $crate::wayland::protocols::output_configuration::OutputConfigurationState<Self>);
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::output_management::v1::server::zwlr_output_configuration_head_v1::ZwlrOutputConfigurationHeadV1: $crate::wayland::protocols::output_configuration::PendingOutputConfiguration
+        ] => $crate::wayland::protocols::output_configuration::OutputConfigurationState<Self>);
+    };
+}
+pub(crate) use delegate_output_configuration;

src/wayland/protocols/toplevel_info.rs

@@ -0,0 +1,381 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+use std::sync::Mutex;
+
+use smithay::{
+    desktop::Window,
+    reexports::{
+        wayland_server::{
+            Client, DataInit,
+            DisplayHandle, Resource, New,
+            GlobalDispatch, Dispatch,
+            DelegateGlobalDispatch, DelegateDispatch,
+            backend::{ClientId, GlobalId, ObjectId},
+        },
+        wayland_protocols::xdg::shell::server::xdg_toplevel,
+    },
+    wayland::{
+        compositor::with_states,
+        output::Output,
+        shell::xdg::XdgToplevelSurfaceRoleAttributes,
+    },
+    utils::IsAlive,
+};
+
+use super::workspace::{WorkspaceHandler, WorkspaceHandle, WorkspaceState};
+
+use cosmic_protocols::{
+    toplevel_info::v1::server::{
+        zcosmic_toplevel_info_v1::{self, ZcosmicToplevelInfoV1},
+        zcosmic_toplevel_handle_v1::{self, ZcosmicToplevelHandleV1, State as States},
+    },
+};
+
+pub struct ToplevelInfoState<D> {
+    dh: DisplayHandle,
+    toplevels: Vec<Window>,
+    instances: Vec<ZcosmicToplevelInfoV1>,
+    global: GlobalId,
+    _dispatch_data: std::marker::PhantomData<D>,
+}
+
+pub trait ToplevelInfoHandler: WorkspaceHandler + Sized {
+    fn toplevel_info_state(&self) -> &ToplevelInfoState<Self>;
+    fn toplevel_info_state_mut(&mut self) -> &mut ToplevelInfoState<Self>;
+}
+
+pub struct ToplevelInfoGlobalData {
+    filter: Box<dyn for<'a> Fn(&'a Client) -> bool + Send + Sync>,
+}
+
+#[derive(Default)]
+struct ToplevelStateInner {
+    instances: Vec<ZcosmicToplevelHandleV1>,
+    outputs: Vec<Output>,
+    workspaces: Vec<WorkspaceHandle>,
+    minimized: bool,
+}
+type ToplevelState = Mutex<ToplevelStateInner>;
+
+#[derive(Default)]
+pub struct ToplevelHandleStateInner {
+    outputs: Vec<Output>,
+    workspaces: Vec<WorkspaceHandle>,
+    title: String,
+    app_id: String,
+    states: Vec<States>,
+}
+pub type ToplevelHandleState = Mutex<ToplevelHandleStateInner>;
+
+impl<D> DelegateGlobalDispatch<ZcosmicToplevelInfoV1, ToplevelInfoGlobalData, D> for ToplevelInfoState<D>
+where
+    D: GlobalDispatch<ZcosmicToplevelInfoV1, ToplevelInfoGlobalData>
+        + Dispatch<ZcosmicToplevelInfoV1, ()>
+        + Dispatch<ZcosmicToplevelHandleV1, ToplevelHandleState>
+        + ToplevelInfoHandler
+        + 'static
+{
+    fn bind(
+        state: &mut D,
+        dh: &DisplayHandle,
+        _client: &Client,
+        resource: New<ZcosmicToplevelInfoV1>,
+        _global_data: &ToplevelInfoGlobalData,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        let instance = data_init.init(resource, ());
+        for window in &state.toplevel_info_state().toplevels {
+            send_toplevel_to_client::<D>(dh, Some(state.workspace_state()), &instance, window);
+        }
+    }
+
+    fn can_view(client: Client, global_data: &ToplevelInfoGlobalData) -> bool {
+        (global_data.filter)(&client)
+    }
+}
+
+impl<D> DelegateDispatch<ZcosmicToplevelInfoV1, (), D> for ToplevelInfoState<D>
+where
+    D: GlobalDispatch<ZcosmicToplevelInfoV1, ToplevelInfoGlobalData>
+        + Dispatch<ZcosmicToplevelInfoV1, ()>
+        + Dispatch<ZcosmicToplevelHandleV1, ToplevelHandleState>
+        + ToplevelInfoHandler
+        + 'static
+{
+    fn request(
+        state: &mut D,
+        _client: &Client,
+        obj: &ZcosmicToplevelInfoV1,
+        request: zcosmic_toplevel_info_v1::Request,
+        _data: &(),
+        _dh: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        match request {
+            zcosmic_toplevel_info_v1::Request::Stop => {
+                state.toplevel_info_state_mut().instances.retain(|i| i != obj);
+            },
+            _ => {},
+        }
+    }
+
+    fn destroyed(
+        state: &mut D, 
+        _client: ClientId, 
+        resource: ObjectId, 
+        _data: &(),
+    ) {
+        state.toplevel_info_state_mut().instances.retain(|i| i.id() != resource);
+    }
+}
+
+impl<D> DelegateDispatch<ZcosmicToplevelHandleV1, ToplevelHandleState, D> for ToplevelInfoState<D>
+where
+    D: GlobalDispatch<ZcosmicToplevelInfoV1, ToplevelInfoGlobalData>
+        + Dispatch<ZcosmicToplevelInfoV1, ()>
+        + Dispatch<ZcosmicToplevelHandleV1, ToplevelHandleState>
+        + ToplevelInfoHandler
+        + 'static
+{
+    fn request(
+        _state: &mut D,
+        _client: &Client,
+        _obj: &ZcosmicToplevelHandleV1,
+        request: zcosmic_toplevel_handle_v1::Request,
+        _data: &ToplevelHandleState,
+        _dh: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        match request {
+            zcosmic_toplevel_handle_v1::Request::Destroy => {},
+            _ => {},
+        }
+    }
+
+    fn destroyed(
+        state: &mut D, 
+        _client: ClientId, 
+        resource: ObjectId, 
+        _data: &ToplevelHandleState,
+    ) {
+        for toplevel in &state.toplevel_info_state_mut().toplevels {
+            if let Some(state) = toplevel.user_data().get::<ToplevelState>() {
+                state.lock().unwrap().instances.retain(|i| i.id() != resource);
+            }
+        }
+    }
+}
+
+impl<D> ToplevelInfoState<D>
+where
+    D: GlobalDispatch<ZcosmicToplevelInfoV1, ToplevelInfoGlobalData>
+        + Dispatch<ZcosmicToplevelInfoV1, ()>
+        + Dispatch<ZcosmicToplevelHandleV1, ToplevelHandleState>
+        + ToplevelInfoHandler
+        + 'static,
+{
+    pub fn new<F>(
+        dh: &DisplayHandle,
+        client_filter: F,
+    ) -> ToplevelInfoState<D>
+    where
+       F: for<'a> Fn(&'a Client) -> bool + Send + Sync + 'static
+    {
+        let global = dh.create_global::<D, ZcosmicToplevelInfoV1, _>(1, ToplevelInfoGlobalData {
+            filter: Box::new(client_filter),
+        });
+        ToplevelInfoState {
+            dh: dh.clone(),
+            toplevels: Vec::new(),
+            instances: Vec::new(),
+            global,
+            _dispatch_data: std::marker::PhantomData,
+        }
+    }
+
+    pub fn new_toplevel(&mut self, toplevel: &Window) {
+        toplevel.user_data().insert_if_missing(ToplevelState::default);
+        for instance in &self.instances {
+            send_toplevel_to_client::<D>(&self.dh, None, instance, toplevel);
+        }
+        self.toplevels.push(toplevel.clone());
+    }
+
+    pub fn toplevel_enter_output(&mut self, toplevel: &Window, output: &Output) {
+        if let Some(state) = toplevel.user_data().get::<ToplevelState>() {
+            state.lock().unwrap().outputs.push(output.clone());
+        }
+    }
+
+    pub fn toplevel_leave_output(&mut self, toplevel: &Window, output: &Output) {
+        if let Some(state) = toplevel.user_data().get::<ToplevelState>() {
+            state.lock().unwrap().outputs.retain(|o| o != output);
+        }
+    }
+
+    pub fn toplevel_enter_workspace(&mut self, toplevel: &Window, workspace: &WorkspaceHandle) {
+        if let Some(state) = toplevel.user_data().get::<ToplevelState>() {
+            state.lock().unwrap().workspaces.push(workspace.clone());
+        }
+    }
+
+    pub fn toplevel_leave_workspace(&mut self, toplevel: &Window, workspace: &WorkspaceHandle) {
+        if let Some(state) = toplevel.user_data().get::<ToplevelState>() {
+            state.lock().unwrap().workspaces.retain(|w| w != workspace);
+        }
+    }
+
+    pub fn refresh(&mut self, workspace_state: Option<&WorkspaceState<D>>) {
+        self.toplevels.retain(|window| {
+            if window.alive() {
+                for instance in &self.instances {
+                    send_toplevel_to_client::<D>(&self.dh, workspace_state, instance, window);
+                }
+                true
+            } else {
+                let state = window.user_data().get::<ToplevelState>().unwrap().lock().unwrap();
+                for handle in &state.instances {
+                    // don't send events to stopped instances
+                    if self.instances.iter().any(|i| i.id().same_client_as(&handle.id())) {
+                        handle.closed();
+                    }
+                }
+                false
+            }
+        });
+    }
+
+    pub fn global_id(&self) -> GlobalId {
+        self.global.clone()
+    }
+}
+
+fn send_toplevel_to_client<D>(dh: &DisplayHandle, workspace_state: Option<&WorkspaceState<D>>, info: &ZcosmicToplevelInfoV1, window: &Window)
+where
+    D: GlobalDispatch<ZcosmicToplevelInfoV1, ToplevelInfoGlobalData>
+        + Dispatch<ZcosmicToplevelInfoV1, ()>
+        + Dispatch<ZcosmicToplevelHandleV1, ToplevelHandleState>
+        + ToplevelInfoHandler
+        + 'static,
+{
+    let mut state = window.user_data().get::<ToplevelState>().unwrap().lock().unwrap();
+    let instance = match state.instances.iter().find(|i| i.id().same_client_as(&info.id())) {
+        Some(i) => i,
+        None => {
+            if let Ok(client) = dh.get_client(info.id()) {
+                if let Ok(toplevel_handle) = client.create_resource::<ZcosmicToplevelHandleV1, _, D>(dh, info.version(), ToplevelHandleState::default()) {
+                    state.instances.push(toplevel_handle);
+                    state.instances.last().unwrap()
+                } else {
+                    return;
+                }
+            } else {
+                return;
+            }
+        }
+    };
+
+    let mut handle_state = instance.data::<ToplevelHandleState>().unwrap().lock().unwrap();
+    let mut changed = false;
+    with_states(window.toplevel().wl_surface(), |states| {
+        let attributes = states
+            .data_map
+            .get::<Mutex<XdgToplevelSurfaceRoleAttributes>>()
+            .unwrap()
+            .lock()
+            .unwrap();
+        
+        if handle_state.title != attributes.title.as_deref().unwrap_or(&"") {
+            handle_state.title = attributes.title.clone().unwrap_or_else(String::new);
+            instance.title(handle_state.title.clone());
+            changed = true;
+        }
+        if handle_state.app_id != attributes.app_id.as_deref().unwrap_or(&"") {
+            handle_state.title = attributes.app_id.clone().unwrap_or_else(String::new);
+            instance.app_id(handle_state.app_id.clone());
+            changed = true;
+        }
+
+        if (handle_state.states.contains(&States::Maximized) != attributes.current.states.contains(xdg_toplevel::State::Maximized))
+        || (handle_state.states.contains(&States::Fullscreen) != attributes.current.states.contains(xdg_toplevel::State::Fullscreen))
+        || (handle_state.states.contains(&States::Activated) != attributes.current.states.contains(xdg_toplevel::State::Activated))
+        || (handle_state.states.contains(&States::Minimized) != state.minimized) {    
+            let mut states = Vec::new();
+            if attributes.current.states.contains(xdg_toplevel::State::Maximized) {
+                states.push(States::Maximized);
+            }
+            if attributes.current.states.contains(xdg_toplevel::State::Fullscreen) {
+                states.push(States::Fullscreen);
+            }
+            if attributes.current.states.contains(xdg_toplevel::State::Activated) {
+                states.push(States::Activated);
+            }
+            if attributes.current.states.contains(xdg_toplevel::State::Maximized) {
+                states.push(States::Maximized);
+            }
+            handle_state.states = states.clone();
+
+            let states: Vec<u8> = {
+                let ratio = std::mem::size_of::<States>() / std::mem::size_of::<u8>();
+                let ptr = states.as_mut_ptr() as *mut u8;
+                let len = states.len() * ratio;
+                let cap = states.capacity() * ratio;
+                std::mem::forget(states);
+                unsafe { Vec::from_raw_parts(ptr, len, cap) }
+            };
+            instance.state(states);
+            changed = true;
+        }
+    });
+
+    if let Ok(client) = dh.get_client(instance.id()) {
+        for new_output in state.outputs.iter().filter(|o| !handle_state.outputs.contains(o)) {
+            new_output.with_client_outputs(dh, &client, |_dh, wl_output| {
+                instance.output_enter(wl_output);
+            });
+            changed = true;
+        }
+        for old_output in handle_state.outputs.iter().filter(|o| !state.outputs.contains(o)) {
+            old_output.with_client_outputs(dh, &client, |_dh, wl_output| {
+                instance.output_leave(wl_output);
+            });
+            changed = true;
+        }
+        handle_state.outputs = state.outputs.clone();
+    }
+
+    if let Some(workspace_state) = workspace_state {
+        for new_workspace in state.workspaces.iter().filter(|w| !handle_state.workspaces.contains(w)) {
+            if let Some(handle) = workspace_state.raw_workspace_handle(&new_workspace, &instance.id()) {
+                instance.workspace_enter(&handle);
+                changed = true;
+            }
+        }
+        for old_workspace in handle_state.workspaces.iter().filter(|w| !state.workspaces.contains(w)) {
+            if let Some(handle) = workspace_state.raw_workspace_handle(&old_workspace, &instance.id()) {
+                instance.workspace_leave(&handle);
+                changed = true;
+            }
+        }
+        handle_state.workspaces = state.workspaces.clone();
+    }
+
+    if changed {
+        instance.done();
+    }
+}
+
+macro_rules! delegate_toplevel_info {
+    ($(@<$( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+>)? $ty: ty) => {
+        smithay::reexports::wayland_server::delegate_global_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            cosmic_protocols::toplevel_info::v1::server::zcosmic_toplevel_info_v1::ZcosmicToplevelInfoV1: $crate::wayland::protocols::toplevel_info::ToplevelInfoGlobalData
+        ] => $crate::wayland::protocols::toplevel_info::ToplevelInfoState<Self>);
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            cosmic_protocols::toplevel_info::v1::server::zcosmic_toplevel_info_v1::ZcosmicToplevelInfoV1: ()
+        ] => $crate::wayland::protocols::toplevel_info::ToplevelInfoState<Self>);
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            cosmic_protocols::toplevel_info::v1::server::zcosmic_toplevel_handle_v1::ZcosmicToplevelHandleV1: $crate::wayland::protocols::toplevel_info::ToplevelHandleState
+        ] => $crate::wayland::protocols::toplevel_info::ToplevelInfoState<Self>);
+    };
+}
+pub(crate) use delegate_toplevel_info;

src/wayland/protocols/workspace.rs

@@ -0,0 +1,807 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+use std::sync::Mutex;
+
+use smithay::{
+    reexports::wayland_server::{
+        Client, DataInit,
+        DisplayHandle, Resource, New,
+        GlobalDispatch, Dispatch,
+        DelegateGlobalDispatch, DelegateDispatch,
+        backend::{ClientId, ClientData, GlobalId, ObjectId},
+    },
+    wayland::output::Output,
+};
+
+use cosmic_protocols::workspace::v1::server::{
+    zcosmic_workspace_manager_v1::{self, ZcosmicWorkspaceManagerV1},
+    zcosmic_workspace_group_handle_v1::{self, ZcosmicWorkspaceGroupHandleV1},
+    zcosmic_workspace_handle_v1::{self, ZcosmicWorkspaceHandleV1},
+};
+
+pub use cosmic_protocols::workspace::v1::server::{
+    zcosmic_workspace_group_handle_v1::ZcosmicWorkspaceGroupCapabilitiesV1 as GroupCapabilities,
+    zcosmic_workspace_handle_v1::ZcosmicWorkspaceCapabilitiesV1 as WorkspaceCapabilities,
+};
+
+pub struct WorkspaceState<D>
+where
+    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
+        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
+        + Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+        + WorkspaceHandler
+        + 'static,
+    <D as WorkspaceHandler>::Client: ClientData
+        + WorkspaceClientHandler
+        + 'static,
+{
+    dh: DisplayHandle,
+    global: GlobalId,
+    instances: Vec<ZcosmicWorkspaceManagerV1>,
+    groups: Vec<WorkspaceGroup>,
+    _marker: std::marker::PhantomData<D>,
+}
+pub struct WorkspaceUpdateGuard<'a, D>(&'a mut WorkspaceState<D>)
+where
+    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
+        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
+        + Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+        + WorkspaceHandler
+        + 'static,
+    <D as WorkspaceHandler>::Client: ClientData
+        + WorkspaceClientHandler
+        + 'static
+;
+
+crate::utils::id_gen!(next_group_id, GROUP_ID, GROUP_IDS);
+crate::utils::id_gen!(next_workspace_id, WORKSPACE_ID, WORKSPACE_IDS);
+
+#[derive(Default)]
+pub struct WorkspaceGroup {
+    id: usize,
+    instances: Vec<ZcosmicWorkspaceGroupHandleV1>,
+    workspaces: Vec<Workspace>,
+    
+    outputs: Vec<Output>,
+    capabilities: Vec<GroupCapabilities>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct WorkspaceGroupHandle {
+    id: usize,
+}
+
+#[derive(Default)]
+pub struct WorkspaceGroupDataInner {
+    outputs: Vec<Output>,
+    capabilities: Vec<GroupCapabilities>,
+}
+pub type WorkspaceGroupData = Mutex<WorkspaceGroupDataInner>;
+
+#[derive(Default)]
+pub struct Workspace {
+    id: usize,
+    instances: Vec<ZcosmicWorkspaceHandleV1>,
+
+    name: String,
+    capabilities: Vec<WorkspaceCapabilities>,
+    coordinates: Vec<u32>,
+    states: Vec<zcosmic_workspace_handle_v1::State>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct WorkspaceHandle {
+    id: usize,
+}
+
+#[derive(Default)]
+pub struct WorkspaceDataInner {
+    name: String,
+    capabilities: Vec<WorkspaceCapabilities>,
+    coordinates: Vec<u32>,
+    states: Vec<zcosmic_workspace_handle_v1::State>,
+}
+pub type WorkspaceData = Mutex<WorkspaceDataInner>;
+
+pub trait WorkspaceHandler
+where
+    Self: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
+        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
+        + Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+        + Sized
+        + 'static,
+{
+    type Client: ClientData
+        + WorkspaceClientHandler
+        + 'static;
+
+    fn workspace_state(&self) -> &WorkspaceState<Self>;
+    fn workspace_state_mut(&mut self) -> &mut WorkspaceState<Self>;
+    fn commit_requests(&mut self, dh: &DisplayHandle, requests: Vec<Request>);
+}
+
+pub struct WorkspaceGlobalData {
+    filter: Box<dyn for<'a> Fn(&'a Client) -> bool + Send + Sync>,
+}
+
+#[derive(Debug)]
+pub enum Request {
+    Activate(WorkspaceHandle),
+    Deactivate(WorkspaceHandle),
+    Remove(WorkspaceHandle),
+    Create {
+        in_group: WorkspaceGroupHandle,
+        name: String,
+    },
+}
+
+#[derive(Debug, Default)]
+pub struct WorkspaceClientStateInner {
+    requests: Vec<Request>,
+}
+pub type WorkspaceClientState = Mutex<WorkspaceClientStateInner>;
+
+
+pub trait WorkspaceClientHandler {
+    fn workspace_state(&self) -> &WorkspaceClientState;
+}
+
+impl<D> DelegateGlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData, D> for WorkspaceState<D>
+where
+    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
+        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
+        + Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+        + WorkspaceHandler
+        + 'static,
+    <D as WorkspaceHandler>::Client: ClientData
+        + WorkspaceClientHandler
+        + 'static,
+{
+    fn bind(
+        state: &mut D,
+        dh: &DisplayHandle,
+        _client: &Client,
+        resource: New<ZcosmicWorkspaceManagerV1>,
+        _global_data: &WorkspaceGlobalData,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        let state = state.workspace_state_mut();
+        let instance = data_init.init(resource, ());
+        for group in &mut state.groups {
+            send_group_to_client::<D>(dh, &instance, group);
+            instance.done();
+        }
+        state.instances.push(instance);
+    }
+
+    fn can_view(client: Client, global_data: &WorkspaceGlobalData) -> bool {
+        (global_data.filter)(&client)
+    }
+}
+
+impl<D> DelegateDispatch<ZcosmicWorkspaceManagerV1, (), D> for WorkspaceState<D>
+where
+    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
+        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
+        + Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+        + WorkspaceHandler
+        + 'static,
+    <D as WorkspaceHandler>::Client: ClientData
+        + WorkspaceClientHandler
+        + 'static,
+{       
+    fn request(
+        state: &mut D,
+        client: &Client,
+        obj: &ZcosmicWorkspaceManagerV1,
+        request: zcosmic_workspace_manager_v1::Request,
+        _data: &(),
+        dh: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        match request {
+            zcosmic_workspace_manager_v1::Request::Commit => {
+                if state.workspace_state().instances.contains(obj) {
+                    let mut client_state = client.get_data::<<D as WorkspaceHandler>::Client>().unwrap().workspace_state().lock().unwrap();
+                    state.commit_requests(dh, std::mem::take(&mut client_state.requests));
+                }
+            },
+            zcosmic_workspace_manager_v1::Request::Stop => {
+                state.workspace_state_mut().instances.retain(|i| i != obj);
+                // without an instance, the whole send_group_to_client machinery doesn't work
+                // so there is no way for the whole clients hierachy to get any new events
+            },
+            _ => {},
+        }
+    }
+
+    fn destroyed(
+        state: &mut D, 
+        _client: ClientId, 
+        resource: ObjectId, 
+        _data: &(),
+    ) {
+        state.workspace_state_mut().instances.retain(|i| i.id() != resource);
+    }
+}
+
+impl<D> DelegateDispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData, D> for WorkspaceState<D>
+where
+    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
+        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
+        + Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+        + WorkspaceHandler
+        + 'static, 
+    <D as WorkspaceHandler>::Client: ClientData
+       + WorkspaceClientHandler
+        + 'static,
+{
+    fn request(
+        state: &mut D,
+        client: &Client,
+        obj: &ZcosmicWorkspaceGroupHandleV1,
+        request: zcosmic_workspace_group_handle_v1::Request,
+        _data: &WorkspaceGroupData,
+        _dh: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        match request {
+            zcosmic_workspace_group_handle_v1::Request::CreateWorkspace { workspace } => {
+                if let Some(id) = state.workspace_state().groups.iter().find(|g| g.instances.contains(obj)).map(|g| g.id) {
+                    let mut state = client.get_data::<<D as WorkspaceHandler>::Client>().unwrap().workspace_state().lock().unwrap();
+                    state.requests.push(Request::Create {
+                        in_group: WorkspaceGroupHandle { id },
+                        name: workspace,
+                    });
+                }
+            },
+            zcosmic_workspace_group_handle_v1::Request::Destroy => {
+                for group in &mut state.workspace_state_mut().groups {
+                    group.instances.retain(|i| i != obj)
+                }
+            },
+            _ => {},
+        }
+    }
+
+    fn destroyed(
+        state: &mut D, 
+        _client: ClientId, 
+        resource: ObjectId, 
+        _data: &WorkspaceGroupData,
+    ) {
+        for group in &mut state.workspace_state_mut().groups {
+            group.instances.retain(|i| i.id() != resource)
+        }
+    }
+}
+
+impl<D> DelegateDispatch<ZcosmicWorkspaceHandleV1, WorkspaceData, D> for WorkspaceState<D>
+where
+    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
+        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
+        + Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+        + WorkspaceHandler
+        + 'static,
+    <D as WorkspaceHandler>::Client: ClientData
+        + WorkspaceClientHandler
+        + 'static,
+{
+    fn request(
+        state: &mut D,
+        client: &Client,
+        obj: &ZcosmicWorkspaceHandleV1,
+        request: zcosmic_workspace_handle_v1::Request,
+        _data: &WorkspaceData,
+        _dh: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        match request {
+            zcosmic_workspace_handle_v1::Request::Activate => {
+                if let Some(id) = state.workspace_state().groups.iter()
+                    .find_map(|g| g.workspaces.iter().find(|w| w.instances.contains(obj)))
+                    .map(|w| w.id)
+                {
+                    let mut state = client.get_data::<<D as WorkspaceHandler>::Client>().unwrap().workspace_state().lock().unwrap();
+                    state.requests.push(Request::Activate(WorkspaceHandle { id }));   
+                }
+            }
+            zcosmic_workspace_handle_v1::Request::Deactivate => {
+                if let Some(id) = state.workspace_state().groups.iter()
+                    .find_map(|g| g.workspaces.iter().find(|w| w.instances.contains(obj)))
+                    .map(|w| w.id)
+                {
+                    let mut state = client.get_data::<<D as WorkspaceHandler>::Client>().unwrap().workspace_state().lock().unwrap();
+                    state.requests.push(Request::Deactivate(WorkspaceHandle { id }));   
+                }
+            }
+            zcosmic_workspace_handle_v1::Request::Remove => {
+                if let Some(id) = state.workspace_state().groups.iter()
+                    .find_map(|g| g.workspaces.iter().find(|w| w.instances.contains(obj)))
+                    .map(|w| w.id)
+                {
+                    let mut state = client.get_data::<<D as WorkspaceHandler>::Client>().unwrap().workspace_state().lock().unwrap();
+                    state.requests.push(Request::Remove(WorkspaceHandle { id }));   
+                }
+            }
+            zcosmic_workspace_handle_v1::Request::Destroy => {
+                for group in &mut state.workspace_state_mut().groups {
+                    for workspace in &mut group.workspaces {
+                        workspace.instances.retain(|i| i != obj)
+                    }
+                }
+            }
+            _ => {},
+        }
+    }
+
+    fn destroyed(
+        state: &mut D, 
+        _client: ClientId, 
+        resource: ObjectId, 
+        _data: &WorkspaceData,
+    ) {
+        for group in &mut state.workspace_state_mut().groups {
+            for workspace in &mut group.workspaces {
+                workspace.instances.retain(|i| i.id() != resource)
+            }
+        }
+    }
+}
+
+
+impl<D> WorkspaceState<D>
+where
+    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
+        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
+        + Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+        + WorkspaceHandler
+        + 'static,
+    <D as WorkspaceHandler>::Client: ClientData
+        + WorkspaceClientHandler
+        + 'static,
+{
+    pub fn new<F>(
+        dh: &DisplayHandle,
+        client_filter: F,
+    ) -> WorkspaceState<D>
+    where    
+        F: for<'a> Fn(&'a Client) -> bool + Send + Sync + 'static,
+    {
+        let global = dh.create_global::<D, ZcosmicWorkspaceManagerV1, _>(1, WorkspaceGlobalData {
+            filter: Box::new(client_filter),
+        });
+
+        WorkspaceState {
+            dh: dh.clone(),
+            global,
+            instances: Vec::new(),
+            groups: Vec::new(),
+            _marker: std::marker::PhantomData,
+        }
+    }
+   
+    pub fn workspace_belongs_to_group(&self, group: &WorkspaceGroupHandle, workspace: &WorkspaceHandle) -> bool {
+        if let Some(group) = self.groups.iter().find(|g| g.id == group.id) {
+            group.workspaces.iter().any(|w| w.id == workspace.id)
+        } else {
+            false
+        }
+    }
+
+    pub fn group_capabilities(&self, group: &WorkspaceGroupHandle) -> Option<impl Iterator<Item=&GroupCapabilities>> {
+        self.groups.iter().find(|g| g.id == group.id).map(|g| g.capabilities.iter())
+    }
+
+    pub fn group_outputs(&self, group: &WorkspaceGroupHandle) -> Option<impl Iterator<Item=&Output>> {
+        self.groups.iter().find(|g| g.id == group.id).map(|g| g.outputs.iter())
+    }
+    
+    pub fn workspace_capabilities(&self, workspace: &WorkspaceHandle) -> Option<impl Iterator<Item=&WorkspaceCapabilities>> {
+        self.groups.iter().find_map(|g| g.workspaces.iter().find(|w| w.id == workspace.id).map(|w| w.capabilities.iter()))
+    }
+
+    pub fn workspace_name(&self, workspace: &WorkspaceHandle) -> Option<&str> {
+        self.groups.iter().find_map(|g| g.workspaces.iter().find(|w| w.id == workspace.id).map(|w| &*w.name))
+    }
+
+    pub fn workspace_coordinates(&self, workspace: &WorkspaceHandle) -> Option<&[u32]> {
+        self.groups.iter().find_map(|g| g.workspaces.iter().find(|w| w.id == workspace.id).map(|w| &*w.coordinates))
+    }
+
+    pub fn workspace_states(&self, workspace: &WorkspaceHandle) -> Option<impl Iterator<Item=&zcosmic_workspace_handle_v1::State>> {
+        self.groups.iter().find_map(|g| g.workspaces.iter().find(|w| w.id == workspace.id).map(|w| w.states.iter()))
+    }
+
+    pub fn raw_group_handle(&self, group: &WorkspaceGroupHandle, client: &ObjectId) -> Option<ZcosmicWorkspaceGroupHandleV1> {
+        self.groups.iter()
+            .find(|g| g.id == group.id)
+            .and_then(|g| g.instances.iter().find(|i| i.id().same_client_as(client)))
+            .cloned()
+    }
+    pub fn raw_workspace_handle(&self, workspace: &WorkspaceHandle, client: &ObjectId) -> Option<ZcosmicWorkspaceHandleV1> {
+        self.groups.iter()
+            .find_map(|g| g.workspaces.iter().find(|w| w.id == workspace.id))
+            .and_then(|w| w.instances.iter().find(|i| i.id().same_client_as(client)))
+            .cloned()
+    }
+
+    pub fn update<'a>(&'a mut self) -> WorkspaceUpdateGuard<'a, D> {
+        WorkspaceUpdateGuard(self)
+    }
+
+    fn done(&mut self) {
+        let mut changed = false;
+        for instance in &self.instances {
+            for mut group in &mut self.groups {
+                if send_group_to_client::<D>(&self.dh, instance, &mut group) {
+                    changed = true;
+                }
+            }
+        }
+        if changed {
+            for instance in &self.instances {
+                instance.done();
+            }
+        }
+    }
+
+    pub fn global_id(&self) -> GlobalId {
+        self.global.clone()
+    }
+}
+
+impl<'a, D> WorkspaceUpdateGuard<'a, D>
+where
+    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
+        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
+        + Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+        + WorkspaceHandler
+        + 'static,
+    <D as WorkspaceHandler>::Client: ClientData
+        + WorkspaceClientHandler
+        + 'static,
+{
+    pub fn create_workspace_group(&mut self) -> WorkspaceGroupHandle {
+        let id = next_group_id();
+        let group = WorkspaceGroup {
+            id,
+            ..Default::default()
+        };
+        self.0.groups.push(group);
+        WorkspaceGroupHandle {
+            id
+        }
+    }
+
+    pub fn create_workspace(&mut self, group: &WorkspaceGroupHandle) -> Option<WorkspaceHandle> {
+        if let Some(group) = self.0.groups.iter_mut().find(|g| g.id == group.id) {
+            let id = next_workspace_id();
+            let workspace = Workspace {
+                id,
+                ..Default::default()
+            };
+            group.workspaces.push(workspace);
+            Some(WorkspaceHandle {
+                id
+            })
+        } else {
+            None
+        }
+    }
+
+    pub fn remove_workspace_group(&mut self, group: WorkspaceGroupHandle) {
+        // "The compositor must remove all workspaces belonging to a workspace group before removing the workspace group."
+        for workspace in self.0.groups.iter()
+            .filter(|g| g.id == group.id)
+            .flat_map(|g| g.workspaces.iter().map(|w| WorkspaceHandle { id: w.id }))
+            .collect::<Vec<_>>().into_iter()
+        {
+            self.remove_workspace(workspace);
+        }
+
+        if let Some(group) = self.0.groups.iter().find(|g| g.id == group.id) {
+            for instance in &group.instances {
+                instance.remove()
+            }
+        }
+        self.0.groups.retain(|g| g.id != group.id);
+        GROUP_IDS.lock().unwrap().remove(&group.id);
+    }
+
+    pub fn remove_workspace(&mut self, workspace: WorkspaceHandle) { 
+        for group in &mut self.0.groups {
+            if let Some(workspace) = group.workspaces.iter().find(|w| w.id == workspace.id) {
+                for instance in &workspace.instances {
+                    instance.remove();
+                }
+            }
+            group.workspaces.retain(|w| w.id != workspace.id);
+        }
+        WORKSPACE_IDS.lock().unwrap().remove(&workspace.id);
+    }
+    
+    pub fn workspace_belongs_to_group(&self, group: &WorkspaceGroupHandle, workspace: &WorkspaceHandle) -> bool {
+        self.0.workspace_belongs_to_group(group, workspace)
+    }
+    
+    pub fn group_capabilities(&mut self, group: &WorkspaceGroupHandle) -> Option<impl Iterator<Item=&GroupCapabilities>> {
+        self.0.group_capabilities(group)
+    }
+
+    pub fn set_group_capabilities(&mut self, group: &WorkspaceGroupHandle, capabilities: impl Iterator<Item=GroupCapabilities>) {
+        if let Some(group) = self.0.groups.iter_mut().find(|g| g.id == group.id) {
+            group.capabilities = capabilities.collect();
+        }
+    }
+
+    pub fn group_outputs(&self, group: &WorkspaceGroupHandle) -> Option<impl Iterator<Item=&Output>> {
+        self.0.group_outputs(group)
+    }
+
+    pub fn add_group_output(&mut self, group: &WorkspaceGroupHandle, output: &Output) {
+        if let Some(group) = self.0.groups.iter_mut().find(|g| g.id == group.id) {
+            group.outputs.push(output.clone())
+        }
+    }
+
+    pub fn remove_group_output(&mut self, group: &WorkspaceGroupHandle, output: &Output) {
+        if let Some(group) = self.0.groups.iter_mut().find(|g| g.id == group.id) {
+            group.outputs.retain(|o| o != output)
+        }
+    }
+    
+    pub fn workspace_capabilities(&self, workspace: &WorkspaceHandle) -> Option<impl Iterator<Item=&WorkspaceCapabilities>> {
+        self.0.workspace_capabilities(workspace)
+    }
+
+    pub fn set_workspace_capabilities(&mut self, workspace: &WorkspaceHandle, capabilities: impl Iterator<Item=WorkspaceCapabilities>) {
+        if let Some(workspace) = self.0.groups.iter_mut()
+            .find_map(|g| g.workspaces.iter_mut().find(|w| w.id == workspace.id))
+        {
+            workspace.capabilities = capabilities.collect();
+        }
+    }
+
+    pub fn workspace_name(&self, workspace: &WorkspaceHandle) -> Option<&str> {
+        self.0.workspace_name(workspace)
+    }
+
+    pub fn set_workspace_name(&mut self, workspace: &WorkspaceHandle, name: impl Into<String>) {
+        if let Some(workspace) = self.0.groups.iter_mut()
+            .find_map(|g| g.workspaces.iter_mut().find(|w| w.id == workspace.id))
+        {
+            workspace.name = name.into();
+        }
+    }
+
+    pub fn workspace_coordinates(&self, workspace: &WorkspaceHandle) -> Option<&[u32]> {
+        self.0.workspace_coordinates(workspace)
+    }
+
+    pub fn set_workspace_coordinates(&mut self, workspace: &WorkspaceHandle, coords: [Option<u32>; 3]) {
+        if let Some(workspace) = self.0.groups.iter_mut()
+            .find_map(|g| g.workspaces.iter_mut().find(|w| w.id == workspace.id))
+        {
+            workspace.coordinates = coords.iter().flat_map(std::convert::identity).copied().collect();
+        }
+    }
+
+    pub fn workspace_states(&self, workspace: &WorkspaceHandle) -> Option<impl Iterator<Item=&zcosmic_workspace_handle_v1::State>> {
+        self.0.workspace_states(workspace)
+    }
+
+    pub fn add_workspace_state(&mut self, workspace: &WorkspaceHandle, state: zcosmic_workspace_handle_v1::State) {
+        if let Some(workspace) = self.0.groups.iter_mut()
+            .find_map(|g| g.workspaces.iter_mut().find(|w| w.id == workspace.id))
+        {
+            workspace.states.push(state);
+        }
+    }
+
+    pub fn remove_workspace_state(&mut self, workspace: &WorkspaceHandle, state: zcosmic_workspace_handle_v1::State) {
+        if let Some(workspace) = self.0.groups.iter_mut()
+            .find_map(|g| g.workspaces.iter_mut().find(|w| w.id == workspace.id))
+        {
+            workspace.states.retain(|s| *s != state);
+        }
+    }
+}
+
+impl<'a, D> Drop for WorkspaceUpdateGuard<'a, D>
+where
+    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
+        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
+        + Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+        + WorkspaceHandler
+        + 'static,
+    <D as WorkspaceHandler>::Client: ClientData
+        + WorkspaceClientHandler
+        + 'static,
+{
+    fn drop(&mut self) {
+        self.0.done();
+    }
+}
+
+fn send_group_to_client<D>(dh: &DisplayHandle, mngr: &ZcosmicWorkspaceManagerV1, group: &mut WorkspaceGroup) -> bool
+where
+    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
+        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
+        + Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+        + WorkspaceHandler
+        + 'static,
+    <D as WorkspaceHandler>::Client: ClientData
+        + WorkspaceClientHandler
+        + 'static,
+{
+    let instance = match group.instances.iter_mut().find(|i| i.id().same_client_as(&mngr.id())) {
+        Some(i) => i,
+        None => {
+            if let Ok(client) = dh.get_client(mngr.id()) {
+                if let Ok(handle) = client.create_resource::<ZcosmicWorkspaceGroupHandleV1, _, D>(dh, mngr.version(), WorkspaceGroupData::default()) {
+                    mngr.workspace_group(&handle);
+                    group.instances.push(handle);
+                    group.instances.last_mut().unwrap()
+                } else {
+                    return false;
+                }
+            } else {
+                return false;
+            }
+        }
+    };
+
+    let mut handle_state = instance.data::<WorkspaceGroupData>().unwrap().lock().unwrap();
+    let mut changed = false;
+    if let Ok(client) = dh.get_client(instance.id()) {
+        for new_output in group.outputs.iter().filter(|o| !handle_state.outputs.contains(o)) {
+            new_output.with_client_outputs(dh, &client, |_dh, wl_output| {
+                instance.output_enter(wl_output);
+            });
+            changed = true;
+        }
+        for old_output in handle_state.outputs.iter().filter(|o| group.outputs.contains(o)) {
+            old_output.with_client_outputs(dh, &client, |_dh, wl_output| {
+                instance.output_leave(wl_output);
+            });
+            changed = true;
+        }
+        handle_state.outputs = group.outputs.clone();
+    }
+
+    if handle_state.capabilities != group.capabilities {
+        let caps: Vec<u8> = {
+            let mut caps = group.capabilities.clone();
+            let ratio = std::mem::size_of::<GroupCapabilities>() / std::mem::size_of::<u8>();
+            let ptr = caps.as_mut_ptr() as *mut u8;
+            let len = caps.len() * ratio;
+            let cap = caps.capacity() * ratio;
+            std::mem::forget(caps);
+            unsafe { Vec::from_raw_parts(ptr, len, cap) }
+        };
+        instance.capabilities(caps);
+        handle_state.capabilities = group.capabilities.clone();
+        changed = true;
+    }
+
+    for workspace in &mut group.workspaces {
+        if send_workspace_to_client::<D>(dh, instance, workspace) {
+            changed = true;
+        }
+    }
+
+    changed
+}
+
+fn send_workspace_to_client<D>(dh: &DisplayHandle, group: &ZcosmicWorkspaceGroupHandleV1, workspace: &mut Workspace) -> bool
+where
+    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
+        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
+        + Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+        + WorkspaceHandler
+        + 'static,
+    <D as WorkspaceHandler>::Client: ClientData
+        + WorkspaceClientHandler
+        + 'static,
+{
+    let instance = match workspace.instances.iter_mut().find(|i| i.id().same_client_as(&group.id())) {
+        Some(i) => i,
+        None => {
+            if let Ok(client) = dh.get_client(group.id()) {
+                if let Ok(handle) = client.create_resource::<ZcosmicWorkspaceHandleV1, _, D>(dh, group.version(), WorkspaceData::default()) {
+                    group.workspace(&handle);
+                    workspace.instances.push(handle);
+                    workspace.instances.last_mut().unwrap()
+                } else {
+                    return false;
+                }
+            } else {
+                return false;
+            }
+        }
+    };
+
+    let mut handle_state = instance.data::<WorkspaceData>().unwrap().lock().unwrap();
+    let mut changed = false;
+    
+    if handle_state.name != workspace.name {
+        instance.name(workspace.name.clone());
+        handle_state.name = workspace.name.clone();
+        changed = true;
+    }
+    if handle_state.coordinates != workspace.coordinates {
+        let coords: Vec<u8> = {
+            let mut coords = workspace.coordinates.clone();
+            let ratio = std::mem::size_of::<u32>() / std::mem::size_of::<u8>();
+            let ptr = coords.as_mut_ptr() as *mut u8;
+            let len = coords.len() * ratio;
+            let cap = coords.capacity() * ratio;
+            std::mem::forget(coords);
+            unsafe { Vec::from_raw_parts(ptr, len, cap) }
+        };
+        instance.coordinates(coords);
+        handle_state.coordinates = workspace.coordinates.clone();
+        changed = true;
+    }
+    if handle_state.capabilities != workspace.capabilities {
+        let caps: Vec<u8> = {
+            let mut caps = workspace.capabilities.clone();
+            let ratio = std::mem::size_of::<WorkspaceCapabilities>() / std::mem::size_of::<u8>();
+            let ptr = caps.as_mut_ptr() as *mut u8;
+            let len = caps.len() * ratio;
+            let cap = caps.capacity() * ratio;
+            std::mem::forget(caps);
+            unsafe { Vec::from_raw_parts(ptr, len, cap) }
+        };
+        instance.capabilities(caps);
+        handle_state.capabilities = workspace.capabilities.clone();
+        changed = true;
+    }
+    if handle_state.states != workspace.states {
+        let states: Vec<u8> = {
+            let mut states = workspace.states.clone();
+            let ratio = std::mem::size_of::<zcosmic_workspace_handle_v1::State>() / std::mem::size_of::<u8>();
+            let ptr = states.as_mut_ptr() as *mut u8;
+            let len = states.len() * ratio;
+            let cap = states.capacity() * ratio;
+            std::mem::forget(states);
+            unsafe { Vec::from_raw_parts(ptr, len, cap) }
+        };
+        instance.state(states);
+        handle_state.states = workspace.states.clone();
+        changed = true;
+    }
+
+    changed
+}
+
+macro_rules! delegate_workspace {
+    ($(@<$( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+>)? $ty: ty) => {
+        smithay::reexports::wayland_server::delegate_global_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            cosmic_protocols::workspace::v1::server::zcosmic_workspace_manager_v1::ZcosmicWorkspaceManagerV1: $crate::wayland::protocols::workspace::WorkspaceGlobalData
+        ] => $crate::wayland::protocols::workspace::WorkspaceState<Self>);
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            cosmic_protocols::workspace::v1::server::zcosmic_workspace_manager_v1::ZcosmicWorkspaceManagerV1: ()
+        ] => $crate::wayland::protocols::workspace::WorkspaceState<Self>);
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            cosmic_protocols::workspace::v1::server::zcosmic_workspace_group_handle_v1::ZcosmicWorkspaceGroupHandleV1: $crate::wayland::protocols::workspace::WorkspaceGroupData
+        ] => $crate::wayland::protocols::workspace::WorkspaceState<Self>);
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            cosmic_protocols::workspace::v1::server::zcosmic_workspace_handle_v1::ZcosmicWorkspaceHandleV1: $crate::wayland::protocols::workspace::WorkspaceData
+        ] => $crate::wayland::protocols::workspace::WorkspaceState<Self>);
+    };
+}
+pub(crate) use delegate_workspace;