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

chore: update smithay

Browse source
This commit is contained in:
Victoria Brekenfeld 2026-06-29 17:20:02 +02:00 • committed by Victoria Brekenfeld
parent 650768211f
commit ccc4f36065
16 changed files with 513 additions and 552 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -61,8 +61,8 @@ use smithay::{
PointerTarget, RelativeMotionEvent,
},
touch::{
DownEvent, MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent, TouchTarget,
UpEvent,
DownEvent, FrameMarker, MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent,
TouchTarget, UpEvent,
},
},
output::Output,
@ -79,7 +79,7 @@ use std::{
hash::Hash,
sync::{
Arc, LazyLock, Mutex,
atomic::{AtomicBool, AtomicU8, AtomicUsize, Ordering},
atomic::{AtomicBool, AtomicU8, AtomicU32, AtomicUsize, Ordering},
},
};
@ -114,6 +114,7 @@ pub struct CosmicStackInternal {
scroll_to_focus: AtomicBool,
previous_keyboard: AtomicUsize,
pointer_entered: AtomicU8,
touch_serial: AtomicU32,
reenter: AtomicBool,
potential_drag: Mutex<Option<usize>>,
override_alive: AtomicBool,
@ -171,6 +172,7 @@ impl CosmicStack {
scroll_to_focus: AtomicBool::new(false),
previous_keyboard: AtomicUsize::new(0),
pointer_entered: AtomicU8::new(0),
touch_serial: AtomicU32::new(0),
reenter: AtomicBool::new(false),
potential_drag: Mutex::new(None),
override_alive: AtomicBool::new(true),
@ -1815,55 +1817,62 @@ impl PointerTarget<State> for CosmicStack {
}
impl TouchTarget<State> for CosmicStack {
fn down(&self, seat: &Seat<State>, data: &mut State, event: &DownEvent, seq: Serial) {
fn down(&self, seat: &Seat<State>, data: &mut State, event: &DownEvent) {
let mut event = event.clone();
let active_window_geo = self.0.with_program(|p| {
p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)].geometry()
});
event.location -= active_window_geo.loc.to_f64();
TouchTarget::down(&self.0, seat, data, &event, seq)
self.0
.with_program(|p| p.touch_serial.store(event.serial.into(), Ordering::Release));
TouchTarget::down(&self.0, seat, data, &event)
}
fn up(&self, seat: &Seat<State>, data: &mut State, event: &UpEvent, seq: Serial) {
TouchTarget::up(&self.0, seat, data, event, seq)
fn up(&self, seat: &Seat<State>, data: &mut State, event: &UpEvent) {
TouchTarget::up(&self.0, seat, data, event)
}
fn motion(&self, seat: &Seat<State>, data: &mut State, event: &TouchMotionEvent, seq: Serial) {
fn motion(&self, seat: &Seat<State>, data: &mut State, event: &TouchMotionEvent) {
let mut event = event.clone();
let active_window_geo = self.0.with_program(|p| {
p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)].geometry()
});
event.location -= active_window_geo.loc.to_f64();
TouchTarget::motion(&self.0, seat, data, &event, seq);
TouchTarget::motion(&self.0, seat, data, &event);
if event.location.y < 0.0
|| event.location.y > TAB_HEIGHT as f64
|| event.location.x < 64.0
|| event.location.x > (active_window_geo.size.w as f64 - 64.0)
{
self.start_drag(data, seat, seq);
self.start_drag(
data,
seat,
self.0
.with_program(|p| p.touch_serial.load(Ordering::Acquire))
.into(),
);
}
}
fn frame(&self, seat: &Seat<State>, data: &mut State, seq: Serial) {
TouchTarget::frame(&self.0, seat, data, seq)
fn frame(&self, seat: &Seat<State>, data: &mut State, frame: FrameMarker) {
TouchTarget::frame(&self.0, seat, data, frame)
}
fn cancel(&self, seat: &Seat<State>, data: &mut State, seq: Serial) {
TouchTarget::cancel(&self.0, seat, data, seq)
fn cancel(&self, seat: &Seat<State>, data: &mut State, frame: FrameMarker) {
TouchTarget::cancel(&self.0, seat, data, frame)
}
fn shape(&self, seat: &Seat<State>, data: &mut State, event: &ShapeEvent, seq: Serial) {
TouchTarget::shape(&self.0, seat, data, event, seq)
fn shape(&self, seat: &Seat<State>, data: &mut State, event: &ShapeEvent) {
TouchTarget::shape(&self.0, seat, data, event)
}
fn orientation(
&self,
_seat: &Seat<State>,
_data: &mut State,
_event: &OrientationEvent,
_seq: Serial,
) {
fn orientation(&self, seat: &Seat<State>, data: &mut State, event: &OrientationEvent) {
TouchTarget::orientation(&self.0, seat, data, event)
}
fn last_frame(&self, seat: &Seat<State>, data: &mut State) -> Option<FrameMarker> {
TouchTarget::last_frame(&self.0, seat, data)
}
}

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

@ -47,8 +47,8 @@ use smithay::{
GestureSwipeUpdateEvent, MotionEvent, PointerTarget, RelativeMotionEvent,
},
touch::{
DownEvent, MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent, TouchTarget,
UpEvent,
DownEvent, FrameMarker, MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent,
TouchTarget, UpEvent,
},
},
output::Output,
@ -1190,43 +1190,42 @@ impl PointerTarget<State> for CosmicWindow {
}
impl TouchTarget<State> for CosmicWindow {
fn down(&self, seat: &Seat<State>, data: &mut State, event: &DownEvent, seq: Serial) {
fn down(&self, seat: &Seat<State>, data: &mut State, event: &DownEvent) {
let mut event = event.clone();
self.0.with_program(|p| {
event.location -= p.window.geometry().loc.to_f64();
});
TouchTarget::down(&self.0, seat, data, &event, seq)
TouchTarget::down(&self.0, seat, data, &event)
}
fn up(&self, seat: &Seat<State>, data: &mut State, event: &UpEvent, seq: Serial) {
TouchTarget::up(&self.0, seat, data, event, seq)
fn up(&self, seat: &Seat<State>, data: &mut State, event: &UpEvent) {
TouchTarget::up(&self.0, seat, data, event)
}
fn motion(&self, seat: &Seat<State>, data: &mut State, event: &TouchMotionEvent, seq: Serial) {
fn motion(&self, seat: &Seat<State>, data: &mut State, event: &TouchMotionEvent) {
let mut event = event.clone();
event.location -= self.0.with_program(|p| p.window.geometry().loc.to_f64());
TouchTarget::motion(&self.0, seat, data, &event, seq)
TouchTarget::motion(&self.0, seat, data, &event)
}
fn frame(&self, seat: &Seat<State>, data: &mut State, seq: Serial) {
TouchTarget::frame(&self.0, seat, data, seq)
fn frame(&self, seat: &Seat<State>, data: &mut State, frame: FrameMarker) {
TouchTarget::frame(&self.0, seat, data, frame)
}
fn cancel(&self, seat: &Seat<State>, data: &mut State, seq: Serial) {
TouchTarget::cancel(&self.0, seat, data, seq)
fn cancel(&self, seat: &Seat<State>, data: &mut State, frame: FrameMarker) {
TouchTarget::cancel(&self.0, seat, data, frame)
}
fn shape(&self, seat: &Seat<State>, data: &mut State, event: &ShapeEvent, seq: Serial) {
TouchTarget::shape(&self.0, seat, data, event, seq)
fn shape(&self, seat: &Seat<State>, data: &mut State, event: &ShapeEvent) {
TouchTarget::shape(&self.0, seat, data, event)
}
fn orientation(
&self,
_seat: &Seat<State>,
_data: &mut State,
_event: &OrientationEvent,
_seq: Serial,
) {
fn orientation(&self, seat: &Seat<State>, data: &mut State, event: &OrientationEvent) {
TouchTarget::orientation(&self.0, seat, data, event)
}
fn last_frame(&self, seat: &Seat<State>, data: &mut State) -> Option<FrameMarker> {
TouchTarget::last_frame(&self.0, seat, data)
}
}

43
src/shell/focus/target.rs
View file

@ -29,8 +29,8 @@ use smithay::{
MotionEvent as PointerMotionEvent, PointerTarget, RelativeMotionEvent,
},
touch::{
DownEvent, MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent, TouchTarget,
UpEvent,
DownEvent, FrameMarker, MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent,
TouchTarget, UpEvent,
},
},
reexports::wayland_server::{
@ -498,39 +498,36 @@ impl PointerTarget<State> for PointerFocusTarget {
}
impl TouchTarget<State> for PointerFocusTarget {
fn down(&self, seat: &Seat<State>, data: &mut State, event: &DownEvent, seq: Serial) {
self.inner_touch_target().down(seat, data, event, seq);
fn down(&self, seat: &Seat<State>, data: &mut State, event: &DownEvent) {
self.inner_touch_target().down(seat, data, event);
}
fn up(&self, seat: &Seat<State>, data: &mut State, event: &UpEvent, seq: Serial) {
self.inner_touch_target().up(seat, data, event, seq);
fn up(&self, seat: &Seat<State>, data: &mut State, event: &UpEvent) {
self.inner_touch_target().up(seat, data, event);
}
fn motion(&self, seat: &Seat<State>, data: &mut State, event: &TouchMotionEvent, seq: Serial) {
self.inner_touch_target().motion(seat, data, event, seq);
fn motion(&self, seat: &Seat<State>, data: &mut State, event: &TouchMotionEvent) {
self.inner_touch_target().motion(seat, data, event);
}
fn frame(&self, seat: &Seat<State>, data: &mut State, seq: Serial) {
self.inner_touch_target().frame(seat, data, seq);
fn frame(&self, seat: &Seat<State>, data: &mut State, frame: FrameMarker) {
self.inner_touch_target().frame(seat, data, frame);
}
fn cancel(&self, seat: &Seat<State>, data: &mut State, seq: Serial) {
self.inner_touch_target().cancel(seat, data, seq);
fn cancel(&self, seat: &Seat<State>, data: &mut State, frame: FrameMarker) {
self.inner_touch_target().cancel(seat, data, frame);
}
fn shape(&self, seat: &Seat<State>, data: &mut State, event: &ShapeEvent, seq: Serial) {
self.inner_touch_target().shape(seat, data, event, seq);
fn shape(&self, seat: &Seat<State>, data: &mut State, event: &ShapeEvent) {
self.inner_touch_target().shape(seat, data, event);
}
fn orientation(
&self,
seat: &Seat<State>,
data: &mut State,
event: &OrientationEvent,
seq: Serial,
) {
self.inner_touch_target()
.orientation(seat, data, event, seq);
fn orientation(&self, seat: &Seat<State>, data: &mut State, event: &OrientationEvent) {
self.inner_touch_target().orientation(seat, data, event);
}
fn last_frame(&self, seat: &Seat<State>, data: &mut State) -> Option<FrameMarker> {
self.inner_touch_target().last_frame(seat, data)
}
}

30
src/shell/grabs/delay.rs
View file

@ -202,19 +202,12 @@ impl<G: TouchGrab<State>> TouchGrab<State> for DelayGrab<G> {
handle: &mut TouchInnerHandle<'_, State>,
focus: Option<(<State as SeatHandler>::TouchFocus, Point<f64, Logical>)>,
event: &DownEvent,
seq: Serial,
) {
handle.down(data, focus, event, seq);
handle.down(data, focus, event);
}
fn up(
&mut self,
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &UpEvent,
seq: Serial,
) {
handle.up(data, event, seq);
fn up(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, event: &UpEvent) {
handle.up(data, event);
if event.slot == TouchGrab::start_data(self).slot {
handle.unset_grab(self, data);
@ -227,9 +220,8 @@ impl<G: TouchGrab<State>> TouchGrab<State> for DelayGrab<G> {
handle: &mut TouchInnerHandle<'_, State>,
focus: Option<(<State as SeatHandler>::TouchFocus, Point<f64, Logical>)>,
event: &TouchMotionEvent,
seq: Serial,
) {
handle.motion(data, focus, event, seq);
handle.motion(data, focus, event);
let distance = self.start_data.distance(event.location);
if distance >= 1.
@ -245,12 +237,12 @@ impl<G: TouchGrab<State>> TouchGrab<State> for DelayGrab<G> {
}
}
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
handle.frame(data, seq)
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
handle.frame(data)
}
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
handle.cancel(data, seq);
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
handle.cancel(data);
handle.unset_grab(self, data);
}
@ -259,9 +251,8 @@ impl<G: TouchGrab<State>> TouchGrab<State> for DelayGrab<G> {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &ShapeEvent,
seq: Serial,
) {
handle.shape(data, event, seq)
handle.shape(data, event)
}
fn orientation(
@ -269,9 +260,8 @@ impl<G: TouchGrab<State>> TouchGrab<State> for DelayGrab<G> {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &OrientationEvent,
seq: Serial,
) {
handle.orientation(data, event, seq);
handle.orientation(data, event);
}
fn start_data(&self) -> &TouchGrabStartData<State> {

34
src/shell/grabs/menu/mod.rs
View file

@ -718,7 +718,6 @@ impl TouchGrab<State> for MenuGrab {
handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &DownEvent,
seq: Serial,
) {
{
let mut guard = self.elements.lock().unwrap();
@ -753,21 +752,15 @@ impl TouchGrab<State> for MenuGrab {
time: event.time,
};
if element.touch_entered.is_none() {
TouchTarget::down(&element.iced, &self.seat, data, &new_event, seq);
TouchTarget::down(&element.iced, &self.seat, data, &new_event);
element.touch_entered = Some(event.slot);
}
}
}
handle.down(data, None, event, seq);
handle.down(data, None, event);
}
fn up(
&mut self,
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &UpEvent,
seq: Serial,
) {
fn up(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, event: &UpEvent) {
{
let elements = self.elements.lock().unwrap();
for element in elements.iter().filter(|elem| {
@ -775,7 +768,7 @@ impl TouchGrab<State> for MenuGrab {
.as_ref()
.is_some_and(|slot| *slot == event.slot)
}) {
TouchTarget::up(&element.iced, &self.seat, data, event, seq);
TouchTarget::up(&element.iced, &self.seat, data, event);
}
}
handle.unset_grab(self, data);
@ -787,7 +780,6 @@ impl TouchGrab<State> for MenuGrab {
handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &TouchMotionEvent,
seq: Serial,
) {
{
let elements = self.elements.lock().unwrap();
@ -796,24 +788,24 @@ impl TouchGrab<State> for MenuGrab {
.as_ref()
.is_some_and(|slot| *slot == event.slot)
}) {
TouchTarget::motion(&element.iced, &self.seat, data, event, seq);
TouchTarget::motion(&element.iced, &self.seat, data, event);
}
}
handle.motion(data, None, event, seq);
handle.motion(data, None, event);
}
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
handle.frame(data, seq);
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
handle.frame(data);
}
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
{
let mut elements = self.elements.lock().unwrap();
for element in elements.iter_mut() {
let _ = element.touch_entered.take();
}
}
handle.cancel(data, seq);
handle.cancel(data);
}
fn shape(
@ -821,9 +813,8 @@ impl TouchGrab<State> for MenuGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &smithay::input::touch::ShapeEvent,
seq: Serial,
) {
handle.shape(data, event, seq);
handle.shape(data, event);
}
fn orientation(
@ -831,9 +822,8 @@ impl TouchGrab<State> for MenuGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &smithay::input::touch::OrientationEvent,
seq: Serial,
) {
handle.orientation(data, event, seq);
handle.orientation(data, event);
}
fn start_data(&self) -> &TouchGrabStartData<State> {

88
src/shell/grabs/mod.rs
View file

@ -387,24 +387,17 @@ impl TouchGrab<State> for ResizeGrab {
handle: &mut TouchInnerHandle<'_, State>,
focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &DownEvent,
seq: Serial,
) {
match self {
ResizeGrab::Floating(grab) => TouchGrab::down(grab, data, handle, focus, event, seq),
ResizeGrab::Tiling(grab) => TouchGrab::down(grab, data, handle, focus, event, seq),
ResizeGrab::Floating(grab) => TouchGrab::down(grab, data, handle, focus, event),
ResizeGrab::Tiling(grab) => TouchGrab::down(grab, data, handle, focus, event),
}
}
fn up(
&mut self,
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &UpEvent,
seq: Serial,
) {
fn up(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, event: &UpEvent) {
match self {
ResizeGrab::Floating(grab) => TouchGrab::up(grab, data, handle, event, seq),
ResizeGrab::Tiling(grab) => TouchGrab::up(grab, data, handle, event, seq),
ResizeGrab::Floating(grab) => TouchGrab::up(grab, data, handle, event),
ResizeGrab::Tiling(grab) => TouchGrab::up(grab, data, handle, event),
}
}
@ -414,25 +407,24 @@ impl TouchGrab<State> for ResizeGrab {
handle: &mut TouchInnerHandle<'_, State>,
focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &TouchMotionEvent,
seq: Serial,
) {
match self {
ResizeGrab::Floating(grab) => TouchGrab::motion(grab, data, handle, focus, event, seq),
ResizeGrab::Tiling(grab) => TouchGrab::motion(grab, data, handle, focus, event, seq),
ResizeGrab::Floating(grab) => TouchGrab::motion(grab, data, handle, focus, event),
ResizeGrab::Tiling(grab) => TouchGrab::motion(grab, data, handle, focus, event),
}
}
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
match self {
ResizeGrab::Floating(grab) => TouchGrab::frame(grab, data, handle, seq),
ResizeGrab::Tiling(grab) => TouchGrab::frame(grab, data, handle, seq),
ResizeGrab::Floating(grab) => TouchGrab::frame(grab, data, handle),
ResizeGrab::Tiling(grab) => TouchGrab::frame(grab, data, handle),
}
}
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
match self {
ResizeGrab::Floating(grab) => TouchGrab::cancel(grab, data, handle, seq),
ResizeGrab::Tiling(grab) => TouchGrab::cancel(grab, data, handle, seq),
ResizeGrab::Floating(grab) => TouchGrab::cancel(grab, data, handle),
ResizeGrab::Tiling(grab) => TouchGrab::cancel(grab, data, handle),
}
}
@ -441,11 +433,10 @@ impl TouchGrab<State> for ResizeGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &ShapeEvent,
seq: Serial,
) {
match self {
ResizeGrab::Floating(grab) => TouchGrab::shape(grab, data, handle, event, seq),
ResizeGrab::Tiling(grab) => TouchGrab::shape(grab, data, handle, event, seq),
ResizeGrab::Floating(grab) => TouchGrab::shape(grab, data, handle, event),
ResizeGrab::Tiling(grab) => TouchGrab::shape(grab, data, handle, event),
}
}
@ -454,11 +445,10 @@ impl TouchGrab<State> for ResizeGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &OrientationEvent,
seq: Serial,
) {
match self {
ResizeGrab::Floating(grab) => TouchGrab::orientation(grab, data, handle, event, seq),
ResizeGrab::Tiling(grab) => TouchGrab::orientation(grab, data, handle, event, seq),
ResizeGrab::Floating(grab) => TouchGrab::orientation(grab, data, handle, event),
ResizeGrab::Tiling(grab) => TouchGrab::orientation(grab, data, handle, event),
}
}
@ -729,24 +719,17 @@ impl TouchGrab<State> for MoveGrab {
handle: &mut TouchInnerHandle<'_, State>,
focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &DownEvent,
seq: Serial,
) {
match self {
MoveGrab::Move(grab) => TouchGrab::down(grab, data, handle, focus, event, seq),
MoveGrab::Delayed(grab) => TouchGrab::down(grab, data, handle, focus, event, seq),
MoveGrab::Move(grab) => TouchGrab::down(grab, data, handle, focus, event),
MoveGrab::Delayed(grab) => TouchGrab::down(grab, data, handle, focus, event),
}
}
fn up(
&mut self,
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &UpEvent,
seq: Serial,
) {
fn up(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, event: &UpEvent) {
match self {
MoveGrab::Move(grab) => TouchGrab::up(grab, data, handle, event, seq),
MoveGrab::Delayed(grab) => TouchGrab::up(grab, data, handle, event, seq),
MoveGrab::Move(grab) => TouchGrab::up(grab, data, handle, event),
MoveGrab::Delayed(grab) => TouchGrab::up(grab, data, handle, event),
}
}
@ -756,25 +739,24 @@ impl TouchGrab<State> for MoveGrab {
handle: &mut TouchInnerHandle<'_, State>,
focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &TouchMotionEvent,
seq: Serial,
) {
match self {
MoveGrab::Move(grab) => TouchGrab::motion(grab, data, handle, focus, event, seq),
MoveGrab::Delayed(grab) => TouchGrab::motion(grab, data, handle, focus, event, seq),
MoveGrab::Move(grab) => TouchGrab::motion(grab, data, handle, focus, event),
MoveGrab::Delayed(grab) => TouchGrab::motion(grab, data, handle, focus, event),
}
}
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
match self {
MoveGrab::Move(grab) => TouchGrab::frame(grab, data, handle, seq),
MoveGrab::Delayed(grab) => TouchGrab::frame(grab, data, handle, seq),
MoveGrab::Move(grab) => TouchGrab::frame(grab, data, handle),
MoveGrab::Delayed(grab) => TouchGrab::frame(grab, data, handle),
}
}
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
match self {
MoveGrab::Move(grab) => TouchGrab::cancel(grab, data, handle, seq),
MoveGrab::Delayed(grab) => TouchGrab::cancel(grab, data, handle, seq),
MoveGrab::Move(grab) => TouchGrab::cancel(grab, data, handle),
MoveGrab::Delayed(grab) => TouchGrab::cancel(grab, data, handle),
}
}
@ -783,11 +765,10 @@ impl TouchGrab<State> for MoveGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &ShapeEvent,
seq: Serial,
) {
match self {
MoveGrab::Move(grab) => TouchGrab::shape(grab, data, handle, event, seq),
MoveGrab::Delayed(grab) => TouchGrab::shape(grab, data, handle, event, seq),
MoveGrab::Move(grab) => TouchGrab::shape(grab, data, handle, event),
MoveGrab::Delayed(grab) => TouchGrab::shape(grab, data, handle, event),
}
}
@ -796,11 +777,10 @@ impl TouchGrab<State> for MoveGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &OrientationEvent,
seq: Serial,
) {
match self {
MoveGrab::Move(grab) => TouchGrab::orientation(grab, data, handle, event, seq),
MoveGrab::Delayed(grab) => TouchGrab::orientation(grab, data, handle, event, seq),
MoveGrab::Move(grab) => TouchGrab::orientation(grab, data, handle, event),
MoveGrab::Delayed(grab) => TouchGrab::orientation(grab, data, handle, event),
}
}

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

@ -40,7 +40,7 @@ use smithay::{
touch::{self, GrabStartData as TouchGrabStartData, TouchGrab, TouchInnerHandle},
},
output::Output,
utils::{IsAlive, Logical, Point, Rectangle, SERIAL_COUNTER, Scale, Serial},
utils::{IsAlive, Logical, Point, Rectangle, SERIAL_COUNTER, Scale},
};
use std::{
collections::HashSet,
@ -652,9 +652,8 @@ impl TouchGrab<State> for MoveGrab {
handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &touch::DownEvent,
seq: Serial,
) {
handle.down(data, None, event, seq)
handle.down(data, None, event)
}
fn up(
@ -662,13 +661,12 @@ impl TouchGrab<State> for MoveGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &touch::UpEvent,
seq: Serial,
) {
if event.slot == <Self as TouchGrab<State>>::start_data(self).slot {
handle.unset_grab(self, data);
}
handle.up(data, event, seq);
handle.up(data, event);
}
fn motion(
@ -677,20 +675,19 @@ impl TouchGrab<State> for MoveGrab {
handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &touch::MotionEvent,
seq: Serial,
) {
if event.slot == <Self as TouchGrab<State>>::start_data(self).slot {
self.update_location(data, event.location);
}
handle.motion(data, None, event, seq);
handle.motion(data, None, event);
}
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
handle.frame(data, seq)
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
handle.frame(data)
}
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, _seq: Serial) {
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
handle.unset_grab(self, data);
}
@ -699,9 +696,8 @@ impl TouchGrab<State> for MoveGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &touch::ShapeEvent,
seq: Serial,
) {
handle.shape(data, event, seq)
handle.shape(data, event)
}
fn orientation(
@ -709,9 +705,8 @@ impl TouchGrab<State> for MoveGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &touch::OrientationEvent,
seq: Serial,
) {
handle.orientation(data, event, seq)
handle.orientation(data, event)
}
fn start_data(&self) -> &TouchGrabStartData<State> {

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

@ -29,7 +29,7 @@ use smithay::{
},
},
output::Output,
utils::{IsAlive, Logical, Point, Rectangle, Serial, Size},
utils::{IsAlive, Logical, Point, Rectangle, Size},
};
use tracing::debug;
@ -330,23 +330,16 @@ impl TouchGrab<State> for ResizeSurfaceGrab {
handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &DownEvent,
seq: Serial,
) {
handle.down(data, None, event, seq)
handle.down(data, None, event)
}
fn up(
&mut self,
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &UpEvent,
seq: Serial,
) {
fn up(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, event: &UpEvent) {
if event.slot == <Self as TouchGrab<State>>::start_data(self).slot {
handle.unset_grab(self, data);
}
handle.up(data, event, seq);
handle.up(data, event);
}
fn motion(
@ -355,7 +348,6 @@ impl TouchGrab<State> for ResizeSurfaceGrab {
handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &TouchMotionEvent,
seq: Serial,
) {
if event.slot == <Self as TouchGrab<State>>::start_data(self).slot
&& self.update_location(event.location.as_global())
@ -363,14 +355,14 @@ impl TouchGrab<State> for ResizeSurfaceGrab {
handle.unset_grab(self, data);
}
handle.motion(data, None, event, seq);
handle.motion(data, None, event);
}
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
handle.frame(data, seq)
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
handle.frame(data)
}
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, _seq: Serial) {
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
handle.unset_grab(self, data);
}
@ -379,9 +371,8 @@ impl TouchGrab<State> for ResizeSurfaceGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &ShapeEvent,
seq: Serial,
) {
handle.shape(data, event, seq)
handle.shape(data, event)
}
fn orientation(
@ -389,9 +380,8 @@ impl TouchGrab<State> for ResizeSurfaceGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &OrientationEvent,
seq: Serial,
) {
handle.orientation(data, event, seq)
handle.orientation(data, event)
}
fn start_data(&self) -> &TouchGrabStartData<State> {

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

@ -32,7 +32,7 @@ pub fn is_dialog(window: &CosmicSurface) -> bool {
}
WindowSurface::X11(surface) => {
if surface.is_override_redirect()
|| surface.is_popup()
|| surface.is_modal()
|| !matches!(
surface.window_type(),
None | Some(WmWindowType::Normal) | Some(WmWindowType::Utility)

64
src/shell/layout/tiling/grabs/resize.rs
View file

@ -22,12 +22,13 @@ use smithay::{
PointerTarget, RelativeMotionEvent,
},
touch::{
DownEvent, GrabStartData as TouchGrabStartData, MotionEvent as TouchMotionEvent,
OrientationEvent, ShapeEvent, TouchGrab, TouchInnerHandle, TouchTarget, UpEvent,
DownEvent, FrameMarker, GrabStartData as TouchGrabStartData,
MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent, TouchGrab,
TouchInnerHandle, TouchTarget, UpEvent,
},
},
output::WeakOutput,
utils::{IsAlive, Logical, Point, Serial},
utils::{IsAlive, Logical, Point},
};
use super::super::{Data, TilingLayout};
@ -126,7 +127,7 @@ impl PointerTarget<State> for ResizeForkTarget {
}
impl TouchTarget<State> for ResizeForkTarget {
fn down(&self, seat: &Seat<State>, data: &mut State, event: &DownEvent, _seq: Serial) {
fn down(&self, seat: &Seat<State>, data: &mut State, event: &DownEvent) {
let seat = seat.clone();
let node = self.node.clone();
let output = self.output.clone();
@ -157,25 +158,14 @@ impl TouchTarget<State> for ResizeForkTarget {
});
}
fn up(&self, _seat: &Seat<State>, _data: &mut State, _event: &UpEvent, _seq: Serial) {}
fn motion(
&self,
_seat: &Seat<State>,
_data: &mut State,
_event: &TouchMotionEvent,
_seq: Serial,
) {
}
fn frame(&self, _seat: &Seat<State>, _data: &mut State, _seq: Serial) {}
fn cancel(&self, _seat: &Seat<State>, _data: &mut State, _seq: Serial) {}
fn shape(&self, _seat: &Seat<State>, _data: &mut State, _event: &ShapeEvent, _seq: Serial) {}
fn orientation(
&self,
_seat: &Seat<State>,
_data: &mut State,
_event: &OrientationEvent,
_seq: Serial,
) {
fn up(&self, _seat: &Seat<State>, _data: &mut State, _event: &UpEvent) {}
fn motion(&self, _seat: &Seat<State>, _data: &mut State, _event: &TouchMotionEvent) {}
fn frame(&self, _seat: &Seat<State>, _data: &mut State, _frame: FrameMarker) {}
fn cancel(&self, _seat: &Seat<State>, _data: &mut State, _frame: FrameMarker) {}
fn shape(&self, _seat: &Seat<State>, _data: &mut State, _event: &ShapeEvent) {}
fn orientation(&self, _seat: &Seat<State>, _data: &mut State, _event: &OrientationEvent) {}
fn last_frame(&self, _seat: &Seat<State>, _data: &mut State) -> Option<FrameMarker> {
None
}
}
@ -508,23 +498,16 @@ impl TouchGrab<State> for ResizeForkGrab {
handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &DownEvent,
seq: Serial,
) {
handle.down(data, None, event, seq)
handle.down(data, None, event)
}
fn up(
&mut self,
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &UpEvent,
seq: Serial,
) {
fn up(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, event: &UpEvent) {
if event.slot == <Self as TouchGrab<State>>::start_data(self).slot {
handle.unset_grab(self, data);
}
handle.up(data, event, seq);
handle.up(data, event);
}
fn motion(
@ -533,7 +516,6 @@ impl TouchGrab<State> for ResizeForkGrab {
handle: &mut TouchInnerHandle<'_, State>,
_focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
event: &TouchMotionEvent,
seq: Serial,
) {
if event.slot == <Self as TouchGrab<State>>::start_data(self).slot
&& self.update_location(data, event.location, false)
@ -541,14 +523,14 @@ impl TouchGrab<State> for ResizeForkGrab {
handle.unset_grab(self, data);
}
handle.motion(data, None, event, seq);
handle.motion(data, None, event);
}
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, seq: Serial) {
handle.frame(data, seq)
fn frame(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
handle.frame(data)
}
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>, _seq: Serial) {
fn cancel(&mut self, data: &mut State, handle: &mut TouchInnerHandle<'_, State>) {
handle.unset_grab(self, data);
}
@ -557,9 +539,8 @@ impl TouchGrab<State> for ResizeForkGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &ShapeEvent,
seq: Serial,
) {
handle.shape(data, event, seq)
handle.shape(data, event)
}
fn start_data(&self) -> &TouchGrabStartData<State> {
@ -574,9 +555,8 @@ impl TouchGrab<State> for ResizeForkGrab {
data: &mut State,
handle: &mut TouchInnerHandle<'_, State>,
event: &OrientationEvent,
seq: Serial,
) {
handle.orientation(data, event, seq)
handle.orientation(data, event)
}
fn unset(&mut self, data: &mut State) {

59
src/shell/zoom.rs
View file

@ -22,8 +22,8 @@ use smithay::{
MotionEvent as PointerMotionEvent, PointerTarget, RelativeMotionEvent,
},
touch::{
DownEvent, MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent, TouchTarget,
UpEvent,
DownEvent, FrameMarker, MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent,
TouchTarget, UpEvent,
},
},
output::Output,
@ -1036,58 +1036,59 @@ impl PointerTarget<State> for ZoomFocusTarget {
}
impl TouchTarget<State> for ZoomFocusTarget {
fn down(&self, seat: &Seat<State>, data: &mut State, event: &DownEvent, seq: Serial) {
fn down(&self, seat: &Seat<State>, data: &mut State, event: &DownEvent) {
match self {
ZoomFocusTarget::Main(elem) => TouchTarget::down(elem, seat, data, event, seq),
ZoomFocusTarget::Menu(elem) => TouchTarget::down(elem, seat, data, event, seq),
ZoomFocusTarget::Main(elem) => TouchTarget::down(elem, seat, data, event),
ZoomFocusTarget::Menu(elem) => TouchTarget::down(elem, seat, data, event),
}
}
fn up(&self, seat: &Seat<State>, data: &mut State, event: &UpEvent, seq: Serial) {
fn up(&self, seat: &Seat<State>, data: &mut State, event: &UpEvent) {
match self {
ZoomFocusTarget::Main(elem) => TouchTarget::up(elem, seat, data, event, seq),
ZoomFocusTarget::Menu(elem) => TouchTarget::up(elem, seat, data, event, seq),
ZoomFocusTarget::Main(elem) => TouchTarget::up(elem, seat, data, event),
ZoomFocusTarget::Menu(elem) => TouchTarget::up(elem, seat, data, event),
}
}
fn motion(&self, seat: &Seat<State>, data: &mut State, event: &TouchMotionEvent, seq: Serial) {
fn motion(&self, seat: &Seat<State>, data: &mut State, event: &TouchMotionEvent) {
match self {
ZoomFocusTarget::Main(elem) => TouchTarget::motion(elem, seat, data, event, seq),
ZoomFocusTarget::Menu(elem) => TouchTarget::motion(elem, seat, data, event, seq),
ZoomFocusTarget::Main(elem) => TouchTarget::motion(elem, seat, data, event),
ZoomFocusTarget::Menu(elem) => TouchTarget::motion(elem, seat, data, event),
}
}
fn frame(&self, seat: &Seat<State>, data: &mut State, seq: Serial) {
fn frame(&self, seat: &Seat<State>, data: &mut State, frame: FrameMarker) {
match self {
ZoomFocusTarget::Main(elem) => TouchTarget::frame(elem, seat, data, seq),
ZoomFocusTarget::Menu(elem) => TouchTarget::frame(elem, seat, data, seq),
ZoomFocusTarget::Main(elem) => TouchTarget::frame(elem, seat, data, frame),
ZoomFocusTarget::Menu(elem) => TouchTarget::frame(elem, seat, data, frame),
}
}
fn cancel(&self, seat: &Seat<State>, data: &mut State, seq: Serial) {
fn cancel(&self, seat: &Seat<State>, data: &mut State, frame: FrameMarker) {
match self {
ZoomFocusTarget::Main(elem) => TouchTarget::cancel(elem, seat, data, seq),
ZoomFocusTarget::Menu(elem) => TouchTarget::cancel(elem, seat, data, seq),
ZoomFocusTarget::Main(elem) => TouchTarget::cancel(elem, seat, data, frame),
ZoomFocusTarget::Menu(elem) => TouchTarget::cancel(elem, seat, data, frame),
}
}
fn shape(&self, seat: &Seat<State>, data: &mut State, event: &ShapeEvent, seq: Serial) {
fn shape(&self, seat: &Seat<State>, data: &mut State, event: &ShapeEvent) {
match self {
ZoomFocusTarget::Main(elem) => TouchTarget::shape(elem, seat, data, event, seq),
ZoomFocusTarget::Menu(elem) => TouchTarget::shape(elem, seat, data, event, seq),
ZoomFocusTarget::Main(elem) => TouchTarget::shape(elem, seat, data, event),
ZoomFocusTarget::Menu(elem) => TouchTarget::shape(elem, seat, data, event),
}
}
fn orientation(
&self,
seat: &Seat<State>,
data: &mut State,
event: &OrientationEvent,
seq: Serial,
) {
fn orientation(&self, seat: &Seat<State>, data: &mut State, event: &OrientationEvent) {
match self {
ZoomFocusTarget::Main(elem) => TouchTarget::orientation(elem, seat, data, event, seq),
ZoomFocusTarget::Menu(elem) => TouchTarget::orientation(elem, seat, data, event, seq),
ZoomFocusTarget::Main(elem) => TouchTarget::orientation(elem, seat, data, event),
ZoomFocusTarget::Menu(elem) => TouchTarget::orientation(elem, seat, data, event),
}
}
fn last_frame(&self, seat: &Seat<State>, data: &mut State) -> Option<FrameMarker> {
match self {
ZoomFocusTarget::Main(elem) => TouchTarget::last_frame(elem, seat, data),
ZoomFocusTarget::Menu(elem) => TouchTarget::last_frame(elem, seat, data),
}
}
}