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

2
src/backend/winit.rs
View file

@ -26,7 +26,7 @@ use smithay::{
calloop::{EventLoop, ping},
wayland_protocols::wp::presentation_time::server::wp_presentation_feedback,
wayland_server::DisplayHandle,
winit::platform::pump_events::PumpStatus,
winit::event_loop::pump_events::PumpStatus,
},
utils::Transform,
wayland::{dmabuf::DmabufFeedbackBuilder, presentation::Refresh},

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),
}
}
}

43
src/utils/iced/mod.rs
View file

@ -51,13 +51,12 @@ use smithay::{
PointerTarget, RelativeMotionEvent,
},
touch::{
DownEvent, MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent, TouchTarget,
UpEvent,
DownEvent, FrameMarker, MotionEvent as TouchMotionEvent, OrientationEvent, ShapeEvent,
TouchTarget, UpEvent,
},
},
output::Output,
reexports::calloop::RegistrationToken,
reexports::calloop::{self, LoopHandle, futures::Scheduler},
reexports::calloop::{self, LoopHandle, RegistrationToken, futures::Scheduler},
utils::{
Buffer as BufferCoords, IsAlive, Logical, Physical, Point, Rectangle, Scale, Serial, Size,
Transform,
@ -180,6 +179,8 @@ pub(crate) struct IcedElementInternal<P: Program + Send + 'static> {
last_seat: Arc<Mutex<Option<(Seat<crate::state::State>, Serial)>>>,
cursor_pos: Option<Point<f64, Logical>>,
touch_map: HashMap<Finger, IcedPoint>,
last_touch_frame: Option<FrameMarker>,
last_touch_serial: Option<Serial>,
// iced
theme: Theme,
@ -228,6 +229,8 @@ impl<P: Program + Send + Clone + 'static> Clone for IcedElementInternal<P> {
last_seat: self.last_seat.clone(),
cursor_pos: self.cursor_pos,
touch_map: self.touch_map.clone(),
last_touch_frame: None,
last_touch_serial: None,
theme: self.theme.clone(),
renderer,
state,
@ -253,6 +256,8 @@ impl<P: Program + Send + 'static> fmt::Debug for IcedElementInternal<P> {
.field("last_seat", &self.last_seat)
.field("cursor_pos", &self.cursor_pos)
.field("touch_map", &self.touch_map)
.field("last_touch_frame", &self.last_touch_frame)
.field("last_touch_serial", &self.last_touch_serial)
.field("theme", &"...")
.field("renderer", &"...")
.field("state", &"...")
@ -309,6 +314,8 @@ impl<P: Program + Send + 'static> IcedElement<P> {
cursor_pos: None,
last_seat,
touch_map: HashMap::new(),
last_touch_frame: None,
last_touch_serial: None,
theme,
renderer,
state,
@ -633,7 +640,6 @@ impl<P: Program + Send + 'static> TouchTarget<crate::state::State> for IcedEleme
seat: &Seat<crate::state::State>,
_data: &mut crate::state::State,
event: &DownEvent,
seq: Serial,
) {
let mut internal = self.0.lock().unwrap();
let id = Finger(i32::from(event.slot) as u64);
@ -644,7 +650,8 @@ impl<P: Program + Send + 'static> TouchTarget<crate::state::State> for IcedEleme
.queue_event(Event::Touch(TouchEvent::FingerPressed { id, position }));
internal.touch_map.insert(id, position);
internal.cursor_pos = Some(event_location);
*internal.last_seat.lock().unwrap() = Some((seat.clone(), seq));
internal.last_touch_serial = Some(event.serial);
*internal.last_seat.lock().unwrap() = Some((seat.clone(), event.serial));
internal.update(false);
}
@ -653,12 +660,12 @@ impl<P: Program + Send + 'static> TouchTarget<crate::state::State> for IcedEleme
seat: &Seat<crate::state::State>,
_data: &mut crate::state::State,
event: &UpEvent,
seq: Serial,
) {
let mut internal = self.0.lock().unwrap();
let id = Finger(i32::from(event.slot) as u64);
if let Some(position) = internal.touch_map.remove(&id) {
*internal.last_seat.lock().unwrap() = Some((seat.clone(), seq));
*internal.last_seat.lock().unwrap() =
Some((seat.clone(), internal.last_touch_serial.unwrap()));
internal
.state
.queue_event(Event::Touch(TouchEvent::FingerLifted { id, position }));
@ -671,13 +678,13 @@ impl<P: Program + Send + 'static> TouchTarget<crate::state::State> for IcedEleme
seat: &Seat<crate::state::State>,
_data: &mut crate::state::State,
event: &TouchMotionEvent,
seq: Serial,
) {
let mut internal = self.0.lock().unwrap();
let id = Finger(i32::from(event.slot) as u64);
let event_location = event.location.downscale(internal.additional_scale);
let position = IcedPoint::new(event_location.x as f32, event_location.y as f32);
*internal.last_seat.lock().unwrap() = Some((seat.clone(), seq));
*internal.last_seat.lock().unwrap() =
Some((seat.clone(), internal.last_touch_serial.unwrap()));
internal
.state
.queue_event(Event::Touch(TouchEvent::FingerMoved { id, position }));
@ -690,17 +697,19 @@ impl<P: Program + Send + 'static> TouchTarget<crate::state::State> for IcedEleme
&self,
_seat: &Seat<crate::state::State>,
_data: &mut crate::state::State,
_seq: Serial,
frame: FrameMarker,
) {
self.0.lock().unwrap().last_touch_frame = Some(frame);
}
fn cancel(
&self,
_seat: &Seat<crate::state::State>,
_data: &mut crate::state::State,
_seq: Serial,
frame: FrameMarker,
) {
let mut internal = self.0.lock().unwrap();
internal.last_touch_frame = Some(frame);
for (id, position) in std::mem::take(&mut internal.touch_map) {
internal
.state
@ -714,7 +723,6 @@ impl<P: Program + Send + 'static> TouchTarget<crate::state::State> for IcedEleme
_seat: &Seat<crate::state::State>,
_data: &mut crate::state::State,
_event: &ShapeEvent,
_seq: Serial,
) {
}
@ -723,9 +731,16 @@ impl<P: Program + Send + 'static> TouchTarget<crate::state::State> for IcedEleme
_seat: &Seat<crate::state::State>,
_data: &mut crate::state::State,
_event: &OrientationEvent,
_seq: Serial,
) {
}
fn last_frame(
&self,
_seat: &Seat<crate::state::State>,
_data: &mut crate::state::State,
) -> Option<FrameMarker> {
self.0.lock().unwrap().last_touch_frame
}
}
impl<P: Program + Send + 'static> KeyboardTarget<crate::state::State> for IcedElement<P> {

1
src/xwayland.rs
View file

@ -115,6 +115,7 @@ impl State {
&self.common.display_handle,
None,
std::iter::empty::<(OsString, OsString)>(),
std::iter::empty::<OsString>(),
true,
Stdio::null(),
Stdio::null(),