feat: support interactive window move and resize
This commit is contained in:
Samuel Onoja committed
1 parent
3c1cfe351c
commit
0cc0488257
7 files changed
+660
-13
No files matched your search
@@ -0,0 +1,401 @@
|
||||
use std::cell::RefCell;
|
||||
|
||||
use smithay::{
|
||||
desktop::{Space, Window},
|
||||
input::pointer::{
|
||||
AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent, GesturePinchBeginEvent,
|
||||
GesturePinchEndEvent, GesturePinchUpdateEvent, GestureSwipeBeginEvent,
|
||||
GestureSwipeEndEvent, GestureSwipeUpdateEvent, GrabStartData, MotionEvent, PointerGrab,
|
||||
PointerInnerHandle, RelativeMotionEvent,
|
||||
},
|
||||
reexports::{
|
||||
wayland_protocols::xdg::shell::server::xdg_toplevel,
|
||||
wayland_server::protocol::wl_surface::WlSurface,
|
||||
},
|
||||
utils::{Logical, Point, Rectangle, Size},
|
||||
wayland::{compositor::with_states, shell::xdg::SurfaceCachedState},
|
||||
};
|
||||
|
||||
use crate::Ferese;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct ResizeEdge(xdg_toplevel::ResizeEdge);
|
||||
|
||||
impl From<xdg_toplevel::ResizeEdge> for ResizeEdge {
|
||||
fn from(edge: xdg_toplevel::ResizeEdge) -> Self {
|
||||
Self(edge)
|
||||
}
|
||||
}
|
||||
|
||||
impl ResizeEdge {
|
||||
fn left(self) -> bool {
|
||||
matches!(
|
||||
self.0,
|
||||
xdg_toplevel::ResizeEdge::Left
|
||||
| xdg_toplevel::ResizeEdge::TopLeft
|
||||
| xdg_toplevel::ResizeEdge::BottomLeft
|
||||
)
|
||||
}
|
||||
|
||||
fn right(self) -> bool {
|
||||
matches!(
|
||||
self.0,
|
||||
xdg_toplevel::ResizeEdge::Right
|
||||
| xdg_toplevel::ResizeEdge::TopRight
|
||||
| xdg_toplevel::ResizeEdge::BottomRight
|
||||
)
|
||||
}
|
||||
|
||||
fn top(self) -> bool {
|
||||
matches!(
|
||||
self.0,
|
||||
xdg_toplevel::ResizeEdge::Top
|
||||
| xdg_toplevel::ResizeEdge::TopLeft
|
||||
| xdg_toplevel::ResizeEdge::TopRight
|
||||
)
|
||||
}
|
||||
|
||||
fn bottom(self) -> bool {
|
||||
matches!(
|
||||
self.0,
|
||||
xdg_toplevel::ResizeEdge::Bottom
|
||||
| xdg_toplevel::ResizeEdge::BottomLeft
|
||||
| xdg_toplevel::ResizeEdge::BottomRight
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
pub struct ResizeSurfaceGrab {
|
||||
start_data: GrabStartData<Ferese>,
|
||||
window: Window,
|
||||
edges: ResizeEdge,
|
||||
initial_rect: Rectangle<i32, Logical>,
|
||||
last_size: Size<i32, Logical>,
|
||||
}
|
||||
|
||||
impl ResizeSurfaceGrab {
|
||||
pub fn new(
|
||||
start_data: GrabStartData<Ferese>,
|
||||
window: Window,
|
||||
edges: ResizeEdge,
|
||||
initial_rect: Rectangle<i32, Logical>,
|
||||
) -> Self {
|
||||
ResizeState::with(
|
||||
window
|
||||
.toplevel()
|
||||
.expect("managed window has a toplevel")
|
||||
.wl_surface(),
|
||||
|state| {
|
||||
*state = ResizeState::Resizing {
|
||||
edges,
|
||||
initial_rect,
|
||||
}
|
||||
},
|
||||
);
|
||||
Self {
|
||||
start_data,
|
||||
window,
|
||||
edges,
|
||||
initial_rect,
|
||||
last_size: initial_rect.size,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl PointerGrab<Ferese> for ResizeSurfaceGrab {
|
||||
fn motion(
|
||||
&mut self,
|
||||
data: &mut Ferese,
|
||||
handle: &mut PointerInnerHandle<'_, Ferese>,
|
||||
_focus: Option<(WlSurface, Point<f64, Logical>)>,
|
||||
event: &MotionEvent,
|
||||
) {
|
||||
handle.motion(data, None, event);
|
||||
let delta = event.location - self.start_data.location;
|
||||
let surface = self
|
||||
.window
|
||||
.toplevel()
|
||||
.expect("managed window has a toplevel");
|
||||
let (minimum, maximum) = with_states(surface.wl_surface(), |states| {
|
||||
let mut cached = states.cached_state.get::<SurfaceCachedState>();
|
||||
let state = cached.current();
|
||||
(state.min_size, state.max_size)
|
||||
});
|
||||
self.last_size =
|
||||
constrained_size(self.initial_rect.size, delta, self.edges, minimum, maximum);
|
||||
|
||||
surface.with_pending_state(|state| {
|
||||
state.states.set(xdg_toplevel::State::Resizing);
|
||||
state.size = Some(self.last_size);
|
||||
});
|
||||
surface.send_pending_configure();
|
||||
}
|
||||
|
||||
fn relative_motion(
|
||||
&mut self,
|
||||
data: &mut Ferese,
|
||||
handle: &mut PointerInnerHandle<'_, Ferese>,
|
||||
focus: Option<(WlSurface, Point<f64, Logical>)>,
|
||||
event: &RelativeMotionEvent,
|
||||
) {
|
||||
handle.relative_motion(data, focus, event);
|
||||
}
|
||||
|
||||
fn button(
|
||||
&mut self,
|
||||
data: &mut Ferese,
|
||||
handle: &mut PointerInnerHandle<'_, Ferese>,
|
||||
event: &ButtonEvent,
|
||||
) {
|
||||
handle.button(data, event);
|
||||
if handle.current_pressed().is_empty() {
|
||||
handle.unset_grab(self, data, event.serial, event.time, true);
|
||||
let surface = self
|
||||
.window
|
||||
.toplevel()
|
||||
.expect("managed window has a toplevel");
|
||||
surface.with_pending_state(|state| {
|
||||
state.states.unset(xdg_toplevel::State::Resizing);
|
||||
state.size = Some(self.last_size);
|
||||
});
|
||||
surface.send_pending_configure();
|
||||
ResizeState::with(surface.wl_surface(), |state| {
|
||||
*state = ResizeState::WaitingForFinalCommit {
|
||||
edges: self.edges,
|
||||
initial_rect: self.initial_rect,
|
||||
};
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
fn axis(
|
||||
&mut self,
|
||||
data: &mut Ferese,
|
||||
handle: &mut PointerInnerHandle<'_, Ferese>,
|
||||
frame: AxisFrame,
|
||||
) {
|
||||
handle.axis(data, frame);
|
||||
}
|
||||
|
||||
fn frame(&mut self, data: &mut Ferese, handle: &mut PointerInnerHandle<'_, Ferese>) {
|
||||
handle.frame(data);
|
||||
}
|
||||
|
||||
fn gesture_swipe_begin(
|
||||
&mut self,
|
||||
data: &mut Ferese,
|
||||
handle: &mut PointerInnerHandle<'_, Ferese>,
|
||||
event: &GestureSwipeBeginEvent,
|
||||
) {
|
||||
handle.gesture_swipe_begin(data, event);
|
||||
}
|
||||
fn gesture_swipe_update(
|
||||
&mut self,
|
||||
data: &mut Ferese,
|
||||
handle: &mut PointerInnerHandle<'_, Ferese>,
|
||||
event: &GestureSwipeUpdateEvent,
|
||||
) {
|
||||
handle.gesture_swipe_update(data, event);
|
||||
}
|
||||
fn gesture_swipe_end(
|
||||
&mut self,
|
||||
data: &mut Ferese,
|
||||
handle: &mut PointerInnerHandle<'_, Ferese>,
|
||||
event: &GestureSwipeEndEvent,
|
||||
) {
|
||||
handle.gesture_swipe_end(data, event);
|
||||
}
|
||||
fn gesture_pinch_begin(
|
||||
&mut self,
|
||||
data: &mut Ferese,
|
||||
handle: &mut PointerInnerHandle<'_, Ferese>,
|
||||
event: &GesturePinchBeginEvent,
|
||||
) {
|
||||
handle.gesture_pinch_begin(data, event);
|
||||
}
|
||||
fn gesture_pinch_update(
|
||||
&mut self,
|
||||
data: &mut Ferese,
|
||||
handle: &mut PointerInnerHandle<'_, Ferese>,
|
||||
event: &GesturePinchUpdateEvent,
|
||||
) {
|
||||
handle.gesture_pinch_update(data, event);
|
||||
}
|
||||
fn gesture_pinch_end(
|
||||
&mut self,
|
||||
data: &mut Ferese,
|
||||
handle: &mut PointerInnerHandle<'_, Ferese>,
|
||||
event: &GesturePinchEndEvent,
|
||||
) {
|
||||
handle.gesture_pinch_end(data, event);
|
||||
}
|
||||
fn gesture_hold_begin(
|
||||
&mut self,
|
||||
data: &mut Ferese,
|
||||
handle: &mut PointerInnerHandle<'_, Ferese>,
|
||||
event: &GestureHoldBeginEvent,
|
||||
) {
|
||||
handle.gesture_hold_begin(data, event);
|
||||
}
|
||||
fn gesture_hold_end(
|
||||
&mut self,
|
||||
data: &mut Ferese,
|
||||
handle: &mut PointerInnerHandle<'_, Ferese>,
|
||||
event: &GestureHoldEndEvent,
|
||||
) {
|
||||
handle.gesture_hold_end(data, event);
|
||||
}
|
||||
|
||||
fn start_data(&self) -> &GrabStartData<Ferese> {
|
||||
&self.start_data
|
||||
}
|
||||
|
||||
fn unset(&mut self, _data: &mut Ferese) {}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default)]
|
||||
enum ResizeState {
|
||||
#[default]
|
||||
Idle,
|
||||
Resizing {
|
||||
edges: ResizeEdge,
|
||||
initial_rect: Rectangle<i32, Logical>,
|
||||
},
|
||||
WaitingForFinalCommit {
|
||||
edges: ResizeEdge,
|
||||
initial_rect: Rectangle<i32, Logical>,
|
||||
},
|
||||
}
|
||||
|
||||
impl ResizeState {
|
||||
fn with<T>(surface: &WlSurface, callback: impl FnOnce(&mut Self) -> T) -> T {
|
||||
with_states(surface, |states| {
|
||||
states.data_map.insert_if_missing(RefCell::<Self>::default);
|
||||
callback(
|
||||
&mut states
|
||||
.data_map
|
||||
.get::<RefCell<Self>>()
|
||||
.expect("resize state was inserted")
|
||||
.borrow_mut(),
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
fn commit(&mut self) -> Option<(ResizeEdge, Rectangle<i32, Logical>)> {
|
||||
match *self {
|
||||
Self::Idle => None,
|
||||
Self::Resizing {
|
||||
edges,
|
||||
initial_rect,
|
||||
} => Some((edges, initial_rect)),
|
||||
Self::WaitingForFinalCommit {
|
||||
edges,
|
||||
initial_rect,
|
||||
} => {
|
||||
*self = Self::Idle;
|
||||
Some((edges, initial_rect))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn handle_resize_commit(space: &mut Space<Window>, surface: &WlSurface) {
|
||||
let Some(window) = space
|
||||
.elements()
|
||||
.find(|window| {
|
||||
window
|
||||
.toplevel()
|
||||
.is_some_and(|toplevel| toplevel.wl_surface() == surface)
|
||||
})
|
||||
.cloned()
|
||||
else {
|
||||
return;
|
||||
};
|
||||
let Some(mut location) = space.element_location(&window) else {
|
||||
return;
|
||||
};
|
||||
let geometry = window.geometry();
|
||||
let Some((edges, initial_rect)) = ResizeState::with(surface, ResizeState::commit) else {
|
||||
return;
|
||||
};
|
||||
|
||||
if edges.left() {
|
||||
location.x = initial_rect.loc.x + initial_rect.size.w - geometry.size.w;
|
||||
}
|
||||
if edges.top() {
|
||||
location.y = initial_rect.loc.y + initial_rect.size.h - geometry.size.h;
|
||||
}
|
||||
if edges.left() || edges.top() {
|
||||
space.map_element(window, location, false);
|
||||
}
|
||||
}
|
||||
|
||||
fn constrained_size(
|
||||
initial: Size<i32, Logical>,
|
||||
delta: Point<f64, Logical>,
|
||||
edges: ResizeEdge,
|
||||
minimum: Size<i32, Logical>,
|
||||
maximum: Size<i32, Logical>,
|
||||
) -> Size<i32, Logical> {
|
||||
let mut width = initial.w;
|
||||
let mut height = initial.h;
|
||||
if edges.left() {
|
||||
width -= delta.x as i32;
|
||||
} else if edges.right() {
|
||||
width += delta.x as i32;
|
||||
}
|
||||
if edges.top() {
|
||||
height -= delta.y as i32;
|
||||
} else if edges.bottom() {
|
||||
height += delta.y as i32;
|
||||
}
|
||||
|
||||
let maximum_width = if maximum.w == 0 { i32::MAX } else { maximum.w };
|
||||
let maximum_height = if maximum.h == 0 { i32::MAX } else { maximum.h };
|
||||
(
|
||||
width.clamp(minimum.w.max(1), maximum_width),
|
||||
height.clamp(minimum.h.max(1), maximum_height),
|
||||
)
|
||||
.into()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn left_and_top_edges_invert_pointer_delta() {
|
||||
let size = constrained_size(
|
||||
(800, 600).into(),
|
||||
(100.0, 50.0).into(),
|
||||
ResizeEdge(xdg_toplevel::ResizeEdge::TopLeft),
|
||||
(1, 1).into(),
|
||||
(0, 0).into(),
|
||||
);
|
||||
assert_eq!(size, (700, 550).into());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn right_and_bottom_edges_follow_pointer_delta() {
|
||||
let size = constrained_size(
|
||||
(800, 600).into(),
|
||||
(100.0, 50.0).into(),
|
||||
ResizeEdge(xdg_toplevel::ResizeEdge::BottomRight),
|
||||
(1, 1).into(),
|
||||
(0, 0).into(),
|
||||
);
|
||||
assert_eq!(size, (900, 650).into());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn client_constraints_clamp_interactive_size() {
|
||||
let size = constrained_size(
|
||||
(800, 600).into(),
|
||||
(1_000.0, 1_000.0).into(),
|
||||
ResizeEdge(xdg_toplevel::ResizeEdge::BottomRight),
|
||||
(640, 480).into(),
|
||||
(1_024, 768).into(),
|
||||
);
|
||||
assert_eq!(size, (1_024, 768).into());
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user