protocol/workspace: Drop support for cosmic v1 protocol

Clients have been updated to use ext-workspace-v1 and
cosmic-workspace-v2.

Removing this should save some duplication of having to update both
cosmic workspace v1 and ext workspace code, and should help with things
like using the same workspace handle when a workspace moves to a
different group (which is something that was changed before the final
version of the ext-workspace-v1 protocol.)

src/wayland/protocols/toplevel_info.rs

@@ -593,10 +593,6 @@ where
         .iter()
         .filter(|w| !handle_state.workspaces.contains(w))
     {
-        for handle in workspace_state.raw_workspace_handles(&new_workspace, &instance.id()) {
-            instance.workspace_enter(&handle);
-            changed = true;
-        }
         for handle in workspace_state.raw_ext_workspace_handles(&new_workspace, &instance.id()) {
             instance.ext_workspace_enter(&handle);
             changed = true;
@@ -607,10 +603,6 @@ where
         .iter()
         .filter(|w| !state.workspaces.contains(w))
     {
-        for handle in workspace_state.raw_workspace_handles(&old_workspace, &instance.id()) {
-            instance.workspace_leave(&handle);
-            changed = true;
-        }
         for handle in workspace_state.raw_ext_workspace_handles(&old_workspace, &instance.id()) {
             instance.ext_workspace_leave(&handle);
             changed = true;

src/wayland/protocols/toplevel_management.rs

@@ -249,20 +249,7 @@ where
                     }
                 }
             }
-            zcosmic_toplevel_manager_v1::Request::MoveToWorkspace {
+            zcosmic_toplevel_manager_v1::Request::MoveToWorkspace { .. } => {}
-                toplevel,
-                workspace,
-                output,
-            } => {
-                let window = window_from_handle(toplevel).unwrap();
-                if let Some(workspace_handle) =
-                    state.workspace_state().get_workspace_handle(&workspace)
-                {
-                    if let Some(output) = Output::from_resource(&output) {
-                        state.move_to_workspace(dh, &window, workspace_handle, output);
-                    }
-                }
-            }
             zcosmic_toplevel_manager_v1::Request::MoveToExtWorkspace {
                 toplevel,
                 workspace,

src/wayland/protocols/workspace/cosmic.rs

@@ -1,532 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-
-use smithay::{
-    reexports::wayland_protocols::ext::workspace::v1::server::ext_workspace_handle_v1,
-    reexports::wayland_server::{
-        backend::{ClientData, ClientId},
-        Client, DataInit, Dispatch, DisplayHandle, GlobalDispatch, New, Resource, WEnum,
-    },
-};
-
-use std::sync::Mutex;
-
-use super::{
-    GroupCapabilities, Request, Workspace, WorkspaceCapabilities, WorkspaceClientHandler,
-    WorkspaceGlobalData, WorkspaceGroup, WorkspaceGroupData, WorkspaceGroupHandle,
-    WorkspaceHandler, WorkspaceState,
-};
-
-use cosmic_protocols::workspace::{
-    v1::server::{
-        zcosmic_workspace_group_handle_v1::{self, ZcosmicWorkspaceGroupHandleV1},
-        zcosmic_workspace_handle_v1::{self, ZcosmicWorkspaceHandleV1},
-        zcosmic_workspace_manager_v1::{self, ZcosmicWorkspaceManagerV1},
-    },
-    v2::server::zcosmic_workspace_handle_v2,
-};
-
-#[derive(Default)]
-pub struct CosmicWorkspaceV1DataInner {
-    name: String,
-    capabilities: Option<WorkspaceCapabilities>,
-    coordinates: Vec<u32>,
-    states: Option<ext_workspace_handle_v1::State>,
-    tiling: Option<zcosmic_workspace_handle_v2::TilingState>,
-}
-
-pub type CosmicWorkspaceV1Data = Mutex<CosmicWorkspaceV1DataInner>;
-
-impl<D> GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData, D> for WorkspaceState<D>
-where
-    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
-        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
-        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
-        + Dispatch<ZcosmicWorkspaceHandleV1, CosmicWorkspaceV1Data>
-        + 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> Dispatch<ZcosmicWorkspaceManagerV1, (), D> for WorkspaceState<D>
-where
-    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
-        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
-        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
-        + Dispatch<ZcosmicWorkspaceHandleV1, CosmicWorkspaceV1Data>
-        + 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: &ZcosmicWorkspaceManagerV1,
-        _data: &(),
-    ) {
-        state
-            .workspace_state_mut()
-            .instances
-            .retain(|i| i != resource);
-    }
-}
-
-impl<D> Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData, D> for WorkspaceState<D>
-where
-    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
-        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
-        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
-        + Dispatch<ZcosmicWorkspaceHandleV1, CosmicWorkspaceV1Data>
-        + 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.iter().any(|(_, i)| i == 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: &ZcosmicWorkspaceGroupHandleV1,
-        _data: &WorkspaceGroupData,
-    ) {
-        for group in &mut state.workspace_state_mut().groups {
-            group.instances.retain(|(_, i)| i != resource)
-        }
-    }
-}
-
-impl<D> Dispatch<ZcosmicWorkspaceHandleV1, CosmicWorkspaceV1Data, D> for WorkspaceState<D>
-where
-    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
-        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
-        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
-        + Dispatch<ZcosmicWorkspaceHandleV1, CosmicWorkspaceV1Data>
-        + 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: &CosmicWorkspaceV1Data,
-        _dh: &DisplayHandle,
-        _data_init: &mut DataInit<'_, D>,
-    ) {
-        match request {
-            zcosmic_workspace_handle_v1::Request::Activate => {
-                if let Some(workspace_handle) = state.workspace_state().get_workspace_handle(obj) {
-                    let mut state = client
-                        .get_data::<<D as WorkspaceHandler>::Client>()
-                        .unwrap()
-                        .workspace_state()
-                        .lock()
-                        .unwrap();
-                    state.requests.push(Request::Activate(workspace_handle));
-                }
-            }
-            zcosmic_workspace_handle_v1::Request::Deactivate => {
-                if let Some(workspace_handle) = state.workspace_state().get_workspace_handle(obj) {
-                    let mut state = client
-                        .get_data::<<D as WorkspaceHandler>::Client>()
-                        .unwrap()
-                        .workspace_state()
-                        .lock()
-                        .unwrap();
-                    state.requests.push(Request::Deactivate(workspace_handle));
-                }
-            }
-            zcosmic_workspace_handle_v1::Request::Remove => {
-                if let Some(workspace_handle) = state.workspace_state().get_workspace_handle(obj) {
-                    let mut state = client
-                        .get_data::<<D as WorkspaceHandler>::Client>()
-                        .unwrap()
-                        .workspace_state()
-                        .lock()
-                        .unwrap();
-                    state.requests.push(Request::Remove(workspace_handle));
-                }
-            }
-            zcosmic_workspace_handle_v1::Request::Rename { name } => {
-                if let Some(workspace_handle) = state.workspace_state().get_workspace_handle(obj) {
-                    let mut state = client
-                        .get_data::<<D as WorkspaceHandler>::Client>()
-                        .unwrap()
-                        .workspace_state()
-                        .lock()
-                        .unwrap();
-                    state.requests.push(Request::Rename {
-                        workspace: workspace_handle,
-                        name,
-                    });
-                }
-            }
-            zcosmic_workspace_handle_v1::Request::SetTilingState {
-                state: tiling_state,
-            } => {
-                if let Some(workspace_handle) = state.workspace_state().get_workspace_handle(obj) {
-                    let mut state = client
-                        .get_data::<<D as WorkspaceHandler>::Client>()
-                        .unwrap()
-                        .workspace_state()
-                        .lock()
-                        .unwrap();
-                    let tiling_state = match tiling_state {
-                        WEnum::Value(zcosmic_workspace_handle_v1::TilingState::FloatingOnly) => {
-                            WEnum::Value(zcosmic_workspace_handle_v2::TilingState::FloatingOnly)
-                        }
-                        WEnum::Value(zcosmic_workspace_handle_v1::TilingState::TilingEnabled) => {
-                            WEnum::Value(zcosmic_workspace_handle_v2::TilingState::TilingEnabled)
-                        }
-                        // Won't be adding more variants to v1, at least
-                        WEnum::Value(_) => unreachable!(),
-                        WEnum::Unknown(value) => WEnum::Unknown(value),
-                    };
-                    state.requests.push(Request::SetTilingState {
-                        workspace: workspace_handle,
-                        state: tiling_state,
-                    });
-                }
-            }
-            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: &ZcosmicWorkspaceHandleV1,
-        _data: &CosmicWorkspaceV1Data,
-    ) {
-        for group in &mut state.workspace_state_mut().groups {
-            for workspace in &mut group.workspaces {
-                workspace.instances.retain(|(_, i)| i != resource)
-            }
-        }
-    }
-}
-
-pub(super) 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, CosmicWorkspaceV1Data>
-        + WorkspaceHandler
-        + 'static,
-    <D as WorkspaceHandler>::Client: ClientData + WorkspaceClientHandler + 'static,
-{
-    let (_, instance) = match group.instances.iter_mut().find(|(m, _)| m == mngr) {
-        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((mngr.downgrade(), 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 output in &group.outputs {
-            for wl_output in output.client_outputs(&client) {
-                if handle_state.wl_outputs.insert(wl_output.clone()) {
-                    instance.output_enter(&wl_output);
-                    changed = true;
-                }
-            }
-        }
-
-        handle_state.wl_outputs.retain(|wl_output| {
-            let retain =
-                wl_output.is_alive() && group.outputs.iter().any(|output| output.owns(wl_output));
-            if !retain {
-                instance.output_leave(&wl_output);
-                changed = true;
-            }
-            retain
-        });
-
-        handle_state.outputs = group.outputs.clone();
-    }
-
-    if handle_state.capabilities != Some(group.capabilities) {
-        let caps = group
-            .capabilities
-            .iter()
-            .filter_map(|cap| match cap {
-                GroupCapabilities::CreateWorkspace => Some(zcosmic_workspace_group_handle_v1::ZcosmicWorkspaceGroupCapabilitiesV1::CreateWorkspace),
-                _ => None,
-            })
-            .flat_map(|cap| (cap as u32).to_ne_bytes())
-            .collect::<Vec<u8>>();
-        instance.capabilities(caps);
-        handle_state.capabilities = Some(group.capabilities.clone());
-        changed = true;
-    }
-
-    if handle_state.workspace_count != group.workspaces.len() {
-        changed = true;
-    }
-    handle_state.workspace_count = group.workspaces.len();
-
-    for workspace in &mut group.workspaces {
-        if send_workspace_to_client::<D>(dh, mngr, instance, workspace) {
-            changed = true;
-        }
-    }
-
-    changed
-}
-
-fn send_workspace_to_client<D>(
-    dh: &DisplayHandle,
-    mngr: &ZcosmicWorkspaceManagerV1,
-    group: &ZcosmicWorkspaceGroupHandleV1,
-    workspace: &mut Workspace,
-) -> bool
-where
-    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
-        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
-        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
-        + Dispatch<ZcosmicWorkspaceHandleV1, CosmicWorkspaceV1Data>
-        + WorkspaceHandler
-        + 'static,
-    <D as WorkspaceHandler>::Client: ClientData + WorkspaceClientHandler + 'static,
-{
-    let (_, instance) = match workspace.instances.iter_mut().find(|(m, _)| m == mngr) {
-        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(),
-                    CosmicWorkspaceV1Data::default(),
-                ) {
-                    group.workspace(&handle);
-                    workspace.instances.push((mngr.downgrade(), handle));
-                    workspace.instances.last_mut().unwrap()
-                } else {
-                    return false;
-                }
-            } else {
-                return false;
-            }
-        }
-    };
-
-    let mut handle_state = instance
-        .data::<CosmicWorkspaceV1Data>()
-        .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 = workspace
-            .coordinates
-            .iter()
-            .flat_map(|coord| coord.to_ne_bytes())
-            .collect::<Vec<u8>>();
-        instance.coordinates(coords);
-        handle_state.coordinates = workspace.coordinates.clone();
-        changed = true;
-    }
-    if handle_state.capabilities != Some(workspace.capabilities) {
-        let caps = workspace
-            .capabilities
-            .iter()
-            .filter_map(|cap| match cap {
-                WorkspaceCapabilities::Activate => {
-                    Some(zcosmic_workspace_handle_v1::ZcosmicWorkspaceCapabilitiesV1::Activate)
-                }
-                WorkspaceCapabilities::Deactivate => {
-                    Some(zcosmic_workspace_handle_v1::ZcosmicWorkspaceCapabilitiesV1::Deactivate)
-                }
-                WorkspaceCapabilities::Remove => {
-                    Some(zcosmic_workspace_handle_v1::ZcosmicWorkspaceCapabilitiesV1::Remove)
-                }
-                WorkspaceCapabilities::Rename => {
-                    Some(zcosmic_workspace_handle_v1::ZcosmicWorkspaceCapabilitiesV1::Rename)
-                }
-                WorkspaceCapabilities::SetTilingState => Some(
-                    zcosmic_workspace_handle_v1::ZcosmicWorkspaceCapabilitiesV1::SetTilingState,
-                ),
-                _ => None,
-            })
-            .flat_map(|cap| (cap as u32).to_ne_bytes())
-            .collect::<Vec<u8>>();
-        instance.capabilities(caps);
-        handle_state.capabilities = Some(workspace.capabilities.clone());
-        changed = true;
-    }
-    if handle_state.states != Some(workspace.states) {
-        let states = workspace
-            .states
-            .iter()
-            .filter_map(|state| match state {
-                ext_workspace_handle_v1::State::Active => {
-                    Some(zcosmic_workspace_handle_v1::State::Active)
-                }
-                ext_workspace_handle_v1::State::Urgent => {
-                    Some(zcosmic_workspace_handle_v1::State::Urgent)
-                }
-                ext_workspace_handle_v1::State::Hidden => {
-                    Some(zcosmic_workspace_handle_v1::State::Hidden)
-                }
-                _ => None,
-            })
-            .flat_map(|state| (state as u32).to_ne_bytes())
-            .collect::<Vec<u8>>();
-        instance.state(states);
-        handle_state.states = Some(workspace.states.clone());
-        changed = true;
-    }
-    if instance.version() >= zcosmic_workspace_handle_v1::EVT_TILING_STATE_SINCE {
-        if handle_state
-            .tiling
-            .map(|state| state != workspace.tiling)
-            .unwrap_or(true)
-        {
-            let tiling_state = match workspace.tiling {
-                zcosmic_workspace_handle_v2::TilingState::FloatingOnly => {
-                    zcosmic_workspace_handle_v1::TilingState::FloatingOnly
-                }
-                zcosmic_workspace_handle_v2::TilingState::TilingEnabled => {
-                    zcosmic_workspace_handle_v1::TilingState::TilingEnabled
-                }
-                _ => {
-                    // Not clear what to do if state doesn't match. Which
-                    // shouldn't happen (or protocol will be irrelevant by
-                    // then).
-                    zcosmic_workspace_handle_v1::TilingState::TilingEnabled
-                }
-            };
-            instance.tiling_state(tiling_state);
-            handle_state.tiling = Some(workspace.tiling);
-            changed = true;
-        }
-    }
-
-    changed
-}

