Struct input_synthesis::synthesizer::TimedKeyEvent

pub struct TimedKeyEvent {
    pub key: Key,
    pub duration_since_start: Duration,
    pub event_type: KeyEventType,
}

A single key event to be replayed by dispatch_key_events_async.

See crate::dispatch_key_events for details of the key event type and the event timing.

For example, a key press like this:

Key1: _________/"""""""""""""""\\___________
               ^               ^--- key released
               `------------------- key pressed
      |<------>|  <-- duration_since_start (50ms)
      |<---------------------->| duration_since_start (100ms)

would be described with a sequence of two TimedKeyEvents (pseudo-code):

[
   { Key1,  50ms, PRESSED  },
   { Key1, 100ms, RELEASED },
]

This is not overly useful in the case of a single key press, but is useful to model multiple concurrent keypresses, while allowing an arbitrary interleaving of key events.

Consider a more complicated timing diagram like this one:

Key1: _________/"""""""""""""""\\_____________
Key2: ____/"""""""""""""""\\__________________
Key3: ______/"""""""""""""""\\________________
Key4: _____________/"""""""""""""""\\_________
Key5: ________________ __/""""""\\____________
Key6: ________/""""""\\_______________________

It then becomes obvious how modeling individual events allows us to express this interaction. Furthermore anchoring duration_since_start to the beginning of the key sequence (instead of, for example, specifying the duration of each key press) gives a common time reference and makes it fairly easy to express the intended key interaction in terms of a TimedKeyEvent sequence.

Fields

key: Key

The input::Key which changed state.

duration_since_start: Duration

The duration of time, relative to the start of the key event sequence that this TimedKeyEvent is part of, at which this event happened at.

event_type: KeyEventType

The type of state change that happened to key. Was it pressed, released or something else.

Implementations

impl TimedKeyEvent

pub fn new( key: Key, type_: KeyEventType, duration_since_start: Duration ) -> Self

Creates a new TimedKeyEvent to inject into the input pipeline. key is the key to be pressed (using Fuchsia HID-like encoding), type_ is the event type (Pressed, or Released etc), and duration_since_start is the duration since the start of the entire event sequence that the key event should be scheduled at.

pub fn vec<'de, D>(deserializer: D) -> Result<Vec<TimedKeyEvent>, D::Error>

where D: Deserializer<'de>,

Deserializes a vector of TimedKeyEvent. A custom deserializer is used because Vec<_> does not work with serde, and the TimedKeyEvent has constituents that don’t have a derived serde representation. See: https://github.com/serde-rs/serde/issues/723#issuecomment-382501277

Trait Implementations

impl Clone for TimedKeyEvent

fn clone(&self) -> TimedKeyEvent

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TimedKeyEvent

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

Formats the value using the given formatter.

impl PartialEq for TimedKeyEvent

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for TimedKeyEvent

impl StructuralPartialEq for TimedKeyEvent