Enum TabletToolEvent

#[non_exhaustive]
pub enum TabletToolEvent {
    Axis(TabletToolAxisEvent),
    Proximity(TabletToolProximityEvent),
    Tip(TabletToolTipEvent),
    Button(TabletToolButtonEvent),
}

An event related to a tablet tool

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Axis(TabletToolAxisEvent)

One or more axes have changed state on a device with the DeviceCapability::TabletTool capability.

This event is only sent when the tool is in proximity, see TabletToolProximityEvent for details.

The proximity event contains the initial state of the axis as the tool comes into proximity. An event of type TabletToolAxisEvent is only sent when an axis value changes from this initial state. It is possible for a tool to enter and leave proximity without sending an event of type TabletToolAxisEvent.

An event of type TabletToolAxisEvent is sent when the tip state does not change. See the documentation for TabletToolTipEvent for more details.

Proximity(TabletToolProximityEvent)

Signals that a tool has come in or out of proximity of a device with the DeviceCapability::TabletTool capability.

Proximity events contain each of the current values for each axis, and these values may be extracted from them in the same way they are with TabletToolAxisEvent events.

Some tools may always be in proximity. For these tools, proximity events with ProximityState::In are sent only once after DeviceAddedEvent, and proximity events with ProximityState::Out are sent only once before DeviceRemovedEvent.

If the tool that comes into proximity supports x/y coordinates, libinput guarantees that both x and y are set in the proximity event.

When a tool goes out of proximity, the value of every axis should be assumed to have an undefined state and any buttons that are currently held down on the stylus are marked as released. Button release events for each button that was held down on the stylus are sent before the proximity out event.

Tip(TabletToolTipEvent)

Signals that a tool has come in contact with the surface of a device with the DeviceCapability::TabletTool capability.

On devices without distance proximity detection, the TabletToolTipEvent is sent immediately after TabletToolProximityEvent for the tip down event, and immediately before for the tip up event.

The decision when a tip touches the surface is device-dependent and may be derived from pressure data or other means. If the tip state is changed by axes changing state, the TabletToolTipEvent includes the changed axes and no additional axis event is sent for this state change. In other words, a caller must look at both TabletToolAxisEvent and TabletToolTipEvent events to know the current state of the axes.

If a button state change occurs at the same time as a tip state change, the order of events is device-dependent.

Button(TabletToolButtonEvent)

Signals that a tool has changed a logical button state on a device with the DeviceCapability::TabletTool capability.

Button state changes occur on their own and do not include axis state changes. If button and axis state changes occur within the same logical hardware event, the order of the TabletToolButtonEvent and TabletToolAxisEvent is device-specific.

This event is not to be confused with the button events emitted by the tablet pad. See TabletPadButtonEvent.

Trait Implementations

impl AsRaw<libinput_event_tablet_tool> for TabletToolEvent

fn as_raw(&self) -> *const libinput_event_tablet_tool

Receive a raw pointer representing this type.

impl Context for TabletToolEvent

fn context(&self) -> &Libinput

Returns the underlying libinput context

impl Debug for TabletToolEvent

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

Formats the value using the given formatter.

impl EventTrait for TabletToolEvent

fn into_event(self) -> Event

where Self: Sized,

Convert into a general Event again

fn device(&self) -> Device

Return the device associated with this event.

impl FromRaw<libinput_event_tablet_tool> for TabletToolEvent

unsafe fn from_raw( event: *mut libinput_event_tablet_tool, context: &Libinput, ) -> Self

Create a new instance of this type from a raw pointer and it’s context. If the type of the struct is a valid libinput type, but is unknown to this library, it panics instead.

impl Hash for TabletToolEvent

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for TabletToolEvent

fn eq(&self, other: &TabletToolEvent) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for TabletToolEvent

impl StructuralPartialEq for TabletToolEvent