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

shell: Cleanup and don't abstract over layouts anymore

Browse source
This commit is contained in:
Victoria Brekenfeld 2022-07-04 15:28:03 +02:00
parent a088f7fd6e
commit b126dfaf77
12 changed files with 1165 additions and 1974 deletions
Download patch file Download diff file Expand all files Collapse all files

161
src/shell/layout/floating/grabs.rs
View file

@ -3,73 +3,70 @@
use smithay::{
desktop::{Kind, Window},
reexports::{
wayland_protocols::xdg_shell::server::xdg_toplevel,
wayland_server::protocol::{wl_pointer::ButtonState, wl_surface},
wayland_protocols::xdg::shell::server::xdg_toplevel,
wayland_server::DisplayHandle,
},
utils::{Logical, Point, Size},
utils::{IsAlive, Logical, Point, Size},
wayland::{
compositor::with_states,
seat::{AxisFrame, PointerGrab, PointerGrabStartData, PointerInnerHandle},
seat::{AxisFrame, PointerGrab, PointerGrabStartData, PointerInnerHandle, MotionEvent, ButtonEvent},
shell::xdg::{SurfaceCachedState, ToplevelConfigure, XdgToplevelSurfaceRoleAttributes},
Serial,
},
};
use std::{cell::RefCell, sync::Mutex};
#[derive(Debug, Default)]
struct MoveData {
new_location: Point<i32, Logical>,
}
use crate::utils::prelude::*;
use std::{
cell::RefCell,
convert::TryFrom,
sync::Mutex,
};
pub struct MoveSurfaceGrab {
start_data: PointerGrabStartData,
window: Window,
initial_window_location: Point<i32, Logical>,
delta: Point<f64, Logical>,
}
impl PointerGrab for MoveSurfaceGrab {
impl PointerGrab<State> for MoveSurfaceGrab {
fn motion(
&mut self,
handle: &mut PointerInnerHandle<'_>,
location: Point<f64, Logical>,
_focus: Option<(wl_surface::WlSurface, Point<i32, Logical>)>,
serial: Serial,
time: u32,
data: &mut State,
_dh: &DisplayHandle,
handle: &mut PointerInnerHandle<'_, State>,
event: &MotionEvent
) {
// While the grab is active, no client has pointer focus
handle.motion(location, None, serial, time);
let delta = location - self.start_data.location;
let new_location = self.initial_window_location.to_f64() + delta;
self.window
.user_data()
.insert_if_missing(|| RefCell::<Option<MoveData>>::new(None));
let data = self
.window
.user_data()
.get::<RefCell<Option<MoveData>>>()
.unwrap();
*data.borrow_mut() = Some(MoveData {
new_location: new_location.to_i32_round(),
});
handle.motion(event.location, None, event.serial, event.time);
self.delta = event.location - self.start_data.location;
if let Some(workspace) = data.common.shell.space_for_surface_mut(self.window.toplevel().wl_surface()) {
let new_location = (self.initial_window_location.to_f64() + self.delta).to_i32_round();
workspace.space.map_window(&self.window, new_location, true);
}
}
fn button(
&mut self,
handle: &mut PointerInnerHandle<'_>,
button: u32,
state: ButtonState,
serial: Serial,
time: u32,
_data: &mut State,
_dh: &DisplayHandle,
handle: &mut PointerInnerHandle<'_, State>,
event: &ButtonEvent,
) {
handle.button(button, state, serial, time);
handle.button(event.button, event.state, event.serial, event.time);
if handle.current_pressed().is_empty() {
// No more buttons are pressed, release the grab.
handle.unset_grab(serial, time);
handle.unset_grab(event.serial, event.time);
}
}
fn axis(&mut self, handle: &mut PointerInnerHandle<'_>, details: AxisFrame) {
fn axis(
&mut self,
_data: &mut State,
_dh: &DisplayHandle,
handle: &mut PointerInnerHandle<'_, State>,
details: AxisFrame,
) {
handle.axis(details)
}
@ -88,19 +85,9 @@ impl MoveSurfaceGrab {
start_data,
window,
initial_window_location,
delta: (0.0, 0.0).into(),
}
}
pub fn apply_move_state(window: &Window) -> Option<Point<i32, Logical>> {
window
.user_data()
.get::<RefCell<Option<MoveData>>>()
.and_then(|opt| {
opt.borrow_mut()
.take()
.map(|move_data| move_data.new_location)
})
}
}
bitflags::bitflags! {
@ -120,14 +107,14 @@ bitflags::bitflags! {
impl From<xdg_toplevel::ResizeEdge> for ResizeEdge {
#[inline]
fn from(x: xdg_toplevel::ResizeEdge) -> Self {
Self::from_bits(x.to_raw()).unwrap()
Self::from_bits(x.into()).unwrap()
}
}
impl From<ResizeEdge> for xdg_toplevel::ResizeEdge {
#[inline]
fn from(x: ResizeEdge) -> Self {
Self::from_raw(x.bits()).unwrap()
Self::try_from(x.bits()).unwrap()
}
}
@ -169,25 +156,24 @@ pub struct ResizeSurfaceGrab {
last_window_size: Size<i32, Logical>,
}
impl PointerGrab for ResizeSurfaceGrab {
impl PointerGrab<State> for ResizeSurfaceGrab {
fn motion(
&mut self,
handle: &mut PointerInnerHandle<'_>,
location: Point<f64, Logical>,
_focus: Option<(wl_surface::WlSurface, Point<i32, Logical>)>,
serial: Serial,
time: u32,
_data: &mut State,
_dh: &DisplayHandle,
handle: &mut PointerInnerHandle<'_, State>,
event: &MotionEvent,
) {
// While the grab is active, no client has pointer focus
handle.motion(location, None, serial, time);
handle.motion(event.location, None, event.serial, event.time);
// It is impossible to get `min_size` and `max_size` of dead toplevel, so we return early.
if !self.window.toplevel().alive() | self.window.toplevel().get_surface().is_none() {
handle.unset_grab(serial, time);
if !self.window.alive() {
handle.unset_grab(event.serial, event.time);
return;
}
let (mut dx, mut dy) = (location - self.start_data.location).into();
let (mut dx, mut dy) = (event.location - self.start_data.location).into();
let mut new_window_width = self.initial_window_size.w;
let mut new_window_height = self.initial_window_size.h;
@ -212,11 +198,10 @@ impl PointerGrab for ResizeSurfaceGrab {
}
let (min_size, max_size) =
with_states(self.window.toplevel().get_surface().unwrap(), |states| {
with_states(self.window.toplevel().wl_surface(), |states| {
let data = states.cached_state.current::<SurfaceCachedState>();
(data.min_size, data.max_size)
})
.unwrap();
});
let min_width = min_size.w.max(1);
let min_height = min_size.h.max(1);
@ -238,44 +223,39 @@ impl PointerGrab for ResizeSurfaceGrab {
match &self.window.toplevel() {
Kind::Xdg(xdg) => {
let ret = xdg.with_pending_state(|state| {
xdg.with_pending_state(|state| {
state.states.set(xdg_toplevel::State::Resizing);
state.size = Some(self.last_window_size);
});
if ret.is_ok() {
xdg.send_configure();
}
xdg.send_configure();
}
}
}
fn button(
&mut self,
handle: &mut PointerInnerHandle<'_>,
button: u32,
state: ButtonState,
serial: Serial,
time: u32,
_data: &mut State,
_dh: &DisplayHandle,
handle: &mut PointerInnerHandle<'_, State>,
event: &ButtonEvent,
) {
handle.button(button, state, serial, time);
handle.button(event.button, event.state, event.serial, event.time);
if handle.current_pressed().is_empty() {
// No more buttons are pressed, release the grab.
handle.unset_grab(serial, time);
handle.unset_grab(event.serial, event.time);
// If toplevel is dead, we can't resize it, so we return early.
if !self.window.toplevel().alive() | self.window.toplevel().get_surface().is_none() {
if !self.window.alive() {
return;
}
#[allow(irrefutable_let_patterns)]
if let Kind::Xdg(xdg) = &self.window.toplevel() {
let ret = xdg.with_pending_state(|state| {
xdg.with_pending_state(|state| {
state.states.unset(xdg_toplevel::State::Resizing);
state.size = Some(self.last_window_size);
});
if ret.is_ok() {
xdg.send_configure();
}
xdg.send_configure();
}
let mut resize_state = self
@ -285,14 +265,20 @@ impl PointerGrab for ResizeSurfaceGrab {
.unwrap()
.borrow_mut();
if let ResizeState::Resizing(resize_data) = *resize_state {
*resize_state = ResizeState::WaitingForFinalAck(resize_data, serial);
*resize_state = ResizeState::WaitingForFinalAck(resize_data, event.serial);
} else {
panic!("invalid resize state: {:?}", resize_state);
}
}
}
fn axis(&mut self, handle: &mut PointerInnerHandle<'_>, details: AxisFrame) {
fn axis(
&mut self,
_data: &mut State,
_dh: &DisplayHandle,
handle: &mut PointerInnerHandle<'_, State>,
details: AxisFrame,
) {
handle.axis(details)
}
@ -334,11 +320,7 @@ impl ResizeSurfaceGrab {
}
pub fn ack_configure(window: &Window, configure: ToplevelConfigure) {
let surface = if let Some(surface) = window.toplevel().get_surface() {
surface
} else {
return;
};
let surface = window.toplevel().wl_surface();
let waiting_for_serial =
if let Some(data) = window.user_data().get::<RefCell<ResizeState>>() {
@ -372,8 +354,7 @@ impl ResizeSurfaceGrab {
.current
.states
.contains(xdg_toplevel::State::Resizing)
})
.unwrap();
});
if configure.serial >= serial && is_resizing {
let mut resize_state = window

165
src/shell/layout/floating/mod.rs
View file

@ -1,9 +1,8 @@
// SPDX-License-Identifier: GPL-3.0-only
use crate::shell::layout::Layout;
use smithay::{
desktop::{layer_map_for_output, Kind, Space, Window},
reexports::wayland_protocols::xdg_shell::server::xdg_toplevel::{
desktop::{layer_map_for_output, Kind, Space, Window, space::RenderZindex},
reexports::wayland_protocols::xdg::shell::server::xdg_toplevel::{
ResizeEdge, State as XdgState,
},
wayland::{
@ -11,7 +10,11 @@ use smithay::{
seat::{PointerGrabStartData, Seat},
Serial,
},
utils::IsAlive,
};
use std::collections::HashSet;
use crate::state::State;
mod grabs;
pub use self::grabs::*;
@ -19,61 +22,94 @@ pub use self::grabs::*;
#[derive(Debug, Default)]
pub struct FloatingLayout {
pending_windows: Vec<Window>,
pub windows: HashSet<Window>,
}
impl Layout for FloatingLayout {
fn map_window<'a>(
impl FloatingLayout {
pub fn new() -> FloatingLayout {
Default::default()
}
pub fn map_window(
&mut self,
space: &mut Space,
window: &Window,
seat: &Seat,
_focus_stack: Box<dyn Iterator<Item = &'a Window> + 'a>,
window: Window,
seat: &Seat<State>,
) {
if let Some(output) = super::output_from_seat(Some(seat), space) {
Self::map_window(space, window, &output)
self.map_window_internal(space, window, &output);
} else {
self.pending_windows.push(window.clone());
self.pending_windows.push(window);
}
}
fn refresh(&mut self, space: &mut Space) {
pub fn refresh(&mut self, space: &mut Space) {
self.pending_windows.retain(|w| w.toplevel().alive());
if let Some(output) = super::output_from_seat(None, space) {
for window in self.pending_windows.drain(..) {
Self::map_window(space, &window, &output);
for window in std::mem::take(&mut self.pending_windows).into_iter() {
self.map_window_internal(space, window, &output);
}
}
// TODO make sure all windows are still visible on any output or move them
}
fn unmap_window(&mut self, space: &mut Space, window: &Window) {
space.unmap_window(window);
self.pending_windows.retain(|w| w != window);
}
fn maximize_request(&mut self, space: &mut Space, window: &Window, output: &Output) {
fn map_window_internal(
&mut self,
space: &mut Space,
window: Window,
output: &Output
) {
let win_geo = window.bbox();
let layers = layer_map_for_output(&output);
let geometry = layers.non_exclusive_zone();
space.map_window(&window, (-geometry.loc.x, -geometry.loc.y), true);
let position = (
-geometry.loc.x + (geometry.size.w / 2) - (win_geo.size.w / 2),
-geometry.loc.y + (geometry.size.h / 2) - (win_geo.size.h / 2),
);
#[allow(irrefutable_let_patterns)]
if let Kind::Xdg(xdg) = &window.toplevel() {
xdg.with_pending_state(|state| {
state.states.unset(XdgState::TiledLeft);
state.states.unset(XdgState::TiledRight);
state.states.unset(XdgState::TiledTop);
state.states.unset(XdgState::TiledBottom);
});
xdg.send_configure();
}
window.override_z_index(RenderZindex::Shell as u8 + 1);
space.map_window(&window, position, false);
self.windows.insert(window);
}
pub fn unmap_window(&mut self, space: &mut Space, window: &Window) {
window.clear_z_index();
space.unmap_window(window);
self.pending_windows.retain(|w| w != window);
self.windows.remove(window);
}
pub fn maximize_request(&mut self, space: &mut Space, window: &Window, output: &Output) {
let layers = layer_map_for_output(&output);
let geometry = layers.non_exclusive_zone();
space.map_window(&window, (geometry.loc.x, geometry.loc.y), true);
#[allow(irrefutable_let_patterns)]
if let Kind::Xdg(surface) = &window.toplevel() {
let ret = surface.with_pending_state(|state| {
surface.with_pending_state(|state| {
state.states.set(XdgState::Maximized);
state.size = Some(geometry.size);
});
if ret.is_ok() {
window.configure();
}
window.configure();
}
}
fn move_request(
pub fn move_request(
&mut self,
space: &mut Space,
window: &Window,
seat: &Seat,
seat: &Seat<State>,
serial: Serial,
start_data: PointerGrabStartData,
) {
@ -83,31 +119,26 @@ impl Layout for FloatingLayout {
#[allow(irrefutable_let_patterns)]
if let Kind::Xdg(surface) = &window.toplevel() {
// If surface is maximized then unmaximize it
if let Some(current_state) = surface.current_state() {
if current_state.states.contains(XdgState::Maximized) {
let fs_changed = surface.with_pending_state(|state| {
state.states.unset(XdgState::Maximized);
state.size = None;
});
let current_state = surface.current_state();
if current_state.states.contains(XdgState::Maximized) {
surface.with_pending_state(|state| {
state.states.unset(XdgState::Maximized);
state.size = None;
});
if fs_changed.is_ok() {
surface.send_configure();
surface.send_configure();
// NOTE: In real compositor mouse location should be mapped to a new window size
// For example, you could:
// 1) transform mouse pointer position from compositor space to window space (location relative)
// 2) divide the x coordinate by width of the window to get the percentage
// - 0.0 would be on the far left of the window
// - 0.5 would be in middle of the window
// - 1.0 would be on the far right of the window
// 3) multiply the percentage by new window width
// 4) by doing that, drag will look a lot more natural
//
// but for anvil needs setting location to pointer location is fine
let pos = pointer.current_location();
initial_window_location = (pos.x as i32, pos.y as i32).into();
}
}
// TODO: The mouse location should be mapped to a new window size
// For example, you could:
// 1) transform mouse pointer position from compositor space to window space (location relative)
// 2) divide the x coordinate by width of the window to get the percentage
// - 0.0 would be on the far left of the window
// - 0.5 would be in middle of the window
// - 1.0 would be on the far right of the window
// 3) multiply the percentage by new window width
// 4) by doing that, drag will look a lot more natural
let pos = pointer.current_location();
initial_window_location = (pos.x as i32, pos.y as i32).into();
}
}
@ -117,11 +148,11 @@ impl Layout for FloatingLayout {
}
}
fn resize_request(
pub fn resize_request(
&mut self,
space: &mut Space,
window: &Window,
seat: &Seat,
seat: &Seat<State>,
serial: Serial,
start_data: PointerGrabStartData,
edges: ResizeEdge,
@ -137,33 +168,3 @@ impl Layout for FloatingLayout {
}
}
}
impl FloatingLayout {
pub fn new() -> FloatingLayout {
Default::default()
}
fn map_window(space: &mut Space, window: &Window, output: &Output) {
let win_geo = window.bbox();
let layers = layer_map_for_output(&output);
let geometry = layers.non_exclusive_zone();
let position = (
-geometry.loc.x + (geometry.size.w / 2) - (win_geo.size.w / 2),
-geometry.loc.y + (geometry.size.h / 2) - (win_geo.size.h / 2),
);
#[allow(irrefutable_let_patterns)]
if let Kind::Xdg(xdg) = &window.toplevel() {
let ret = xdg.with_pending_state(|state| {
state.states.unset(XdgState::TiledLeft);
state.states.unset(XdgState::TiledRight);
state.states.unset(XdgState::TiledTop);
state.states.unset(XdgState::TiledBottom);
});
if ret.is_ok() {
xdg.send_configure();
}
}
space.map_window(&window, position, false);
}
}