Struct PointerInnerHandle

pub struct PointerInnerHandle<'a, D: SeatHandler> { /* private fields */ }

This inner handle is accessed from inside a pointer grab logic, and directly sends event to the client

Implementations

impl<D: SeatHandler + 'static> PointerInnerHandle<'_, D>

pub fn set_grab<G: PointerGrab<D> + 'static>( &mut self, handler: &mut dyn PointerGrab<D>, data: &mut D, serial: Serial, focus: Focus, grab: G, )

Change the current grab on this pointer to the provided grab

Overwrites any current grab.

pub fn unset_grab( &mut self, handler: &mut dyn PointerGrab<D>, data: &mut D, serial: Serial, time: u32, restore_focus: bool, )

Remove any current grab on this pointer, resetting it to the default behavior

This will also restore the focus of the underlying pointer if restore_focus is true

pub fn current_focus( &self, ) -> Option<(<D as SeatHandler>::PointerFocus, Point<f64, Logical>)>

Access the current focus of this pointer

pub fn current_location(&self) -> Point<f64, Logical>

Access the current location of this pointer in the global space

pub fn current_pressed(&self) -> &[u32]

A list of the currently physically pressed buttons

This still includes buttons that your grab have intercepted and not sent to the client.

pub fn motion( &mut self, data: &mut D, focus: Option<(<D as SeatHandler>::PointerFocus, Point<f64, Logical>)>, event: &MotionEvent, )

Notify that the pointer moved

You provide the new location of the pointer, in the form of:

• The coordinates of the pointer in the global compositor space
• The surface on top of which the cursor is, and the coordinates of its origin in the global compositor space (or None of the pointer is not on top of a client surface).

This will internally take care of notifying the appropriate client objects of enter/motion/leave events.

pub fn relative_motion( &mut self, data: &mut D, focus: Option<(<D as SeatHandler>::PointerFocus, Point<f64, Logical>)>, event: &RelativeMotionEvent, )

Notify about relative pointer motion

This will internally send the appropriate button event to the client objects matching with the currently focused surface, if the client uses the relative pointer protocol.

pub fn button(&mut self, data: &mut D, event: &ButtonEvent)

Notify that a button was pressed

This will internally send the appropriate button event to the client objects matching with the currently focused surface.

pub fn axis(&mut self, data: &mut D, details: AxisFrame)

Notify that an axis was scrolled

This will internally send the appropriate axis events to the client objects matching with the currently focused surface.

pub fn frame(&mut self, data: &mut D)

End of a pointer frame

This will internally send the appropriate frame event to the client objects matching with the currently focused surface.

pub fn gesture_swipe_begin( &mut self, data: &mut D, event: &GestureSwipeBeginEvent, )

Notify about swipe gesture begin

This will internally send the appropriate button event to the client objects matching with the currently focused surface, if the client uses the pointer gestures protocol.

pub fn gesture_swipe_update( &mut self, data: &mut D, event: &GestureSwipeUpdateEvent, )

Notify about swipe gesture update

This will internally send the appropriate button event to the client objects matching with the currently focused surface, if the client uses the pointer gestures protocol.

pub fn gesture_swipe_end(&mut self, data: &mut D, event: &GestureSwipeEndEvent)

Notify about swipe gesture end

This will internally send the appropriate button event to the client objects matching with the currently focused surface, if the client uses the pointer gestures protocol.

pub fn gesture_pinch_begin( &mut self, data: &mut D, event: &GesturePinchBeginEvent, )

Notify about pinch gesture begin

This will internally send the appropriate button event to the client objects matching with the currently focused surface, if the client uses the pointer gestures protocol.

pub fn gesture_pinch_update( &mut self, data: &mut D, event: &GesturePinchUpdateEvent, )

Notify about pinch gesture update

This will internally send the appropriate button event to the client objects matching with the currently focused surface, if the client uses the pointer gestures protocol.

pub fn gesture_pinch_end(&mut self, data: &mut D, event: &GesturePinchEndEvent)

Notify about pinch gesture end

This will internally send the appropriate button event to the client objects matching with the currently focused surface, if the client uses the pointer gestures protocol.

pub fn gesture_hold_begin( &mut self, data: &mut D, event: &GestureHoldBeginEvent, )

Notify about hold gesture begin

This will internally send the appropriate button event to the client objects matching with the currently focused surface, if the client uses the pointer gestures protocol.

pub fn gesture_hold_end(&mut self, data: &mut D, event: &GestureHoldEndEvent)

Notify about hold gesture end

This will internally send the appropriate button event to the client objects matching with the currently focused surface, if the client uses the pointer gestures protocol.

Trait Implementations

impl<D: SeatHandler> Debug for PointerInnerHandle<'_, D>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.