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

deps: Update smithay

Browse source
This commit is contained in:
Victoria Brekenfeld 2023-01-03 19:17:51 +01:00
parent ec647597f1
commit 8a2e1e5c89
10 changed files with 334 additions and 316 deletions
Download patch file Download diff file Expand all files Collapse all files

196
src/backend/kms/mod.rs
View file

@ -28,7 +28,7 @@ use smithay::{
glow::GlowRenderer,
multigpu::{egl::EglGlesBackend, GpuManager},
},
session::{auto::AutoSession, Session, Signal},
session::{libseat::LibSeatSession, Event as SessionEvent, Session},
udev::{all_gpus, primary_gpu, UdevBackend, UdevEvent},
},
desktop::utils::OutputPresentationFeedback,
@ -45,10 +45,7 @@ use smithay::{
wayland_protocols::wp::presentation_time::server::wp_presentation_feedback,
wayland_server::{protocol::wl_surface::WlSurface, DisplayHandle, Resource},
},
utils::{
signaling::{Linkable, SignalToken, Signaler},
DeviceFd, Size, Transform,
},
utils::{DeviceFd, Size, Transform},
wayland::dmabuf::DmabufGlobal,
};
@ -72,9 +69,7 @@ pub struct KmsState {
devices: HashMap<DrmNode, Device>,
pub api: GpuManager<EglGlesBackend<GlowRenderer>>,
pub primary: DrmNode,
session: AutoSession,
signaler: Signaler<Signal>,
_restart_token: SignalToken,
session: LibSeatSession,
_tokens: Vec<RegistrationToken>,
}
@ -107,17 +102,15 @@ pub fn init_backend(
event_loop: &mut EventLoop<'static, Data>,
state: &mut State,
) -> Result<()> {
let (session, notifier) = AutoSession::new(None).context("Failed to acquire session")?;
let signaler = notifier.signaler();
let (session, notifier) = LibSeatSession::new(None).context("Failed to acquire session")?;
let udev_backend = UdevBackend::new(session.seat(), None)?;
let mut libinput_context =
Libinput::new_with_udev::<LibinputSessionInterface<AutoSession>>(session.clone().into());
Libinput::new_with_udev::<LibinputSessionInterface<LibSeatSession>>(session.clone().into());
libinput_context
.udev_assign_seat(&session.seat())
.map_err(|_| anyhow::anyhow!("Failed to assign seat to libinput"))?;
let mut libinput_backend = LibinputInputBackend::new(libinput_context, None);
libinput_backend.link(signaler.clone());
let libinput_backend = LibinputInputBackend::new(libinput_context.clone(), None);
let libinput_event_source = event_loop
.handle()
@ -143,12 +136,6 @@ pub fn init_backend(
})
.map_err(|err| err.error)
.context("Failed to initialize libinput event source")?;
let session_event_source = event_loop
.handle()
.insert_source(notifier, |(), &mut (), _state| {})
.map_err(|err| err.error)
.context("Failed to initialize session event source")?;
let api = GpuManager::new(EglGlesBackend::<GlowRenderer>::default(), None)
.context("Failed to initialize renderers")?;
@ -209,85 +196,98 @@ pub fn init_backend(
let handle = event_loop.handle();
let loop_signal = state.common.event_loop_signal.clone();
let dispatcher = udev_dispatcher.clone();
let _restart_token = signaler.register(move |signal| {
if let Signal::ActivateSession = signal {
let dispatcher = dispatcher.clone();
handle.insert_idle(move |data| {
for (dev, path) in dispatcher.as_source_ref().device_list() {
let drm_node = match DrmNode::from_dev_id(dev) {
Ok(node) => node,
Err(err) => {
slog_scope::error!(
"Failed to read drm device {}: {}",
path.display(),
err
);
continue;
}
};
if data.state.backend.kms().devices.contains_key(&drm_node) {
if let Err(err) = data.state.device_changed(dev) {
slog_scope::error!(
"Failed to update drm device {}: {}",
path.display(),
err
);
}
} else {
if let Err(err) =
data.state
.device_added(dev, path.into(), &data.display.handle())
{
slog_scope::error!(
"Failed to add drm device {}: {}",
path.display(),
err
);
}
}
let session_event_source = event_loop
.handle()
.insert_source(notifier, move |event, &mut (), data| match event {
SessionEvent::ActivateSession => {
if let Err(err) = libinput_context.resume() {
slog_scope::error!("Failed to resume libinput context: {:?}", err);
}
let seats = data.state.common.seats().cloned().collect::<Vec<_>>();
data.state.common.config.read_outputs(
&mut data.state.common.output_configuration_state,
&mut data.state.backend,
&mut data.state.common.shell,
seats.into_iter(),
&data.state.common.event_loop_handle,
);
for surface in data
.state
.backend
.kms()
.devices
.values_mut()
.flat_map(|d| d.surfaces.values_mut())
{
surface.pending = false;
}
for output in data.state.common.shell.outputs() {
let sessions = output.pending_buffers().collect::<Vec<_>>();
if let Err(err) = data.state.backend.kms().schedule_render(
&data.state.common.event_loop_handle,
output,
None,
if !sessions.is_empty() {
Some(sessions)
let dispatcher = dispatcher.clone();
handle.insert_idle(move |data| {
for (dev, path) in dispatcher.as_source_ref().device_list() {
let drm_node = match DrmNode::from_dev_id(dev) {
Ok(node) => node,
Err(err) => {
slog_scope::error!(
"Failed to read drm device {}: {}",
path.display(),
err
);
continue;
}
};
if data.state.backend.kms().devices.contains_key(&drm_node) {
if let Err(err) = data.state.device_changed(dev) {
slog_scope::error!(
"Failed to update drm device {}: {}",
path.display(),
err
);
}
} else {
None
},
) {
slog_scope::crit!(
"Error scheduling event loop for output {}: {:?}",
output.name(),
err
);
if let Err(err) =
data.state
.device_added(dev, path.into(), &data.display.handle())
{
slog_scope::error!(
"Failed to add drm device {}: {}",
path.display(),
err
);
}
}
}
let seats = data.state.common.seats().cloned().collect::<Vec<_>>();
data.state.common.config.read_outputs(
&mut data.state.common.output_configuration_state,
&mut data.state.backend,
&mut data.state.common.shell,
seats.into_iter(),
&data.state.common.event_loop_handle,
);
for surface in data
.state
.backend
.kms()
.devices
.values_mut()
.flat_map(|d| d.surfaces.values_mut())
{
surface.pending = false;
}
for output in data.state.common.shell.outputs() {
let sessions = output.pending_buffers().collect::<Vec<_>>();
if let Err(err) = data.state.backend.kms().schedule_render(
&data.state.common.event_loop_handle,
output,
None,
if !sessions.is_empty() {
Some(sessions)
} else {
None
},
) {
slog_scope::crit!(
"Error scheduling event loop for output {}: {:?}",
output.name(),
err
);
}
}
});
loop_signal.wakeup();
}
SessionEvent::PauseSession => {
libinput_context.suspend();
for device in data.state.backend.kms().devices.values() {
device.drm.as_source_ref().pause();
}
});
loop_signal.wakeup();
}
});
}
})
.map_err(|err| err.error)
.context("Failed to initialize session event source")?;
state.backend = BackendData::Kms(KmsState {
api,
@ -298,8 +298,6 @@ pub fn init_backend(
],
primary,
session,
signaler,
_restart_token,
devices: HashMap::new(),
});
@ -337,7 +335,7 @@ impl State {
},
None,
);
let mut drm = DrmDevice::new(fd.clone(), false, None)
let drm = DrmDevice::new(fd.clone(), false, None)
.with_context(|| format!("Failed to initialize drm device for: {}", path.display()))?;
let drm_node = DrmNode::from_dev_id(dev)?;
let supports_atomic = drm.is_atomic();
@ -369,7 +367,6 @@ impl State {
})?;
let formats = egl_context.dmabuf_render_formats().clone();
drm.link(self.backend.kms().signaler.clone());
let dispatcher =
Dispatcher::new(drm, move |event, metadata, data: &mut Data| match event {
DrmEvent::VBlank(crtc) => {
@ -943,9 +940,8 @@ impl KmsState {
surface.vrr = drm_helpers::set_vrr(drm, *crtc, conn, output_config.vrr)
.unwrap_or(false);
surface.refresh_rate = drm_helpers::calculate_refresh_rate(*mode);
let mut drm_surface = drm.create_surface(*crtc, *mode, &[conn])?;
drm_surface.link(self.signaler.clone());
let drm_surface = drm.create_surface(*crtc, *mode, &[conn])?;
let target = GbmBufferedSurface::new(
drm_surface,
device.allocator.clone(),

156
src/shell/element/mod.rs
View file

@ -13,7 +13,7 @@ use smithay::{
ImportAll, Renderer,
},
},
desktop::{space::SpaceElement, Kind, PopupManager, Window, WindowSurfaceType},
desktop::{space::SpaceElement, PopupManager, Window, WindowSurfaceType},
input::{
keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
pointer::{AxisFrame, ButtonEvent, MotionEvent, PointerTarget},
@ -252,16 +252,13 @@ impl CosmicMapped {
CosmicMappedInternal::Window(w) => Box::new(std::iter::once(w.window.clone())),
_ => unreachable!(),
} {
match window.toplevel() {
Kind::Xdg(xdg) => xdg.with_pending_state(|state| {
if resizing {
state.states.set(XdgState::Resizing);
} else {
state.states.unset(XdgState::Resizing);
}
}),
// Kind::X11?
};
window.toplevel().with_pending_state(|state| {
if resizing {
state.states.set(XdgState::Resizing);
} else {
state.states.unset(XdgState::Resizing);
}
});
}
}
@ -272,37 +269,31 @@ impl CosmicMapped {
_ => unreachable!(),
};
match window.toplevel() {
Kind::Xdg(xdg) => {
xdg.current_state().states.contains(XdgState::Resizing)
|| xdg.with_pending_state(|states| states.states.contains(XdgState::Resizing))
} // Kind::X11?
}
let xdg = window.toplevel();
xdg.current_state().states.contains(XdgState::Resizing)
|| xdg.with_pending_state(|states| states.states.contains(XdgState::Resizing))
}
pub fn set_tiled(&self, tiled: bool) {
for toplevel in match &self.element {
for xdg in match &self.element {
// we use the tiled state of stack windows anyway to get rid of decorations
CosmicMappedInternal::Stack(_) => None,
CosmicMappedInternal::Window(w) => Some(w.window.toplevel()),
_ => unreachable!(),
} {
match toplevel {
Kind::Xdg(xdg) => xdg.with_pending_state(|state| {
if tiled {
state.states.set(XdgState::TiledLeft);
state.states.set(XdgState::TiledRight);
state.states.set(XdgState::TiledTop);
state.states.set(XdgState::TiledBottom);
} else {
state.states.unset(XdgState::TiledLeft);
state.states.unset(XdgState::TiledRight);
state.states.unset(XdgState::TiledTop);
state.states.unset(XdgState::TiledBottom);
}
}),
// Kind::X11?
};
xdg.with_pending_state(|state| {
if tiled {
state.states.set(XdgState::TiledLeft);
state.states.set(XdgState::TiledRight);
state.states.set(XdgState::TiledTop);
state.states.set(XdgState::TiledBottom);
} else {
state.states.unset(XdgState::TiledLeft);
state.states.unset(XdgState::TiledRight);
state.states.unset(XdgState::TiledTop);
state.states.unset(XdgState::TiledBottom);
}
});
}
}
@ -313,10 +304,11 @@ impl CosmicMapped {
_ => unreachable!(),
};
match window.toplevel() {
Kind::Xdg(xdg) => xdg.current_state().states.contains(XdgState::TiledLeft),
// Kind::X11?
}
window
.toplevel()
.current_state()
.states
.contains(XdgState::TiledLeft)
}
pub fn set_fullscreen(&self, fullscreen: bool) {
@ -327,16 +319,13 @@ impl CosmicMapped {
CosmicMappedInternal::Window(w) => Box::new(std::iter::once(w.window.clone())),
_ => unreachable!(),
} {
match window.toplevel() {
Kind::Xdg(xdg) => xdg.with_pending_state(|state| {
if fullscreen {
state.states.set(XdgState::Fullscreen);
} else {
state.states.unset(XdgState::Fullscreen);
}
}),
// Kind::X11?
};
window.toplevel().with_pending_state(|state| {
if fullscreen {
state.states.set(XdgState::Fullscreen);
} else {
state.states.unset(XdgState::Fullscreen);
}
});
}
}
@ -347,12 +336,9 @@ impl CosmicMapped {
_ => unreachable!(),
};
match window.toplevel() {
Kind::Xdg(xdg) => {
xdg.current_state().states.contains(XdgState::Fullscreen)
|| xdg.with_pending_state(|states| states.states.contains(XdgState::Fullscreen))
} // Kind::X11?
}
let xdg = window.toplevel();
xdg.current_state().states.contains(XdgState::Fullscreen)
|| xdg.with_pending_state(|states| states.states.contains(XdgState::Fullscreen))
}
pub fn set_maximized(&self, maximized: bool) {
@ -363,16 +349,13 @@ impl CosmicMapped {
CosmicMappedInternal::Window(w) => Box::new(std::iter::once(w.window.clone())),
_ => unreachable!(),
} {
match window.toplevel() {
Kind::Xdg(xdg) => xdg.with_pending_state(|state| {
if maximized {
state.states.set(XdgState::Maximized);
} else {
state.states.unset(XdgState::Maximized);
}
}),
// Kind::X11?
};
window.toplevel().with_pending_state(|state| {
if maximized {
state.states.set(XdgState::Maximized);
} else {
state.states.unset(XdgState::Maximized);
}
});
}
}
@ -383,12 +366,9 @@ impl CosmicMapped {
_ => unreachable!(),
};
match window.toplevel() {
Kind::Xdg(xdg) => {
xdg.current_state().states.contains(XdgState::Maximized)
|| xdg.with_pending_state(|states| states.states.contains(XdgState::Maximized))
} // Kind::X11?
}
let xdg = window.toplevel();
xdg.current_state().states.contains(XdgState::Maximized)
|| xdg.with_pending_state(|states| states.states.contains(XdgState::Maximized))
}
pub fn set_activated(&self, activated: bool) {
@ -399,16 +379,13 @@ impl CosmicMapped {
CosmicMappedInternal::Window(w) => Box::new(std::iter::once(w.window.clone())),
_ => unreachable!(),
} {
match window.toplevel() {
Kind::Xdg(xdg) => xdg.with_pending_state(|state| {
if activated {
state.states.set(XdgState::Activated);
} else {
state.states.unset(XdgState::Activated);
}
}),
// Kind::X11?
};
window.toplevel().with_pending_state(|state| {
if activated {
state.states.set(XdgState::Activated);
} else {
state.states.unset(XdgState::Activated);
}
});
}
}
@ -419,12 +396,9 @@ impl CosmicMapped {
_ => unreachable!(),
};
match window.toplevel() {
Kind::Xdg(xdg) => {
xdg.current_state().states.contains(XdgState::Activated)
|| xdg.with_pending_state(|states| states.states.contains(XdgState::Activated))
} // Kind::X11?
}
let xdg = window.toplevel();
xdg.current_state().states.contains(XdgState::Activated)
|| xdg.with_pending_state(|states| states.states.contains(XdgState::Activated))
}
pub fn set_size(&self, size: Size<i32, Logical>) {
@ -536,10 +510,7 @@ impl CosmicMapped {
CosmicMappedInternal::Window(w) => Box::new(std::iter::once(w.window.clone())),
_ => unreachable!(),
} {
match window.toplevel() {
Kind::Xdg(xdg) => xdg.send_configure(),
// Kind::X11?
};
window.toplevel().send_configure();
}
}
@ -550,10 +521,7 @@ impl CosmicMapped {
_ => unreachable!(),
};
match window.toplevel() {
Kind::Xdg(xdg) => xdg.send_close(),
// Kind::X11?
};
window.toplevel().send_close();
}
#[cfg(feature = "debug")]

8
src/shell/element/stack.rs
View file

@ -10,7 +10,7 @@ use smithay::{
ImportAll, Renderer,
},
},
desktop::{space::SpaceElement, Kind, Window},
desktop::{space::SpaceElement, Window},
input::{
keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
pointer::{AxisFrame, ButtonEvent, MotionEvent, PointerTarget},
@ -95,9 +95,9 @@ impl CosmicStack {
.into();
for window in self.windows.lock().unwrap().iter() {
match window.toplevel() {
Kind::Xdg(xdg) => xdg.with_pending_state(|state| state.size = Some(surface_size)),
};
window
.toplevel()
.with_pending_state(|state| state.size = Some(surface_size));
}
}

14
src/shell/element/window.rs
View file

@ -9,7 +9,7 @@ use smithay::{
ImportAll, Renderer,
},
},
desktop::{space::SpaceElement, Kind, Window},
desktop::{space::SpaceElement, Window},
input::{
keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
pointer::{AxisFrame, ButtonEvent, MotionEvent, PointerTarget},
@ -72,18 +72,16 @@ impl CosmicWindow {
.unwrap_or(0),
)
.into();
match self.window.toplevel() {
Kind::Xdg(xdg) => xdg.with_pending_state(|state| state.size = Some(surface_size)),
};
self.window
.toplevel()
.with_pending_state(|state| state.size = Some(surface_size));
}
}
impl From<Window> for CosmicWindow {
fn from(window: Window) -> Self {
let is_ssd = matches!(
match window.toplevel() {
Kind::Xdg(xdg) => xdg.current_state().decoration_mode,
},
window.toplevel().current_state().decoration_mode,
Some(DecorationMode::ServerSide)
);
CosmicWindow {
@ -100,7 +98,7 @@ impl From<ToplevelSurface> for CosmicWindow {
Some(DecorationMode::ServerSide)
);
CosmicWindow {
window: Window::new(Kind::Xdg(surf)),
window: Window::new(surf),
header: Arc::new(Mutex::new(is_ssd.then_some(HeaderBar::default()))),
}
}

78
src/shell/workspace.rs
View file

@ -21,7 +21,7 @@ use smithay::{
element::{surface::WaylandSurfaceRenderElement, AsRenderElements, Element, RenderElement},
ImportAll, Renderer,
},
desktop::{layer_map_for_output, space::SpaceElement, Kind, LayerSurface, Window},
desktop::{layer_map_for_output, space::SpaceElement, LayerSurface, Window},
input::{pointer::GrabStartData as PointerGrabStartData, Seat},
output::Output,
reexports::{
@ -197,13 +197,10 @@ impl Workspace {
self.floating_layer.maximize_request(window);
#[allow(irrefutable_let_patterns)]
if let Kind::Xdg(xdg) = &window.toplevel() {
xdg.with_pending_state(|state| {
state.states.set(xdg_toplevel::State::Maximized);
state.states.unset(xdg_toplevel::State::Fullscreen);
});
}
window.toplevel().with_pending_state(|state| {
state.states.set(xdg_toplevel::State::Maximized);
state.states.unset(xdg_toplevel::State::Fullscreen);
});
self.set_fullscreen(window, output)
}
@ -219,13 +216,10 @@ impl Workspace {
return;
}
#[allow(irrefutable_let_patterns)]
if let Kind::Xdg(xdg) = &window.toplevel() {
xdg.with_pending_state(|state| {
state.states.set(xdg_toplevel::State::Fullscreen);
state.states.unset(xdg_toplevel::State::Maximized);
});
}
window.toplevel().with_pending_state(|state| {
state.states.set(xdg_toplevel::State::Fullscreen);
state.states.unset(xdg_toplevel::State::Maximized);
});
self.set_fullscreen(window, output)
}
@ -238,38 +232,33 @@ impl Workspace {
mapped.set_active(window);
}
#[allow(irrefutable_let_patterns)]
if let Kind::Xdg(xdg) = &window.toplevel() {
xdg.with_pending_state(|state| {
state.size = Some(
output
.current_mode()
.map(|m| m.size)
.unwrap_or((0, 0).into())
.to_f64()
.to_logical(output.current_scale().fractional_scale())
.to_i32_round(),
);
});
xdg.send_configure();
}
let xdg = window.toplevel();
xdg.with_pending_state(|state| {
state.size = Some(
output
.current_mode()
.map(|m| m.size)
.unwrap_or((0, 0).into())
.to_f64()
.to_logical(output.current_scale().fractional_scale())
.to_i32_round(),
);
});
xdg.send_configure();
self.fullscreen.insert(output.clone(), window.clone());
}
pub fn unfullscreen_request(&mut self, window: &Window) {
if self.fullscreen.values().any(|w| w == window) {
#[allow(irrefutable_let_patterns)]
if let Kind::Xdg(xdg) = &window.toplevel() {
xdg.with_pending_state(|state| {
state.states.unset(xdg_toplevel::State::Fullscreen);
state.states.unset(xdg_toplevel::State::Maximized);
state.size = None;
});
self.floating_layer.refresh();
self.tiling_layer.refresh();
xdg.send_configure();
}
let xdg = window.toplevel();
xdg.with_pending_state(|state| {
state.states.unset(xdg_toplevel::State::Fullscreen);
state.states.unset(xdg_toplevel::State::Maximized);
state.size = None;
});
self.floating_layer.refresh();
self.tiling_layer.refresh();
xdg.send_configure();
self.fullscreen.retain(|_, w| w != window);
}
}
@ -331,10 +320,7 @@ impl Workspace {
if mapped.is_fullscreen() || mapped.is_maximized() {
// If surface is maximized then unmaximize it
self.unmaximize_request(window);
let new_size = match window.toplevel() {
Kind::Xdg(toplevel) => toplevel.with_pending_state(|state| state.size),
//_ => unreachable!(), // TODO x11
};
let new_size = window.toplevel().with_pending_state(|state| state.size);
let ratio = pos.x / output.geometry().size.w as f64;
initial_window_location = new_size

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

@ -4,7 +4,7 @@ use crate::{state::BackendData, utils::prelude::*, wayland::protocols::screencop
use smithay::{
backend::renderer::utils::{on_commit_buffer_handler, with_renderer_surface_state},
delegate_compositor,
desktop::{layer_map_for_output, Kind, LayerSurface, PopupKind, WindowSurfaceType},
desktop::{layer_map_for_output, LayerSurface, PopupKind, WindowSurfaceType},
reexports::wayland_server::protocol::wl_surface::WlSurface,
wayland::{
compositor::{with_states, CompositorHandler, CompositorState},
@ -116,19 +116,14 @@ impl CompositorHandler for State {
.find(|(window, _)| window.toplevel().wl_surface() == surface)
.cloned()
{
match window.toplevel() {
Kind::Xdg(toplevel) => {
if self.toplevel_ensure_initial_configure(&toplevel)
&& with_renderer_surface_state(&surface, |state| {
state.wl_buffer().is_some()
})
{
let output = seat.active_output();
Shell::map_window(self, &window, &output);
} else {
return;
}
}
let toplevel = window.toplevel();
if self.toplevel_ensure_initial_configure(&toplevel)
&& with_renderer_surface_state(&surface, |state| state.wl_buffer().is_some())
{
let output = seat.active_output();
Shell::map_window(self, &window, &output);
} else {
return;
}
}

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

@ -1,10 +1,6 @@
// SPDX-License-Identifier: GPL-3.0-only
use smithay::{
desktop::{Kind, Window},
input::Seat,
reexports::wayland_server::DisplayHandle,
};
use smithay::{desktop::Window, input::Seat, reexports::wayland_server::DisplayHandle};
use crate::{
utils::prelude::*,
@ -52,10 +48,7 @@ impl ToplevelManagementHandler for State {
}
fn close(&mut self, _dh: &DisplayHandle, window: &Window) {
#[allow(irrefutable_let_patterns)]
if let Kind::Xdg(xdg) = &window.toplevel() {
xdg.send_close();
}
window.toplevel().send_close();
}
}

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

@ -4,7 +4,7 @@ use crate::{utils::prelude::*, wayland::protocols::screencopy::SessionType};
use smithay::{
delegate_xdg_shell,
desktop::{
find_popup_root_surface, Kind, PopupGrab, PopupKeyboardGrab, PopupKind, PopupPointerGrab,
find_popup_root_surface, PopupGrab, PopupKeyboardGrab, PopupKind, PopupPointerGrab,
PopupUngrabStrategy, Window,
},
input::{
@ -39,7 +39,7 @@ impl XdgShellHandler for State {
fn new_toplevel(&mut self, surface: ToplevelSurface) {
let seat = self.common.last_active_seat().clone();
let window = Window::new(Kind::Xdg(surface));
let window = Window::new(surface);
self.common.shell.toplevel_info_state.new_toplevel(&window);
self.common.shell.pending_windows.push((window, seat));
// We will position the window after the first commit, when we know its size hints
@ -149,7 +149,7 @@ impl XdgShellHandler for State {
let output = seat.active_output();
let (window, _) = mapped
.windows()
.find(|(w, _)| matches!(w.toplevel(), Kind::Xdg(s) if s == &surface))
.find(|(w, _)| w.toplevel() == &surface)
.unwrap();
if let Some(grab) =
workspace.move_request(&window, &seat, &output, serial, start_data)
@ -213,7 +213,7 @@ impl XdgShellHandler for State {
if let Some(workspace) = self.common.shell.space_for_mut(&mapped) {
let (window, _) = mapped
.windows()
.find(|(w, _)| matches!(w.toplevel(), Kind::Xdg(s) if s == &surface))
.find(|(w, _)| w.toplevel() == &surface)
.unwrap();
workspace.maximize_request(&window, &output)
}
@ -230,7 +230,7 @@ impl XdgShellHandler for State {
if let Some(workspace) = self.common.shell.space_for_mut(&mapped) {
let (window, _) = mapped
.windows()
.find(|(w, _)| matches!(w.toplevel(), Kind::Xdg(s) if s == &surface))
.find(|(w, _)| w.toplevel() == &surface)
.unwrap();
workspace.unmaximize_request(&window)
}
@ -255,7 +255,7 @@ impl XdgShellHandler for State {
if let Some(workspace) = self.common.shell.space_for_mut(&mapped) {
let (window, _) = mapped
.windows()
.find(|(w, _)| matches!(w.toplevel(), Kind::Xdg(s) if s == &surface))
.find(|(w, _)| w.toplevel() == &surface)
.unwrap();
workspace.fullscreen_request(&window, &output)
}
@ -272,7 +272,7 @@ impl XdgShellHandler for State {
if let Some(workspace) = self.common.shell.space_for_mut(&mapped) {
let (window, _) = mapped
.windows()
.find(|(w, _)| matches!(w.toplevel(), Kind::Xdg(s) if s == &surface))
.find(|(w, _)| w.toplevel() == &surface)
.unwrap();
workspace.unfullscreen_request(&window)
}