420 lines
13 KiB
Rust
420 lines
13 KiB
Rust
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
|
|
|
use crate::{
|
|
shell::{
|
|
element::CosmicMapped,
|
|
focus::target::PointerFocusTarget,
|
|
grabs::{ReleaseMode, ResizeEdge},
|
|
},
|
|
utils::prelude::*,
|
|
};
|
|
use smithay::{
|
|
backend::input::ButtonState,
|
|
desktop::{space::SpaceElement, WindowSurface},
|
|
input::{
|
|
pointer::{
|
|
AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent,
|
|
GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent,
|
|
GestureSwipeBeginEvent, GestureSwipeEndEvent, GestureSwipeUpdateEvent,
|
|
GrabStartData as PointerGrabStartData, MotionEvent, PointerGrab, PointerInnerHandle,
|
|
RelativeMotionEvent,
|
|
},
|
|
Seat,
|
|
},
|
|
utils::{IsAlive, Logical, Point, Rectangle, Serial, Size},
|
|
};
|
|
|
|
/// Information about the resize operation.
|
|
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
|
|
pub struct ResizeData {
|
|
/// The edges the surface is being resized with.
|
|
pub edges: ResizeEdge,
|
|
/// The initial window location.
|
|
pub initial_window_location: Point<i32, Local>,
|
|
/// The initial window size (geometry width and height).
|
|
pub initial_window_size: Size<i32, Logical>,
|
|
}
|
|
|
|
/// State of the resize operation.
|
|
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
|
|
pub enum ResizeState {
|
|
/// The surface is currently being resized.
|
|
Resizing(ResizeData),
|
|
/// The resize has finished, and the surface needs to commit its final state.
|
|
WaitingForCommit(ResizeData),
|
|
}
|
|
|
|
pub struct ResizeSurfaceGrab {
|
|
start_data: PointerGrabStartData<State>,
|
|
seat: Seat<State>,
|
|
window: CosmicMapped,
|
|
edges: ResizeEdge,
|
|
initial_window_size: Size<i32, Logical>,
|
|
last_window_size: Size<i32, Logical>,
|
|
release: ReleaseMode,
|
|
}
|
|
|
|
impl PointerGrab<State> for ResizeSurfaceGrab {
|
|
fn motion(
|
|
&mut self,
|
|
data: &mut State,
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
|
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
|
|
event: &MotionEvent,
|
|
) {
|
|
// While the grab is active, no client has pointer focus
|
|
handle.motion(data, None, event);
|
|
|
|
// It is impossible to get `min_size` and `max_size` of dead toplevel, so we return early.
|
|
if !self.window.alive() {
|
|
self.seat
|
|
.user_data()
|
|
.get::<ResizeGrabMarker>()
|
|
.unwrap()
|
|
.0
|
|
.store(false, Ordering::SeqCst);
|
|
handle.unset_grab(data, event.serial, event.time, true);
|
|
return;
|
|
}
|
|
|
|
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;
|
|
|
|
let left_right = ResizeEdge::LEFT | ResizeEdge::RIGHT;
|
|
let top_bottom = ResizeEdge::TOP | ResizeEdge::BOTTOM;
|
|
|
|
if self.edges.intersects(left_right) {
|
|
if self.edges.intersects(ResizeEdge::LEFT) {
|
|
dx = -dx;
|
|
}
|
|
|
|
new_window_width = (self.initial_window_size.w as f64 + dx) as i32;
|
|
}
|
|
|
|
if self.edges.intersects(top_bottom) {
|
|
if self.edges.intersects(ResizeEdge::TOP) {
|
|
dy = -dy;
|
|
}
|
|
|
|
new_window_height = (self.initial_window_size.h as f64 + dy) as i32;
|
|
}
|
|
|
|
let (min_size, max_size) = (self.window.min_size(), self.window.max_size());
|
|
|
|
let min_width = min_size.map(|s| s.w).unwrap_or(360);
|
|
let min_height = min_size.map(|s| s.h).unwrap_or(240);
|
|
let max_width = max_size.map(|s| s.w).unwrap_or(i32::max_value());
|
|
let max_height = max_size.map(|s| s.h).unwrap_or(i32::max_value());
|
|
|
|
new_window_width = new_window_width.max(min_width).min(max_width);
|
|
new_window_height = new_window_height.max(min_height).min(max_height);
|
|
|
|
self.last_window_size = (new_window_width, new_window_height).into();
|
|
|
|
self.window.set_resizing(true);
|
|
self.window.set_geometry(Rectangle::from_loc_and_size(
|
|
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(),
|
|
));
|
|
self.window.configure();
|
|
}
|
|
|
|
fn relative_motion(
|
|
&mut self,
|
|
state: &mut State,
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
|
_focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
|
|
event: &RelativeMotionEvent,
|
|
) {
|
|
// While the grab is active, no client has pointer focus
|
|
handle.relative_motion(state, None, event);
|
|
}
|
|
|
|
fn button(
|
|
&mut self,
|
|
data: &mut State,
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
|
event: &ButtonEvent,
|
|
) {
|
|
handle.button(data, event);
|
|
match self.release {
|
|
ReleaseMode::NoMouseButtons => {
|
|
if handle.current_pressed().is_empty() {
|
|
self.ungrab(data, handle, event.serial, event.time);
|
|
}
|
|
}
|
|
ReleaseMode::Click => {
|
|
if event.state == ButtonState::Pressed {
|
|
self.ungrab(data, handle, event.serial, event.time);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn axis(
|
|
&mut self,
|
|
data: &mut State,
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
|
details: AxisFrame,
|
|
) {
|
|
handle.axis(data, details)
|
|
}
|
|
|
|
fn frame(&mut self, data: &mut State, handle: &mut PointerInnerHandle<'_, State>) {
|
|
handle.frame(data)
|
|
}
|
|
|
|
fn gesture_swipe_begin(
|
|
&mut self,
|
|
data: &mut State,
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
|
event: &GestureSwipeBeginEvent,
|
|
) {
|
|
handle.gesture_swipe_begin(data, event)
|
|
}
|
|
|
|
fn gesture_swipe_update(
|
|
&mut self,
|
|
data: &mut State,
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
|
event: &GestureSwipeUpdateEvent,
|
|
) {
|
|
handle.gesture_swipe_update(data, event)
|
|
}
|
|
|
|
fn gesture_swipe_end(
|
|
&mut self,
|
|
data: &mut State,
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
|
event: &GestureSwipeEndEvent,
|
|
) {
|
|
handle.gesture_swipe_end(data, event)
|
|
}
|
|
|
|
fn gesture_pinch_begin(
|
|
&mut self,
|
|
data: &mut State,
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
|
event: &GesturePinchBeginEvent,
|
|
) {
|
|
handle.gesture_pinch_begin(data, event)
|
|
}
|
|
|
|
fn gesture_pinch_update(
|
|
&mut self,
|
|
data: &mut State,
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
|
event: &GesturePinchUpdateEvent,
|
|
) {
|
|
handle.gesture_pinch_update(data, event)
|
|
}
|
|
|
|
fn gesture_pinch_end(
|
|
&mut self,
|
|
data: &mut State,
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
|
event: &GesturePinchEndEvent,
|
|
) {
|
|
handle.gesture_pinch_end(data, event)
|
|
}
|
|
|
|
fn gesture_hold_begin(
|
|
&mut self,
|
|
data: &mut State,
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
|
event: &GestureHoldBeginEvent,
|
|
) {
|
|
handle.gesture_hold_begin(data, event)
|
|
}
|
|
|
|
fn gesture_hold_end(
|
|
&mut self,
|
|
data: &mut State,
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
|
event: &GestureHoldEndEvent,
|
|
) {
|
|
handle.gesture_hold_end(data, event)
|
|
}
|
|
|
|
fn start_data(&self) -> &PointerGrabStartData<State> {
|
|
&self.start_data
|
|
}
|
|
}
|
|
|
|
pub struct ResizeGrabMarker(AtomicBool);
|
|
|
|
impl ResizeGrabMarker {
|
|
pub fn get(&self) -> bool {
|
|
self.0.load(Ordering::SeqCst)
|
|
}
|
|
}
|
|
|
|
impl ResizeSurfaceGrab {
|
|
pub fn new(
|
|
start_data: PointerGrabStartData<State>,
|
|
mapped: CosmicMapped,
|
|
edges: ResizeEdge,
|
|
initial_window_location: Point<i32, Local>,
|
|
initial_window_size: Size<i32, Logical>,
|
|
seat: &Seat<State>,
|
|
release: ReleaseMode,
|
|
) -> ResizeSurfaceGrab {
|
|
let resize_state = ResizeState::Resizing(ResizeData {
|
|
edges,
|
|
initial_window_location,
|
|
initial_window_size,
|
|
});
|
|
|
|
*mapped.resize_state.lock().unwrap() = Some(resize_state);
|
|
seat.user_data()
|
|
.get_or_insert::<ResizeGrabMarker, _>(|| ResizeGrabMarker(AtomicBool::new(true)))
|
|
.0
|
|
.store(true, Ordering::SeqCst);
|
|
|
|
ResizeSurfaceGrab {
|
|
start_data,
|
|
seat: seat.clone(),
|
|
window: mapped,
|
|
edges,
|
|
initial_window_size,
|
|
last_window_size: initial_window_size,
|
|
release,
|
|
}
|
|
}
|
|
|
|
pub fn apply_resize_to_location(window: CosmicMapped, shell: &mut Shell) {
|
|
let mut resize_state = window.resize_state.lock().unwrap();
|
|
|
|
if resize_state.is_none() {
|
|
return;
|
|
}
|
|
|
|
let (output, floating_layer) = if let Some((output, set)) = shell
|
|
.workspaces
|
|
.sets
|
|
.iter_mut()
|
|
.find(|(_, set)| set.sticky_layer.mapped().any(|m| m == &window))
|
|
{
|
|
(output, &mut set.sticky_layer)
|
|
} else if let Some(workspace) = shell.space_for_mut(&window) {
|
|
(&workspace.output, &mut workspace.floating_layer)
|
|
} else {
|
|
return;
|
|
};
|
|
|
|
if let Some(location) = floating_layer
|
|
.space
|
|
.element_location(&window)
|
|
.map(PointExt::as_local)
|
|
.map(|p| p.to_global(output))
|
|
{
|
|
let mut new_location = None;
|
|
|
|
// If the window is being resized by top or left, its location must be adjusted
|
|
// accordingly.
|
|
match *resize_state {
|
|
Some(ResizeState::Resizing(resize_data))
|
|
| Some(ResizeState::WaitingForCommit(resize_data)) => {
|
|
let ResizeData {
|
|
edges,
|
|
initial_window_location,
|
|
initial_window_size,
|
|
} = resize_data;
|
|
let initial_window_location = initial_window_location.to_global(output);
|
|
|
|
if edges.intersects(ResizeEdge::TOP_LEFT) {
|
|
let size = window.geometry().size;
|
|
let mut new = location.clone();
|
|
if edges.intersects(ResizeEdge::LEFT) {
|
|
new.x = initial_window_location.x + (initial_window_size.w - size.w);
|
|
}
|
|
if edges.intersects(ResizeEdge::TOP) {
|
|
new.y = initial_window_location.y + (initial_window_size.h - size.h);
|
|
}
|
|
|
|
new_location = Some(new);
|
|
}
|
|
}
|
|
_ => {}
|
|
};
|
|
|
|
// Finish resizing.
|
|
if let Some(ResizeState::WaitingForCommit(_)) = *resize_state {
|
|
if !window.is_resizing(false).unwrap_or(false) {
|
|
*resize_state = None;
|
|
}
|
|
}
|
|
std::mem::drop(resize_state);
|
|
|
|
if let Some(new_location) = new_location {
|
|
for (window, offset) in window.windows() {
|
|
match window.0.underlying_surface() {
|
|
WindowSurface::Wayland(toplevel) => {
|
|
update_reactive_popups(
|
|
toplevel,
|
|
new_location + offset.as_global(),
|
|
floating_layer.space.outputs(),
|
|
);
|
|
}
|
|
WindowSurface::X11(surface) => {
|
|
let mut geometry = surface.geometry();
|
|
geometry.loc += (location - new_location).as_logical();
|
|
let _ = surface.configure(geometry);
|
|
}
|
|
}
|
|
}
|
|
floating_layer
|
|
.space
|
|
.map_element(window, new_location.as_logical(), false);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn ungrab(
|
|
&mut self,
|
|
data: &mut State,
|
|
handle: &mut PointerInnerHandle<'_, State>,
|
|
serial: Serial,
|
|
time: u32,
|
|
) {
|
|
// No more buttons are pressed, release the grab.
|
|
self.seat
|
|
.user_data()
|
|
.get::<ResizeGrabMarker>()
|
|
.unwrap()
|
|
.0
|
|
.store(false, Ordering::SeqCst);
|
|
handle.unset_grab(data, serial, time, true);
|
|
|
|
// If toplevel is dead, we can't resize it, so we return early.
|
|
if !self.window.alive() {
|
|
return;
|
|
}
|
|
|
|
self.window.set_resizing(false);
|
|
self.window.set_geometry(Rectangle::from_loc_and_size(
|
|
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(),
|
|
));
|
|
self.window.configure();
|
|
|
|
let mut resize_state = self.window.resize_state.lock().unwrap();
|
|
if let Some(ResizeState::Resizing(resize_data)) = *resize_state {
|
|
*resize_state = Some(ResizeState::WaitingForCommit(resize_data));
|
|
} else {
|
|
panic!("invalid resize state: {:?}", resize_state);
|
|
}
|
|
}
|
|
}
|