event_types 0.1.0

//! Collection of types describing data associated with some common input events
//!
//! Notably these do not have timestamps or references to the target element. Wrap these in your own Event<T> struct with such data.

use crate::pointer::{PointerButton, PointerProperties};
use crate::{KeyProperties, WheelDelta};
use keyboard_types::Modifiers;

/// Pointer button is pressed, when no other buttons are held
///
/// For touch, this is when physical contact is made.
#[derive(Clone, PartialEq, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PointerDown {
    pointer: PointerProperties,
    /// Modifier keys held at time of event
    modifiers: Modifiers,
    button_pressed: PointerButton,
    click_count: i64,
}

impl PointerDown {
    pub fn new(
        pointer: PointerProperties,
        modifiers: Modifiers,
        button_pressed: PointerButton,
        click_count: i64,
    ) -> Self {
        Self {
            pointer,
            modifiers,
            button_pressed,
            click_count,
        }
    }

    /// The properties of the pointer at the time of the event
    pub fn pointer(&self) -> &PointerProperties {
        &self.pointer
    }

    /// The button which triggered this event
    pub fn button_pressed(&self) -> &PointerButton {
        &self.button_pressed
    }

    /// The number of consecutive presses, including this one
    ///
    /// For example, if a mouse is only pressed down once, `click_count` will be 1.
    pub fn click_count(&self) -> i64 {
        self.click_count
    }

    /// Modifier keys held at time of event
    pub fn modifiers(&self) -> Modifiers {
        self.modifiers
    }
}

/// Last held pointer button is released
///
/// For mouse, this is when the device transitions from at least one button depressed to no buttons depressed. For touch, this is when physical contact is removed.
#[derive(Clone, PartialEq, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PointerUp {
    pointer: PointerProperties,
    /// Modifier keys held at time of event
    modifiers: Modifiers,
    button_released: PointerButton,
    click_count: i64,
}

impl PointerUp {
    pub fn new(
        pointer: PointerProperties,
        modifiers: Modifiers,
        button_released: PointerButton,
        click_count: i64,
    ) -> Self {
        Self {
            pointer,
            modifiers,
            button_released,
            click_count,
        }
    }

    /// The properties of the pointer at the time of the event
    pub fn pointer(&self) -> &PointerProperties {
        &self.pointer
    }

    /// Modifier keys held at time of event
    pub fn modifiers(&self) -> Modifiers {
        self.modifiers
    }

    /// The button which triggered this event
    pub fn button_released(&self) -> &PointerButton {
        &self.button_released
    }

    /// The number of consecutive presses, including this one
    ///
    /// For example, if a mouse is only pressed&released once, `click_count` will be 1.
    pub fn click_count(&self) -> i64 {
        self.click_count
    }
}

/// Pointer is moved into boundaries of an element
///
/// This may also be as a result of a pointer being pressed on a device that does not support hover
#[derive(Clone, PartialEq, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PointerEnter {
    pointer: PointerProperties,
    /// Modifier keys held at time of event
    modifiers: Modifiers,
}

impl PointerEnter {
    pub fn new(pointer: PointerProperties, modifiers: Modifiers) -> Self {
        Self { pointer, modifiers }
    }

    /// The properties of the pointer at the time of the event
    pub fn pointer(&self) -> &PointerProperties {
        &self.pointer
    }

    /// Modifier keys held at time of event
    pub fn modifiers(&self) -> Modifiers {
        self.modifiers
    }
}

/// Pointer leaves an element
///
/// This can happen when any of the following occurs:
///
/// - The pointing device is moved out of the hit test boundaries of an element.
/// - After a pointer is released for a device that does not support hover.
/// - The user agent has detected a scenario to suppress a pointer event stream.
#[derive(Clone, PartialEq, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PointerLeave {
    pointer: PointerProperties,
    /// Modifier keys held at time of event
    modifiers: Modifiers,
}

impl PointerLeave {
    pub fn new(pointer: PointerProperties, modifiers: Modifiers) -> Self {
        Self { pointer, modifiers }
    }

    /// The properties of the pointer at the time of the event
    pub fn pointer(&self) -> &PointerProperties {
        &self.pointer
    }

    /// Modifier keys held at time of event
    pub fn modifiers(&self) -> Modifiers {
        self.modifiers
    }
}

/// Pointer changes any properties that don't fire [PointerDown] or [PointerUp] events.
///
/// This includes any changes to coordinates, pressure, tangential pressure, tilt, twist, dimensions or pressing/releasing buttons while another button is held.
#[derive(Clone, PartialEq, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PointerMove {
    pointer: PointerProperties,
    /// Modifier keys held at time of event
    modifiers: Modifiers,
}

impl PointerMove {
    pub fn new(pointer: PointerProperties, modifiers: Modifiers) -> Self {
        Self { pointer, modifiers }
    }

    /// The properties of the pointer at the time of the event
    pub fn pointer(&self) -> &PointerProperties {
        &self.pointer
    }
    /// Modifier keys held at time of event
    pub fn modifiers(&self) -> Modifiers {
        self.modifiers
    }
}

/// Fires upon detecting a pointer is unlikely to continue to produce events.
///
/// Any of the following scenarios satisfy this condition (there MAY be additional scenarios):
///
/// - The user agent has opened a modal dialog or menu.
/// - A pointer input device is physically disconnected, or a hoverable pointer input device (e.g. a hoverable pen/stylus) has left the hover range detectable by the digitizer.
/// - The pointer is subsequently used by the user agent to manipulate the page viewport (e.g. panning or zooming). See the section on touch-action CSS property for details.
#[derive(Clone, PartialEq, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PointerCancel {
    pointer: PointerProperties,
    /// Modifier keys held at time of event
    modifiers: Modifiers,
}

