cosmic-comp/src/wayland/protocols/workspace.rs

// 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;