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

cargo fmt

Browse source
This commit is contained in:
Victoria Brekenfeld 2022-07-04 16:00:29 +02:00
parent 43062c1754
commit 39de286d51
40 changed files with 1557 additions and 1080 deletions
Download patch file Download diff file Expand all files Collapse all files

7
src/wayland/handlers/buffer.rs
View file

@ -1,10 +1,9 @@
// SPDX-License-Identifier: GPL-3.0-only
use smithay::{
reexports::wayland_server::protocol::wl_buffer::WlBuffer,
wayland::buffer::BufferHandler,
};
use crate::utils::prelude::*;
use smithay::{
reexports::wayland_server::protocol::wl_buffer::WlBuffer, wayland::buffer::BufferHandler,
};
impl BufferHandler for State {
fn buffer_destroyed(&mut self, _buffer: &WlBuffer) {}

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

@ -1,43 +1,22 @@
// SPDX-License-Identifier: GPL-3.0-only
use std::{
sync::Mutex,
};
use crate::{state::BackendData, utils::prelude::*};
use smithay::{
backend::renderer::utils::{
on_commit_buffer_handler,
},
desktop::{
LayerSurface,
PopupKind,
Kind,
WindowSurfaceType,
},
reexports::wayland_server::{
DisplayHandle,
protocol::wl_surface::WlSurface,
},
wayland::{
compositor::{
CompositorHandler,
CompositorState,
with_states,
},
shell::{
xdg::{
ToplevelSurface,
XdgToplevelSurfaceRoleAttributes,
XdgPopupSurfaceRoleAttributes,
},
wlr_layer::LayerSurfaceAttributes,
},
},
backend::renderer::utils::on_commit_buffer_handler,
delegate_compositor,
desktop::{Kind, LayerSurface, PopupKind, WindowSurfaceType},
reexports::wayland_server::{protocol::wl_surface::WlSurface, DisplayHandle},
wayland::{
compositor::{with_states, CompositorHandler, CompositorState},
shell::{
wlr_layer::LayerSurfaceAttributes,
xdg::{
ToplevelSurface, XdgPopupSurfaceRoleAttributes, XdgToplevelSurfaceRoleAttributes,
},
},
},
};
use crate::{
state::BackendData,
utils::prelude::*,
};
use std::sync::Mutex;
impl State {
fn early_import_surface(&mut self, dh: &DisplayHandle, surface: &WlSurface) {
@ -46,12 +25,17 @@ impl State {
if let BackendData::Kms(ref mut kms_state) = &mut self.backend {
if let Some(target) = kms_state.target_node_for_output(&output) {
if import_nodes.insert(target) {
kms_state.try_early_import(dh, surface, &output, target, &self.common.shell);
kms_state.try_early_import(
dh,
surface,
&output,
target,
&self.common.shell,
);
}
}
}
self
.backend
self.backend
.schedule_render(&self.common.event_loop_handle, &output);
}
}
@ -119,9 +103,14 @@ impl CompositorHandler for State {
fn commit(&mut self, dh: &DisplayHandle, surface: &WlSurface) {
// initial configure
if let Some((window, seat)) = self.common.shell.pending_windows.iter().find(|(window, _)| {
window.toplevel().wl_surface() == surface
}).cloned() {
if let Some((window, seat)) = self
.common
.shell
.pending_windows
.iter()
.find(|(window, _)| window.toplevel().wl_surface() == surface)
.cloned()
{
match window.toplevel() {
Kind::Xdg(toplevel) => {
if self.toplevel_ensure_initial_configure(&toplevel) {
@ -134,9 +123,14 @@ impl CompositorHandler for State {
}
}
if let Some((layer_surface, _, _)) = self.common.shell.pending_layers.iter().find(|(layer_surface, _, _)| {
layer_surface.wl_surface() == surface
}).cloned() {
if let Some((layer_surface, _, _)) = self
.common
.shell
.pending_layers
.iter()
.find(|(layer_surface, _, _)| layer_surface.wl_surface() == surface)
.cloned()
{
if self.layer_surface_ensure_inital_configure(&layer_surface) {
self.common.shell.map_layer(&layer_surface, dh);
} else {
@ -163,16 +157,17 @@ impl CompositorHandler for State {
.map(|window| (&mut workspace.space, window))
})
{
let new_location = crate::shell::layout::floating::ResizeSurfaceGrab::apply_resize_state(
&window,
space.window_location(&window).unwrap(),
window.geometry().size,
);
let new_location =
crate::shell::layout::floating::ResizeSurfaceGrab::apply_resize_state(
&window,
space.window_location(&window).unwrap(),
window.geometry().size,
);
if let Some(location) = new_location {
space.map_window(&window, location, true);
}
}
on_commit_buffer_handler(surface);
self.early_import_surface(dh, surface);
self.common.shell.popups.commit(surface);

24
src/wayland/handlers/data_device.rs
View file

@ -1,23 +1,17 @@
// SPDX-License-Identifier: GPL-3.0-only
use std::cell::RefCell;
use crate::state::State;
use smithay::{
reexports::wayland_server::protocol::{
wl_data_source::WlDataSource,
wl_surface::WlSurface,
},
delegate_data_device,
reexports::wayland_server::protocol::{wl_data_source::WlDataSource, wl_surface::WlSurface},
wayland::{
data_device::{
DataDeviceState,
DataDeviceHandler,
ClientDndGrabHandler,
ServerDndGrabHandler,
ClientDndGrabHandler, DataDeviceHandler, DataDeviceState, ServerDndGrabHandler,
},
seat::Seat,
},
delegate_data_device,
};
use crate::state::State;
use std::cell::RefCell;
pub struct DnDIcon {
surface: RefCell<Option<WlSurface>>,
@ -32,10 +26,10 @@ pub fn get_dnd_icon(seat: &Seat<State>) -> Option<WlSurface> {
impl ClientDndGrabHandler for State {
fn started(
&mut self,
_source: Option<WlDataSource>,
icon: Option<WlSurface>,
seat: Seat<Self>
&mut self,
_source: Option<WlDataSource>,
icon: Option<WlSurface>,
seat: Seat<Self>,
) {
let user_data = seat.user_data();
user_data.insert_if_missing(|| DnDIcon {

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

@ -1,32 +1,36 @@
// SPDX-License-Identifier: GPL-3.0-only
use crate::state::{BackendData, State};
use smithay::{
backend::{
allocator::dmabuf::Dmabuf,
renderer::ImportDma,
},
backend::{allocator::dmabuf::Dmabuf, renderer::ImportDma},
delegate_dmabuf,
reexports::wayland_server::DisplayHandle,
wayland::dmabuf::{DmabufGlobal, DmabufHandler, DmabufState, ImportError},
delegate_dmabuf,
};
use crate::state::{BackendData, State};
impl DmabufHandler for State {
fn dmabuf_state(&mut self) -> &mut DmabufState {
&mut self.common.dmabuf_state
}
fn dmabuf_imported(&mut self, dh: &DisplayHandle, global: &DmabufGlobal, dmabuf: Dmabuf) -> Result<(), ImportError> {
fn dmabuf_imported(
&mut self,
dh: &DisplayHandle,
global: &DmabufGlobal,
dmabuf: Dmabuf,
) -> Result<(), ImportError> {
match &mut self.backend {
BackendData::Kms(ref mut state) => state
.dmabuf_imported(dh, global, dmabuf)
.map_err(|_| ImportError::Failed),
BackendData::Winit(ref mut state) => state.backend
BackendData::Winit(ref mut state) => state
.backend
.renderer()
.import_dmabuf(&dmabuf, None)
.map(|_| ())
.map_err(|_| ImportError::Failed),
BackendData::X11(ref mut state) => state.renderer
BackendData::X11(ref mut state) => state
.renderer
.import_dmabuf(&dmabuf, None)
.map(|_| ())
.map_err(|_| ImportError::Failed),

26
src/wayland/handlers/layer_shell.rs
View file

@ -1,23 +1,17 @@
// SPDX-License-Identifier: GPL-3.0-only
use crate::utils::prelude::*;
use smithay::{
delegate_layer_shell,
desktop::LayerSurface,
reexports::wayland_server::{
DisplayHandle,
protocol::wl_output::WlOutput,
},
reexports::wayland_server::{protocol::wl_output::WlOutput, DisplayHandle},
wayland::{
output::Output,
shell::wlr_layer::{
WlrLayerShellHandler,
WlrLayerShellState,
LayerSurface as WlrLayerSurface,
Layer,
Layer, LayerSurface as WlrLayerSurface, WlrLayerShellHandler, WlrLayerShellState,
},
},
delegate_layer_shell,
};
use crate::utils::prelude::*;
impl WlrLayerShellHandler for State {
fn shell_state(&mut self) -> &mut WlrLayerShellState {
@ -25,12 +19,12 @@ impl WlrLayerShellHandler for State {
}
fn new_layer_surface(
&mut self,
_dh: &DisplayHandle,
surface: WlrLayerSurface,
wl_output: Option<WlOutput>,
_layer: Layer,
namespace: String
&mut self,
_dh: &DisplayHandle,
surface: WlrLayerSurface,
wl_output: Option<WlOutput>,
_layer: Layer,
namespace: String,
) {
super::mark_dirty_on_drop(&self.common, surface.wl_surface());
let seat = self.common.last_active_seat.clone();

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

@ -23,8 +23,8 @@ use smithay::{
fn mark_dirty_on_drop(state: &Common, wl_surface: &WlSurface) {
use std::sync::{
Arc,
atomic::{AtomicBool, Ordering},
Arc,
};
let dirty = state.dirty_flag.clone();
@ -33,7 +33,9 @@ fn mark_dirty_on_drop(state: &Common, wl_surface: &WlSurface) {
with_states(wl_surface, |data| {
data.data_map.insert_if_missing(|| DirtyFlag(dirty));
});
add_destruction_hook(wl_surface, |data| if let Some(DirtyFlag(dirty)) = data.data_map.get::<DirtyFlag>() {
dirty.store(true, Ordering::SeqCst);
add_destruction_hook(wl_surface, |data| {
if let Some(DirtyFlag(dirty)) = data.data_map.get::<DirtyFlag>() {
dirty.store(true, Ordering::SeqCst);
}
})
}
}

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

@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-3.0-only
use smithay::delegate_output;
use crate::state::State;
use smithay::delegate_output;
delegate_output!(State);

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

@ -6,11 +6,8 @@ use crate::{
config::OutputConfig,
state::State,
wayland::protocols::output_configuration::{
OutputConfigurationState,
OutputConfigurationHandler,
OutputConfiguration,
ModeConfiguration,
delegate_output_configuration,
delegate_output_configuration, ModeConfiguration, OutputConfiguration,
OutputConfigurationHandler, OutputConfigurationState,
},
};
@ -30,8 +27,15 @@ impl OutputConfigurationHandler for State {
}
impl State {
fn output_configuration(&mut self, test_only: bool, conf: Vec<(Output, OutputConfiguration)>) -> bool {
if conf.iter().all(|(_, conf)| matches!(conf, OutputConfiguration::Disabled)) {
fn output_configuration(
&mut self,
test_only: bool,
conf: Vec<(Output, OutputConfiguration)>,
) -> bool {
if conf
.iter()
.all(|(_, conf)| matches!(conf, OutputConfiguration::Disabled))
{
return false; // we don't allow the user to accidentally disable all their outputs
}
@ -50,15 +54,15 @@ impl State {
scale,
transform,
position,
} = conf {
} = conf
{
match mode {
Some(ModeConfiguration::Mode(mode)) => {
current_config.mode =
((mode.size.w, mode.size.h), Some(mode.refresh as u32));
}
Some(ModeConfiguration::Custom { size, refresh }) => {
current_config.mode =
((size.w, size.h), refresh.map(|x| x as u32));
current_config.mode = ((size.w, size.h), refresh.map(|x| x as u32));
}
_ => {}
}
@ -116,22 +120,25 @@ impl State {
}
}
for output in conf.iter().filter(|(_, c)| matches!(c, OutputConfiguration::Enabled { .. })).map(|(o, _)| o) {
for output in conf
.iter()
.filter(|(_, c)| matches!(c, OutputConfiguration::Enabled { .. }))
.map(|(o, _)| o)
{
self.common.output_configuration_state.enable_head(output);
}
for output in conf.iter().filter(|(_, c)| matches!(c, OutputConfiguration::Disabled)).map(|(o, _)| o) {
for output in conf
.iter()
.filter(|(_, c)| matches!(c, OutputConfiguration::Disabled))
.map(|(o, _)| o)
{
self.common.output_configuration_state.disable_head(output);
}
self
.common
self.common
.config
.write_outputs(self.common.output_configuration_state.outputs());
self.common.event_loop_handle.insert_idle(move |data| {
data
.state
.common
.output_configuration_state
.update();
data.state.common.output_configuration_state.update();
});
true

8
src/wayland/handlers/seat.rs
View file

@ -1,10 +1,10 @@
// SPDX-License-Identifier: GPL-3.0-only
use smithay::{
wayland::seat::{SeatHandler, SeatState},
delegate_seat,
};
use crate::state::State;
use smithay::{
delegate_seat,
wayland::seat::{SeatHandler, SeatState},
};
impl SeatHandler for State {
fn seat_state(&mut self) -> &mut SeatState<Self> {

8
src/wayland/handlers/shm.rs
View file

@ -1,10 +1,10 @@
// SPDX-License-Identifier: GPL-3.0-only
use smithay::{
wayland::shm::{ShmHandler, ShmState},
delegate_shm,
};
use crate::state::State;
use smithay::{
delegate_shm,
wayland::shm::{ShmHandler, ShmState},
};
impl ShmHandler for State {
fn shm_state(&self) -> &ShmState {

4
src/wayland/handlers/toplevel_info.rs
View file

@ -3,9 +3,7 @@
use crate::{
state::State,
wayland::protocols::toplevel_info::{
ToplevelInfoHandler,
ToplevelInfoState,
delegate_toplevel_info,
delegate_toplevel_info, ToplevelInfoHandler, ToplevelInfoState,
},
};

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

@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-3.0-only
use smithay::delegate_viewporter;
use crate::state::State;
use smithay::delegate_viewporter;
delegate_viewporter!(State);

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

@ -1,8 +1,5 @@
// SPDX-License-Identifier: GPL-3.0-only
use crate::{
state::State,
wayland::protocols::drm::delegate_wl_drm,
};
use crate::{state::State, wayland::protocols::drm::delegate_wl_drm};
delegate_wl_drm!(State);

28
src/wayland/handlers/workspace.rs
View file

@ -1,18 +1,14 @@
// SPDX-License-Identifier: GPL-3.0-only
use smithay::reexports::wayland_server::DisplayHandle;
use crate::{
state::ClientState,
wayland::protocols::workspace::{
Request,
WorkspaceHandler,
WorkspaceState,
WorkspaceClientHandler,
WorkspaceClientState,
delegate_workspace,
},
utils::prelude::*,
wayland::protocols::workspace::{
delegate_workspace, Request, WorkspaceClientHandler, WorkspaceClientState,
WorkspaceHandler, WorkspaceState,
},
};
use smithay::reexports::wayland_server::DisplayHandle;
impl WorkspaceClientHandler for ClientState {
fn workspace_state(&self) -> &WorkspaceClientState {
@ -28,18 +24,24 @@ impl WorkspaceHandler for State {
fn workspace_state_mut(&mut self) -> &mut WorkspaceState<Self> {
&mut self.common.shell.workspace_state
}
fn commit_requests(&mut self, _dh: &DisplayHandle, requests: Vec<Request>) {
for request in requests.into_iter() {
match request {
Request::Activate(handle) => {
if let Some(idx) = self.common.shell.spaces.iter().position(|w| w.handle == handle) {
if let Some(idx) = self
.common
.shell
.spaces
.iter()
.position(|w| w.handle == handle)
{
let seat = &self.common.last_active_seat;
let output = active_output(seat, &self.common);
self.common.shell.activate(seat, &output, idx);
}
},
_ => {},
}
_ => {}
}
}
}

143
src/wayland/handlers/xdg_shell.rs
View file

@ -1,53 +1,36 @@
// SPDX-License-Identifier: GPL-3.0-only
use crate::utils::prelude::*;
use smithay::{
delegate_xdg_shell,
desktop::{
Kind,
PopupKind,
PopupUngrabStrategy,
PopupKeyboardGrab,
PopupPointerGrab,
PopupGrab,
Window,
WindowSurfaceType,
Kind, PopupGrab, PopupKeyboardGrab, PopupKind, PopupPointerGrab, PopupUngrabStrategy,
Window, WindowSurfaceType,
},
reexports::{
wayland_server::{
DisplayHandle,
protocol::{
wl_seat::WlSeat,
wl_surface::WlSurface,
wl_output::WlOutput,
},
},
wayland_protocols::xdg::shell::server::xdg_toplevel,
wayland_server::{
protocol::{wl_output::WlOutput, wl_seat::WlSeat, wl_surface::WlSurface},
DisplayHandle,
},
},
wayland::{
shell::xdg::{
XdgShellHandler,
XdgShellState,
ToplevelSurface,
PopupSurface,
PositionerState,
Configure,
},
seat::{
Seat,
PointerGrabStartData,
},
output::Output,
seat::{PointerGrabStartData, Seat},
shell::xdg::{
Configure, PopupSurface, PositionerState, ToplevelSurface, XdgShellHandler,
XdgShellState,
},
Serial,
},
delegate_xdg_shell,
};
use std::cell::Cell;
use crate::utils::prelude::*;
pub type PopupGrabData = Cell<Option<PopupGrab>>;
impl XdgShellHandler for State {
fn xdg_shell_state(&mut self) -> &mut XdgShellState {
&mut self.common.shell.xdg_shell_state
&mut self.common.shell.xdg_shell_state
}
fn new_toplevel(&mut self, _dh: &DisplayHandle, surface: ToplevelSurface) {
@ -56,7 +39,10 @@ impl XdgShellHandler for State {
let seat = &self.common.last_active_seat;
let window = Window::new(Kind::Xdg(surface));
self.common.shell.toplevel_info_state.new_toplevel(&window);
self.common.shell.pending_windows.push((window, seat.clone()));
self.common
.shell
.pending_windows
.push((window, seat.clone()));
// We will position the window after the first commit, when we know its size hints
}
@ -67,7 +53,7 @@ impl XdgShellHandler for State {
_positioner: PositionerState,
) {
super::mark_dirty_on_drop(&self.common, surface.wl_surface());
self.common
.shell
.popups
@ -75,37 +61,33 @@ impl XdgShellHandler for State {
.unwrap();
}
fn ack_configure(
&mut self,
_dh: &DisplayHandle,
surface: WlSurface,
configure: Configure
) {
fn ack_configure(&mut self, _dh: &DisplayHandle, surface: WlSurface, configure: Configure) {
if let Configure::Toplevel(configure) = configure {
// If we would re-position the window inside the grab we would get a weird jittery animation.
// We only want to resize once the client has acknoledged & commited the new size,
// so we need to carefully track the state through different handlers.
if let Some(window) = self.common
.shell
.space_for_surface(&surface)
.and_then(|workspace| workspace.space.window_for_surface(&surface, WindowSurfaceType::TOPLEVEL))
if let Some(window) =
self.common
.shell
.space_for_surface(&surface)
.and_then(|workspace| {
workspace
.space
.window_for_surface(&surface, WindowSurfaceType::TOPLEVEL)
})
{
crate::shell::layout::floating::ResizeSurfaceGrab::ack_configure(
window, configure,
)
crate::shell::layout::floating::ResizeSurfaceGrab::ack_configure(window, configure)
}
}
}
fn grab(
&mut self,
dh: &DisplayHandle,
surface: PopupSurface,
seat: WlSeat,
serial: Serial,
) {
fn grab(&mut self, dh: &DisplayHandle, surface: PopupSurface, seat: WlSeat, serial: Serial) {
let seat = Seat::from_resource(&seat).unwrap();
let ret = self.common.shell.popups.grab_popup(dh, surface.into(), &seat, serial);
let ret = self
.common
.shell
.popups
.grab_popup(dh, surface.into(), &seat, serial);
if let Ok(mut grab) = ret {
if let Some(keyboard) = seat.get_keyboard() {
@ -116,16 +98,16 @@ impl XdgShellHandler for State {
grab.ungrab(dh, PopupUngrabStrategy::All);
return;
}
self.common.set_focus(dh, grab.current_grab().as_ref(), &seat, Some(serial));
self.common
.set_focus(dh, grab.current_grab().as_ref(), &seat, Some(serial));
keyboard.set_grab(PopupKeyboardGrab::new(&grab), serial);
}
if let Some(pointer) = seat.get_pointer() {
if pointer.is_grabbed()
&& !(pointer.has_grab(serial)
|| pointer.has_grab(
grab.previous_serial().unwrap_or_else(|| grab.serial()),
))
|| pointer
.has_grab(grab.previous_serial().unwrap_or_else(|| grab.serial())))
{
grab.ungrab(dh, PopupUngrabStrategy::All);
return;
@ -147,7 +129,7 @@ impl XdgShellHandler for State {
_dh: &DisplayHandle,
surface: PopupSurface,
positioner: PositionerState,
token: u32
token: u32,
) {
surface.with_pending_state(|state| {
// TODO: This is a simplification, a proper compositor would
@ -166,12 +148,10 @@ impl XdgShellHandler for State {
_dh: &DisplayHandle,
surface: ToplevelSurface,
seat: WlSeat,
serial: Serial
serial: Serial,
) {
let seat = Seat::from_resource(&seat).unwrap();
if let Some(start_data) =
check_grab_preconditions(&seat, surface.wl_surface(), serial)
{
if let Some(start_data) = check_grab_preconditions(&seat, surface.wl_surface(), serial) {
let workspace = self
.common
.shell
@ -184,7 +164,7 @@ impl XdgShellHandler for State {
.clone();
workspace.move_request(&window, &seat, serial, start_data);
}
}
}
fn resize_request(
@ -193,12 +173,10 @@ impl XdgShellHandler for State {
surface: ToplevelSurface,
seat: WlSeat,
serial: Serial,
edges: xdg_toplevel::ResizeEdge
edges: xdg_toplevel::ResizeEdge,
) {
let seat = Seat::from_resource(&seat).unwrap();
if let Some(start_data) =
check_grab_preconditions(&seat, surface.wl_surface(), serial)
{
if let Some(start_data) = check_grab_preconditions(&seat, surface.wl_surface(), serial) {
let workspace = self
.common
.shell
@ -220,8 +198,11 @@ impl XdgShellHandler for State {
let output = active_output(seat, &self.common);
if let Some(workspace) = self.common.shell.space_for_surface_mut(surface) {
let window =
workspace.space.window_for_surface(surface, WindowSurfaceType::TOPLEVEL).unwrap().clone();
let window = workspace
.space
.window_for_surface(surface, WindowSurfaceType::TOPLEVEL)
.unwrap()
.clone();
workspace.maximize_request(&window, &output)
}
}
@ -234,7 +215,12 @@ impl XdgShellHandler for State {
surface.send_configure();
}
fn fullscreen_request(&mut self, _dh: &DisplayHandle, surface: ToplevelSurface, output: Option<WlOutput>) {
fn fullscreen_request(
&mut self,
_dh: &DisplayHandle,
surface: ToplevelSurface,
output: Option<WlOutput>,
) {
let output = output
.as_ref()
.and_then(Output::from_resource)
@ -245,8 +231,11 @@ impl XdgShellHandler for State {
let surface = surface.wl_surface();
if let Some(workspace) = self.common.shell.space_for_surface_mut(surface) {
let window =
workspace.space.window_for_surface(surface, WindowSurfaceType::TOPLEVEL).unwrap().clone();
let window = workspace
.space
.window_for_surface(surface, WindowSurfaceType::TOPLEVEL)
.unwrap()
.clone();
workspace.fullscreen_request(&window, &output)
}
}
@ -254,8 +243,11 @@ impl XdgShellHandler for State {
fn unfullscreen_request(&mut self, _dh: &DisplayHandle, surface: ToplevelSurface) {
let surface = surface.wl_surface();
if let Some(workspace) = self.common.shell.space_for_surface_mut(surface) {
let window =
workspace.space.window_for_surface(surface, WindowSurfaceType::TOPLEVEL).unwrap().clone();
let window = workspace
.space
.window_for_surface(surface, WindowSurfaceType::TOPLEVEL)
.unwrap()
.clone();
workspace.unfullscreen_request(&window)
}
}
@ -294,5 +286,4 @@ fn check_grab_preconditions(
Some(start_data)
}
delegate_xdg_shell!(State);

2
src/wayland/mod.rs
View file

@ -1,4 +1,4 @@
// SPDX-License-Identifier: GPL-3.0-only
pub mod protocols;
pub mod handlers;
pub mod protocols;

89
src/wayland/protocols/drm.rs
View file

@ -26,11 +26,8 @@ use smithay::{
Format, Fourcc, Modifier,
},
reexports::wayland_server::{
Client, DataInit, DisplayHandle,
DelegateGlobalDispatch, DelegateDispatch,
GlobalDispatch, Dispatch, Resource,
New, backend::GlobalId,
protocol::wl_buffer::WlBuffer,
backend::GlobalId, protocol::wl_buffer::WlBuffer, Client, DataInit, DelegateDispatch,
DelegateGlobalDispatch, Dispatch, DisplayHandle, GlobalDispatch, New, Resource,
},
wayland::{
buffer::BufferHandler,
@ -38,11 +35,7 @@ use smithay::{
},
};
use std::{
convert::TryFrom,
path::PathBuf,
sync::Arc,
};
use std::{convert::TryFrom, path::PathBuf, sync::Arc};
pub struct WlDrmState;
@ -118,18 +111,14 @@ where
) {
match request {
wl_drm::Request::Authenticate { .. } => drm.authenticated(),
wl_drm::Request::CreateBuffer { .. } => {
drm.post_error(
wl_drm::Error::InvalidName,
String::from("Flink handles are unsupported, use PRIME"),
)
},
wl_drm::Request::CreatePlanarBuffer { .. } => {
drm.post_error(
wl_drm::Error::InvalidName,
String::from("Flink handles are unsupported, use PRIME"),
)
},
wl_drm::Request::CreateBuffer { .. } => drm.post_error(
wl_drm::Error::InvalidName,
String::from("Flink handles are unsupported, use PRIME"),
),
wl_drm::Request::CreatePlanarBuffer { .. } => drm.post_error(
wl_drm::Error::InvalidName,
String::from("Flink handles are unsupported, use PRIME"),
),
wl_drm::Request::CreatePrimeBuffer {
id,
name,
@ -150,7 +139,7 @@ where
return;
}
format
},
}
Err(_) => {
drm.post_error(
wl_drm::Error::InvalidFormat,
@ -171,29 +160,30 @@ where
let mut dma = Dmabuf::builder((width, height), format, DmabufFlags::empty());
dma.add_plane(name, 0, offset0 as u32, stride0 as u32, Modifier::Invalid);
match dma.build() {
Some(dmabuf) => match state.dmabuf_imported(dh, &data.dmabuf_global, dmabuf.clone()) {
Ok(_) => {
// import was successful
data_init.init(id, dmabuf);
slog_scope::trace!("Created a new validated dma wl_buffer via wl_drm.");
},
Some(dmabuf) => {
match state.dmabuf_imported(dh, &data.dmabuf_global, dmabuf.clone()) {
Ok(_) => {
// import was successful
data_init.init(id, dmabuf);
slog_scope::trace!(
"Created a new validated dma wl_buffer via wl_drm."
);
}
Err(ImportError::InvalidFormat) => {
drm.post_error(
wl_drm::Error::InvalidFormat,
"format and plane combination are not valid",
);
}
Err(ImportError::InvalidFormat) => {
drm.post_error(
wl_drm::Error::InvalidFormat,
"format and plane combination are not valid",
);
}
Err(ImportError::Failed) => {
// Buffer import failed. The protocol documentation heavily implies killing the
// client is the right thing to do here.
drm.post_error(
wl_drm::Error::InvalidName,
"buffer import failed",
);
Err(ImportError::Failed) => {
// Buffer import failed. The protocol documentation heavily implies killing the
// client is the right thing to do here.
drm.post_error(wl_drm::Error::InvalidName, "buffer import failed");
}
}
},
}
None => {
// Buffer import failed. The protocol documentation heavily implies killing the
// client is the right thing to do here.
@ -223,7 +213,9 @@ impl WlDrmState {
+ DmabufHandler
+ 'static,
{
self.create_global_with_filter::<D, _>(display, device_path, formats, dmabuf_global, |_| true)
self.create_global_with_filter::<D, _>(display, device_path, formats, dmabuf_global, |_| {
true
})
}
pub fn create_global_with_filter<D, F>(
@ -242,7 +234,13 @@ impl WlDrmState {
+ 'static,
F: for<'a> Fn(&'a Client) -> bool + Send + Sync + 'static,
{
let formats = Arc::new(formats.into_iter().filter(|f| f.modifier == Modifier::Invalid).map(|f| f.code).collect());
let formats = Arc::new(
formats
.into_iter()
.filter(|f| f.modifier == Modifier::Invalid)
.map(|f| f.code)
.collect(),
);
let data = DrmGlobalData {
filter: Box::new(client_filter),
formats,
@ -266,4 +264,3 @@ macro_rules! delegate_wl_drm {
};
}
pub(crate) use delegate_wl_drm;

246
src/wayland/protocols/output_configuration.rs
View file

@ -1,12 +1,5 @@
// SPDX-License-Identifier: GPL-3.0-only
use std::{
convert::{TryFrom, TryInto},
sync::{
Arc, Mutex,
atomic::{AtomicBool, Ordering},
},
};
use smithay::{
reexports::{
wayland_protocols_wlr::output_management::v1::server::{
@ -17,16 +10,21 @@ use smithay::{
zwlr_output_mode_v1::{self, ZwlrOutputModeV1},
},
wayland_server::{
Client, DisplayHandle,
GlobalDispatch, Dispatch,
DelegateGlobalDispatch, DelegateDispatch,
DataInit, New, Resource,
backend::{ClientId, GlobalId, ObjectId},
protocol::wl_output::WlOutput,
Client, DataInit, DelegateDispatch, DelegateGlobalDispatch, Dispatch, DisplayHandle,
GlobalDispatch, New, Resource,
},
},
wayland::output::{Output, Mode, OutputData},
utils::{Logical, Physical, Point, Size, Transform},
wayland::output::{Mode, Output, OutputData},
};
use std::{
convert::{TryFrom, TryInto},
sync::{
atomic::{AtomicBool, Ordering},
Arc, Mutex,
},
};
pub struct OutputConfigurationState<D> {
@ -105,7 +103,9 @@ pub enum OutputConfiguration {
impl<'a> TryFrom<&'a mut PendingOutputConfigurationInner> for OutputConfiguration {
type Error = zwlr_output_configuration_head_v1::Error;
fn try_from(pending: &'a mut PendingOutputConfigurationInner) -> Result<OutputConfiguration, Self::Error> {
fn try_from(
pending: &'a mut PendingOutputConfigurationInner,
) -> Result<OutputConfiguration, Self::Error> {
let mode = match pending.mode.clone() {
Some(ModeConfiguration::Mode(wlr_mode)) => Some(ModeConfiguration::Mode(
wlr_mode
@ -133,7 +133,8 @@ struct OutputStateInner {
}
type OutputState = Mutex<OutputStateInner>;
impl<D> DelegateGlobalDispatch<ZwlrOutputManagerV1, OutputMngrGlobalData, D> for OutputConfigurationState<D>
impl<D> DelegateGlobalDispatch<ZwlrOutputManagerV1, OutputMngrGlobalData, D>
for OutputConfigurationState<D>
where
D: GlobalDispatch<ZwlrOutputManagerV1, OutputMngrGlobalData>
+ Dispatch<ZwlrOutputManagerV1, OutputMngrInstanceData>
@ -142,7 +143,7 @@ where
+ Dispatch<ZwlrOutputConfigurationV1, PendingConfiguration>
+ Dispatch<ZwlrOutputConfigurationHeadV1, PendingOutputConfiguration>
+ OutputConfigurationHandler
+ 'static
+ 'static,
{
fn bind(
state: &mut D,
@ -161,7 +162,7 @@ where
heads: Vec::new(),
active,
};
let mngr_state = state.output_configuration_state();
for output in &mngr_state.outputs {
send_head_to_client::<D>(dh, &mut instance, output);
@ -175,7 +176,8 @@ where
}
}
impl<D> DelegateDispatch<ZwlrOutputManagerV1, OutputMngrInstanceData, D> for OutputConfigurationState<D>
impl<D> DelegateDispatch<ZwlrOutputManagerV1, OutputMngrInstanceData, D>
for OutputConfigurationState<D>
where
D: GlobalDispatch<ZwlrOutputManagerV1, OutputMngrGlobalData>
+ Dispatch<ZwlrOutputManagerV1, OutputMngrInstanceData>
@ -184,7 +186,7 @@ where
+ Dispatch<ZwlrOutputConfigurationV1, PendingConfiguration>
+ Dispatch<ZwlrOutputConfigurationHeadV1, PendingOutputConfiguration>
+ OutputConfigurationHandler
+ 'static
+ 'static,
{
fn request(
state: &mut D,
@ -196,25 +198,25 @@ where
data_init: &mut DataInit<'_, D>,
) {
match request {
zwlr_output_manager_v1::Request::CreateConfiguration {
id,
serial,
} => {
let conf = data_init.init(id, PendingConfiguration::new(PendingConfigurationInner {
serial,
used: false,
heads: Vec::new(),
}));
zwlr_output_manager_v1::Request::CreateConfiguration { id, serial } => {
let conf = data_init.init(
id,
PendingConfiguration::new(PendingConfigurationInner {
serial,
used: false,
heads: Vec::new(),
}),
);
let state = state.output_configuration_state();
if serial != state.serial_counter {
conf.cancelled();
}
},
}
zwlr_output_manager_v1::Request::Stop => {
data.active.store(false, Ordering::SeqCst);
},
_ => {},
}
_ => {}
}
}
}
@ -228,7 +230,7 @@ where
+ Dispatch<ZwlrOutputConfigurationV1, PendingConfiguration>
+ Dispatch<ZwlrOutputConfigurationHeadV1, PendingOutputConfiguration>
+ OutputConfigurationHandler
+ 'static
+ 'static,
{
fn request(
_state: &mut D,
@ -244,12 +246,7 @@ where
}
}
fn destroyed(
state: &mut D,
_client: ClientId,
resource: ObjectId,
_data: &Output,
) {
fn destroyed(state: &mut D, _client: ClientId, resource: ObjectId, _data: &Output) {
for instance in &mut state.output_configuration_state().instances {
instance.heads.retain(|h| h.head.id() != resource);
}
@ -265,7 +262,7 @@ where
+ Dispatch<ZwlrOutputConfigurationV1, PendingConfiguration>
+ Dispatch<ZwlrOutputConfigurationHeadV1, PendingOutputConfiguration>
+ OutputConfigurationHandler
+ 'static
+ 'static,
{
fn request(
_state: &mut D,
@ -282,7 +279,8 @@ where
}
}
impl<D> DelegateDispatch<ZwlrOutputConfigurationV1, PendingConfiguration, D> for OutputConfigurationState<D>
impl<D> DelegateDispatch<ZwlrOutputConfigurationV1, PendingConfiguration, D>
for OutputConfigurationState<D>
where
D: GlobalDispatch<ZwlrOutputManagerV1, OutputMngrGlobalData>
+ Dispatch<ZwlrOutputManagerV1, OutputMngrInstanceData>
@ -291,7 +289,7 @@ where
+ Dispatch<ZwlrOutputConfigurationV1, PendingConfiguration>
+ Dispatch<ZwlrOutputConfigurationHeadV1, PendingOutputConfiguration>
+ OutputConfigurationHandler
+ 'static
+ 'static,
{
fn request(
state: &mut D,
@ -315,7 +313,7 @@ where
let conf_head = data_init.init(id, PendingOutputConfiguration::default());
pending.heads.push((head, Some(conf_head)));
},
}
zwlr_output_configuration_v1::Request::DisableHead { head } => {
let mut pending = data.lock().unwrap();
if pending.heads.iter().any(|(h, _)| *h == head) {
@ -326,11 +324,11 @@ where
return;
}
pending.heads.push((head, None));
},
}
x @ zwlr_output_configuration_v1::Request::Apply
| x @ zwlr_output_configuration_v1::Request::Test => {
let mut pending = data.lock().unwrap();
if pending.used {
return obj.post_error(
zwlr_output_configuration_v1::Error::AlreadyUsed,
@ -350,16 +348,17 @@ where
.iter_mut()
.map(|(head, conf)| {
let output = match {
inner.instances
inner
.instances
.iter()
.find_map(|instance| instance.heads.iter().find(|h| h.head == *head))
.find_map(|instance| {
instance.heads.iter().find(|h| h.head == *head)
})
.map(|i| i.output.clone())
} {
Some(o) => o,
None => {
return Err(
zwlr_output_configuration_head_v1::Error::InvalidMode,
);
return Err(zwlr_output_configuration_head_v1::Error::InvalidMode);
}
};
@ -374,8 +373,10 @@ where
None => Ok((output, OutputConfiguration::Disabled)),
}
})
.collect::<Result<Vec<(Output, OutputConfiguration)>, zwlr_output_configuration_head_v1::Error>>()
{
.collect::<Result<
Vec<(Output, OutputConfiguration)>,
zwlr_output_configuration_head_v1::Error,
>>() {
Ok(conf) => conf,
Err(code) => {
return obj.post_error(code, "Incomplete configuration".to_string());
@ -393,14 +394,15 @@ where
} else {
obj.failed();
}
},
zwlr_output_configuration_v1::Request::Destroy => {},
_ => {},
}
zwlr_output_configuration_v1::Request::Destroy => {}
_ => {}
}
}
}
impl<D> DelegateDispatch<ZwlrOutputConfigurationHeadV1, PendingOutputConfiguration, D> for OutputConfigurationState<D>
impl<D> DelegateDispatch<ZwlrOutputConfigurationHeadV1, PendingOutputConfiguration, D>
for OutputConfigurationState<D>
where
D: GlobalDispatch<ZwlrOutputManagerV1, OutputMngrGlobalData>
+ Dispatch<ZwlrOutputManagerV1, OutputMngrInstanceData>
@ -409,7 +411,7 @@ where
+ Dispatch<ZwlrOutputConfigurationV1, PendingConfiguration>
+ Dispatch<ZwlrOutputConfigurationHeadV1, PendingOutputConfiguration>
+ OutputConfigurationHandler
+ 'static
+ 'static,
{
fn request(
_state: &mut D,
@ -431,8 +433,12 @@ where
return;
}
pending.mode = Some(ModeConfiguration::Mode(mode));
},
zwlr_output_configuration_head_v1::Request::SetCustomMode { width, height, refresh } => {
}
zwlr_output_configuration_head_v1::Request::SetCustomMode {
width,
height,
refresh,
} => {
let mut pending = data.lock().unwrap();
if pending.mode.is_some() {
obj.post_error(
@ -445,7 +451,7 @@ where
size: Size::from((width, height)),
refresh: if refresh == 0 { None } else { Some(refresh) },
});
},
}
zwlr_output_configuration_head_v1::Request::SetPosition { x, y } => {
let mut pending = data.lock().unwrap();
if pending.position.is_some() {
@ -456,7 +462,7 @@ where
return;
}
pending.position = Some(Point::from((x, y)));
},
}
zwlr_output_configuration_head_v1::Request::SetScale { scale } => {
let mut pending = data.lock().unwrap();
if pending.scale.is_some() {
@ -467,7 +473,7 @@ where
return;
}
pending.scale = Some(scale);
},
}
zwlr_output_configuration_head_v1::Request::SetTransform { transform } => {
let mut pending = data.lock().unwrap();
if pending.transform.is_some() {
@ -485,36 +491,36 @@ where
format!("Invalid transform: {:?}", err),
);
return;
},
}
});
},
_ => {},
}
_ => {}
}
}
}
impl<D> OutputConfigurationState<D>
where
D: GlobalDispatch<ZwlrOutputManagerV1, OutputMngrGlobalData>
+ GlobalDispatch<WlOutput, OutputData>
+ Dispatch<ZwlrOutputManagerV1, OutputMngrInstanceData>
+ Dispatch<ZwlrOutputHeadV1, Output>
+ Dispatch<ZwlrOutputModeV1, Mode>
+ Dispatch<ZwlrOutputConfigurationV1, PendingConfiguration>
+ Dispatch<ZwlrOutputConfigurationHeadV1, PendingOutputConfiguration>
+ OutputConfigurationHandler
+ 'static,
D: GlobalDispatch<ZwlrOutputManagerV1, OutputMngrGlobalData>
+ GlobalDispatch<WlOutput, OutputData>
+ Dispatch<ZwlrOutputManagerV1, OutputMngrInstanceData>
+ Dispatch<ZwlrOutputHeadV1, Output>
+ Dispatch<ZwlrOutputModeV1, Mode>
+ Dispatch<ZwlrOutputConfigurationV1, PendingConfiguration>
+ Dispatch<ZwlrOutputConfigurationHeadV1, PendingOutputConfiguration>
+ OutputConfigurationHandler
+ 'static,
{
pub fn new<F>(
dh: &DisplayHandle,
client_filter: F,
) -> OutputConfigurationState<D>
pub fn new<F>(dh: &DisplayHandle, client_filter: F) -> OutputConfigurationState<D>
where
F: for<'a> Fn(&'a Client) -> bool + Send + Sync + 'static,
{
let global = dh.create_global::<D, ZwlrOutputManagerV1, _>(2, OutputMngrGlobalData {
filter: Box::new(client_filter),
});
let global = dh.create_global::<D, ZwlrOutputManagerV1, _>(
2,
OutputMngrGlobalData {
filter: Box::new(client_filter),
},
);
OutputConfigurationState {
outputs: Vec::new(),
@ -530,19 +536,23 @@ where
pub fn global_id(&self) -> GlobalId {
self.global.clone()
}
pub fn add_heads<'a>(&mut self, outputs: impl Iterator<Item = &'a Output>) {
let new_outputs = outputs.filter(|o| !self.outputs.contains(o)).collect::<Vec<_>>();
let new_outputs = outputs
.filter(|o| !self.outputs.contains(o))
.collect::<Vec<_>>();
for output in new_outputs {
output.user_data().insert_if_missing(|| OutputState::new(OutputStateInner {
enabled: true,
global: None,
}));
output.user_data().insert_if_missing(|| {
OutputState::new(OutputStateInner {
enabled: true,
global: None,
})
});
self.outputs.push(output.clone());
}
}
pub fn remove_heads<'a>(&mut self, outputs: impl Iterator<Item = &'a Output>) {
for output in outputs {
if self.outputs.contains(output) {
@ -577,17 +587,19 @@ where
pub fn update(&mut self) {
self.instances.retain(|x| x.active.load(Ordering::SeqCst));
self.serial_counter += 1;
for output in std::mem::take(&mut self.removed_outputs).into_iter() {
for instance in &mut self.instances {
instance.heads.retain_mut(|head| if &head.output == &output {
for mode in &head.modes {
mode.finished();
instance.heads.retain_mut(|head| {
if &head.output == &output {
for mode in &head.modes {
mode.finished();
}
head.head.finished();
false
} else {
true
}
head.head.finished();
false
} else {
true
});
}
}
@ -624,13 +636,17 @@ where
+ Dispatch<ZwlrOutputModeV1, Mode>
+ Dispatch<ZwlrOutputConfigurationV1, PendingConfiguration>
+ OutputConfigurationHandler
+ 'static
+ 'static,
{
let instance = match mngr.heads.iter_mut().find(|i| i.output == *output) {
Some(i) => i,
None => {
if let Ok(client) = dh.get_client(mngr.obj.id()) {
if let Ok(head) = client.create_resource::<ZwlrOutputHeadV1, _, D>(dh, mngr.obj.version(), output.clone()) {
if let Ok(head) = client.create_resource::<ZwlrOutputHeadV1, _, D>(
dh,
mngr.obj.version(),
output.clone(),
) {
mngr.obj.head(&head);
let data = OutputHeadInstance {
head,
@ -652,7 +668,9 @@ where
instance.head.description(output.description());
let physical = output.physical_properties();
if !(physical.size.w == 0 || physical.size.h == 0) {
instance.head.physical_size(physical.size.w, physical.size.h);
instance
.head
.physical_size(physical.size.w, physical.size.h);
}
let inner = output
@ -664,26 +682,37 @@ where
let output_modes = output.modes();
// remove old modes
instance.modes.retain_mut(|m| if !output_modes.contains(m.data::<Mode>().unwrap()) {
m.finished();
false
} else {
true
instance.modes.retain_mut(|m| {
if !output_modes.contains(m.data::<Mode>().unwrap()) {
m.finished();
false
} else {
true
}
});
// update other modes
for output_mode in output_modes.into_iter() {
if let Some(mode) = if let Some(wlr_mode) = instance.modes
if let Some(mode) = if let Some(wlr_mode) = instance
.modes
.iter()
.find(|mode| *mode.data::<Mode>().unwrap() == output_mode)
{
Some(wlr_mode)
} else if let Ok(client) = dh.get_client(instance.head.id()) {
// create the mode if it does not exist yet
if let Ok(mode) = client.create_resource::<ZwlrOutputModeV1, _, D>(dh, instance.head.version(), output_mode) {
if let Ok(mode) = client.create_resource::<ZwlrOutputModeV1, _, D>(
dh,
instance.head.version(),
output_mode,
) {
instance.head.mode(&mode);
mode.size(output_mode.size.w, output_mode.size.h);
mode.refresh(output_mode.refresh);
if output.preferred_mode().map(|p| p == output_mode).unwrap_or(false) {
if output
.preferred_mode()
.map(|p| p == output_mode)
.unwrap_or(false)
{
mode.preferred();
}
instance.modes.push(mode);
@ -694,7 +723,12 @@ where
} else {
None
} {
if inner.enabled && output.current_mode().map(|c| c == output_mode).unwrap_or(false) {
if inner.enabled
&& output
.current_mode()
.map(|c| c == output_mode)
.unwrap_or(false)
{
instance.head.current_mode(&*mode);
}
}

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

@ -5,30 +5,24 @@ use std::sync::Mutex;
use smithay::{
desktop::Window,
reexports::{
wayland_server::{
Client, DataInit,
DisplayHandle, Resource, New,
GlobalDispatch, Dispatch,
DelegateGlobalDispatch, DelegateDispatch,
backend::{ClientId, GlobalId, ObjectId},
},
wayland_protocols::xdg::shell::server::xdg_toplevel,
},
wayland::{
compositor::with_states,
output::Output,
shell::xdg::XdgToplevelSurfaceRoleAttributes,
wayland_server::{
backend::{ClientId, GlobalId, ObjectId},
Client, DataInit, DelegateDispatch, DelegateGlobalDispatch, Dispatch, DisplayHandle,
GlobalDispatch, New, Resource,
},
},
utils::IsAlive,
wayland::{
compositor::with_states, output::Output, shell::xdg::XdgToplevelSurfaceRoleAttributes,
},
};
use super::workspace::{WorkspaceHandler, WorkspaceHandle, WorkspaceState};
use super::workspace::{WorkspaceHandle, WorkspaceHandler, WorkspaceState};
use cosmic_protocols::{
toplevel_info::v1::server::{
zcosmic_toplevel_info_v1::{self, ZcosmicToplevelInfoV1},
zcosmic_toplevel_handle_v1::{self, ZcosmicToplevelHandleV1, State as States},
},
use cosmic_protocols::toplevel_info::v1::server::{
zcosmic_toplevel_handle_v1::{self, State as States, ZcosmicToplevelHandleV1},
zcosmic_toplevel_info_v1::{self, ZcosmicToplevelInfoV1},
};
pub struct ToplevelInfoState<D> {
@ -67,13 +61,14 @@ pub struct ToplevelHandleStateInner {
}
pub type ToplevelHandleState = Mutex<ToplevelHandleStateInner>;
impl<D> DelegateGlobalDispatch<ZcosmicToplevelInfoV1, ToplevelInfoGlobalData, D> for ToplevelInfoState<D>
impl<D> DelegateGlobalDispatch<ZcosmicToplevelInfoV1, ToplevelInfoGlobalData, D>
for ToplevelInfoState<D>
where
D: GlobalDispatch<ZcosmicToplevelInfoV1, ToplevelInfoGlobalData>
+ Dispatch<ZcosmicToplevelInfoV1, ()>
+ Dispatch<ZcosmicToplevelHandleV1, ToplevelHandleState>
+ ToplevelInfoHandler
+ 'static
+ 'static,
{
fn bind(
state: &mut D,
@ -100,7 +95,7 @@ where
+ Dispatch<ZcosmicToplevelInfoV1, ()>
+ Dispatch<ZcosmicToplevelHandleV1, ToplevelHandleState>
+ ToplevelInfoHandler
+ 'static
+ 'static,
{
fn request(
state: &mut D,
@ -113,19 +108,20 @@ where
) {
match request {
zcosmic_toplevel_info_v1::Request::Stop => {
state.toplevel_info_state_mut().instances.retain(|i| i != obj);
},
_ => {},
state
.toplevel_info_state_mut()
.instances
.retain(|i| i != obj);
}
_ => {}
}
}
fn destroyed(
state: &mut D,
_client: ClientId,
resource: ObjectId,
_data: &(),
) {
state.toplevel_info_state_mut().instances.retain(|i| i.id() != resource);
fn destroyed(state: &mut D, _client: ClientId, resource: ObjectId, _data: &()) {
state
.toplevel_info_state_mut()
.instances
.retain(|i| i.id() != resource);
}
}
@ -135,7 +131,7 @@ where
+ Dispatch<ZcosmicToplevelInfoV1, ()>
+ Dispatch<ZcosmicToplevelHandleV1, ToplevelHandleState>
+ ToplevelInfoHandler
+ 'static
+ 'static,
{
fn request(
_state: &mut D,
@ -147,20 +143,24 @@ where
_data_init: &mut DataInit<'_, D>,
) {
match request {
zcosmic_toplevel_handle_v1::Request::Destroy => {},
_ => {},
zcosmic_toplevel_handle_v1::Request::Destroy => {}
_ => {}
}
}
fn destroyed(
state: &mut D,
_client: ClientId,
resource: ObjectId,
state: &mut D,
_client: ClientId,
resource: ObjectId,
_data: &ToplevelHandleState,
) {
for toplevel in &state.toplevel_info_state_mut().toplevels {
if let Some(state) = toplevel.user_data().get::<ToplevelState>() {
state.lock().unwrap().instances.retain(|i| i.id() != resource);
state
.lock()
.unwrap()
.instances
.retain(|i| i.id() != resource);
}
}
}
@ -174,16 +174,16 @@ where
+ ToplevelInfoHandler
+ 'static,
{
pub fn new<F>(
dh: &DisplayHandle,
client_filter: F,
) -> ToplevelInfoState<D>
pub fn new<F>(dh: &DisplayHandle, client_filter: F) -> ToplevelInfoState<D>
where
F: for<'a> Fn(&'a Client) -> bool + Send + Sync + 'static
F: for<'a> Fn(&'a Client) -> bool + Send + Sync + 'static,
{
let global = dh.create_global::<D, ZcosmicToplevelInfoV1, _>(1, ToplevelInfoGlobalData {
filter: Box::new(client_filter),
});
let global = dh.create_global::<D, ZcosmicToplevelInfoV1, _>(
1,
ToplevelInfoGlobalData {
filter: Box::new(client_filter),
},
);
ToplevelInfoState {
dh: dh.clone(),
toplevels: Vec::new(),
@ -194,7 +194,9 @@ where
}
pub fn new_toplevel(&mut self, toplevel: &Window) {
toplevel.user_data().insert_if_missing(ToplevelState::default);
toplevel
.user_data()
.insert_if_missing(ToplevelState::default);
for instance in &self.instances {
send_toplevel_to_client::<D>(&self.dh, None, instance, toplevel);
}
@ -233,10 +235,19 @@ where
}
true
} else {
let state = window.user_data().get::<ToplevelState>().unwrap().lock().unwrap();
let state = window
.user_data()
.get::<ToplevelState>()
.unwrap()
.lock()
.unwrap();
for handle in &state.instances {
// don't send events to stopped instances
if self.instances.iter().any(|i| i.id().same_client_as(&handle.id())) {
if self
.instances
.iter()
.any(|i| i.id().same_client_as(&handle.id()))
{
handle.closed();
}
}
@ -250,20 +261,39 @@ where
}
}
fn send_toplevel_to_client<D>(dh: &DisplayHandle, workspace_state: Option<&WorkspaceState<D>>, info: &ZcosmicToplevelInfoV1, window: &Window)
where
fn send_toplevel_to_client<D>(
dh: &DisplayHandle,
workspace_state: Option<&WorkspaceState<D>>,
info: &ZcosmicToplevelInfoV1,
window: &Window,
) where
D: GlobalDispatch<ZcosmicToplevelInfoV1, ToplevelInfoGlobalData>
+ Dispatch<ZcosmicToplevelInfoV1, ()>
+ Dispatch<ZcosmicToplevelHandleV1, ToplevelHandleState>
+ ToplevelInfoHandler
+ 'static,
{
let mut state = window.user_data().get::<ToplevelState>().unwrap().lock().unwrap();
let instance = match state.instances.iter().find(|i| i.id().same_client_as(&info.id())) {
let mut state = window
.user_data()
.get::<ToplevelState>()
.unwrap()
.lock()
.unwrap();
let instance = match state
.instances
.iter()
.find(|i| i.id().same_client_as(&info.id()))
{
Some(i) => i,
None => {
if let Ok(client) = dh.get_client(info.id()) {
if let Ok(toplevel_handle) = client.create_resource::<ZcosmicToplevelHandleV1, _, D>(dh, info.version(), ToplevelHandleState::default()) {
if let Ok(toplevel_handle) = client
.create_resource::<ZcosmicToplevelHandleV1, _, D>(
dh,
info.version(),
ToplevelHandleState::default(),
)
{
state.instances.push(toplevel_handle);
state.instances.last().unwrap()
} else {
@ -275,7 +305,11 @@ where
}
};
let mut handle_state = instance.data::<ToplevelHandleState>().unwrap().lock().unwrap();
let mut handle_state = instance
.data::<ToplevelHandleState>()
.unwrap()
.lock()
.unwrap();
let mut changed = false;
with_states(window.toplevel().wl_surface(), |states| {
let attributes = states
@ -284,7 +318,7 @@ where
.unwrap()
.lock()
.unwrap();
if handle_state.title != attributes.title.as_deref().unwrap_or(&"") {
handle_state.title = attributes.title.clone().unwrap_or_else(String::new);
instance.title(handle_state.title.clone());
@ -296,21 +330,50 @@ where
changed = true;
}
if (handle_state.states.contains(&States::Maximized) != attributes.current.states.contains(xdg_toplevel::State::Maximized))
|| (handle_state.states.contains(&States::Fullscreen) != attributes.current.states.contains(xdg_toplevel::State::Fullscreen))
|| (handle_state.states.contains(&States::Activated) != attributes.current.states.contains(xdg_toplevel::State::Activated))
|| (handle_state.states.contains(&States::Minimized) != state.minimized) {
if (handle_state.states.contains(&States::Maximized)
!= attributes
.current
.states
.contains(xdg_toplevel::State::Maximized))
|| (handle_state.states.contains(&States::Fullscreen)
!= attributes
.current
.states
.contains(xdg_toplevel::State::Fullscreen))
|| (handle_state.states.contains(&States::Activated)
!= attributes
.current
.states
.contains(xdg_toplevel::State::Activated))
|| (handle_state.states.contains(&States::Minimized) != state.minimized)
{
let mut states = Vec::new();
if attributes.current.states.contains(xdg_toplevel::State::Maximized) {
if attributes
.current
.states
.contains(xdg_toplevel::State::Maximized)
{
states.push(States::Maximized);
}
if attributes.current.states.contains(xdg_toplevel::State::Fullscreen) {
if attributes
.current
.states
.contains(xdg_toplevel::State::Fullscreen)
{
states.push(States::Fullscreen);
}
if attributes.current.states.contains(xdg_toplevel::State::Activated) {
if attributes
.current
.states
.contains(xdg_toplevel::State::Activated)
{
states.push(States::Activated);
}
if attributes.current.states.contains(xdg_toplevel::State::Maximized) {
if attributes
.current
.states
.contains(xdg_toplevel::State::Maximized)
{
states.push(States::Maximized);
}
handle_state.states = states.clone();
@ -329,13 +392,21 @@ where
});
if let Ok(client) = dh.get_client(instance.id()) {
for new_output in state.outputs.iter().filter(|o| !handle_state.outputs.contains(o)) {
for new_output in state
.outputs
.iter()
.filter(|o| !handle_state.outputs.contains(o))
{
new_output.with_client_outputs(dh, &client, |_dh, wl_output| {
instance.output_enter(wl_output);
});
changed = true;
}
for old_output in handle_state.outputs.iter().filter(|o| !state.outputs.contains(o)) {
for old_output in handle_state
.outputs
.iter()
.filter(|o| !state.outputs.contains(o))
{
old_output.with_client_outputs(dh, &client, |_dh, wl_output| {
instance.output_leave(wl_output);
});
@ -345,14 +416,26 @@ where
}
if let Some(workspace_state) = workspace_state {
for new_workspace in state.workspaces.iter().filter(|w| !handle_state.workspaces.contains(w)) {
if let Some(handle) = workspace_state.raw_workspace_handle(&new_workspace, &instance.id()) {
for new_workspace in state
.workspaces
.iter()
.filter(|w| !handle_state.workspaces.contains(w))
{
if let Some(handle) =
workspace_state.raw_workspace_handle(&new_workspace, &instance.id())
{
instance.workspace_enter(&handle);
changed = true;
}
}
for old_workspace in handle_state.workspaces.iter().filter(|w| !state.workspaces.contains(w)) {
if let Some(handle) = workspace_state.raw_workspace_handle(&old_workspace, &instance.id()) {
for old_workspace in handle_state
.workspaces
.iter()
.filter(|w| !state.workspaces.contains(w))
{
if let Some(handle) =
workspace_state.raw_workspace_handle(&old_workspace, &instance.id())
{
instance.workspace_leave(&handle);
changed = true;
}

448
src/wayland/protocols/workspace.rs
View file

@ -4,19 +4,17 @@ use std::sync::Mutex;
use smithay::{
reexports::wayland_server::{
Client, DataInit,
DisplayHandle, Resource, New,
GlobalDispatch, Dispatch,
DelegateGlobalDispatch, DelegateDispatch,
backend::{ClientId, ClientData, GlobalId, ObjectId},
backend::{ClientData, ClientId, GlobalId, ObjectId},
Client, DataInit, DelegateDispatch, DelegateGlobalDispatch, Dispatch, DisplayHandle,
GlobalDispatch, New, Resource,
},
wayland::output::Output,
};
use cosmic_protocols::workspace::v1::server::{
zcosmic_workspace_manager_v1::{self, ZcosmicWorkspaceManagerV1},
zcosmic_workspace_group_handle_v1::{self, ZcosmicWorkspaceGroupHandleV1},
zcosmic_workspace_handle_v1::{self, ZcosmicWorkspaceHandleV1},
zcosmic_workspace_manager_v1::{self, ZcosmicWorkspaceManagerV1},
};
pub use cosmic_protocols::workspace::v1::server::{
@ -32,9 +30,7 @@ where
+ Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+ WorkspaceHandler
+ 'static,
<D as WorkspaceHandler>::Client: ClientData
+ WorkspaceClientHandler
+ 'static,
<D as WorkspaceHandler>::Client: ClientData + WorkspaceClientHandler + 'static,
{
dh: DisplayHandle,
global: GlobalId,
@ -50,10 +46,7 @@ where
+ Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+ WorkspaceHandler
+ 'static,
<D as WorkspaceHandler>::Client: ClientData
+ WorkspaceClientHandler
+ 'static
;
<D as WorkspaceHandler>::Client: ClientData + WorkspaceClientHandler + 'static;
crate::utils::id_gen!(next_group_id, GROUP_ID, GROUP_IDS);
crate::utils::id_gen!(next_workspace_id, WORKSPACE_ID, WORKSPACE_IDS);
@ -63,7 +56,7 @@ pub struct WorkspaceGroup {
id: usize,
instances: Vec<ZcosmicWorkspaceGroupHandleV1>,
workspaces: Vec<Workspace>,
outputs: Vec<Output>,
capabilities: Vec<GroupCapabilities>,
}
@ -114,9 +107,7 @@ where
+ Sized
+ 'static,
{
type Client: ClientData
+ WorkspaceClientHandler
+ 'static;
type Client: ClientData + WorkspaceClientHandler + 'static;
fn workspace_state(&self) -> &WorkspaceState<Self>;
fn workspace_state_mut(&mut self) -> &mut WorkspaceState<Self>;
@ -144,12 +135,12 @@ pub struct WorkspaceClientStateInner {
}
pub type WorkspaceClientState = Mutex<WorkspaceClientStateInner>;
pub trait WorkspaceClientHandler {
fn workspace_state(&self) -> &WorkspaceClientState;
}
impl<D> DelegateGlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData, D> for WorkspaceState<D>
impl<D> DelegateGlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData, D>
for WorkspaceState<D>
where
D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+ Dispatch<ZcosmicWorkspaceManagerV1, ()>
@ -157,9 +148,7 @@ where
+ Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+ WorkspaceHandler
+ 'static,
<D as WorkspaceHandler>::Client: ClientData
+ WorkspaceClientHandler
+ 'static,
<D as WorkspaceHandler>::Client: ClientData + WorkspaceClientHandler + 'static,
{
fn bind(
state: &mut D,
@ -191,10 +180,8 @@ where
+ Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+ WorkspaceHandler
+ 'static,
<D as WorkspaceHandler>::Client: ClientData
+ WorkspaceClientHandler
+ 'static,
{
<D as WorkspaceHandler>::Client: ClientData + WorkspaceClientHandler + 'static,
{
fn request(
state: &mut D,
client: &Client,
@ -207,26 +194,29 @@ where
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();
let mut client_state = client
.get_data::<<D as WorkspaceHandler>::Client>()
.unwrap()
.workspace_state()
.lock()
.unwrap();
state.commit_requests(dh, std::mem::take(&mut client_state.requests));
}
},
}
zcosmic_workspace_manager_v1::Request::Stop => {
state.workspace_state_mut().instances.retain(|i| i != obj);
// without an instance, the whole send_group_to_client machinery doesn't work
// so there is no way for the whole clients hierachy to get any new events
},
_ => {},
}
_ => {}
}
}
fn destroyed(
state: &mut D,
_client: ClientId,
resource: ObjectId,
_data: &(),
) {
state.workspace_state_mut().instances.retain(|i| i.id() != resource);
fn destroyed(state: &mut D, _client: ClientId, resource: ObjectId, _data: &()) {
state
.workspace_state_mut()
.instances
.retain(|i| i.id() != resource);
}
}
@ -237,10 +227,8 @@ where
+ Dispatch<ZcosmicWorkspaceGroupHandleV1, WorkspaceGroupData>
+ Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+ WorkspaceHandler
+ 'static,
<D as WorkspaceHandler>::Client: ClientData
+ WorkspaceClientHandler
+ 'static,
<D as WorkspaceHandler>::Client: ClientData + WorkspaceClientHandler + 'static,
{
fn request(
state: &mut D,
@ -253,29 +241,35 @@ where
) {
match request {
zcosmic_workspace_group_handle_v1::Request::CreateWorkspace { workspace } => {
if let Some(id) = state.workspace_state().groups.iter().find(|g| g.instances.contains(obj)).map(|g| g.id) {
let mut state = client.get_data::<<D as WorkspaceHandler>::Client>().unwrap().workspace_state().lock().unwrap();
if let Some(id) = state
.workspace_state()
.groups
.iter()
.find(|g| g.instances.contains(obj))
.map(|g| g.id)
{
let mut state = client
.get_data::<<D as WorkspaceHandler>::Client>()
.unwrap()
.workspace_state()
.lock()
.unwrap();
state.requests.push(Request::Create {
in_group: WorkspaceGroupHandle { id },
name: workspace,
});
}
},
}
zcosmic_workspace_group_handle_v1::Request::Destroy => {
for group in &mut state.workspace_state_mut().groups {
group.instances.retain(|i| i != obj)
}
},
_ => {},
}
_ => {}
}
}
fn destroyed(
state: &mut D,
_client: ClientId,
resource: ObjectId,
_data: &WorkspaceGroupData,
) {
fn destroyed(state: &mut D, _client: ClientId, resource: ObjectId, _data: &WorkspaceGroupData) {
for group in &mut state.workspace_state_mut().groups {
group.instances.retain(|i| i.id() != resource)
}
@ -290,9 +284,7 @@ where
+ Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+ WorkspaceHandler
+ 'static,
<D as WorkspaceHandler>::Client: ClientData
+ WorkspaceClientHandler
+ 'static,
<D as WorkspaceHandler>::Client: ClientData + WorkspaceClientHandler + 'static,
{
fn request(
state: &mut D,
@ -305,30 +297,58 @@ where
) {
match request {
zcosmic_workspace_handle_v1::Request::Activate => {
if let Some(id) = state.workspace_state().groups.iter()
if let Some(id) = state
.workspace_state()
.groups
.iter()
.find_map(|g| g.workspaces.iter().find(|w| w.instances.contains(obj)))
.map(|w| w.id)
{
let mut state = client.get_data::<<D as WorkspaceHandler>::Client>().unwrap().workspace_state().lock().unwrap();
state.requests.push(Request::Activate(WorkspaceHandle { id }));
let mut state = client
.get_data::<<D as WorkspaceHandler>::Client>()
.unwrap()
.workspace_state()
.lock()
.unwrap();
state
.requests
.push(Request::Activate(WorkspaceHandle { id }));
}
}
zcosmic_workspace_handle_v1::Request::Deactivate => {
if let Some(id) = state.workspace_state().groups.iter()
if let Some(id) = state
.workspace_state()
.groups
.iter()
.find_map(|g| g.workspaces.iter().find(|w| w.instances.contains(obj)))
.map(|w| w.id)
{
let mut state = client.get_data::<<D as WorkspaceHandler>::Client>().unwrap().workspace_state().lock().unwrap();
state.requests.push(Request::Deactivate(WorkspaceHandle { id }));
let mut state = client
.get_data::<<D as WorkspaceHandler>::Client>()
.unwrap()
.workspace_state()
.lock()
.unwrap();
state
.requests
.push(Request::Deactivate(WorkspaceHandle { id }));
}
}
zcosmic_workspace_handle_v1::Request::Remove => {
if let Some(id) = state.workspace_state().groups.iter()
if let Some(id) = state
.workspace_state()
.groups
.iter()
.find_map(|g| g.workspaces.iter().find(|w| w.instances.contains(obj)))
.map(|w| w.id)
{
let mut state = client.get_data::<<D as WorkspaceHandler>::Client>().unwrap().workspace_state().lock().unwrap();
state.requests.push(Request::Remove(WorkspaceHandle { id }));
let mut state = client
.get_data::<<D as WorkspaceHandler>::Client>()
.unwrap()
.workspace_state()
.lock()
.unwrap();
state.requests.push(Request::Remove(WorkspaceHandle { id }));
}
}
zcosmic_workspace_handle_v1::Request::Destroy => {
@ -338,16 +358,11 @@ where
}
}
}
_ => {},
_ => {}
}
}
fn destroyed(
state: &mut D,
_client: ClientId,
resource: ObjectId,
_data: &WorkspaceData,
) {
fn destroyed(state: &mut D, _client: ClientId, resource: ObjectId, _data: &WorkspaceData) {
for group in &mut state.workspace_state_mut().groups {
for workspace in &mut group.workspaces {
workspace.instances.retain(|i| i.id() != resource)
@ -356,7 +371,6 @@ where
}
}
impl<D> WorkspaceState<D>
where
D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
@ -365,20 +379,18 @@ where
+ Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+ WorkspaceHandler
+ 'static,
<D as WorkspaceHandler>::Client: ClientData
+ WorkspaceClientHandler
+ 'static,
<D as WorkspaceHandler>::Client: ClientData + WorkspaceClientHandler + 'static,
{
pub fn new<F>(
dh: &DisplayHandle,
client_filter: F,
) -> WorkspaceState<D>
where
pub fn new<F>(dh: &DisplayHandle, client_filter: F) -> WorkspaceState<D>
where
F: for<'a> Fn(&'a Client) -> bool + Send + Sync + 'static,
{
let global = dh.create_global::<D, ZcosmicWorkspaceManagerV1, _>(1, WorkspaceGlobalData {
filter: Box::new(client_filter),
});
let global = dh.create_global::<D, ZcosmicWorkspaceManagerV1, _>(
1,
WorkspaceGlobalData {
filter: Box::new(client_filter),
},
);
WorkspaceState {
dh: dh.clone(),
@ -388,8 +400,12 @@ where
_marker: std::marker::PhantomData,
}
}
pub fn workspace_belongs_to_group(&self, group: &WorkspaceGroupHandle, workspace: &WorkspaceHandle) -> bool {
pub fn workspace_belongs_to_group(
&self,
group: &WorkspaceGroupHandle,
workspace: &WorkspaceHandle,
) -> bool {
if let Some(group) = self.groups.iter().find(|g| g.id == group.id) {
group.workspaces.iter().any(|w| w.id == workspace.id)
} else {
@ -397,38 +413,86 @@ where
}
}
pub fn group_capabilities(&self, group: &WorkspaceGroupHandle) -> Option<impl Iterator<Item=&GroupCapabilities>> {
self.groups.iter().find(|g| g.id == group.id).map(|g| g.capabilities.iter())
pub fn group_capabilities(
&self,
group: &WorkspaceGroupHandle,
) -> Option<impl Iterator<Item = &GroupCapabilities>> {
self.groups
.iter()
.find(|g| g.id == group.id)
.map(|g| g.capabilities.iter())
}
pub fn group_outputs(&self, group: &WorkspaceGroupHandle) -> Option<impl Iterator<Item=&Output>> {
self.groups.iter().find(|g| g.id == group.id).map(|g| g.outputs.iter())
pub fn group_outputs(
&self,
group: &WorkspaceGroupHandle,
) -> Option<impl Iterator<Item = &Output>> {
self.groups
.iter()
.find(|g| g.id == group.id)
.map(|g| g.outputs.iter())
}
pub fn workspace_capabilities(&self, workspace: &WorkspaceHandle) -> Option<impl Iterator<Item=&WorkspaceCapabilities>> {
self.groups.iter().find_map(|g| g.workspaces.iter().find(|w| w.id == workspace.id).map(|w| w.capabilities.iter()))
pub fn workspace_capabilities(
&self,
workspace: &WorkspaceHandle,
) -> Option<impl Iterator<Item = &WorkspaceCapabilities>> {
self.groups.iter().find_map(|g| {
g.workspaces
.iter()
.find(|w| w.id == workspace.id)
.map(|w| w.capabilities.iter())
})
}
pub fn workspace_name(&self, workspace: &WorkspaceHandle) -> Option<&str> {
self.groups.iter().find_map(|g| g.workspaces.iter().find(|w| w.id == workspace.id).map(|w| &*w.name))
self.groups.iter().find_map(|g| {
g.workspaces
.iter()
.find(|w| w.id == workspace.id)
.map(|w| &*w.name)
})
}
pub fn workspace_coordinates(&self, workspace: &WorkspaceHandle) -> Option<&[u32]> {
self.groups.iter().find_map(|g| g.workspaces.iter().find(|w| w.id == workspace.id).map(|w| &*w.coordinates))
self.groups.iter().find_map(|g| {
g.workspaces
.iter()
.find(|w| w.id == workspace.id)
.map(|w| &*w.coordinates)
})
}
pub fn workspace_states(&self, workspace: &WorkspaceHandle) -> Option<impl Iterator<Item=&zcosmic_workspace_handle_v1::State>> {
self.groups.iter().find_map(|g| g.workspaces.iter().find(|w| w.id == workspace.id).map(|w| w.states.iter()))
pub fn workspace_states(
&self,
workspace: &WorkspaceHandle,
) -> Option<impl Iterator<Item = &zcosmic_workspace_handle_v1::State>> {
self.groups.iter().find_map(|g| {
g.workspaces
.iter()
.find(|w| w.id == workspace.id)
.map(|w| w.states.iter())
})
}
pub fn raw_group_handle(&self, group: &WorkspaceGroupHandle, client: &ObjectId) -> Option<ZcosmicWorkspaceGroupHandleV1> {
self.groups.iter()
pub fn raw_group_handle(
&self,
group: &WorkspaceGroupHandle,
client: &ObjectId,
) -> Option<ZcosmicWorkspaceGroupHandleV1> {
self.groups
.iter()
.find(|g| g.id == group.id)
.and_then(|g| g.instances.iter().find(|i| i.id().same_client_as(client)))
.cloned()
}
pub fn raw_workspace_handle(&self, workspace: &WorkspaceHandle, client: &ObjectId) -> Option<ZcosmicWorkspaceHandleV1> {
self.groups.iter()
pub fn raw_workspace_handle(
&self,
workspace: &WorkspaceHandle,
client: &ObjectId,
) -> Option<ZcosmicWorkspaceHandleV1> {
self.groups
.iter()
.find_map(|g| g.workspaces.iter().find(|w| w.id == workspace.id))
.and_then(|w| w.instances.iter().find(|i| i.id().same_client_as(client)))
.cloned()
@ -467,9 +531,7 @@ where
+ Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+ WorkspaceHandler
+ 'static,
<D as WorkspaceHandler>::Client: ClientData
+ WorkspaceClientHandler
+ 'static,
<D as WorkspaceHandler>::Client: ClientData + WorkspaceClientHandler + 'static,
{
pub fn create_workspace_group(&mut self) -> WorkspaceGroupHandle {
let id = next_group_id();
@ -478,9 +540,7 @@ where
..Default::default()
};
self.0.groups.push(group);
WorkspaceGroupHandle {
id
}
WorkspaceGroupHandle { id }
}
pub fn create_workspace(&mut self, group: &WorkspaceGroupHandle) -> Option<WorkspaceHandle> {
@ -491,9 +551,7 @@ where
..Default::default()
};
group.workspaces.push(workspace);
Some(WorkspaceHandle {
id
})
Some(WorkspaceHandle { id })
} else {
None
}
@ -501,10 +559,14 @@ where
pub fn remove_workspace_group(&mut self, group: WorkspaceGroupHandle) {
// "The compositor must remove all workspaces belonging to a workspace group before removing the workspace group."
for workspace in self.0.groups.iter()
for workspace in self
.0
.groups
.iter()
.filter(|g| g.id == group.id)
.flat_map(|g| g.workspaces.iter().map(|w| WorkspaceHandle { id: w.id }))
.collect::<Vec<_>>().into_iter()
.collect::<Vec<_>>()
.into_iter()
{
self.remove_workspace(workspace);
}
@ -518,7 +580,7 @@ where
GROUP_IDS.lock().unwrap().remove(&group.id);
}
pub fn remove_workspace(&mut self, workspace: WorkspaceHandle) {
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 {
@ -529,22 +591,36 @@ where
}
WORKSPACE_IDS.lock().unwrap().remove(&workspace.id);
}
pub fn workspace_belongs_to_group(&self, group: &WorkspaceGroupHandle, workspace: &WorkspaceHandle) -> bool {
pub fn workspace_belongs_to_group(
&self,
group: &WorkspaceGroupHandle,
workspace: &WorkspaceHandle,
) -> bool {
self.0.workspace_belongs_to_group(group, workspace)
}
pub fn group_capabilities(&mut self, group: &WorkspaceGroupHandle) -> Option<impl Iterator<Item=&GroupCapabilities>> {
pub fn group_capabilities(
&mut self,
group: &WorkspaceGroupHandle,
) -> Option<impl Iterator<Item = &GroupCapabilities>> {
self.0.group_capabilities(group)
}
pub fn set_group_capabilities(&mut self, group: &WorkspaceGroupHandle, capabilities: impl Iterator<Item=GroupCapabilities>) {
pub fn set_group_capabilities(
&mut self,
group: &WorkspaceGroupHandle,
capabilities: impl Iterator<Item = GroupCapabilities>,
) {
if let Some(group) = self.0.groups.iter_mut().find(|g| g.id == group.id) {
group.capabilities = capabilities.collect();
}
}
pub fn group_outputs(&self, group: &WorkspaceGroupHandle) -> Option<impl Iterator<Item=&Output>> {
pub fn group_outputs(
&self,
group: &WorkspaceGroupHandle,
) -> Option<impl Iterator<Item = &Output>> {
self.0.group_outputs(group)
}
@ -559,13 +635,23 @@ where
group.outputs.retain(|o| o != output)
}
}
pub fn workspace_capabilities(&self, workspace: &WorkspaceHandle) -> Option<impl Iterator<Item=&WorkspaceCapabilities>> {
pub fn workspace_capabilities(
&self,
workspace: &WorkspaceHandle,
) -> Option<impl Iterator<Item = &WorkspaceCapabilities>> {
self.0.workspace_capabilities(workspace)
}
pub fn set_workspace_capabilities(&mut self, workspace: &WorkspaceHandle, capabilities: impl Iterator<Item=WorkspaceCapabilities>) {
if let Some(workspace) = self.0.groups.iter_mut()
pub fn set_workspace_capabilities(
&mut self,
workspace: &WorkspaceHandle,
capabilities: impl Iterator<Item = WorkspaceCapabilities>,
) {
if let Some(workspace) = self
.0
.groups
.iter_mut()
.find_map(|g| g.workspaces.iter_mut().find(|w| w.id == workspace.id))
{
workspace.capabilities = capabilities.collect();
@ -577,7 +663,10 @@ where
}
pub fn set_workspace_name(&mut self, workspace: &WorkspaceHandle, name: impl Into<String>) {
if let Some(workspace) = self.0.groups.iter_mut()
if let Some(workspace) = self
.0
.groups
.iter_mut()
.find_map(|g| g.workspaces.iter_mut().find(|w| w.id == workspace.id))
{
workspace.name = name.into();
@ -588,28 +677,56 @@ where
self.0.workspace_coordinates(workspace)
}
pub fn set_workspace_coordinates(&mut self, workspace: &WorkspaceHandle, coords: [Option<u32>; 3]) {
if let Some(workspace) = self.0.groups.iter_mut()
pub fn set_workspace_coordinates(
&mut self,
workspace: &WorkspaceHandle,
coords: [Option<u32>; 3],
) {
if let Some(workspace) = self
.0
.groups
.iter_mut()
.find_map(|g| g.workspaces.iter_mut().find(|w| w.id == workspace.id))
{
workspace.coordinates = coords.iter().flat_map(std::convert::identity).copied().collect();
workspace.coordinates = coords
.iter()
.flat_map(std::convert::identity)
.copied()
.collect();
}
}
pub fn workspace_states(&self, workspace: &WorkspaceHandle) -> Option<impl Iterator<Item=&zcosmic_workspace_handle_v1::State>> {
pub fn workspace_states(
&self,
workspace: &WorkspaceHandle,
) -> Option<impl Iterator<Item = &zcosmic_workspace_handle_v1::State>> {
self.0.workspace_states(workspace)
}
pub fn add_workspace_state(&mut self, workspace: &WorkspaceHandle, state: zcosmic_workspace_handle_v1::State) {
if let Some(workspace) = self.0.groups.iter_mut()
pub fn add_workspace_state(
&mut self,
workspace: &WorkspaceHandle,
state: zcosmic_workspace_handle_v1::State,
) {
if let Some(workspace) = self
.0
.groups
.iter_mut()
.find_map(|g| g.workspaces.iter_mut().find(|w| w.id == workspace.id))
{
workspace.states.push(state);
}
}
pub fn remove_workspace_state(&mut self, workspace: &WorkspaceHandle, state: zcosmic_workspace_handle_v1::State) {
if let Some(workspace) = self.0.groups.iter_mut()
pub fn remove_workspace_state(
&mut self,
workspace: &WorkspaceHandle,
state: zcosmic_workspace_handle_v1::State,
) {
if let Some(workspace) = self
.0
.groups
.iter_mut()
.find_map(|g| g.workspaces.iter_mut().find(|w| w.id == workspace.id))
{
workspace.states.retain(|s| *s != state);
@ -625,16 +742,18 @@ where
+ Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+ WorkspaceHandler
+ 'static,
<D as WorkspaceHandler>::Client: ClientData
+ WorkspaceClientHandler
+ 'static,
<D as WorkspaceHandler>::Client: ClientData + WorkspaceClientHandler + 'static,
{
fn drop(&mut self) {
self.0.done();
}
}
fn send_group_to_client<D>(dh: &DisplayHandle, mngr: &ZcosmicWorkspaceManagerV1, group: &mut WorkspaceGroup) -> bool
fn send_group_to_client<D>(
dh: &DisplayHandle,
mngr: &ZcosmicWorkspaceManagerV1,
group: &mut WorkspaceGroup,
) -> bool
where
D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+ Dispatch<ZcosmicWorkspaceManagerV1, ()>
@ -642,15 +761,21 @@ where
+ Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+ WorkspaceHandler
+ 'static,
<D as WorkspaceHandler>::Client: ClientData
+ WorkspaceClientHandler
+ 'static,
<D as WorkspaceHandler>::Client: ClientData + WorkspaceClientHandler + 'static,
{
let instance = match group.instances.iter_mut().find(|i| i.id().same_client_as(&mngr.id())) {
let instance = match group
.instances
.iter_mut()
.find(|i| i.id().same_client_as(&mngr.id()))
{
Some(i) => i,
None => {
if let Ok(client) = dh.get_client(mngr.id()) {
if let Ok(handle) = client.create_resource::<ZcosmicWorkspaceGroupHandleV1, _, D>(dh, mngr.version(), WorkspaceGroupData::default()) {
if let Ok(handle) = client.create_resource::<ZcosmicWorkspaceGroupHandleV1, _, D>(
dh,
mngr.version(),
WorkspaceGroupData::default(),
) {
mngr.workspace_group(&handle);
group.instances.push(handle);
group.instances.last_mut().unwrap()
@ -663,16 +788,28 @@ where
}
};
let mut handle_state = instance.data::<WorkspaceGroupData>().unwrap().lock().unwrap();
let mut handle_state = instance
.data::<WorkspaceGroupData>()
.unwrap()
.lock()
.unwrap();
let mut changed = false;
if let Ok(client) = dh.get_client(instance.id()) {
for new_output in group.outputs.iter().filter(|o| !handle_state.outputs.contains(o)) {
for new_output in group
.outputs
.iter()
.filter(|o| !handle_state.outputs.contains(o))
{
new_output.with_client_outputs(dh, &client, |_dh, wl_output| {
instance.output_enter(wl_output);
});
changed = true;
}
for old_output in handle_state.outputs.iter().filter(|o| group.outputs.contains(o)) {
for old_output in handle_state
.outputs
.iter()
.filter(|o| group.outputs.contains(o))
{
old_output.with_client_outputs(dh, &client, |_dh, wl_output| {
instance.output_leave(wl_output);
});
@ -705,7 +842,11 @@ where
changed
}
fn send_workspace_to_client<D>(dh: &DisplayHandle, group: &ZcosmicWorkspaceGroupHandleV1, workspace: &mut Workspace) -> bool
fn send_workspace_to_client<D>(
dh: &DisplayHandle,
group: &ZcosmicWorkspaceGroupHandleV1,
workspace: &mut Workspace,
) -> bool
where
D: GlobalDispatch<ZcosmicWorkspaceManagerV1, WorkspaceGlobalData>
+ Dispatch<ZcosmicWorkspaceManagerV1, ()>
@ -713,15 +854,21 @@ where
+ Dispatch<ZcosmicWorkspaceHandleV1, WorkspaceData>
+ WorkspaceHandler
+ 'static,
<D as WorkspaceHandler>::Client: ClientData
+ WorkspaceClientHandler
+ 'static,
<D as WorkspaceHandler>::Client: ClientData + WorkspaceClientHandler + 'static,
{
let instance = match workspace.instances.iter_mut().find(|i| i.id().same_client_as(&group.id())) {
let instance = match workspace
.instances
.iter_mut()
.find(|i| i.id().same_client_as(&group.id()))
{
Some(i) => i,
None => {
if let Ok(client) = dh.get_client(group.id()) {
if let Ok(handle) = client.create_resource::<ZcosmicWorkspaceHandleV1, _, D>(dh, group.version(), WorkspaceData::default()) {
if let Ok(handle) = client.create_resource::<ZcosmicWorkspaceHandleV1, _, D>(
dh,
group.version(),
WorkspaceData::default(),
) {
group.workspace(&handle);
workspace.instances.push(handle);
workspace.instances.last_mut().unwrap()
@ -736,7 +883,7 @@ where
let mut handle_state = instance.data::<WorkspaceData>().unwrap().lock().unwrap();
let mut changed = false;
if handle_state.name != workspace.name {
instance.name(workspace.name.clone());
handle_state.name = workspace.name.clone();
@ -773,7 +920,8 @@ where
if handle_state.states != workspace.states {
let states: Vec<u8> = {
let mut states = workspace.states.clone();
let ratio = std::mem::size_of::<zcosmic_workspace_handle_v1::State>() / std::mem::size_of::<u8>();
let ratio = std::mem::size_of::<zcosmic_workspace_handle_v1::State>()
/ std::mem::size_of::<u8>();
let ptr = states.as_mut_ptr() as *mut u8;
let len = states.len() * ratio;
let cap = states.capacity() * ratio;