impl PointerCancel {
    pub fn new(pointer: PointerProperties, modifiers: Modifiers) -> Self {
        Self { pointer, modifiers }
    }

    /// The properties of the pointer at the time of the event
    pub fn pointer(&self) -> &PointerProperties {
        &self.pointer
    }
    /// Modifier keys held at time of event
    pub fn modifiers(&self) -> Modifiers {
        self.modifiers
    }
}

/// Pointer clicks on an element with the primary button
///
/// For a mouse, this means pressing and releasing the button
#[derive(Clone, PartialEq, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PrimaryClick {
    pointer: PointerProperties,
    /// Modifier keys held at time of event
    modifiers: Modifiers,
    click_count: i64,
}

impl PrimaryClick {
    pub fn new(pointer: PointerProperties, modifiers: Modifiers, click_count: i64) -> Self {
        Self {
            pointer,
            modifiers,
            click_count,
        }
    }

    /// The properties of the pointer at the time of the event
    pub fn pointer(&self) -> &PointerProperties {
        &self.pointer
    }

    /// The number of consecutive presses, including this one
    ///
    /// For example, if a mouse is only clicked once, `click_count` will be 1.
    pub fn click_count(&self) -> i64 {
        self.click_count
    }

    /// Modifier keys held at time of event
    pub fn modifiers(&self) -> Modifiers {
        self.modifiers
    }
}

/// Pointer clicks twice on an element with the primary button
///
/// For a mouse, this means pressing and releasing the button twice
#[derive(Clone, PartialEq, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DoubleClick {
    pointer: PointerProperties,
    /// Modifier keys held at time of event
    modifiers: Modifiers,
    click_count: i64,
}

impl DoubleClick {
    pub fn new(pointer: PointerProperties, modifiers: Modifiers, click_count: i64) -> Self {
        Self {
            pointer,
            modifiers,
            click_count,
        }
    }

    /// The properties of the pointer at the time of the event
    pub fn pointer(&self) -> &PointerProperties {
        &self.pointer
    }

    /// The number of consecutive presses, including this one
    ///
    /// For example, if a mouse is double-clicked, `click_count` will be 2.
    pub fn click_count(&self) -> i64 {
        self.click_count
    }

    /// Modifier keys held at time of event
    pub fn modifiers(&self) -> Modifiers {
        self.modifiers
    }
}

/// Pointer clicks on an element with something other than the primary button
///
/// For a mouse, this means pressing and releasing the button
#[derive(Clone, PartialEq, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AuxiliaryClick {
    pointer: PointerProperties,
    /// Modifier keys held at time of event
    modifiers: Modifiers,
    clicked_button: PointerButton,
    click_count: i64,
}

impl AuxiliaryClick {
    pub fn new(
        pointer: PointerProperties,
        modifiers: Modifiers,
        clicked_button: PointerButton,
        click_count: i64,
    ) -> Self {
        Self {
            pointer,
            modifiers,
            clicked_button,
            click_count,
        }
    }

    /// The properties of the pointer at the time of the event
    pub fn pointer(&self) -> &PointerProperties {
        &self.pointer
    }

    /// The button which triggered this event
    pub fn clicked_button(&self) -> &PointerButton {
        &self.clicked_button
    }

    /// The number of consecutive presses, including this one
    ///
    /// For example, if a mouse is only clicked once, `click_count` will be 1.
    pub fn click_count(&self) -> i64 {
        self.click_count
    }

    /// Modifier keys held at time of event
    pub fn modifiers(&self) -> Modifiers {
        self.modifiers
    }
}

/// A key is pressed down
#[derive(Clone, PartialEq, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct KeyDown {
    key: KeyProperties,
}

impl KeyDown {
    pub fn new(key: KeyProperties) -> Self {
        Self { key }
    }

    /// Properties of key at time of event
    pub fn key(&self) -> &KeyProperties {
        &self.key
    }
}

/// A key is released
#[derive(Clone, PartialEq, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct KeyUp {
    key: KeyProperties,
}

impl KeyUp {
    pub fn new(key: KeyProperties) -> Self {
        Self { key }
    }

    /// Properties of key at time of event
    pub fn key(&self) -> &KeyProperties {
        &self.key
    }
}

/// A key is pressed down, and would normally produce a character value
///
/// Also known as the key "press" event
#[derive(Clone, PartialEq, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct KeyTyped {
    key: KeyProperties,
}

impl KeyTyped {
    pub fn new(key: KeyProperties) -> Self {
        Self { key }
    }

    /// Properties of key at time of event
    pub fn key(&self) -> &KeyProperties {
        &self.key
    }
}

/// Mouse wheel has been rotated around any axis
///
/// Also triggered when an equivalent input device (such as a mouse-ball, certain tablets or touchpads, etc.) has emulated such an action
#[derive(Clone, PartialEq, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WheelMove {
    delta: WheelDelta,
}

impl WheelMove {
    pub fn new(delta: WheelDelta) -> Self {
        Self { delta }
    }

    /// Amount that the page would normally scroll due to this event
    pub fn delta(&self) -> WheelDelta {
        self.delta
    }
}