leyoda/cosmic-comp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

protocol/workspace: Drop support for cosmic v1 protocol

Browse source 
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.)
This commit is contained in:
Ian Douglas Scott 2025-04-16 14:07:15 -07:00 • committed by Ian Douglas Scott
parent 2cbe89d89d
commit 85254b47d6
4 changed files with 10 additions and 713 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/wayland/protocols/toplevel_info.rs
View file

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

15
src/wayland/protocols/toplevel_management.rs
View file

@ -249,20 +249,7 @@ where
}
}
}
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::MoveToWorkspace { .. } => {}
zcosmic_toplevel_manager_v1::Request::MoveToExtWorkspace {
toplevel,
workspace,

532
src/wayland/protocols/workspace/cosmic.rs
View file

@ -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
}

168
src/wayland/protocols/workspace/mod.rs
View file

@ -19,20 +19,11 @@ use smithay::{
};
use wayland_backend::protocol::WEnum;
use cosmic_protocols::workspace::{
v1::server::{
zcosmic_workspace_group_handle_v1::ZcosmicWorkspaceGroupHandleV1,
zcosmic_workspace_handle_v1::ZcosmicWorkspaceHandleV1,
zcosmic_workspace_manager_v1::ZcosmicWorkspaceManagerV1,
},
v2::server::{
zcosmic_workspace_handle_v2::{self, ZcosmicWorkspaceHandleV2},
zcosmic_workspace_manager_v2::ZcosmicWorkspaceManagerV2,
},
use cosmic_protocols::workspace::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>
+ Dispatch<ZcosmicWorkspaceManagerV1, ()>
+ Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
+ Dispatch<ZcosmicWorkspaceHandleV1, CosmicWorkspaceV1Data>
+ GlobalDispatch<ExtWorkspaceManagerV1, WorkspaceGlobalData>
D: 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>
+ Dispatch<ZcosmicWorkspaceManagerV1, ()>
+ Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
+ Dispatch<ZcosmicWorkspaceHandleV1, CosmicWorkspaceV1Data>
+ WorkspaceHandler
+ 'static,
D: 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>
+ Dispatch<ZcosmicWorkspaceManagerV1, ()>
+ Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
+ Dispatch<ZcosmicWorkspaceHandleV1, CosmicWorkspaceV1Data>
+ GlobalDispatch<ExtWorkspaceManagerV1, WorkspaceGlobalData>
Self: 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>
+ Dispatch<ZcosmicWorkspaceManagerV1, ()>
+ Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
+ Dispatch<ZcosmicWorkspaceHandleV1, CosmicWorkspaceV1Data>
+ GlobalDispatch<ExtWorkspaceManagerV1, WorkspaceGlobalData>
D: 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>
+ Dispatch<ZcosmicWorkspaceManagerV1, ()>
+ Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
+ Dispatch<ZcosmicWorkspaceHandleV1, CosmicWorkspaceV1Data>
+ Dispatch<ExtWorkspaceManagerV1, ()>
D: 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>
+ Dispatch<ZcosmicWorkspaceManagerV1, ()>
+ Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
+ Dispatch<ZcosmicWorkspaceHandleV1, CosmicWorkspaceV1Data>
+ GlobalDispatch<ExtWorkspaceManagerV1, WorkspaceGlobalData>
D: 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>);