src/wayland/protocols/workspace/mod.rs

@@ -19,20 +19,11 @@ use smithay::{
 };
 use wayland_backend::protocol::WEnum;
 
-use cosmic_protocols::workspace::{
+use cosmic_protocols::workspace::v2::server::{
-    v1::server::{
+    zcosmic_workspace_handle_v2::{self, ZcosmicWorkspaceHandleV2},
-        zcosmic_workspace_group_handle_v1::ZcosmicWorkspaceGroupHandleV1,
+    zcosmic_workspace_manager_v2::ZcosmicWorkspaceManagerV2,
-        zcosmic_workspace_handle_v1::ZcosmicWorkspaceHandleV1,
-        zcosmic_workspace_manager_v1::ZcosmicWorkspaceManagerV1,
-    },
-    v2::server::{
-        zcosmic_workspace_handle_v2::{self, ZcosmicWorkspaceHandleV2},
-        zcosmic_workspace_manager_v2::ZcosmicWorkspaceManagerV2,
-    },
 };
 
-mod cosmic;
-pub use cosmic::CosmicWorkspaceV1Data;
 mod cosmic_v2;
 pub use cosmic_v2::CosmicWorkspaceV2Data;
 mod ext;
@@ -58,11 +49,7 @@ bitflags::bitflags! {
 #[derive(Debug)]
 pub struct WorkspaceState<D>
 where
-    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+    D: GlobalDispatch<ExtWorkspaceManagerV1, WorkspaceGlobalData>
-        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
-        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
-        + Dispatch<ZcosmicWorkspaceHandleV1, CosmicWorkspaceV1Data>
-        + GlobalDispatch<ExtWorkspaceManagerV1, WorkspaceGlobalData>
         + Dispatch<ExtWorkspaceManagerV1, ()>
         + Dispatch<ExtWorkspaceGroupHandleV1, WorkspaceGroupData>
         + Dispatch<ExtWorkspaceHandleV1, WorkspaceData>
@@ -74,22 +61,15 @@ where
     <D as WorkspaceHandler>::Client: ClientData + WorkspaceClientHandler + 'static,
 {
     dh: DisplayHandle,
-    cosmic_global: GlobalId,
     ext_global: GlobalId,
     cosmic_v2_global: GlobalId,
-    instances: Vec<ZcosmicWorkspaceManagerV1>,
     ext_instances: Vec<ExtWorkspaceManagerV1>,
     groups: Vec<WorkspaceGroup>,
     _marker: std::marker::PhantomData<D>,
 }
 pub struct WorkspaceUpdateGuard<'a, D>(&'a mut WorkspaceState<D>)
 where
-    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+    D: WorkspaceHandler + 'static,
-        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
-        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
-        + Dispatch<ZcosmicWorkspaceHandleV1, CosmicWorkspaceV1Data>
-        + WorkspaceHandler
-        + 'static,
     <D as WorkspaceHandler>::Client: ClientData + WorkspaceClientHandler + 'static;
 
 crate::utils::id_gen!(next_group_id, GROUP_ID, GROUP_IDS);
@@ -98,10 +78,6 @@ crate::utils::id_gen!(next_workspace_id, WORKSPACE_ID, WORKSPACE_IDS);
 #[derive(Debug)]
 pub struct WorkspaceGroup {
     id: usize,
-    instances: Vec<(
-        Weak<ZcosmicWorkspaceManagerV1>,
-        ZcosmicWorkspaceGroupHandleV1,
-    )>,
     ext_instances: Vec<(Weak<ExtWorkspaceManagerV1>, ExtWorkspaceGroupHandleV1)>,
     workspaces: Vec<Workspace>,
 
@@ -113,7 +89,6 @@ impl Default for WorkspaceGroup {
     fn default() -> Self {
         Self {
             id: 0,
-            instances: Vec::new(),
             ext_instances: Vec::new(),
             workspaces: Vec::new(),
 
@@ -141,7 +116,6 @@ pub type WorkspaceGroupData = Mutex<WorkspaceGroupDataInner>;
 #[derive(Debug)]
 pub struct Workspace {
     id: usize,
-    instances: Vec<(Weak<ZcosmicWorkspaceManagerV1>, ZcosmicWorkspaceHandleV1)>,
     ext_instances: Vec<(Weak<ExtWorkspaceManagerV1>, ExtWorkspaceHandleV1)>,
 
     name: String,
@@ -159,11 +133,7 @@ pub struct WorkspaceHandle {
 
 pub trait WorkspaceHandler
 where
-    Self: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+    Self: GlobalDispatch<ExtWorkspaceManagerV1, WorkspaceGlobalData>
-        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
-        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
-        + Dispatch<ZcosmicWorkspaceHandleV1, CosmicWorkspaceV1Data>
-        + GlobalDispatch<ExtWorkspaceManagerV1, WorkspaceGlobalData>
         + Dispatch<ExtWorkspaceManagerV1, ()>
         + Dispatch<ExtWorkspaceGroupHandleV1, WorkspaceGroupData>
         + Dispatch<ExtWorkspaceHandleV1, WorkspaceData>
@@ -219,11 +189,7 @@ pub trait WorkspaceClientHandler {
 
 impl<D> WorkspaceState<D>
 where
-    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+    D: GlobalDispatch<ExtWorkspaceManagerV1, WorkspaceGlobalData>
-        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
-        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
-        + Dispatch<ZcosmicWorkspaceHandleV1, CosmicWorkspaceV1Data>
-        + GlobalDispatch<ExtWorkspaceManagerV1, WorkspaceGlobalData>
         + Dispatch<ExtWorkspaceManagerV1, ()>
         + Dispatch<ExtWorkspaceGroupHandleV1, WorkspaceGroupData>
         + Dispatch<ExtWorkspaceHandleV1, WorkspaceData>
@@ -238,13 +204,6 @@ where
     where
         F: for<'a> Fn(&'a Client) -> bool + Clone + Send + Sync + 'static,
     {
-        let cosmic_global = dh.create_global::<D, ZcosmicWorkspaceManagerV1, _>(
-            2,
-            WorkspaceGlobalData {
-                filter: Box::new(client_filter.clone()),
-            },
-        );
-
         let ext_global = dh.create_global::<D, ExtWorkspaceManagerV1, _>(
             1,
             WorkspaceGlobalData {
@@ -261,10 +220,8 @@ where
 
         WorkspaceState {
             dh: dh.clone(),
-            cosmic_global,
             ext_global,
             cosmic_v2_global,
-            instances: Vec::new(),
             ext_instances: Vec::new(),
             groups: Vec::new(),
             _marker: std::marker::PhantomData,
@@ -350,57 +307,6 @@ where
         })
     }
 
-    pub fn group_handle(
-        &self,
-        group: &ZcosmicWorkspaceGroupHandleV1,
-    ) -> Option<WorkspaceGroupHandle> {
-        self.groups
-            .iter()
-            .find(|g| g.instances.iter().any(|(_, i)| i == group))
-            .map(|g| WorkspaceGroupHandle { id: g.id })
-    }
-
-    pub fn workspace_handle(
-        &self,
-        workspace: &ZcosmicWorkspaceHandleV1,
-    ) -> Option<WorkspaceHandle> {
-        self.groups
-            .iter()
-            .find_map(|g| {
-                g.workspaces
-                    .iter()
-                    .find(|w| w.instances.iter().any(|(_, i)| i == workspace))
-            })
-            .map(|w| WorkspaceHandle { id: w.id })
-    }
-
-    pub fn raw_group_handles<'a>(
-        &'a self,
-        group: &'a WorkspaceGroupHandle,
-        client: &'a ObjectId,
-    ) -> impl Iterator<Item = &ZcosmicWorkspaceGroupHandleV1> + 'a {
-        self.groups
-            .iter()
-            .filter(|g| g.id == group.id)
-            .flat_map(|g| &g.instances)
-            .map(|(_, i)| i)
-            .filter(|i| i.id().same_client_as(client))
-    }
-
-    pub fn raw_workspace_handles<'a>(
-        &'a self,
-        workspace: &'a WorkspaceHandle,
-        client: &'a ObjectId,
-    ) -> impl Iterator<Item = &ZcosmicWorkspaceHandleV1> + 'a {
-        self.groups
-            .iter()
-            .find_map(|g| g.workspaces.iter().find(|w| w.id == workspace.id))
-            .into_iter()
-            .flat_map(|w| &w.instances)
-            .map(|(_, i)| i)
-            .filter(|i| i.id().same_client_as(client))
-    }
-
     pub fn raw_ext_workspace_handles<'a>(
         &'a self,
         workspace: &'a WorkspaceHandle,
@@ -421,13 +327,6 @@ where
 
     fn done(&mut self) {
         let mut changed = false;
-        for instance in &self.instances {
-            for mut group in &mut self.groups {
-                if cosmic::send_group_to_client::<D>(&self.dh, instance, &mut group) {
-                    changed = true;
-                }
-            }
-        }
         for instance in &self.ext_instances {
             for mut group in &mut self.groups {
                 if ext::send_group_to_client::<D>(&self.dh, instance, &mut group) {
@@ -436,29 +335,12 @@ where
             }
         }
         if changed {
-            for instance in &self.instances {
-                instance.done();
-            }
             for instance in &self.ext_instances {
                 instance.done();
             }
         }
     }
 
-    pub fn get_workspace_handle(
-        &self,
-        handle: &ZcosmicWorkspaceHandleV1,
-    ) -> Option<WorkspaceHandle> {
-        self.groups
-            .iter()
-            .find_map(|g| {
-                g.workspaces
-                    .iter()
-                    .find(|w| w.instances.iter().any(|(_, i)| i == handle))
-            })
-            .map(|w| WorkspaceHandle { id: w.id })
-    }
-
     pub fn get_ext_workspace_handle(
         &self,
         handle: &ExtWorkspaceHandleV1,
@@ -473,10 +355,6 @@ where
             .map(|w| WorkspaceHandle { id: w.id })
     }
 
-    pub fn cosmic_global_id(&self) -> GlobalId {
-        self.cosmic_global.clone()
-    }
-
     pub fn ext_global_id(&self) -> GlobalId {
         self.ext_global.clone()
     }
@@ -488,11 +366,7 @@ where
 
 impl<'a, D> WorkspaceUpdateGuard<'a, D>
 where
-    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+    D: Dispatch<ExtWorkspaceManagerV1, ()>
-        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
-        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
-        + Dispatch<ZcosmicWorkspaceHandleV1, CosmicWorkspaceV1Data>
-        + Dispatch<ExtWorkspaceManagerV1, ()>
         + Dispatch<ExtWorkspaceGroupHandleV1, WorkspaceGroupData>
         + Dispatch<ExtWorkspaceHandleV1, WorkspaceData>
         + GlobalDispatch<ZcosmicWorkspaceManagerV2, WorkspaceGlobalData>
@@ -523,7 +397,6 @@ where
             let workspace = Workspace {
                 id,
                 tiling,
-                instances: Default::default(),
                 ext_instances: Default::default(),
                 name: Default::default(),
                 capabilities: WorkspaceCapabilities::empty(),
@@ -553,9 +426,6 @@ where
         }
 
         if let Some(group) = self.0.groups.iter().find(|g| g.id == group.id) {
-            for (_, instance) in &group.instances {
-                instance.remove();
-            }
             for (_, instance) in &group.ext_instances {
                 instance.removed();
             }
@@ -567,9 +437,6 @@ where
     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();
-                }
                 for (manager, instance) in &workspace.ext_instances {
                     for (group_manager, group_instance) in &group.ext_instances {
                         if manager == group_manager {
@@ -742,11 +609,7 @@ where
 
 impl<'a, D> Drop for WorkspaceUpdateGuard<'a, D>
 where
-    D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+    D: GlobalDispatch<ExtWorkspaceManagerV1, WorkspaceGlobalData>
-        + Dispatch<ZcosmicWorkspaceManagerV1, ()>
-        + Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
-        + Dispatch<ZcosmicWorkspaceHandleV1, CosmicWorkspaceV1Data>
-        + GlobalDispatch<ExtWorkspaceManagerV1, WorkspaceGlobalData>
         + Dispatch<ExtWorkspaceManagerV1, ()>
         + Dispatch<ExtWorkspaceGroupHandleV1, WorkspaceGroupData>
         + Dispatch<ExtWorkspaceHandleV1, WorkspaceData>
@@ -764,19 +627,6 @@ where
 
 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::CosmicWorkspaceV1Data
-        ] => $crate::wayland::protocols::workspace::WorkspaceState<Self>);
-
         smithay::reexports::wayland_server::delegate_global_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
             smithay::reexports::wayland_protocols::ext::workspace::v1::server::ext_workspace_manager_v1::ExtWorkspaceManagerV1: $crate::wayland::protocols::workspace::WorkspaceGlobalData
         ] => $crate::wayland::protocols::workspace::WorkspaceState<Self>);