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

Update Smithay, adjusting for API changes

Browse source 
The main changes are those related to pointer gestures. Which are a bit
verbose but not too difficult.
This commit is contained in:
Ian Douglas Scott 2023-09-05 10:55:23 -07:00
parent 1392fc7c95
commit e7e9b768c8
15 changed files with 1151 additions and 119 deletions
Download patch file Download diff file Expand all files Collapse all files

31
Cargo.lock generated
View file

@ -1063,17 +1063,6 @@ version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
[[package]]
name = "errno"
version = "0.2.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f639046355ee4f37944e44f60642c6f3a7efa3cf6b78c78a0d989a8ce6c396a1"
dependencies = [
"errno-dragonfly",
"libc",
"winapi",
]
[[package]]
name = "errno"
version = "0.3.2"
@ -2230,13 +2219,13 @@ checksum = "f7012b1bbb0719e1097c47611d3898568c546d597c2e74d66f6087edd5233ff4"
[[package]]
name = "libseat"
version = "0.1.7"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "845e5c255462c9bc7c71c17b996766b76e3c66f2ddd5846bfbc83f18382aa648"
checksum = "54a0adf8d8607a73a5b74cbe4132f57cb349e4bf860103cd089461bbcbc9907e"
dependencies = [
"errno 0.2.8",
"errno",
"libseat-sys",
"slog",
"log",
]
[[package]]
@ -3579,7 +3568,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4d69718bf81c6127a49dc64e44a742e8bb9213c0ff8869a22c308f84c1d4ab06"
dependencies = [
"bitflags 1.3.2",
"errno 0.3.2",
"errno",
"io-lifetimes",
"libc",
"linux-raw-sys 0.3.8",
@ -3593,7 +3582,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0a962918ea88d644592894bc6dc55acc6c0956488adcebbfb6e273506b7fd6e5"
dependencies = [
"bitflags 2.3.3",
"errno 0.3.2",
"errno",
"libc",
"linux-raw-sys 0.4.3",
"windows-sys 0.48.0",
@ -3754,12 +3743,6 @@ dependencies = [
"autocfg",
]
[[package]]
name = "slog"
version = "2.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8347046d4ebd943127157b94d63abb990fcf729dc4e9978927fdf4ac3c998d06"
[[package]]
name = "slotmap"
version = "1.0.6"
@ -3778,7 +3761,7 @@ checksum = "62bb4feee49fdd9f707ef802e22365a35de4b7b299de4763d44bfea899442ff9"
[[package]]
name = "smithay"
version = "0.3.0"
source = "git+https://github.com/smithay//smithay?rev=02ccc8ca17#02ccc8ca17fbc655d2247124fe628d276cb5179a"
source = "git+https://github.com/smithay//smithay?rev=36a0ec69b1#36a0ec69b1a2331b1a2d0e046b026cb85d7d132c"
dependencies = [
"appendlist",
"ash",

2
Cargo.toml
View file

@ -87,4 +87,4 @@ debug = true
lto = "fat"
[patch."https://github.com/Smithay/smithay.git"]
smithay = { git = "https://github.com/smithay//smithay", rev = "02ccc8ca17" }
smithay = { git = "https://github.com/smithay//smithay", rev = "36a0ec69b1" }

23
src/backend/kms/mod.rs
View file

@ -507,7 +507,11 @@ impl State {
surface
.output
.current_mode()
.map(|mode| mode.refresh as u32)
.map(|mode| {
Duration::from_secs_f64(
1_000.0 / mode.refresh as f64,
)
})
.unwrap_or_default(),
seq as u64,
flags,
@ -1002,19 +1006,20 @@ fn get_surface_dmabuf_feedback(
.collect::<HashSet<_>>();
let surface = compositor.surface();
let planes = surface.planes().unwrap();
let planes = surface.planes();
// We limit the scan-out trache to formats we can also render from
// so that there is always a fallback render path available in case
// the supplied buffer can not be scanned out directly
let planes_formats = surface
.supported_formats(planes.primary.handle)
.unwrap()
.into_iter()
let planes_formats = planes
.primary
.formats
.iter()
.cloned()
.chain(
planes
.overlay
.iter()
.flat_map(|p| surface.supported_formats(p.handle).unwrap()),
.flat_map(|p| p.formats.iter().cloned()),
)
.collect::<HashSet<_>>()
.intersection(&combined_formats)
@ -1330,9 +1335,7 @@ impl KmsState {
let driver = drm
.get_driver()
.with_context(|| "Failed to query drm driver")?;
let mut planes = drm_surface
.planes()
.with_context(|| "Failed to query drm planes")?;
let mut planes = drm_surface.planes().clone();
// QUIRK: Using an overlay plane on a nvidia card breaks the display controller (wtf...)
if driver
.name()

4
src/backend/winit.rs
View file

@ -30,7 +30,7 @@ use smithay::{
utils::Transform,
wayland::dmabuf::DmabufFeedbackBuilder,
};
use std::cell::RefCell;
use std::{cell::RefCell, time::Duration};
use tracing::{error, info, warn};
#[cfg(feature = "debug")]
@ -94,7 +94,7 @@ impl WinitState {
state.clock.now(),
self.output
.current_mode()
.map(|mode| mode.refresh as u32)
.map(|mode| Duration::from_secs_f64(1_000.0 / mode.refresh as f64))
.unwrap_or_default(),
0,
wp_presentation_feedback::Kind::Vsync,

4
src/backend/x11.rs
View file

@ -39,7 +39,7 @@ use smithay::{
utils::{DeviceFd, Transform},
wayland::dmabuf::DmabufFeedbackBuilder,
};
use std::{cell::RefCell, os::unix::io::OwnedFd};
use std::{cell::RefCell, os::unix::io::OwnedFd, time::Duration};
use tracing::{debug, error, info, warn};
#[cfg(feature = "debug")]
@ -260,7 +260,7 @@ impl Surface {
state.clock.now(),
self.output
.current_mode()
.map(|mode| mode.refresh as u32)
.map(|mode| Duration::from_secs_f64(1_000.0 / mode.refresh as f64))
.unwrap_or_default(),
0,
wp_presentation_feedback::Kind::Vsync,

128
src/shell/element/mod.rs
View file

@ -25,7 +25,12 @@ use smithay::{
desktop::{space::SpaceElement, PopupManager, WindowSurfaceType},
input::{
keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
pointer::{AxisFrame, ButtonEvent, MotionEvent, PointerTarget, RelativeMotionEvent},
pointer::{
AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent,
GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent,
GestureSwipeBeginEvent, GestureSwipeEndEvent, GestureSwipeUpdateEvent, MotionEvent,
PointerTarget, RelativeMotionEvent,
},
Seat,
},
output::Output,
@ -909,6 +914,127 @@ impl PointerTarget<State> for CosmicMapped {
_ => {}
}
}
fn gesture_swipe_begin(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GestureSwipeBeginEvent,
) {
match &self.element {
CosmicMappedInternal::Stack(s) => {
PointerTarget::gesture_swipe_begin(s, seat, data, event)
}
CosmicMappedInternal::Window(w) => {
PointerTarget::gesture_swipe_begin(w, seat, data, event)
}
_ => {}
}
}
fn gesture_swipe_update(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GestureSwipeUpdateEvent,
) {
match &self.element {
CosmicMappedInternal::Stack(s) => {
PointerTarget::gesture_swipe_update(s, seat, data, event)
}
CosmicMappedInternal::Window(w) => {
PointerTarget::gesture_swipe_update(w, seat, data, event)
}
_ => {}
}
}
fn gesture_swipe_end(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GestureSwipeEndEvent,
) {
match &self.element {
CosmicMappedInternal::Stack(s) => {
PointerTarget::gesture_swipe_end(s, seat, data, event)
}
CosmicMappedInternal::Window(w) => {
PointerTarget::gesture_swipe_end(w, seat, data, event)
}
_ => {}
}
}
fn gesture_pinch_begin(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GesturePinchBeginEvent,
) {
match &self.element {
CosmicMappedInternal::Stack(s) => {
PointerTarget::gesture_pinch_begin(s, seat, data, event)
}
CosmicMappedInternal::Window(w) => {
PointerTarget::gesture_pinch_begin(w, seat, data, event)
}
_ => {}
}
}
fn gesture_pinch_update(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GesturePinchUpdateEvent,
) {
match &self.element {
CosmicMappedInternal::Stack(s) => {
PointerTarget::gesture_pinch_update(s, seat, data, event)
}
CosmicMappedInternal::Window(w) => {
PointerTarget::gesture_pinch_update(w, seat, data, event)
}
_ => {}
}
}
fn gesture_pinch_end(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GesturePinchEndEvent,
) {
match &self.element {
CosmicMappedInternal::Stack(s) => {
PointerTarget::gesture_pinch_end(s, seat, data, event)
}
CosmicMappedInternal::Window(w) => {
PointerTarget::gesture_pinch_end(w, seat, data, event)
}
_ => {}
}
}
fn gesture_hold_begin(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GestureHoldBeginEvent,
) {
match &self.element {
CosmicMappedInternal::Stack(s) => {
PointerTarget::gesture_hold_begin(s, seat, data, event)
}
CosmicMappedInternal::Window(w) => {
PointerTarget::gesture_hold_begin(w, seat, data, event)
}
_ => {}
}
}
fn gesture_hold_end(&self, seat: &Seat<State>, data: &mut State, event: &GestureHoldEndEvent) {
match &self.element {
CosmicMappedInternal::Stack(s) => PointerTarget::gesture_hold_end(s, seat, data, event),
CosmicMappedInternal::Window(w) => {
PointerTarget::gesture_hold_end(w, seat, data, event)
}
_ => {}
}
}
}
impl WaylandFocus for CosmicMapped {

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

@ -32,8 +32,10 @@ use smithay::{
input::{
keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
pointer::{
AxisFrame, ButtonEvent, GrabStartData as PointerGrabStartData, MotionEvent,
PointerTarget, RelativeMotionEvent,
AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent,
GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent,
GestureSwipeBeginEvent, GestureSwipeEndEvent, GestureSwipeUpdateEvent,
GrabStartData as PointerGrabStartData, MotionEvent, PointerTarget, RelativeMotionEvent,
},
Seat,
},
@ -1179,6 +1181,113 @@ impl PointerTarget<State> for CosmicStack {
_ => {}
}
}
fn gesture_swipe_begin(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GestureSwipeBeginEvent,
) {
self.0.with_program(|p| {
if p.current_focus() == Focus::Window {
let window = &p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)];
window.gesture_swipe_begin(seat, data, event)
}
})
}
fn gesture_swipe_update(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GestureSwipeUpdateEvent,
) {
self.0.with_program(|p| {
if p.current_focus() == Focus::Window {
let window = &p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)];
window.gesture_swipe_update(seat, data, event)
}
})
}
fn gesture_swipe_end(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GestureSwipeEndEvent,
) {
self.0.with_program(|p| {
if p.current_focus() == Focus::Window {
let window = &p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)];
window.gesture_swipe_end(seat, data, event)
}
})
}
fn gesture_pinch_begin(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GesturePinchBeginEvent,
) {
self.0.with_program(|p| {
if p.current_focus() == Focus::Window {
let window = &p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)];
window.gesture_pinch_begin(seat, data, event)
}
})
}
fn gesture_pinch_update(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GesturePinchUpdateEvent,
) {
self.0.with_program(|p| {
if p.current_focus() == Focus::Window {
let window = &p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)];
window.gesture_pinch_update(seat, data, event)
}
})
}
fn gesture_pinch_end(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GesturePinchEndEvent,
) {
self.0.with_program(|p| {
if p.current_focus() == Focus::Window {
let window = &p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)];
window.gesture_pinch_end(seat, data, event)
}
})
}
fn gesture_hold_begin(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GestureHoldBeginEvent,
) {
self.0.with_program(|p| {
if p.current_focus() == Focus::Window {
let window = &p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)];
window.gesture_hold_begin(seat, data, event)
}
})
}
fn gesture_hold_end(&self, seat: &Seat<State>, data: &mut State, event: &GestureHoldEndEvent) {
self.0.with_program(|p| {
if p.current_focus() == Focus::Window {
let window = &p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)];
window.gesture_hold_end(seat, data, event)
}
})
}
}
render_elements! {

233
src/shell/element/surface.rs
View file

@ -17,7 +17,16 @@ use smithay::{
},
PopupManager, Window,
},
input::{keyboard::KeyboardTarget, pointer::PointerTarget},
input::{
keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
pointer::{
AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent,
GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent,
GestureSwipeBeginEvent, GestureSwipeEndEvent, GestureSwipeUpdateEvent, MotionEvent,
PointerTarget, RelativeMotionEvent,
},
Seat,
},
output::Output,
reexports::{
wayland_protocols::{
@ -34,12 +43,15 @@ use smithay::{
wayland::{
compositor::{with_states, SurfaceData},
seat::WaylandFocus,
shell::xdg::{ToplevelSurface, XdgToplevelSurfaceData},
shell::xdg::{SurfaceCachedState, ToplevelSurface, XdgToplevelSurfaceData},
},
xwayland::{xwm::X11Relatable, X11Surface},
};
use crate::{state::SurfaceDmabufFeedback, wayland::handlers::decoration::PreferredDecorationMode};
use crate::{
state::{State, SurfaceDmabufFeedback},
wayland::handlers::decoration::PreferredDecorationMode,
};
space_elements! {
#[derive(Debug, Clone, PartialEq)]
@ -363,13 +375,7 @@ impl CosmicSurface {
match self {
CosmicSurface::Wayland(window) => {
Some(with_states(window.toplevel().wl_surface(), |states| {
let attrs = states
.data_map
.get::<XdgToplevelSurfaceData>()
.unwrap()
.lock()
.unwrap();
attrs.min_size
states.cached_state.current::<SurfaceCachedState>().min_size
}))
.filter(|size| !(size.w == 0 && size.h == 0))
}
@ -389,13 +395,7 @@ impl CosmicSurface {
match self {
CosmicSurface::Wayland(window) => {
Some(with_states(window.toplevel().wl_surface(), |states| {
let attrs = states
.data_map
.get::<XdgToplevelSurfaceData>()
.unwrap()
.lock()
.unwrap();
attrs.max_size
states.cached_state.current::<SurfaceCachedState>().max_size
}))
.filter(|size| !(size.w == 0 && size.h == 0))
}
@ -638,12 +638,12 @@ impl CosmicSurface {
}
}
impl KeyboardTarget<crate::state::State> for CosmicSurface {
impl KeyboardTarget<State> for CosmicSurface {
fn enter(
&self,
seat: &smithay::input::Seat<crate::state::State>,
data: &mut crate::state::State,
keys: Vec<smithay::input::keyboard::KeysymHandle<'_>>,
seat: &Seat<State>,
data: &mut State,
keys: Vec<KeysymHandle<'_>>,
serial: smithay::utils::Serial,
) {
match self {
@ -657,12 +657,7 @@ impl KeyboardTarget<crate::state::State> for CosmicSurface {
}
}
fn leave(
&self,
seat: &smithay::input::Seat<crate::state::State>,
data: &mut crate::state::State,
serial: smithay::utils::Serial,
) {
fn leave(&self, seat: &Seat<State>, data: &mut State, serial: smithay::utils::Serial) {
match self {
CosmicSurface::Wayland(window) => KeyboardTarget::leave(window, seat, data, serial),
CosmicSurface::X11(surface) => KeyboardTarget::leave(surface, seat, data, serial),
@ -672,9 +667,9 @@ impl KeyboardTarget<crate::state::State> for CosmicSurface {
fn key(
&self,
seat: &smithay::input::Seat<crate::state::State>,
data: &mut crate::state::State,
key: smithay::input::keyboard::KeysymHandle<'_>,
seat: &Seat<State>,
data: &mut State,
key: KeysymHandle<'_>,
state: smithay::backend::input::KeyState,
serial: smithay::utils::Serial,
time: u32,
@ -692,9 +687,9 @@ impl KeyboardTarget<crate::state::State> for CosmicSurface {
fn modifiers(
&self,
seat: &smithay::input::Seat<crate::state::State>,
data: &mut crate::state::State,
modifiers: smithay::input::keyboard::ModifiersState,
seat: &Seat<State>,
data: &mut State,
modifiers: ModifiersState,
serial: smithay::utils::Serial,
) {
match self {
@ -709,13 +704,8 @@ impl KeyboardTarget<crate::state::State> for CosmicSurface {
}
}
impl PointerTarget<crate::state::State> for CosmicSurface {
fn enter(
&self,
seat: &smithay::input::Seat<crate::state::State>,
data: &mut crate::state::State,
event: &smithay::input::pointer::MotionEvent,
) {
impl PointerTarget<State> for CosmicSurface {
fn enter(&self, seat: &Seat<State>, data: &mut State, event: &MotionEvent) {
match self {
CosmicSurface::Wayland(window) => PointerTarget::enter(window, seat, data, event),
CosmicSurface::X11(surface) => PointerTarget::enter(surface, seat, data, event),
@ -723,12 +713,7 @@ impl PointerTarget<crate::state::State> for CosmicSurface {
}
}
fn motion(
&self,
seat: &smithay::input::Seat<crate::state::State>,
data: &mut crate::state::State,
event: &smithay::input::pointer::MotionEvent,
) {
fn motion(&self, seat: &Seat<State>, data: &mut State, event: &MotionEvent) {
match self {
CosmicSurface::Wayland(window) => PointerTarget::motion(window, seat, data, event),
CosmicSurface::X11(surface) => PointerTarget::motion(surface, seat, data, event),
@ -736,12 +721,7 @@ impl PointerTarget<crate::state::State> for CosmicSurface {
}
}
fn relative_motion(
&self,
seat: &smithay::input::Seat<crate::state::State>,
data: &mut crate::state::State,
event: &smithay::input::pointer::RelativeMotionEvent,
) {
fn relative_motion(&self, seat: &Seat<State>, data: &mut State, event: &RelativeMotionEvent) {
match self {
CosmicSurface::Wayland(window) => {
PointerTarget::relative_motion(window, seat, data, event)
@ -753,12 +733,7 @@ impl PointerTarget<crate::state::State> for CosmicSurface {
}
}
fn button(
&self,
seat: &smithay::input::Seat<crate::state::State>,
data: &mut crate::state::State,
event: &smithay::input::pointer::ButtonEvent,
) {
fn button(&self, seat: &Seat<State>, data: &mut State, event: &ButtonEvent) {
match self {
CosmicSurface::Wayland(window) => PointerTarget::button(window, seat, data, event),
CosmicSurface::X11(surface) => PointerTarget::button(surface, seat, data, event),
@ -766,12 +741,7 @@ impl PointerTarget<crate::state::State> for CosmicSurface {
}
}
fn axis(
&self,
seat: &smithay::input::Seat<crate::state::State>,
data: &mut crate::state::State,
frame: smithay::input::pointer::AxisFrame,
) {
fn axis(&self, seat: &Seat<State>, data: &mut State, frame: AxisFrame) {
match self {
CosmicSurface::Wayland(window) => PointerTarget::axis(window, seat, data, frame),
CosmicSurface::X11(surface) => PointerTarget::axis(surface, seat, data, frame),
@ -781,8 +751,8 @@ impl PointerTarget<crate::state::State> for CosmicSurface {
fn leave(
&self,
seat: &smithay::input::Seat<crate::state::State>,
data: &mut crate::state::State,
seat: &Seat<State>,
data: &mut State,
serial: smithay::utils::Serial,
time: u32,
) {
@ -794,6 +764,137 @@ impl PointerTarget<crate::state::State> for CosmicSurface {
_ => unreachable!(),
}
}
fn gesture_swipe_begin(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GestureSwipeBeginEvent,
) {
match self {
CosmicSurface::Wayland(window) => {
PointerTarget::gesture_swipe_begin(window, seat, data, event)
}
CosmicSurface::X11(surface) => {
PointerTarget::gesture_swipe_begin(surface, seat, data, event)
}
_ => unreachable!(),
}
}
fn gesture_swipe_update(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GestureSwipeUpdateEvent,
) {
match self {
CosmicSurface::Wayland(window) => {
PointerTarget::gesture_swipe_update(window, seat, data, event)
}
CosmicSurface::X11(surface) => {
PointerTarget::gesture_swipe_update(surface, seat, data, event)
}
_ => unreachable!(),
}
}
fn gesture_swipe_end(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GestureSwipeEndEvent,
) {
match self {
CosmicSurface::Wayland(window) => {
PointerTarget::gesture_swipe_end(window, seat, data, event)
}
CosmicSurface::X11(surface) => {
PointerTarget::gesture_swipe_end(surface, seat, data, event)
}
_ => unreachable!(),
}
}
fn gesture_pinch_begin(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GesturePinchBeginEvent,
) {
match self {
CosmicSurface::Wayland(window) => {
PointerTarget::gesture_pinch_begin(window, seat, data, event)
}
CosmicSurface::X11(surface) => {
PointerTarget::gesture_pinch_begin(surface, seat, data, event)
}
_ => unreachable!(),
}
}
fn gesture_pinch_update(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GesturePinchUpdateEvent,
) {
match self {
CosmicSurface::Wayland(window) => {
PointerTarget::gesture_pinch_update(window, seat, data, event)
}
CosmicSurface::X11(surface) => {
PointerTarget::gesture_pinch_update(surface, seat, data, event)
}
_ => unreachable!(),
}
}
fn gesture_pinch_end(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GesturePinchEndEvent,
) {
match self {
CosmicSurface::Wayland(window) => {
PointerTarget::gesture_pinch_end(window, seat, data, event)
}
CosmicSurface::X11(surface) => {
PointerTarget::gesture_pinch_end(surface, seat, data, event)
}
_ => unreachable!(),
}
}
fn gesture_hold_begin(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GestureHoldBeginEvent,
) {
match self {
CosmicSurface::Wayland(window) => {
PointerTarget::gesture_hold_begin(window, seat, data, event)
}
CosmicSurface::X11(surface) => {
PointerTarget::gesture_hold_begin(surface, seat, data, event)
}
_ => unreachable!(),
}
}
fn gesture_hold_end(&self, seat: &Seat<State>, data: &mut State, event: &GestureHoldEndEvent) {
match self {
CosmicSurface::Wayland(window) => {
PointerTarget::gesture_hold_end(window, seat, data, event)
}
CosmicSurface::X11(surface) => {
PointerTarget::gesture_hold_end(surface, seat, data, event)
}
_ => unreachable!(),
}
}
}
impl WaylandFocus for CosmicSurface {

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

@ -24,7 +24,12 @@ use smithay::{
desktop::space::SpaceElement,
input::{
keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
pointer::{AxisFrame, ButtonEvent, MotionEvent, PointerTarget, RelativeMotionEvent},
pointer::{
AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent,
GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent,
GestureSwipeBeginEvent, GestureSwipeEndEvent, GestureSwipeUpdateEvent, MotionEvent,
PointerTarget, RelativeMotionEvent,
},
Seat,
},
output::Output,
@ -590,6 +595,105 @@ impl PointerTarget<State> for CosmicWindow {
_ => {}
}
}
fn gesture_swipe_begin(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GestureSwipeBeginEvent,
) {
self.0.with_program(|p| {
if !p.has_ssd(false) || p.current_focus() == Focus::Window {
PointerTarget::gesture_swipe_begin(&p.window, seat, data, event)
}
})
}
fn gesture_swipe_update(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GestureSwipeUpdateEvent,
) {
self.0.with_program(|p| {
if !p.has_ssd(false) || p.current_focus() == Focus::Window {
PointerTarget::gesture_swipe_update(&p.window, seat, data, event)
}
})
}
fn gesture_swipe_end(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GestureSwipeEndEvent,
) {
self.0.with_program(|p| {
if !p.has_ssd(false) || p.current_focus() == Focus::Window {
PointerTarget::gesture_swipe_end(&p.window, seat, data, event)
}
})
}
fn gesture_pinch_begin(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GesturePinchBeginEvent,
) {
self.0.with_program(|p| {
if !p.has_ssd(false) || p.current_focus() == Focus::Window {
PointerTarget::gesture_pinch_begin(&p.window, seat, data, event)
}
})
}
fn gesture_pinch_update(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GesturePinchUpdateEvent,
) {
self.0.with_program(|p| {
if !p.has_ssd(false) || p.current_focus() == Focus::Window {
PointerTarget::gesture_pinch_update(&p.window, seat, data, event)
}
})
}
fn gesture_pinch_end(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GesturePinchEndEvent,
) {
self.0.with_program(|p| {
if !p.has_ssd(false) || p.current_focus() == Focus::Window {
PointerTarget::gesture_pinch_end(&p.window, seat, data, event)
}
})
}
fn gesture_hold_begin(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GestureHoldBeginEvent,
) {
self.0.with_program(|p| {
if !p.has_ssd(false) || p.current_focus() == Focus::Window {
PointerTarget::gesture_hold_begin(&p.window, seat, data, event)
}
})
}
fn gesture_hold_end(&self, seat: &Seat<State>, data: &mut State, event: &GestureHoldEndEvent) {
self.0.with_program(|p| {
if !p.has_ssd(false) || p.current_focus() == Focus::Window {
PointerTarget::gesture_hold_end(&p.window, seat, data, event)
}
})
}
}
render_elements! {

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

@ -11,7 +11,12 @@ use smithay::{
desktop::{LayerSurface, PopupKind},
input::{
keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
pointer::{AxisFrame, ButtonEvent, MotionEvent, PointerTarget, RelativeMotionEvent},
pointer::{
AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent,
GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent,
GestureSwipeBeginEvent, GestureSwipeEndEvent, GestureSwipeUpdateEvent, MotionEvent,
PointerTarget, RelativeMotionEvent,
},
Seat,
},
output::WeakOutput,
@ -198,6 +203,215 @@ impl PointerTarget<State> for PointerFocusTarget {
PointerFocusTarget::ResizeFork(f) => PointerTarget::leave(f, seat, data, serial, time),
}
}
fn gesture_swipe_begin(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GestureSwipeBeginEvent,
) {
match self {
PointerFocusTarget::Element(w) => {
PointerTarget::gesture_swipe_begin(w, seat, data, event)
}
PointerFocusTarget::Fullscreen(w) => {
PointerTarget::gesture_swipe_begin(w, seat, data, event)
}
PointerFocusTarget::LayerSurface(l) => {
PointerTarget::gesture_swipe_begin(l, seat, data, event)
}
PointerFocusTarget::Popup(p) => {
PointerTarget::gesture_swipe_begin(p.wl_surface(), seat, data, event)
}
PointerFocusTarget::OverrideRedirect(s) => {
PointerTarget::gesture_swipe_begin(s, seat, data, event)
}
PointerFocusTarget::ResizeFork(f) => {
PointerTarget::gesture_swipe_begin(f, seat, data, event)
}
}
}
fn gesture_swipe_update(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GestureSwipeUpdateEvent,
) {
match self {
PointerFocusTarget::Element(w) => {
PointerTarget::gesture_swipe_update(w, seat, data, event)
}
PointerFocusTarget::Fullscreen(w) => {
PointerTarget::gesture_swipe_update(w, seat, data, event)
}
PointerFocusTarget::LayerSurface(l) => {
PointerTarget::gesture_swipe_update(l, seat, data, event)
}
PointerFocusTarget::Popup(p) => {
PointerTarget::gesture_swipe_update(p.wl_surface(), seat, data, event)
}
PointerFocusTarget::OverrideRedirect(s) => {
PointerTarget::gesture_swipe_update(s, seat, data, event)
}
PointerFocusTarget::ResizeFork(f) => {
PointerTarget::gesture_swipe_update(f, seat, data, event)
}
}
}
fn gesture_swipe_end(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GestureSwipeEndEvent,
) {
match self {
PointerFocusTarget::Element(w) => {
PointerTarget::gesture_swipe_end(w, seat, data, event)
}
PointerFocusTarget::Fullscreen(w) => {
PointerTarget::gesture_swipe_end(w, seat, data, event)
}
PointerFocusTarget::LayerSurface(l) => {
PointerTarget::gesture_swipe_end(l, seat, data, event)
}
PointerFocusTarget::Popup(p) => {
PointerTarget::gesture_swipe_end(p.wl_surface(), seat, data, event)
}
PointerFocusTarget::OverrideRedirect(s) => {
PointerTarget::gesture_swipe_end(s, seat, data, event)
}
PointerFocusTarget::ResizeFork(f) => {
PointerTarget::gesture_swipe_end(f, seat, data, event)
}
}
}
fn gesture_pinch_begin(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GesturePinchBeginEvent,
) {
match self {
PointerFocusTarget::Element(w) => {
PointerTarget::gesture_pinch_begin(w, seat, data, event)
}
PointerFocusTarget::Fullscreen(w) => {
PointerTarget::gesture_pinch_begin(w, seat, data, event)
}
PointerFocusTarget::LayerSurface(l) => {
PointerTarget::gesture_pinch_begin(l, seat, data, event)
}
PointerFocusTarget::Popup(p) => {
PointerTarget::gesture_pinch_begin(p.wl_surface(), seat, data, event)
}
PointerFocusTarget::OverrideRedirect(s) => {
PointerTarget::gesture_pinch_begin(s, seat, data, event)
}
PointerFocusTarget::ResizeFork(f) => {
PointerTarget::gesture_pinch_begin(f, seat, data, event)
}
}
}
fn gesture_pinch_update(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GesturePinchUpdateEvent,
) {
match self {
PointerFocusTarget::Element(w) => {
PointerTarget::gesture_pinch_update(w, seat, data, event)
}
PointerFocusTarget::Fullscreen(w) => {
PointerTarget::gesture_pinch_update(w, seat, data, event)
}
PointerFocusTarget::LayerSurface(l) => {
PointerTarget::gesture_pinch_update(l, seat, data, event)
}
PointerFocusTarget::Popup(p) => {
PointerTarget::gesture_pinch_update(p.wl_surface(), seat, data, event)
}
PointerFocusTarget::OverrideRedirect(s) => {
PointerTarget::gesture_pinch_update(s, seat, data, event)
}
PointerFocusTarget::ResizeFork(f) => {
PointerTarget::gesture_pinch_update(f, seat, data, event)
}
}
}
fn gesture_pinch_end(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GesturePinchEndEvent,
) {
match self {
PointerFocusTarget::Element(w) => {
PointerTarget::gesture_pinch_end(w, seat, data, event)
}
PointerFocusTarget::Fullscreen(w) => {
PointerTarget::gesture_pinch_end(w, seat, data, event)
}
PointerFocusTarget::LayerSurface(l) => {
PointerTarget::gesture_pinch_end(l, seat, data, event)
}
PointerFocusTarget::Popup(p) => {
PointerTarget::gesture_pinch_end(p.wl_surface(), seat, data, event)
}
PointerFocusTarget::OverrideRedirect(s) => {
PointerTarget::gesture_pinch_end(s, seat, data, event)
}
PointerFocusTarget::ResizeFork(f) => {
PointerTarget::gesture_pinch_end(f, seat, data, event)
}
}
}
fn gesture_hold_begin(
&self,
seat: &Seat<State>,
data: &mut State,
event: &GestureHoldBeginEvent,
) {
match self {
PointerFocusTarget::Element(w) => {
PointerTarget::gesture_hold_begin(w, seat, data, event)
}
PointerFocusTarget::Fullscreen(w) => {
PointerTarget::gesture_hold_begin(w, seat, data, event)
}
PointerFocusTarget::LayerSurface(l) => {
PointerTarget::gesture_hold_begin(l, seat, data, event)
}
PointerFocusTarget::Popup(p) => {
PointerTarget::gesture_hold_begin(p.wl_surface(), seat, data, event)
}
PointerFocusTarget::OverrideRedirect(s) => {
PointerTarget::gesture_hold_begin(s, seat, data, event)
}
PointerFocusTarget::ResizeFork(f) => {
PointerTarget::gesture_hold_begin(f, seat, data, event)
}
}
}
fn gesture_hold_end(&self, seat: &Seat<State>, data: &mut State, event: &GestureHoldEndEvent) {
match self {
PointerFocusTarget::Element(w) => PointerTarget::gesture_hold_end(w, seat, data, event),
PointerFocusTarget::Fullscreen(w) => {
PointerTarget::gesture_hold_end(w, seat, data, event)
}
PointerFocusTarget::LayerSurface(l) => {
PointerTarget::gesture_hold_end(l, seat, data, event)
}
PointerFocusTarget::Popup(p) => {
PointerTarget::gesture_hold_end(p.wl_surface(), seat, data, event)
}
PointerFocusTarget::OverrideRedirect(s) => {
PointerTarget::gesture_hold_end(s, seat, data, event)
}
PointerFocusTarget::ResizeFork(f) => {
PointerTarget::gesture_hold_end(f, seat, data, event)
}
}
}
}
impl KeyboardTarget<State> for KeyboardFocusTarget {

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

@ -1,7 +1,9 @@
use smithay::{
input::pointer::{
AxisFrame, ButtonEvent, GrabStartData as PointerGrabStartData, MotionEvent, PointerGrab,
PointerInnerHandle, RelativeMotionEvent,
AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent, GesturePinchBeginEvent,
GesturePinchEndEvent, GesturePinchUpdateEvent, GestureSwipeBeginEvent,
GestureSwipeEndEvent, GestureSwipeUpdateEvent, GrabStartData as PointerGrabStartData,
MotionEvent, PointerGrab, PointerInnerHandle, RelativeMotionEvent,
},
reexports::wayland_protocols::xdg::shell::server::xdg_toplevel,
utils::{Logical, Point},
@ -150,6 +152,102 @@ impl PointerGrab<State> for ResizeGrab {
}
}
fn gesture_swipe_begin(
&mut self,
data: &mut State,
handle: &mut PointerInnerHandle<'_, State>,
event: &GestureSwipeBeginEvent,
) {
match self {
ResizeGrab::Floating(grab) => grab.gesture_swipe_begin(data, handle, event),
ResizeGrab::Tiling(grab) => grab.gesture_swipe_begin(data, handle, event),
}
}
fn gesture_swipe_update(
&mut self,
data: &mut State,
handle: &mut PointerInnerHandle<'_, State>,
event: &GestureSwipeUpdateEvent,
) {
match self {
ResizeGrab::Floating(grab) => grab.gesture_swipe_update(data, handle, event),
ResizeGrab::Tiling(grab) => grab.gesture_swipe_update(data, handle, event),
}
}
fn gesture_swipe_end(
&mut self,
data: &mut State,
handle: &mut PointerInnerHandle<'_, State>,
event: &GestureSwipeEndEvent,
) {
match self {
ResizeGrab::Floating(grab) => grab.gesture_swipe_end(data, handle, event),
ResizeGrab::Tiling(grab) => grab.gesture_swipe_end(data, handle, event),
}
}
fn gesture_pinch_begin(
&mut self,
data: &mut State,
handle: &mut PointerInnerHandle<'_, State>,
event: &GesturePinchBeginEvent,
) {
match self {
ResizeGrab::Floating(grab) => grab.gesture_pinch_begin(data, handle, event),
ResizeGrab::Tiling(grab) => grab.gesture_pinch_begin(data, handle, event),
}
}
fn gesture_pinch_update(
&mut self,
data: &mut State,
handle: &mut PointerInnerHandle<'_, State>,
event: &GesturePinchUpdateEvent,
) {
match self {
ResizeGrab::Floating(grab) => grab.gesture_pinch_update(data, handle, event),
ResizeGrab::Tiling(grab) => grab.gesture_pinch_update(data, handle, event),
}
}
fn gesture_pinch_end(
&mut self,
data: &mut State,
handle: &mut PointerInnerHandle<'_, State>,
event: &GesturePinchEndEvent,
) {
match self {
ResizeGrab::Floating(grab) => grab.gesture_pinch_end(data, handle, event),
ResizeGrab::Tiling(grab) => grab.gesture_pinch_end(data, handle, event),
}
}
fn gesture_hold_begin(
&mut self,
data: &mut State,
handle: &mut PointerInnerHandle<'_, State>,
event: &GestureHoldBeginEvent,
) {
match self {
ResizeGrab::Floating(grab) => grab.gesture_hold_begin(data, handle, event),
ResizeGrab::Tiling(grab) => grab.gesture_hold_begin(data, handle, event),
}
}
fn gesture_hold_end(
&mut self,
data: &mut State,
handle: &mut PointerInnerHandle<'_, State>,
event: &GestureHoldEndEvent,
) {
match self {
ResizeGrab::Floating(grab) => grab.gesture_hold_end(data, handle, event),
ResizeGrab::Tiling(grab) => grab.gesture_hold_end(data, handle, event),
}
}
fn start_data(&self) -> &PointerGrabStartData<State> {
match self {
ResizeGrab::Floating(grab) => grab.start_data(),

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

@ -25,8 +25,11 @@ use smithay::{
desktop::space::SpaceElement,
input::{
pointer::{
AxisFrame, ButtonEvent, GrabStartData as PointerGrabStartData, MotionEvent,
PointerGrab, PointerInnerHandle, RelativeMotionEvent,
AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent,
GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent,
GestureSwipeBeginEvent, GestureSwipeEndEvent, GestureSwipeUpdateEvent,
GrabStartData as PointerGrabStartData, MotionEvent, PointerGrab, PointerInnerHandle,
RelativeMotionEvent,
},
Seat,
},
@ -308,6 +311,78 @@ impl PointerGrab<State> for MoveGrab {
handle.axis(state, details);
}
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
}

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

@ -9,8 +9,10 @@ use crate::{
use smithay::{
desktop::space::SpaceElement,
input::pointer::{
AxisFrame, ButtonEvent, GrabStartData as PointerGrabStartData, MotionEvent, PointerGrab,
PointerInnerHandle, RelativeMotionEvent,
AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent, GesturePinchBeginEvent,
GesturePinchEndEvent, GesturePinchUpdateEvent, GestureSwipeBeginEvent,
GestureSwipeEndEvent, GestureSwipeUpdateEvent, GrabStartData as PointerGrabStartData,
MotionEvent, PointerGrab, PointerInnerHandle, RelativeMotionEvent,
},
utils::{IsAlive, Logical, Point, Rectangle, Size},
};
@ -162,6 +164,78 @@ impl PointerGrab<State> for ResizeSurfaceGrab {
handle.axis(data, details)
}
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
}

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

@ -10,8 +10,11 @@ use smithay::{
backend::input::ButtonState,
input::{
pointer::{
AxisFrame, ButtonEvent, Focus, GrabStartData as PointerGrabStartData, MotionEvent,
PointerGrab, PointerInnerHandle, PointerTarget, RelativeMotionEvent,
AxisFrame, ButtonEvent, Focus, GestureHoldBeginEvent, GestureHoldEndEvent,
GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent,
GestureSwipeBeginEvent, GestureSwipeEndEvent, GestureSwipeUpdateEvent,
GrabStartData as PointerGrabStartData, MotionEvent, PointerGrab, PointerInnerHandle,
PointerTarget, RelativeMotionEvent,
},
Seat,
},
@ -99,6 +102,14 @@ impl PointerTarget<State> for ResizeForkTarget {
) {
}
fn axis(&self, _seat: &Seat<State>, _data: &mut State, _frame: AxisFrame) {}
fn gesture_swipe_begin(&self, _: &Seat<State>, _: &mut State, _: &GestureSwipeBeginEvent) {}
fn gesture_swipe_update(&self, _: &Seat<State>, _: &mut State, _: &GestureSwipeUpdateEvent) {}
fn gesture_swipe_end(&self, _: &Seat<State>, _: &mut State, _: &GestureSwipeEndEvent) {}
fn gesture_pinch_begin(&self, _: &Seat<State>, _: &mut State, _: &GesturePinchBeginEvent) {}
fn gesture_pinch_update(&self, _: &Seat<State>, _: &mut State, _: &GesturePinchUpdateEvent) {}
fn gesture_pinch_end(&self, _: &Seat<State>, _: &mut State, _: &GesturePinchEndEvent) {}
fn gesture_hold_begin(&self, _: &Seat<State>, _: &mut State, _: &GestureHoldBeginEvent) {}
fn gesture_hold_end(&self, _: &Seat<State>, _: &mut State, _: &GestureHoldEndEvent) {}
}
pub struct ResizeForkGrab {
@ -223,6 +234,78 @@ impl PointerGrab<State> for ResizeForkGrab {
handle.axis(data, details)
}
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
}

64
src/utils/iced.rs
View file

@ -44,7 +44,12 @@ use smithay::{
desktop::space::{RenderZindex, SpaceElement},
input::{
keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
pointer::{AxisFrame, ButtonEvent, MotionEvent, PointerTarget, RelativeMotionEvent},
pointer::{
AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent,
GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent,
GestureSwipeBeginEvent, GestureSwipeEndEvent, GestureSwipeUpdateEvent, MotionEvent,
PointerTarget, RelativeMotionEvent,
},
Seat,
},
output::Output,
@ -461,6 +466,63 @@ impl<P: Program + Send + 'static> PointerTarget<crate::state::State> for IcedEle
.queue_event(Event::Mouse(MouseEvent::CursorLeft));
let _ = internal.update(true);
}
fn gesture_swipe_begin(
&self,
_: &Seat<crate::state::State>,
_: &mut crate::state::State,
_: &GestureSwipeBeginEvent,
) {
}
fn gesture_swipe_update(
&self,
_: &Seat<crate::state::State>,
_: &mut crate::state::State,
_: &GestureSwipeUpdateEvent,
) {
}
fn gesture_swipe_end(
&self,
_: &Seat<crate::state::State>,
_: &mut crate::state::State,
_: &GestureSwipeEndEvent,
) {
}
fn gesture_pinch_begin(
&self,
_: &Seat<crate::state::State>,
_: &mut crate::state::State,
_: &GesturePinchBeginEvent,
) {
}
fn gesture_pinch_update(
&self,
_: &Seat<crate::state::State>,
_: &mut crate::state::State,
_: &GesturePinchUpdateEvent,
) {
}
fn gesture_pinch_end(
&self,
_: &Seat<crate::state::State>,
_: &mut crate::state::State,
_: &GesturePinchEndEvent,
) {
}
fn gesture_hold_begin(
&self,
_: &Seat<crate::state::State>,
_: &mut crate::state::State,
_: &GestureHoldBeginEvent,
) {
}
fn gesture_hold_end(
&self,
_: &Seat<crate::state::State>,
_: &mut crate::state::State,
_: &GestureHoldEndEvent,
) {
}
}
impl<P: Program + Send + 'static> KeyboardTarget<crate::state::State> for IcedElement<P> {