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

Update Smithay, with Window that supports X11 surfaces

Browse source
This commit is contained in:
Ian Douglas Scott 2024-02-21 13:24:56 -08:00 • committed by Victoria Brekenfeld
parent 849882a7db
commit 3036448c19
24 changed files with 482 additions and 619 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -642,7 +642,7 @@ impl State {
if non_desktop {
let Ok(output_name) = drm_helpers::interface_name(&device.drm, conn) else {
continue
continue;
};
let drm_helpers::EdidInfo {
model,
@ -779,7 +779,7 @@ impl State {
if non_desktop {
let Ok(output_name) = drm_helpers::interface_name(&device.drm, conn) else {
continue
continue;
};
let drm_helpers::EdidInfo {
model,

4
src/backend/x11.rs
View file

@ -302,7 +302,9 @@ fn try_vulkan_allocator(node: &DrmNode) -> Option<Allocator> {
let Some(device) = devices
.filter(|phd| {
phd.has_device_extension(smithay::reexports::ash::extensions::ext::PhysicalDeviceDrm::name())
phd.has_device_extension(
smithay::reexports::ash::extensions::ext::PhysicalDeviceDrm::name(),
)
})
.find(|phd| {
phd.primary_node().unwrap() == Some(*node) || phd.render_node().unwrap() == Some(*node)

16
src/input/mod.rs
View file

@ -1156,7 +1156,9 @@ impl State {
}
InputEvent::TouchDown { event, .. } => {
if let Some(seat) = self.common.seat_with_device(&event.device()).cloned() {
let Some(output) = mapped_output_for_device(&self.common, &event.device()).cloned() else {
let Some(output) =
mapped_output_for_device(&self.common, &event.device()).cloned()
else {
return;
};
@ -1187,7 +1189,9 @@ impl State {
}
InputEvent::TouchMotion { event, .. } => {
if let Some(seat) = self.common.seat_with_device(&event.device()).cloned() {
let Some(output) = mapped_output_for_device(&self.common, &event.device()).cloned() else {
let Some(output) =
mapped_output_for_device(&self.common, &event.device()).cloned()
else {
return;
};
@ -1227,7 +1231,9 @@ impl State {
InputEvent::TouchFrame { event: _, .. } => {}
InputEvent::TabletToolAxis { event, .. } => {
if let Some(seat) = self.common.seat_with_device(&event.device()).cloned() {
let Some(output) = mapped_output_for_device(&self.common, &event.device()).cloned() else {
let Some(output) =
mapped_output_for_device(&self.common, &event.device()).cloned()
else {
return;
};
let geometry = output.geometry();
@ -1288,7 +1294,9 @@ impl State {
}
InputEvent::TabletToolProximity { event, .. } => {
if let Some(seat) = self.common.seat_with_device(&event.device()).cloned() {
let Some(output) = mapped_output_for_device(&self.common, &event.device()).cloned() else {
let Some(output) =
mapped_output_for_device(&self.common, &event.device()).cloned()
else {
return;
};
let geometry = output.geometry();

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

@ -843,10 +843,7 @@ impl SpaceElement for CosmicMapped {
impl X11Relatable for CosmicMapped {
fn is_window(&self, window: &X11Surface) -> bool {
match self.active_window() {
CosmicSurface::X11(surface) => &surface == window,
_ => false,
}
self.active_window().x11_surface() == Some(window)
}
}

656
src/shell/element/surface.rs
View file

File diff suppressed because it is too large Load diff

12
src/shell/focus/mod.rs
View file

@ -20,7 +20,7 @@ use tracing::{debug, trace};
use self::target::{KeyboardFocusTarget, WindowGroup};
use super::{layout::floating::FloatingLayout, CosmicSurface};
use super::layout::floating::FloatingLayout;
pub mod target;
@ -207,11 +207,11 @@ fn raise_with_children(floating_layer: &mut FloatingLayout, focused: &CosmicMapp
.space
.elements()
.filter(|elem| {
let parent = match elem.active_window() {
CosmicSurface::Wayland(w) => w.toplevel().parent(),
_ => None,
};
let parent = elem
.active_window()
.0
.toplevel()
.and_then(|toplevel| toplevel.parent());
parent == focused.active_window().wl_surface()
})
.cloned()

8
src/shell/grabs/menu/default.rs
View file

@ -24,7 +24,9 @@ fn toggle_stacking(state: &mut State, mapped: &CosmicMapped) {
fn move_prev_workspace(state: &mut State, mapped: &CosmicMapped) {
let seat = state.common.last_active_seat().clone();
let (current_handle, output) = {
let Some(ws) = state.common.shell.space_for(mapped) else { return };
let Some(ws) = state.common.shell.space_for(mapped) else {
return;
};
(ws.handle, ws.output.clone())
};
let maybe_handle = state
@ -59,7 +61,9 @@ fn move_prev_workspace(state: &mut State, mapped: &CosmicMapped) {
fn move_next_workspace(state: &mut State, mapped: &CosmicMapped) {
let seat = state.common.last_active_seat().clone();
let (current_handle, output) = {
let Some(ws) = state.common.shell.space_for(mapped) else { return };
let Some(ws) = state.common.shell.space_for(mapped) else {
return;
};
(ws.handle, ws.output.clone())
};
let maybe_handle = state

2
src/shell/grabs/moving.rs
View file

@ -230,7 +230,7 @@ impl PointerGrab<State> for MoveGrab {
.as_logical()
.overlaps_or_touches(Rectangle::from_loc_and_size(
handle.current_location().to_i32_floor(),
(0,0),
(0, 0),
))
})
.cloned()

26
src/shell/layout/floating/grabs/resize.rs
View file

@ -7,13 +7,12 @@ use crate::{
element::CosmicMapped,
focus::target::PointerFocusTarget,
grabs::{ReleaseMode, ResizeEdge},
CosmicSurface,
},
utils::prelude::*,
};
use smithay::{
backend::input::ButtonState,
desktop::space::SpaceElement,
desktop::{space::SpaceElement, WindowSurface},
input::{
pointer::{
AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent,
@ -118,9 +117,10 @@ impl PointerGrab<State> for ResizeSurfaceGrab {
self.window.set_resizing(true);
self.window.set_geometry(Rectangle::from_loc_and_size(
match self.window.active_window() {
CosmicSurface::X11(s) => s.geometry().loc.as_global(),
_ => (0, 0).into(),
if let Some(s) = self.window.active_window().x11_surface() {
s.geometry().loc.as_global()
} else {
(0, 0).into()
},
self.last_window_size.as_global(),
));
@ -356,20 +356,19 @@ impl ResizeSurfaceGrab {
if let Some(new_location) = new_location {
for (window, offset) in window.windows() {
match window {
CosmicSurface::Wayland(window) => {
match window.0.underlying_surface() {
WindowSurface::Wayland(toplevel) => {
update_reactive_popups(
&window,
toplevel,
new_location + offset.as_global(),
floating_layer.space.outputs(),
);
}
CosmicSurface::X11(surface) => {
WindowSurface::X11(surface) => {
let mut geometry = surface.geometry();
geometry.loc += (location - new_location).as_logical();
let _ = surface.configure(geometry);
}
_ => unreachable!(),
}
}
floating_layer
@ -402,9 +401,10 @@ impl ResizeSurfaceGrab {
self.window.set_resizing(false);
self.window.set_geometry(Rectangle::from_loc_and_size(
match self.window.active_window() {
CosmicSurface::X11(s) => s.geometry().loc.as_global(),
_ => (0, 0).into(),
if let Some(x11_surface) = self.window.active_window().x11_surface() {
x11_surface.geometry().loc.as_global()
} else {
(0, 0).into()
},
self.last_window_size.as_global(),
));

10
src/shell/layout/mod.rs
View file

@ -2,6 +2,7 @@
use regex::RegexSet;
use smithay::{
desktop::WindowSurface,
wayland::{compositor::with_states, shell::xdg::XdgToplevelSurfaceData},
xwayland::xwm::WmWindowType,
};
@ -100,9 +101,9 @@ lazy_static::lazy_static! {
pub fn is_dialog(window: &CosmicSurface) -> bool {
// Check "window type"
match window {
CosmicSurface::Wayland(window) => {
if with_states(window.toplevel().wl_surface(), |states| {
match window.0.underlying_surface() {
WindowSurface::Wayland(toplevel) => {
if with_states(toplevel.wl_surface(), |states| {
let attrs = states
.data_map
.get::<XdgToplevelSurfaceData>()
@ -114,7 +115,7 @@ pub fn is_dialog(window: &CosmicSurface) -> bool {
return true;
}
}
CosmicSurface::X11(surface) => {
WindowSurface::X11(surface) => {
if surface.is_override_redirect()
|| surface.is_popup()
|| !matches!(
@ -125,7 +126,6 @@ pub fn is_dialog(window: &CosmicSurface) -> bool {
return true;
}
}
_ => {}
};
// Check if sizing suggest dialog

12
src/shell/layout/tiling/grabs/swap.rs
View file

@ -58,11 +58,19 @@ impl KeyboardGrab<State> for SwapWindowGrab {
.iter()
.filter(|(_, action)| matches!(action, Action::Focus(_)))
.map(|(pattern, action)| {
let Action::Focus(direction) = action else { unreachable!() };
let Action::Focus(direction) = action else {
unreachable!()
};
(pattern.key, *direction)
})
.collect::<Vec<_>>();
let Some(direction) = syms.iter().find_map(|sym| focus_bindings.iter().find_map(|(key, direction)| (key.is_some() && sym == key.as_ref().unwrap()).then_some(*direction))) else { return };
let Some(direction) = syms.iter().find_map(|sym| {
focus_bindings.iter().find_map(|(key, direction)| {
(key.is_some() && sym == key.as_ref().unwrap()).then_some(*direction)
})
}) else {
return;
};
data.handle_action(
Action::Focus(direction),

84
src/shell/layout/tiling/mod.rs
View file

@ -462,7 +462,9 @@ impl TilingLayout {
pub fn replace_window(&mut self, old: &CosmicMapped, new: &CosmicMapped) {
let gaps = self.gaps();
let Some(old_id) = old.tiling_node_id.lock().unwrap().clone() else { return };
let Some(old_id) = old.tiling_node_id.lock().unwrap().clone() else {
return;
};
let mut tree = self.queue.trees.back().unwrap().0.copy_clone();
if let Ok(node) = tree.get_mut(&old_id) {
@ -501,7 +503,13 @@ impl TilingLayout {
match desc.stack_window {
Some(stack_surface) => {
let node = this_tree.get(&desc.node).ok()?;
let Data::Mapped { mapped: this_mapped, .. } = node.data() else { return None };
let Data::Mapped {
mapped: this_mapped,
..
} = node.data()
else {
return None;
};
let this_stack = this_mapped.stack_ref()?;
this_stack.remove_window(&stack_surface);
if !this_stack.alive() {
@ -698,7 +706,9 @@ impl TilingLayout {
}
}
(None, None) => {
let Some(other_tree) = other_tree.as_mut() else { unreachable!() };
let Some(other_tree) = other_tree.as_mut() else {
unreachable!()
};
let this_node = this_tree.get_mut(&this_desc.node).ok()?;
let other_node = other_tree.get_mut(&other_desc.node).ok()?;
@ -842,7 +852,13 @@ impl TilingLayout {
return None;
}
let this_node = this_tree.get_mut(&this_desc.node).ok()?;
let Data::Mapped { mapped: this_mapped, .. } = this_node.data() else { return None };
let Data::Mapped {
mapped: this_mapped,
..
} = this_node.data()
else {
return None;
};
let this_mapped = this_mapped.clone();
let geometry = *this_node.data().geometry();
assert!(this_mapped.is_stack());
@ -927,7 +943,13 @@ impl TilingLayout {
let other_tree = other_tree.as_mut().unwrap_or(&mut this_tree);
let other_node = other_tree.get_mut(&other_desc.node).ok()?;
let Data::Mapped { mapped: other_mapped, .. } = other_node.data() else { return None };
let Data::Mapped {
mapped: other_mapped,
..
} = other_node.data()
else {
return None;
};
let other_mapped = other_mapped.clone();
let geometry = *other_node.data().geometry();
assert!(other_mapped.is_stack());
@ -1259,9 +1281,7 @@ impl TilingLayout {
let Some(target) = seat.get_keyboard().unwrap().current_focus() else {
return MoveResult::None;
};
let Some((node_id, data)) =
TilingLayout::currently_focused_node(&mut tree, target)
else {
let Some((node_id, data)) = TilingLayout::currently_focused_node(&mut tree, target) else {
return MoveResult::None;
};
@ -1587,14 +1607,10 @@ impl TilingLayout {
let Some(target) = seat.get_keyboard().unwrap().current_focus() else {
return FocusResult::None;
};
let Some(focused) =
TilingLayout::currently_focused_node(tree, target).or_else(
|| {
TilingLayout::last_active_window(tree, focus_stack)
.map(|(id, mapped)| (id, FocusedNodeData::Window(mapped)))
},
)
else {
let Some(focused) = TilingLayout::currently_focused_node(tree, target).or_else(|| {
TilingLayout::last_active_window(tree, focus_stack)
.map(|(id, mapped)| (id, FocusedNodeData::Window(mapped)))
}) else {
return FocusResult::None;
};
@ -2252,21 +2268,23 @@ impl TilingLayout {
let gaps = self.gaps();
let mut tree = self.queue.trees.back().unwrap().0.copy_clone();
let Some(root_id) = tree.root_node_id() else { return false };
let Some(mut node_id) =
(match TilingLayout::currently_focused_node(&tree, focused.clone()) {
Some((_id, FocusedNodeData::Window(mapped))) =>
// we need to make sure the id belongs to this tree..
{
tree.traverse_pre_order_ids(root_id)
.unwrap()
.find(|id| tree.get(id).unwrap().data().is_mapped(Some(&mapped)))
}
Some((id, FocusedNodeData::Group(_, _))) => Some(id), // in this case the workspace handle was already matched, so the id is to be trusted
_ => None,
}) else {
return false
};
let Some(root_id) = tree.root_node_id() else {
return false;
};
let Some(mut node_id) = (match TilingLayout::currently_focused_node(&tree, focused.clone())
{
Some((_id, FocusedNodeData::Window(mapped))) =>
// we need to make sure the id belongs to this tree..
{
tree.traverse_pre_order_ids(root_id)
.unwrap()
.find(|id| tree.get(id).unwrap().data().is_mapped(Some(&mapped)))
}
Some((id, FocusedNodeData::Group(_, _))) => Some(id), // in this case the workspace handle was already matched, so the id is to be trusted
_ => None,
}) else {
return false;
};
while let Some(group_id) = tree.get(&node_id).unwrap().parent().cloned() {
let orientation = tree.get(&group_id).unwrap().data().orientation();
@ -3138,8 +3156,8 @@ impl TilingLayout {
.unwrap()
.position(|node| {
let Some(geo) = geometries.get(node) else {
return false;
};
return false;
};
match orientation {
Orientation::Vertical => location.x < geo.loc.x,
Orientation::Horizontal => location.y < geo.loc.y,

73
src/shell/mod.rs
View file

@ -15,7 +15,7 @@ use keyframe::{ease, functions::EaseInOutCubic};
use smithay::{
desktop::{
layer_map_for_output, space::SpaceElement, LayerSurface, PopupKind, PopupManager,
WindowSurfaceType,
WindowSurface, WindowSurfaceType,
},
input::{
pointer::{Focus, GrabStartData as PointerGrabStartData, MotionEvent},
@ -170,10 +170,11 @@ pub enum ActivationKey {
impl From<&CosmicSurface> for ActivationKey {
fn from(value: &CosmicSurface) -> Self {
match value {
CosmicSurface::Wayland(w) => ActivationKey::Wayland(w.toplevel().wl_surface().clone()),
CosmicSurface::X11(s) => ActivationKey::X11(s.window_id()),
_ => unreachable!(),
match value.0.underlying_surface() {
WindowSurface::Wayland(toplevel) => {
ActivationKey::Wayland(toplevel.wl_surface().clone())
}
WindowSurface::X11(s) => ActivationKey::X11(s.window_id()),
}
}
}
@ -1091,19 +1092,19 @@ impl Shell {
.map(|(_, w, _)| w)
.chain(set.workspaces[set.active].floating_layer.space.elements())
{
if let CosmicSurface::X11(surf) = window.active_window() {
let _ = xwm.raise_window(&surf);
if let Some(surf) = window.active_window().x11_surface() {
let _ = xwm.raise_window(surf);
}
}
for window in set.sticky_layer.space.elements() {
if let CosmicSurface::X11(surf) = window.active_window() {
let _ = xwm.raise_window(&surf);
if let Some(surf) = window.active_window().x11_surface() {
let _ = xwm.raise_window(surf);
}
}
if let Some(CosmicSurface::X11(ref surf)) = set.workspaces[set.active]
if let Some(surf) = set.workspaces[set.active]
.fullscreen
.as_ref()
.map(|f| &f.surface)
.and_then(|f| f.surface.x11_surface())
{
let _ = xwm.raise_window(surf);
}
@ -1258,6 +1259,19 @@ impl Shell {
})
}
pub fn element_for_x11_surface(&self, surface: &X11Surface) -> Option<&CosmicMapped> {
self.workspaces.sets.values().find_map(|set| {
set.sticky_layer
.mapped()
.find(|w| w.windows().any(|(s, _)| s.x11_surface() == Some(surface)))
.or_else(|| {
set.workspaces
.iter()
.find_map(|w| w.element_for_x11_surface(surface))
})
})
}
pub fn space_for(&self, mapped: &CosmicMapped) -> Option<&Workspace> {
self.workspaces
.spaces()
@ -1554,25 +1568,24 @@ impl Shell {
.unwrap();
let (window, seat, output) = state.common.shell.pending_windows.remove(pos);
let parent_is_sticky = match window.clone() {
CosmicSurface::Wayland(toplevel) => {
if let Some(parent) = toplevel.toplevel().parent() {
if let Some(elem) = state.common.shell.element_for_wl_surface(&parent) {
state
.common
.shell
.workspaces
.sets
.values()
.any(|set| set.sticky_layer.mapped().any(|m| m == elem))
} else {
false
}
let parent_is_sticky = if let Some(toplevel) = window.0.toplevel() {
if let Some(parent) = toplevel.parent() {
if let Some(elem) = state.common.shell.element_for_wl_surface(&parent) {
state
.common
.shell
.workspaces
.sets
.values()
.any(|set| set.sticky_layer.mapped().any(|m| m == elem))
} else {
false
}
} else {
false
}
_ => false,
} else {
false
};
let pending_activation = state
@ -2013,11 +2026,11 @@ impl Shell {
.unwrap()
.loc
.to_global(&workspace.output);
for (toplevel, offset) in mapped.windows() {
if let CosmicSurface::Wayland(toplevel) = toplevel {
let window_geo_offset = toplevel.geometry().loc.as_global();
for (window, offset) in mapped.windows() {
if let Some(toplevel) = window.0.toplevel() {
let window_geo_offset = window.geometry().loc.as_global();
update_reactive_popups(
&toplevel,
toplevel,
element_loc + offset.as_global() + window_geo_offset,
self.outputs(),
);

8
src/shell/workspace.rs
View file

@ -44,6 +44,7 @@ use smithay::{
seat::WaylandFocus,
xdg_activation::{XdgActivationState, XdgActivationToken},
},
xwayland::X11Surface,
};
use std::{
collections::{HashMap, HashSet, VecDeque},
@ -418,6 +419,13 @@ impl Workspace {
})
}
pub fn element_for_x11_surface(&self, surface: &X11Surface) -> Option<&CosmicMapped> {
self.floating_layer
.mapped()
.chain(self.tiling_layer.mapped().map(|(_, w, _)| w))
.find(|e| e.windows().any(|(w, _)| w.x11_surface() == Some(surface)))
}
pub fn element_under(
&mut self,
location: Point<f64, Global>,

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

@ -1,9 +1,6 @@
// SPDX-License-Identifier: GPL-3.0-only
use crate::{
shell::CosmicSurface, state::ClientState, utils::prelude::*,
wayland::protocols::screencopy::SessionType,
};
use crate::{state::ClientState, utils::prelude::*, wayland::protocols::screencopy::SessionType};
use calloop::Interest;
use smithay::{
backend::renderer::utils::{on_commit_buffer_handler, with_renderer_surface_state},
@ -157,21 +154,14 @@ impl CompositorHandler for State {
.find(|(window, _, _)| window.wl_surface().as_ref() == Some(surface))
.cloned()
{
match window {
CosmicSurface::Wayland(ref wl_window) => {
let toplevel = wl_window.toplevel();
if self.toplevel_ensure_initial_configure(&toplevel)
&& with_renderer_surface_state(&surface, |state| state.buffer().is_some())
.unwrap_or(false)
{
window.on_commit();
Shell::map_window(self, &window);
} else {
return;
}
if let Some(toplevel) = window.0.toplevel() {
if self.toplevel_ensure_initial_configure(&toplevel)
&& with_renderer_surface_state(&surface, |state| state.buffer().is_some())
.unwrap_or(false)
{
window.on_commit();
Shell::map_window(self, &window);
}
CosmicSurface::X11(_) => {}
_ => unreachable!(),
}
}

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

@ -20,10 +20,7 @@ use smithay::{
};
use wayland_backend::protocol::WEnum;
use crate::{
shell::{CosmicMapped, CosmicSurface},
state::State,
};
use crate::{shell::CosmicMapped, state::State};
pub struct PreferredDecorationMode(RefCell<Option<XdgMode>>);
@ -60,53 +57,61 @@ impl PreferredDecorationMode {
impl State {
pub fn new_decoration(mapped: &CosmicMapped, surface: &WlSurface) -> KdeMode {
if mapped.is_stack() {
if let Some((CosmicSurface::Wayland(window), _)) = mapped
if let Some((window, _)) = mapped
.windows()
.find(|(window, _)| window.wl_surface().as_ref() == Some(surface))
{
window
.toplevel()
.with_pending_state(|state| state.decoration_mode = Some(XdgMode::ServerSide));
window.toplevel().send_configure();
if let Some(toplevel) = window.0.toplevel() {
toplevel.with_pending_state(|state| {
state.decoration_mode = Some(XdgMode::ServerSide)
});
toplevel.send_configure();
}
}
KdeMode::Server
} else {
if let Some((CosmicSurface::Wayland(window), _)) = mapped
if let Some((window, _)) = mapped
.windows()
.find(|(window, _)| window.wl_surface().as_ref() == Some(surface))
{
window
.toplevel()
.with_pending_state(|state| state.decoration_mode = Some(XdgMode::ClientSide));
window.toplevel().send_configure();
if let Some(toplevel) = window.0.toplevel() {
toplevel.with_pending_state(|state| {
state.decoration_mode = Some(XdgMode::ClientSide)
});
toplevel.send_configure();
}
}
KdeMode::Client
}
}
pub fn request_mode(mapped: &CosmicMapped, surface: &WlSurface, mode: XdgMode) {
if let Some((CosmicSurface::Wayland(window), _)) = mapped
if let Some((window, _)) = mapped
.windows()
.find(|(window, _)| window.wl_surface().as_ref() == Some(surface))
{
PreferredDecorationMode::update(&window, Some(mode));
window.toplevel().with_pending_state(|state| {
state.decoration_mode = Some(mode);
});
window.toplevel().send_configure();
if let Some(toplevel) = window.0.toplevel() {
PreferredDecorationMode::update(&window.0, Some(mode));
toplevel.with_pending_state(|state| {
state.decoration_mode = Some(mode);
});
toplevel.send_configure();
}
}
}
pub fn unset_mode(mapped: &CosmicMapped, surface: &WlSurface) {
if let Some((CosmicSurface::Wayland(window), _)) = mapped
if let Some((window, _)) = mapped
.windows()
.find(|(window, _)| window.wl_surface().as_ref() == Some(surface))
{
PreferredDecorationMode::update(&window, None);
window.toplevel().with_pending_state(|state| {
state.decoration_mode = None;
});
window.toplevel().send_configure();
if let Some(toplevel) = window.0.toplevel() {
PreferredDecorationMode::update(&window.0, None);
toplevel.with_pending_state(|state| {
state.decoration_mode = None;
});
toplevel.send_configure();
}
}
}
}

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

@ -30,7 +30,7 @@ impl DmabufHandler for State {
Ok(Some(node)) => {
// kms backend
let Ok(buffer) = import_notifier.successful::<State>() else {
return
return;
};
if let BackendData::Kms(kms_state) = &mut self.backend {

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

@ -68,7 +68,12 @@ impl ToplevelManagementHandler for State {
workspace: ZcosmicWorkspaceHandleV1,
_output: Output,
) {
let Some(to_handle) = self.common.shell.workspace_state.get_workspace_handle(&workspace) else {
let Some(to_handle) = self
.common
.shell
.workspace_state
.get_workspace_handle(&workspace)
else {
return;
};

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

@ -61,14 +61,16 @@ impl XdgActivationHandler for State {
// Tokens without validation aren't allowed to steal focus
let Some((serial, seat)) = data.serial else {
data.user_data.insert_if_missing(|| ActivationContext::UrgentOnly);
data.user_data
.insert_if_missing(|| ActivationContext::UrgentOnly);
debug!(?token, "created urgent-only token for missing seat/serial");
return true
return true;
};
let Some(seat) = Seat::from_resource(&seat) else {
data.user_data.insert_if_missing(|| ActivationContext::UrgentOnly);
data.user_data
.insert_if_missing(|| ActivationContext::UrgentOnly);
debug!(?token, "created urgent-only token for unknown seat");
return true
return true;
};
// At this point we don't bother with urgent-only tokens.

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

@ -9,7 +9,7 @@ use smithay::{
delegate_xdg_shell,
desktop::{
find_popup_root_surface, PopupGrab, PopupKeyboardGrab, PopupKind, PopupPointerGrab,
PopupUngrabStrategy, Window,
PopupUngrabStrategy,
},
input::{pointer::Focus, Seat},
output::Output,
@ -43,7 +43,7 @@ impl XdgShellHandler for State {
fn new_toplevel(&mut self, surface: ToplevelSurface) {
let seat = self.common.last_active_seat().clone();
let window = CosmicSurface::Wayland(Window::new(surface));
let window = CosmicSurface::from(surface);
self.common.shell.pending_windows.push((window, seat, None));
// We will position the window after the first commit, when we know its size hints
}

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

@ -3,7 +3,7 @@
use crate::{shell::Shell, utils::prelude::*};
use smithay::{
desktop::{
layer_map_for_output, space::SpaceElement, LayerSurface, PopupKind, PopupManager, Window,
layer_map_for_output, space::SpaceElement, LayerSurface, PopupKind, PopupManager,
WindowSurfaceType,
},
output::Output,
@ -18,8 +18,8 @@ use smithay::{
compositor::{get_role, with_states},
seat::WaylandFocus,
shell::xdg::{
PopupSurface, PositionerState, SurfaceCachedState, XdgPopupSurfaceRoleAttributes,
XDG_POPUP_ROLE,
PopupSurface, PositionerState, SurfaceCachedState, ToplevelSurface,
XdgPopupSurfaceRoleAttributes, XDG_POPUP_ROLE,
},
},
};
@ -85,12 +85,12 @@ impl Shell {
}
pub fn update_reactive_popups<'a>(
window: &Window,
toplevel: &ToplevelSurface,
loc: Point<i32, Global>,
outputs: impl Iterator<Item = &'a Output>,
) {
let output_geo = outputs.map(|o| o.geometry()).collect::<Vec<_>>();
for (popup, _) in PopupManager::popups_for_surface(window.toplevel().wl_surface()) {
for (popup, _) in PopupManager::popups_for_surface(toplevel.wl_surface()) {
match popup {
PopupKind::Xdg(surface) => {
let positioner = with_states(&surface.wl_surface(), |states| {

61
src/xwayland.rs
View file

@ -153,8 +153,7 @@ impl XwmHandler for State {
}
let startup_id = window.startup_id();
let surface = CosmicSurface::X11(window.clone());
if self.common.shell.element_for_surface(&surface).is_some() {
if self.common.shell.element_for_x11_surface(&window).is_some() {
return;
}
@ -175,6 +174,7 @@ impl XwmHandler for State {
);
}
let surface = CosmicSurface::from(window);
self.common
.shell
.pending_windows
@ -187,13 +187,7 @@ impl XwmHandler for State {
.shell
.pending_windows
.iter()
.find(|(window, _, _)| {
if let CosmicSurface::X11(window) = window {
window == &surface
} else {
false
}
})
.find(|(window, _, _)| window.x11_surface() == Some(&surface))
.cloned()
{
if !self
@ -202,10 +196,7 @@ impl XwmHandler for State {
.pending_activations
.contains_key(&crate::shell::ActivationKey::X11(surface.window_id()))
{
if let Some(startup_id) = match &window {
CosmicSurface::X11(x11) => x11.startup_id(),
_ => None,
} {
if let Some(startup_id) = window.x11_surface().and_then(|x| x.startup_id()) {
if let Some(context) = self
.common
.shell
@ -238,7 +229,6 @@ impl XwmHandler for State {
}
fn unmapped_window(&mut self, _xwm: XwmId, window: X11Surface) {
let surface = CosmicSurface::X11(window.clone());
if window.is_override_redirect() {
self.common
.shell
@ -247,7 +237,7 @@ impl XwmHandler for State {
} else if let Some((element, space)) = self
.common
.shell
.element_for_surface(&surface)
.element_for_x11_surface(&window)
.cloned()
.and_then(|element| {
self.common
@ -257,7 +247,12 @@ impl XwmHandler for State {
})
{
if element.is_stack() && element.stack_ref().unwrap().len() >= 2 {
element.stack_ref().unwrap().remove_window(&surface);
if let Some((surface, _)) = element
.windows()
.find(|(w, _)| w.x11_surface() == Some(&window))
{
element.stack_ref().unwrap().remove_window(&surface);
}
} else {
space.unmap(&element);
}
@ -322,11 +317,7 @@ impl XwmHandler for State {
) {
// We only allow floating X11 windows to resize themselves. Nothing else
let mut current_geo = window.geometry();
if let Some(mapped) = self
.common
.shell
.element_for_surface(&CosmicSurface::X11(window.clone()))
{
if let Some(mapped) = self.common.shell.element_for_x11_surface(&window) {
let space = self.common.shell.space_for(mapped).unwrap();
if space.is_floating(mapped) {
mapped.set_geometry(
@ -424,24 +415,26 @@ impl XwmHandler for State {
}
fn maximize_request(&mut self, _xwm: XwmId, window: X11Surface) {
let surface = CosmicSurface::X11(window);
if let Some(mapped) = self.common.shell.element_for_surface(&surface).cloned() {
if let Some(mapped) = self.common.shell.element_for_x11_surface(&window).cloned() {
self.common.shell.maximize_request(&mapped);
}
}
fn unmaximize_request(&mut self, _xwm: XwmId, window: X11Surface) {
let surface = CosmicSurface::X11(window);
if let Some(mapped) = self.common.shell.element_for_surface(&surface).cloned() {
if let Some(mapped) = self.common.shell.element_for_x11_surface(&window).cloned() {
self.common.shell.unmaximize_request(&mapped);
}
}
fn fullscreen_request(&mut self, _xwm: XwmId, window: X11Surface) {
let surface = CosmicSurface::X11(window);
if let Some(mapped) = self.common.shell.element_for_surface(&surface).cloned() {
if let Some(mapped) = self.common.shell.element_for_x11_surface(&window).cloned() {
if let Some(workspace) = self.common.shell.space_for_mut(&mapped) {
workspace.fullscreen_request(&surface, None)
if let Some((surface, _)) = mapped
.windows()
.find(|(w, _)| w.x11_surface() == Some(&window))
{
workspace.fullscreen_request(&surface, None)
}
}
} else {
let output = self.common.last_active_seat().active_output();
@ -450,7 +443,7 @@ impl XwmHandler for State {
.shell
.pending_windows
.iter_mut()
.find(|(s, _, _)| s == &surface)
.find(|(s, _, _)| s.x11_surface() == Some(&window))
.map(|(_, _, o)| o)
{
*o = Some(output);
@ -459,10 +452,12 @@ impl XwmHandler for State {
}
fn unfullscreen_request(&mut self, _xwm: XwmId, window: X11Surface) {
let surface = CosmicSurface::X11(window);
if let Some(mapped) = self.common.shell.element_for_surface(&surface).cloned() {
if let Some(mapped) = self.common.shell.element_for_x11_surface(&window).cloned() {
if let Some(workspace) = self.common.shell.space_for_mut(&mapped) {
let (window, _) = mapped.windows().find(|(w, _)| w == &surface).unwrap();
let (window, _) = mapped
.windows()
.find(|(w, _)| w.x11_surface() == Some(&window))
.unwrap();
let previous = workspace.unfullscreen_request(&window);
assert!(previous.is_none());
}
@ -539,7 +534,7 @@ impl Common {
fn is_x_focused(&self, xwm: XwmId) -> bool {
if let Some(keyboard) = self.last_active_seat().get_keyboard() {
if let Some(KeyboardFocusTarget::Element(mapped)) = keyboard.current_focus() {
if let CosmicSurface::X11(surface) = mapped.active_window() {
if let Some(surface) = mapped.active_window().x11_surface() {
return surface.xwm_id().unwrap() == xwm;
}
}