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

chore: clippy

Browse source
This commit is contained in:
Vukašin Vojinović 2026-02-23 16:25:06 +01:00 • committed by Victoria Brekenfeld
parent c13e52da04
commit 2ca99c670a
59 changed files with 1974 additions and 2137 deletions
Download patch file Download diff file Expand all files Collapse all files

103
src/wayland/handlers/compositor.rs
View file

@ -73,7 +73,7 @@ fn xdg_popup_ensure_initial_configure(popup: &PopupKind) {
fn layer_surface_check_inital_configure(surface: &LayerSurface) -> bool {
// send the initial configure if relevant
let initial_configure_sent = with_states(surface.wl_surface(), |states| {
with_states(surface.wl_surface(), |states| {
states
.data_map
.get::<Mutex<LayerSurfaceAttributes>>()
@ -81,9 +81,7 @@ fn layer_surface_check_inital_configure(surface: &LayerSurface) -> bool {
.lock()
.unwrap()
.initial_configure_sent
});
initial_configure_sent
})
}
pub fn client_compositor_state(client: &Client) -> &CompositorClientState {
@ -195,23 +193,24 @@ impl CompositorHandler for State {
})
});
if let Some(dmabuf) = maybe_dmabuf {
if let Some(acquire_point) = acquire_point {
if let Ok((blocker, source)) = acquire_point.generate_blocker() {
let client = surface.client().unwrap();
let res = state.common.event_loop_handle.insert_source(
source,
move |_, _, state| {
if let Some(acquire_point) = acquire_point
&& let Ok((blocker, source)) = acquire_point.generate_blocker()
{
let client = surface.client().unwrap();
let res =
state
.common
.event_loop_handle
.insert_source(source, move |_, _, state| {
let dh = state.common.display_handle.clone();
state
.client_compositor_state(&client)
.blocker_cleared(state, &dh);
Ok(())
},
);
if res.is_ok() {
add_blocker(surface, blocker);
return;
}
});
if res.is_ok() {
add_blocker(surface, blocker);
return;
}
}
if let Ok((blocker, source)) = dmabuf.generate_blocker(Interest::READ) {
@ -379,35 +378,34 @@ impl State {
.pending_windows
.iter()
.find(|pending| pending.surface.wl_surface().as_deref() == Some(surface))
&& let Some(toplevel) = pending.surface.0.toplevel()
{
if let Some(toplevel) = pending.surface.0.toplevel() {
let initial_size = if let Some(output) = pending.fullscreen.as_ref() {
Some(output.geometry().size.as_logical())
} else if pending.maximized {
let active_output = shell.seats.last_active().active_output();
let zone = layer_map_for_output(&active_output).non_exclusive_zone();
Some(zone.size)
} else {
None
};
if toplevel_ensure_initial_configure(toplevel, initial_size)
&& with_renderer_surface_state(surface, |state| state.buffer().is_some())
.unwrap_or(false)
{
let window = pending.surface.clone();
window.on_commit();
let res = shell.map_window(
&window,
&mut self.common.toplevel_info_state,
&mut self.common.workspace_state,
&self.common.event_loop_handle,
);
if let Some(target) = res {
let seat = shell.seats.last_active().clone();
std::mem::drop(shell);
Shell::set_focus(self, Some(&target), &seat, None, true);
return true;
}
let initial_size = if let Some(output) = pending.fullscreen.as_ref() {
Some(output.geometry().size.as_logical())
} else if pending.maximized {
let active_output = shell.seats.last_active().active_output();
let zone = layer_map_for_output(&active_output).non_exclusive_zone();
Some(zone.size)
} else {
None
};
if toplevel_ensure_initial_configure(toplevel, initial_size)
&& with_renderer_surface_state(surface, |state| state.buffer().is_some())
.unwrap_or(false)
{
let window = pending.surface.clone();
window.on_commit();
let res = shell.map_window(
&window,
&mut self.common.toplevel_info_state,
&mut self.common.workspace_state,
&self.common.event_loop_handle,
);
if let Some(target) = res {
let seat = shell.seats.last_active().clone();
std::mem::drop(shell);
Shell::set_focus(self, Some(&target), &seat, None, true);
return true;
}
}
}
@ -417,17 +415,16 @@ impl State {
.iter()
.find(|pending| pending.surface.wl_surface() == surface)
.map(|pending| pending.surface.clone())
&& !layer_surface_check_inital_configure(&layer_surface)
{
if !layer_surface_check_inital_configure(&layer_surface) {
// compute initial dimensions by mapping
if let Some(target) = shell.map_layer(&layer_surface) {
let seat = shell.seats.last_active().clone();
std::mem::drop(shell);
Shell::set_focus(self, Some(&target), &seat, None, false);
}
layer_surface.layer_surface().send_configure();
return true;
// compute initial dimensions by mapping
if let Some(target) = shell.map_layer(&layer_surface) {
let seat = shell.seats.last_active().clone();
std::mem::drop(shell);
Shell::set_focus(self, Some(&target), &seat, None, false);
}
layer_surface.layer_surface().send_configure();
return true;
};
false

44
src/wayland/handlers/decoration.rs
View file

@ -74,13 +74,12 @@ impl XdgDecorationHandler for State {
if let Some((window, _)) = mapped
.windows()
.find(|(window, _)| window.wl_surface().as_deref() == Some(toplevel.wl_surface()))
&& let Some(toplevel) = window.0.toplevel()
{
if let Some(toplevel) = window.0.toplevel() {
toplevel.with_pending_state(|state| {
state.decoration_mode = Some(mode);
});
toplevel.send_configure();
}
toplevel.with_pending_state(|state| {
state.decoration_mode = Some(mode);
});
toplevel.send_configure();
}
}
}
@ -91,14 +90,13 @@ impl XdgDecorationHandler for State {
if let Some((window, _)) = mapped
.windows()
.find(|(window, _)| window.wl_surface().as_deref() == Some(toplevel.wl_surface()))
&& let Some(toplevel) = window.0.toplevel()
{
if let Some(toplevel) = window.0.toplevel() {
PreferredDecorationMode::update(&window.0, Some(mode));
toplevel.with_pending_state(|state| {
state.decoration_mode = Some(mode);
});
toplevel.send_configure();
}
PreferredDecorationMode::update(&window.0, Some(mode));
toplevel.with_pending_state(|state| {
state.decoration_mode = Some(mode);
});
toplevel.send_configure();
}
} else {
toplevel.with_pending_state(|state| state.decoration_mode = Some(mode));
@ -107,19 +105,17 @@ impl XdgDecorationHandler for State {
fn unset_mode(&mut self, toplevel: ToplevelSurface) {
let shell = self.common.shell.read();
if let Some(mapped) = shell.element_for_surface(toplevel.wl_surface()) {
if let Some((window, _)) = mapped
if let Some(mapped) = shell.element_for_surface(toplevel.wl_surface())
&& let Some((window, _)) = mapped
.windows()
.find(|(window, _)| window.wl_surface().as_deref() == Some(toplevel.wl_surface()))
{
if let Some(toplevel) = window.0.toplevel() {
PreferredDecorationMode::update(&window.0, None);
toplevel.with_pending_state(|state| {
state.decoration_mode = None;
});
toplevel.send_configure();
}
}
&& let Some(toplevel) = window.0.toplevel()
{
PreferredDecorationMode::update(&window.0, None);
toplevel.with_pending_state(|state| {
state.decoration_mode = None;
});
toplevel.send_configure();
}
}
}

12
src/wayland/handlers/dmabuf.rs
View file

@ -79,14 +79,12 @@ impl DmabufHandler for State {
feedback
.primary_scanout_feedback
.unwrap_or(feedback.render_feedback)
} else if frame_time_filter_fn(data) == Kind::ScanoutCandidate {
feedback
.overlay_scanout_feedback
.unwrap_or(feedback.render_feedback)
} else {
if frame_time_filter_fn(data) == Kind::ScanoutCandidate {
feedback
.overlay_scanout_feedback
.unwrap_or(feedback.render_feedback)
} else {
feedback.render_feedback
}
feedback.render_feedback
}
}))
}

32
src/wayland/handlers/image_copy_capture/mod.rs
View file

@ -237,22 +237,22 @@ impl ImageCopyCaptureHandler for State {
}
ImageCaptureSourceKind::Toplevel(mut toplevel) => {
let shell = self.common.shell.read();
if let Some(element) = shell.element_for_surface(&toplevel) {
if element.has_active_window(&toplevel) {
if let Some(workspace) = shell.space_for(element) {
if let Some(geometry) = workspace.element_geometry(element) {
let mut surface_geo = element.active_window_geometry().as_local();
surface_geo.loc += geometry.loc;
let global_geo = surface_geo.to_global(workspace.output());
if global_geo.contains(pointer_loc) {
let buffer_pos = (pointer_loc - global_geo.loc)
.as_logical()
.to_buffer(1, Transform::Normal, &toplevel.geometry().size);
session.set_cursor_hotspot(hotspot);
session.set_cursor_pos(Some(buffer_pos));
}
}
}
if let Some(element) = shell.element_for_surface(&toplevel)
&& element.has_active_window(&toplevel)
&& let Some(workspace) = shell.space_for(element)
&& let Some(geometry) = workspace.element_geometry(element)
{
let mut surface_geo = element.active_window_geometry().as_local();
surface_geo.loc += geometry.loc;
let global_geo = surface_geo.to_global(workspace.output());
if global_geo.contains(pointer_loc) {
let buffer_pos = (pointer_loc - global_geo.loc).as_logical().to_buffer(
1,
Transform::Normal,
&toplevel.geometry().size,
);
session.set_cursor_hotspot(hotspot);
session.set_cursor_pos(Some(buffer_pos));
}
}

46
src/wayland/handlers/image_copy_capture/render.rs
View file

@ -577,18 +577,16 @@ pub fn render_window_to_buffer(
let pointer = seat.get_pointer().unwrap();
let pointer_loc = pointer.current_location().to_i32_round().as_global();
let mut location = None;
if let Some(element) = shell.element_for_surface(toplevel) {
if element.has_active_window(toplevel) {
if let Some(workspace) = shell.space_for(element) {
if let Some(geometry) = workspace.element_geometry(element) {
let mut surface_geo = element.active_window_geometry().as_local();
surface_geo.loc += geometry.loc;
let global_geo = surface_geo.to_global(workspace.output());
if global_geo.contains(pointer_loc) {
location = Some((pointer_loc - global_geo.loc).as_logical().to_f64());
}
}
}
if let Some(element) = shell.element_for_surface(toplevel)
&& element.has_active_window(toplevel)
&& let Some(workspace) = shell.space_for(element)
&& let Some(geometry) = workspace.element_geometry(element)
{
let mut surface_geo = element.active_window_geometry().as_local();
surface_geo.loc += geometry.loc;
let global_geo = surface_geo.to_global(workspace.output());
if global_geo.contains(pointer_loc) {
location = Some((pointer_loc - global_geo.loc).as_logical().to_f64());
}
};
std::mem::drop(shell);
@ -620,19 +618,17 @@ pub fn render_window_to_buffer(
// TODO cosmic-workspaces wants to omit, but metadata cursor capture in portal should
// still include dnd surface in window capture buffer?
if draw_cursor {
if let Some(dnd_icon) = get_dnd_icon(&seat) {
elements.extend(
cursor::draw_dnd_icon(
renderer,
&dnd_icon.surface,
(location + dnd_icon.offset.to_f64()).to_i32_round(),
1.0,
)
.into_iter()
.map(WindowCaptureElement::from),
);
}
if draw_cursor && let Some(dnd_icon) = get_dnd_icon(&seat) {
elements.extend(
cursor::draw_dnd_icon(
renderer,
&dnd_icon.surface,
(location + dnd_icon.offset.to_f64()).to_i32_round(),
1.0,
)
.into_iter()
.map(WindowCaptureElement::from),
);
}
}

10
src/wayland/handlers/output_configuration.rs
View file

@ -174,8 +174,8 @@ impl State {
*current_config = backup;
}
}
if !test_only {
if let Err(err) = backend.apply_config_for_outputs(
if !test_only
&& let Err(err) = backend.apply_config_for_outputs(
false,
&self.common.event_loop_handle,
self.common.config.dynamic_conf.screen_filter(),
@ -184,9 +184,9 @@ impl State {
&self.common.xdg_activation_state,
self.common.startup_done.clone(),
&self.common.clock,
) {
error!("Failed to reset output config: {:?}", err);
}
)
{
error!("Failed to reset output config: {:?}", err);
}
return false;
}

5
src/wayland/handlers/selection.rs
View file

@ -70,10 +70,9 @@ impl SelectionHandler for State {
.xwayland_state
.as_mut()
.and_then(|xstate| xstate.xwm.as_mut())
&& let Err(err) = xwm.send_selection(target, mime_type, fd)
{
if let Err(err) = xwm.send_selection(target, mime_type, fd) {
warn!(?err, "Failed to send selection (X11 -> Wayland).");
}
warn!(?err, "Failed to send selection (X11 -> Wayland).");
}
}
}

31
src/wayland/handlers/session_lock.rs
View file

@ -21,15 +21,14 @@ impl SessionLockHandler for State {
let mut shell = self.common.shell.write();
// Reject lock if sesion lock exists and is still valid
if let Some(session_lock) = shell.session_lock.as_ref() {
if self
if let Some(session_lock) = shell.session_lock.as_ref()
&& self
.common
.display_handle
.get_client(session_lock.ext_session_lock.id())
.is_ok()
{
return;
}
{
return;
}
let ext_session_lock = locker.ext_session_lock().clone();
@ -55,17 +54,17 @@ impl SessionLockHandler for State {
fn new_surface(&mut self, lock_surface: LockSurface, wl_output: WlOutput) {
let mut shell = self.common.shell.write();
if let Some(session_lock) = &mut shell.session_lock {
if let Some(output) = Output::from_resource(&wl_output) {
lock_surface.with_pending_state(|states| {
let size = output.geometry().size;
states.size = Some(Size::from((size.w as u32, size.h as u32)));
});
lock_surface.send_configure();
session_lock
.surfaces
.insert(output.clone(), lock_surface.clone());
}
if let Some(session_lock) = &mut shell.session_lock
&& let Some(output) = Output::from_resource(&wl_output)
{
lock_surface.with_pending_state(|states| {
let size = output.geometry().size;
states.size = Some(Size::from((size.w as u32, size.h as u32)));
});
lock_surface.send_configure();
session_lock
.surfaces
.insert(output.clone(), lock_surface.clone());
}
}
}

29
src/wayland/handlers/toplevel_management.rs
View file

@ -113,22 +113,21 @@ impl ToplevelManagementHandler for State {
// move pointer to window if it’s on a different monitor/output
if seat.active_output() != *output
&& self.common.config.cosmic_conf.cursor_follows_focus
&& let Some(new_pos) = new_pos
{
if let Some(new_pos) = new_pos {
seat.set_active_output(output);
if let Some(ptr) = seat.get_pointer() {
let serial = SERIAL_COUNTER.next_serial();
ptr.motion(
self,
None,
&MotionEvent {
location: new_pos.to_f64().as_logical(),
serial,
time: self.common.clock.now().as_millis(),
},
);
ptr.frame(self);
}
seat.set_active_output(output);
if let Some(ptr) = seat.get_pointer() {
let serial = SERIAL_COUNTER.next_serial();
ptr.motion(
self,
None,
&MotionEvent {
location: new_pos.to_f64().as_logical(),
serial,
time: self.common.clock.now().as_millis(),
},
);
ptr.frame(self);
}
}

2
src/wayland/handlers/xdg_activation.rs
View file

@ -213,7 +213,7 @@ impl State {
None,
false,
);
} else if let Some((workspace, _)) = shell.workspace_for_surface(&surface) {
} else if let Some((workspace, _)) = shell.workspace_for_surface(surface) {
let current_workspace = shell.active_space(&current_output).unwrap();
if workspace == current_workspace.handle {
let Some(target) = shell

7
src/wayland/handlers/xdg_shell/mod.rs
View file

@ -45,12 +45,7 @@ impl XdgShellHandler for State {
let mut shell = self.common.shell.write();
let seat = shell.seats.last_active().clone();
if shell
.pending_windows
.iter()
.find(|w| &w.surface == &surface)
.is_none()
{
if !shell.pending_windows.iter().any(|w| w.surface == surface) {
let surface = CosmicSurface::from(surface);
shell.pending_windows.push(PendingWindow {
surface,

2
src/wayland/handlers/xdg_shell/popup.rs
View file

@ -96,7 +96,7 @@ pub fn update_reactive_popups<'a>(
for (popup, _) in PopupManager::popups_for_surface(toplevel.wl_surface()) {
match popup {
PopupKind::Xdg(surface) => {
let positioner = with_states(&surface.wl_surface(), |states| {
let positioner = with_states(surface.wl_surface(), |states| {
let mut guard = states.cached_state.get::<PopupCachedState>();
guard
.current()

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

@ -204,10 +204,10 @@ where
state.request_screen_invert(inverted);
}
if let Ok(filter) = filter {
if filter != state.a11y_state().screen_filter {
state.request_screen_filter(filter);
}
if let Ok(filter) = filter
&& filter != state.a11y_state().screen_filter
{
state.request_screen_filter(filter);
}
}
_ => unreachable!(),

27
src/wayland/protocols/output_configuration/mod.rs
View file

@ -428,15 +428,13 @@ where
}
} else {
None
} {
if inner.enabled
&& output
.current_mode()
.map(|c| c == output_mode)
.unwrap_or(false)
{
instance.obj.current_mode(mode);
}
} && inner.enabled
&& output
.current_mode()
.map(|c| c == output_mode)
.unwrap_or(false)
{
instance.obj.current_mode(mode);
}
}
@ -513,12 +511,11 @@ where
}
}
if let Some(extension_obj) = instance.extension_obj.as_ref() {
if inner.enabled
&& extension_obj.version() >= zcosmic_output_head_v1::EVT_XWAYLAND_PRIMARY_SINCE
{
extension_obj.xwayland_primary(output.config().xwayland_primary as u32);
}
if let Some(extension_obj) = instance.extension_obj.as_ref()
&& inner.enabled
&& extension_obj.version() >= zcosmic_output_head_v1::EVT_XWAYLAND_PRIMARY_SINCE
{
extension_obj.xwayland_primary(output.config().xwayland_primary as u32);
}
}

14
src/wayland/protocols/output_power.rs
View file

@ -58,13 +58,13 @@ impl OutputPowerState {
let mut output_powers = mem::take(&mut state.output_power_state().output_powers);
for (output_power, old_mode) in output_powers.iter_mut() {
let data = output_power.data::<OutputPowerData>().unwrap();
if let Some(output) = data.output.upgrade() {
if let Some(on) = state.get_dpms(&output) {
let mode = output_power_mode(on);
if mode != *old_mode {
output_power.mode(mode);
*old_mode = mode;
}
if let Some(output) = data.output.upgrade()
&& let Some(on) = state.get_dpms(&output)
{
let mode = output_power_mode(on);
if mode != *old_mode {
output_power.mode(mode);
*old_mode = mode;
}
}
}

67
src/wayland/protocols/overlap_notify.rs
View file

@ -124,16 +124,16 @@ impl OverlapNotifyState {
})
})
{
if let Some(window_geo) = window.global_geometry() {
if let Some(intersection) = layer_geo.intersection(window_geo) {
// relative to layer location
let region = Rectangle::new(
intersection.loc - layer_geo.loc,
intersection.size,
)
.as_logical();
new_snapshot.add_toplevel(window, region);
}
if let Some(window_geo) = window.global_geometry()
&& let Some(intersection) = layer_geo.intersection(window_geo)
{
// relative to layer location
let region = Rectangle::new(
intersection.loc - layer_geo.loc,
intersection.size,
)
.as_logical();
new_snapshot.add_toplevel(window, region);
}
}
@ -238,16 +238,15 @@ impl LayerOverlapNotificationDataInternal {
.collect::<Vec<_>>();
for toplevel in self.last_snapshot.toplevel_overlaps.keys() {
if !new_snapshot.toplevel_overlaps.contains_key(toplevel) {
if let Ok(toplevel) = toplevel.upgrade() {
if let Some(client) = toplevel.client() {
for notification in notifications
.iter()
.filter(|n| n.client().is_some_and(|c| c == client))
{
notification.toplevel_leave(&toplevel);
}
}
if !new_snapshot.toplevel_overlaps.contains_key(toplevel)
&& let Ok(toplevel) = toplevel.upgrade()
&& let Some(client) = toplevel.client()
{
for notification in notifications
.iter()
.filter(|n| n.client().is_some_and(|c| c == client))
{
notification.toplevel_leave(&toplevel);
}
}
}
@ -257,22 +256,20 @@ impl LayerOverlapNotificationDataInternal {
.toplevel_overlaps
.get(toplevel)
.is_some_and(|old_overlap| old_overlap == overlap)
&& let Ok(toplevel) = toplevel.upgrade()
&& let Some(client) = toplevel.client()
{
if let Ok(toplevel) = toplevel.upgrade() {
if let Some(client) = toplevel.client() {
for notification in notifications
.iter()
.filter(|n| n.client().is_some_and(|c| c == client))
{
notification.toplevel_enter(
&toplevel,
overlap.loc.x,
overlap.loc.y,
overlap.size.w,
overlap.size.h,
);
}
}
for notification in notifications
.iter()
.filter(|n| n.client().is_some_and(|c| c == client))
{
notification.toplevel_enter(
&toplevel,
overlap.loc.x,
overlap.loc.y,
overlap.size.w,
overlap.size.h,
);
}
}
}

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

@ -574,10 +574,8 @@ where
instance.geometry(&wl_output, geo.loc.x, geo.loc.y, geo.size.w, geo.size.h);
}
changed = true;
} else if geometry_changed {
if let Some(geo) = geometry {
instance.geometry(&wl_output, geo.loc.x, geo.loc.y, geo.size.w, geo.size.h);
}
} else if geometry_changed && let Some(geo) = geometry {
instance.geometry(&wl_output, geo.loc.x, geo.loc.y, geo.size.w, geo.size.h);
}
}
}
@ -635,10 +633,10 @@ pub fn window_from_handle<W: Window + 'static>(handle: ZcosmicToplevelHandleV1)
.and_then(|state| state.lock().unwrap().window.clone())
}
pub fn window_from_ext<'a, W: Window + 'static, D>(
state: &'a D,
pub fn window_from_ext<W: Window + 'static, D>(
state: &D,
handle: ForeignToplevelHandle,
) -> Option<&'a W>
) -> Option<&W>
where
D: ToplevelInfoHandler<Window = W>,
{

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

@ -258,10 +258,9 @@ where
let window = window_from_handle(toplevel).unwrap();
if let Some(workspace_handle) =
state.workspace_state().get_ext_workspace_handle(&workspace)
&& let Some(output) = Output::from_resource(&output)
{
if let Some(output) = Output::from_resource(&output) {
state.move_to_workspace(dh, &window, workspace_handle, output);
}
state.move_to_workspace(dh, &window, workspace_handle, output);
}
}
_ => unreachable!(),

167
src/wayland/protocols/workspace/cosmic_v2.rs
View file

@ -94,11 +94,10 @@ where
.iter()
.flat_map(|g| &g.workspaces)
.find(|w| w.ext_instances.contains(&workspace))
&& let Ok(ext_mngr) = data.manager.upgrade()
{
if let Ok(ext_mngr) = data.manager.upgrade() {
send_workspace_to_client(&cosmic_workspace, workspace);
ext_mngr.done();
}
send_workspace_to_client(&cosmic_workspace, workspace);
ext_mngr.done();
}
}
}
@ -128,20 +127,18 @@ where
zcosmic_workspace_handle_v2::Request::Rename { name } => {
if let Some(workspace_handle) =
state.workspace_state().get_ext_workspace_handle(&workspace)
{
if let Ok(manager) =
&& let Ok(manager) =
workspace.data::<WorkspaceData>().unwrap().manager.upgrade()
{
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::Rename {
workspace: workspace_handle,
name,
});
}
{
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::Rename {
workspace: workspace_handle,
name,
});
}
}
zcosmic_workspace_handle_v2::Request::SetTilingState {
@ -149,58 +146,52 @@ where
} => {
if let Some(workspace_handle) =
state.workspace_state().get_ext_workspace_handle(&workspace)
{
if let Ok(manager) =
&& let Ok(manager) =
workspace.data::<WorkspaceData>().unwrap().manager.upgrade()
{
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::SetTilingState {
workspace: workspace_handle,
state: tiling_state,
});
}
{
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::SetTilingState {
workspace: workspace_handle,
state: tiling_state,
});
}
}
zcosmic_workspace_handle_v2::Request::Pin => {
if let Some(workspace_handle) =
state.workspace_state().get_ext_workspace_handle(&workspace)
{
if let Ok(manager) =
&& let Ok(manager) =
workspace.data::<WorkspaceData>().unwrap().manager.upgrade()
{
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::SetPin {
workspace: workspace_handle,
pinned: true,
});
}
{
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::SetPin {
workspace: workspace_handle,
pinned: true,
});
}
}
zcosmic_workspace_handle_v2::Request::Unpin => {
if let Some(workspace_handle) =
state.workspace_state().get_ext_workspace_handle(&workspace)
{
if let Ok(manager) =
&& let Ok(manager) =
workspace.data::<WorkspaceData>().unwrap().manager.upgrade()
{
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::SetPin {
workspace: workspace_handle,
pinned: false,
});
}
{
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::SetPin {
workspace: workspace_handle,
pinned: false,
});
}
}
zcosmic_workspace_handle_v2::Request::MoveBefore {
@ -209,26 +200,22 @@ where
} => {
if let Some(workspace_handle) =
state.workspace_state().get_ext_workspace_handle(&workspace)
{
if let Some(other_workspace) = state
&& let Some(other_workspace) = state
.workspace_state()
.get_ext_workspace_handle(&other_workspace)
{
if let Ok(manager) =
workspace.data::<WorkspaceData>().unwrap().manager.upgrade()
{
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::MoveBefore {
workspace: workspace_handle,
other_workspace,
axis,
});
}
}
&& let Ok(manager) =
workspace.data::<WorkspaceData>().unwrap().manager.upgrade()
{
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::MoveBefore {
workspace: workspace_handle,
other_workspace,
axis,
});
}
}
zcosmic_workspace_handle_v2::Request::MoveAfter {
@ -237,26 +224,22 @@ where
} => {
if let Some(workspace_handle) =
state.workspace_state().get_ext_workspace_handle(&workspace)
{
if let Some(other_workspace) = state
&& let Some(other_workspace) = state
.workspace_state()
.get_ext_workspace_handle(&other_workspace)
{
if let Ok(manager) =
workspace.data::<WorkspaceData>().unwrap().manager.upgrade()
{
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::MoveAfter {
workspace: workspace_handle,
other_workspace,
axis,
});
}
}
&& let Ok(manager) =
workspace.data::<WorkspaceData>().unwrap().manager.upgrade()
{
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::MoveAfter {
workspace: workspace_handle,
other_workspace,
axis,
});
}
}
zcosmic_workspace_handle_v2::Request::Destroy => {}

101
src/wayland/protocols/workspace/ext.rs
View file

@ -152,18 +152,17 @@ where
.iter()
.find(|g| g.ext_instances.contains(obj))
.map(|g| g.id)
&& let Ok(manager) = data.manager.upgrade()
{
if let Ok(manager) = data.manager.upgrade() {
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::Create {
in_group: WorkspaceGroupHandle { id },
name: workspace,
});
}
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::Create {
in_group: WorkspaceGroupHandle { id },
name: workspace,
});
}
}
ext_workspace_group_handle_v1::Request::Destroy => {
@ -204,68 +203,62 @@ where
ext_workspace_handle_v1::Request::Activate => {
if let Some(workspace_handle) =
state.workspace_state().get_ext_workspace_handle(obj)
&& let Ok(manager) = data.manager.upgrade()
{
if let Ok(manager) = data.manager.upgrade() {
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::Activate(workspace_handle));
}
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::Activate(workspace_handle));
}
}
ext_workspace_handle_v1::Request::Deactivate => {
if let Some(workspace_handle) =
state.workspace_state().get_ext_workspace_handle(obj)
&& let Ok(manager) = data.manager.upgrade()
{
if let Ok(manager) = data.manager.upgrade() {
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::Deactivate(workspace_handle));
}
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::Deactivate(workspace_handle));
}
}
ext_workspace_handle_v1::Request::Remove => {
if let Some(workspace_handle) =
state.workspace_state().get_ext_workspace_handle(obj)
&& let Ok(manager) = data.manager.upgrade()
{
if let Ok(manager) = data.manager.upgrade() {
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::Remove(workspace_handle));
}
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::Remove(workspace_handle));
}
}
ext_workspace_handle_v1::Request::Assign { workspace_group } => {
if let Some(workspace_handle) =
state.workspace_state().get_ext_workspace_handle(obj)
{
if let Some(group_id) = state
&& let Some(group_id) = state
.workspace_state()
.groups
.iter()
.find(|g| g.ext_instances.contains(&workspace_group))
.map(|g| g.id)
{
if let Ok(manager) = data.manager.upgrade() {
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::Assign {
workspace: workspace_handle,
group: WorkspaceGroupHandle { id: group_id },
});
}
}
&& let Ok(manager) = data.manager.upgrade()
{
let mut state = manager
.data::<WorkspaceManagerData>()
.unwrap()
.lock()
.unwrap();
state.requests.push(Request::Assign {
workspace: workspace_handle,
group: WorkspaceGroupHandle { id: group_id },
});
}
}
ext_workspace_handle_v1::Request::Destroy => {
@ -491,10 +484,10 @@ where
changed = true;
}
if handle_state.ext_id.is_none() {
if let Some(id) = workspace.ext_id.clone() {
instance.id(id);
}
if handle_state.ext_id.is_none()
&& let Some(id) = workspace.ext_id.clone()
{
instance.id(id);
}
if let Some(cosmic_v2_handle) = handle_state