use crate::{    Bounds, Capslock, Context, Empty, IntoElement, Keystroke, Modifiers, Pixels, Point, Render,    Window, point, seal::Sealed,};use smallvec::SmallVec;use std::{any::Any, fmt::Debug, ops::Deref, path::PathBuf}; /// An event from a platform input source.pub trait InputEvent: Sealed + 'static {    /// Convert this event into the platform input enum.    fn to_platform_input(self) -> PlatformInput;} /// A key event from the platform.pub trait KeyEvent: InputEvent {} /// A mouse event from the platform.pub trait MouseEvent: InputEvent {} /// The key down event equivalent for the platform.#[derive(Clone, Debug, Eq, PartialEq)]pub struct KeyDownEvent {    /// The keystroke that was generated.    pub keystroke: Keystroke,     /// Whether the key is currently held down.    pub is_held: bool,     /// Whether to prefer character input over keybindings for this keystroke.    /// In some cases, like AltGr on Windows, modifiers are significant for character input.    pub prefer_character_input: bool,} impl Sealed for KeyDownEvent {}impl InputEvent for KeyDownEvent {    fn to_platform_input(self) -> PlatformInput {        PlatformInput::KeyDown(self)    }}impl KeyEvent for KeyDownEvent {} /// The key up event equivalent for the platform.#[derive(Clone, Debug)]pub struct KeyUpEvent {    /// The keystroke that was released.    pub keystroke: Keystroke,} impl Sealed for KeyUpEvent {}impl InputEvent for KeyUpEvent {    fn to_platform_input(self) -> PlatformInput {        PlatformInput::KeyUp(self)    }}impl KeyEvent for KeyUpEvent {} /// The modifiers changed event equivalent for the platform.#[derive(Clone, Debug, Default)]pub struct ModifiersChangedEvent {    /// The new state of the modifier keys    pub modifiers: Modifiers,    /// The new state of the capslock key    pub capslock: Capslock,} impl Sealed for ModifiersChangedEvent {}impl InputEvent for ModifiersChangedEvent {    fn to_platform_input(self) -> PlatformInput {        PlatformInput::ModifiersChanged(self)    }}impl KeyEvent for ModifiersChangedEvent {} impl Deref for ModifiersChangedEvent {    type Target = Modifiers;     fn deref(&self) -> &Self::Target {        &self.modifiers    }} /// The phase of a touch motion event./// Based on the winit enum of the same name.#[derive(Clone, Copy, Debug, Default)]pub enum TouchPhase {    /// The touch started.    Started,    /// The touch event is moving.    #[default]    Moved,    /// The touch phase has ended    Ended,} /// A mouse down event from the platform#[derive(Clone, Debug, Default)]pub struct MouseDownEvent {    /// Which mouse button was pressed.    pub button: MouseButton,     /// The position of the mouse on the window.    pub position: Point<Pixels>,     /// The modifiers that were held down when the mouse was pressed.    pub modifiers: Modifiers,     /// The number of times the button has been clicked.    pub click_count: usize,     /// Whether this is the first, focusing click.    pub first_mouse: bool,} impl Sealed for MouseDownEvent {}impl InputEvent for MouseDownEvent {    fn to_platform_input(self) -> PlatformInput {        PlatformInput::MouseDown(self)    }}impl MouseEvent for MouseDownEvent {} impl MouseDownEvent {    /// Returns true if this mouse up event should focus the element.    pub fn is_focusing(&self) -> bool {        match self.button {            MouseButton::Left => true,            _ => false,        }    }} /// A mouse up event from the platform#[derive(Clone, Debug, Default)]pub struct MouseUpEvent {    /// Which mouse button was released.    pub button: MouseButton,     /// The position of the mouse on the window.    pub position: Point<Pixels>,     /// The modifiers that were held down when the mouse was released.    pub modifiers: Modifiers,     /// The number of times the button has been clicked.    pub click_count: usize,} impl Sealed for MouseUpEvent {}impl InputEvent for MouseUpEvent {    fn to_platform_input(self) -> PlatformInput {        PlatformInput::MouseUp(self)    }} impl MouseEvent for MouseUpEvent {} impl MouseUpEvent {    /// Returns true if this mouse up event should focus the element.    pub fn is_focusing(&self) -> bool {        match self.button {            MouseButton::Left => true,            _ => false,        }    }} /// A click event, generated when a mouse button is pressed and released.#[derive(Clone, Debug, Default)]pub struct MouseClickEvent {    /// The mouse event when the button was pressed.    pub down: MouseDownEvent,     /// The mouse event when the button was released.    pub up: MouseUpEvent,} /// A click event that was generated by a keyboard button being pressed and released.#[derive(Clone, Debug, Default)]pub struct KeyboardClickEvent {    /// The keyboard button that was pressed to trigger the click.    pub button: KeyboardButton,     /// The bounds of the element that was clicked.    pub bounds: Bounds<Pixels>,} /// A click event, generated when a mouse button or keyboard button is pressed and released.#[derive(Clone, Debug)]pub enum ClickEvent {    /// A click event trigger by a mouse button being pressed and released.    Mouse(MouseClickEvent),    /// A click event trigger by a keyboard button being pressed and released.    Keyboard(KeyboardClickEvent),} impl Default for ClickEvent {    fn default() -> Self {        ClickEvent::Keyboard(KeyboardClickEvent::default())    }} impl ClickEvent {    /// Returns the modifiers that were held during the click event    ///    /// `Keyboard`: The keyboard click events never have modifiers.    /// `Mouse`: Modifiers that were held during the mouse key up event.    pub fn modifiers(&self) -> Modifiers {        match self {            // Click events are only generated from keyboard events _without any modifiers_, so we know the modifiers are always Default            ClickEvent::Keyboard(_) => Modifiers::default(),            // Click events on the web only reflect the modifiers for the keyup event,            // tested via observing the behavior of the `ClickEvent.shiftKey` field in Chrome 138            // under various combinations of modifiers and keyUp / keyDown events.            ClickEvent::Mouse(event) => event.up.modifiers,        }    }     /// Returns the position of the click event    ///    /// `Keyboard`: The bottom left corner of the clicked hitbox    /// `Mouse`: The position of the mouse when the button was released.    pub fn position(&self) -> Point<Pixels> {        match self {            ClickEvent::Keyboard(event) => event.bounds.bottom_left(),            ClickEvent::Mouse(event) => event.up.position,        }    }     /// Returns the mouse position of the click event    ///    /// `Keyboard`: None    /// `Mouse`: The position of the mouse when the button was released.    pub fn mouse_position(&self) -> Option<Point<Pixels>> {        match self {            ClickEvent::Keyboard(_) => None,            ClickEvent::Mouse(event) => Some(event.up.position),        }    }     /// Returns if this was a right click    ///    /// `Keyboard`: false    /// `Mouse`: Whether the right button was pressed and released    pub fn is_right_click(&self) -> bool {        match self {            ClickEvent::Keyboard(_) => false,            ClickEvent::Mouse(event) => {                event.down.button == MouseButton::Right && event.up.button == MouseButton::Right            }        }    }     /// Returns whether the click was a standard click    ///    /// `Keyboard`: Always true    /// `Mouse`: Left button pressed and released    pub fn standard_click(&self) -> bool {        match self {            ClickEvent::Keyboard(_) => true,            ClickEvent::Mouse(event) => {                event.down.button == MouseButton::Left && event.up.button == MouseButton::Left            }        }    }     /// Returns whether the click focused the element    ///    /// `Keyboard`: false, keyboard clicks only work if an element is already focused    /// `Mouse`: Whether this was the first focusing click    pub fn first_focus(&self) -> bool {        match self {            ClickEvent::Keyboard(_) => false,            ClickEvent::Mouse(event) => event.down.first_mouse,        }    }     /// Returns the click count of the click event    ///    /// `Keyboard`: Always 1    /// `Mouse`: Count of clicks from MouseUpEvent    pub fn click_count(&self) -> usize {        match self {            ClickEvent::Keyboard(_) => 1,            ClickEvent::Mouse(event) => event.up.click_count,        }    }     /// Returns whether the click event is generated by a keyboard event    pub fn is_keyboard(&self) -> bool {        match self {            ClickEvent::Mouse(_) => false,            ClickEvent::Keyboard(_) => true,        }    }} /// An enum representing the keyboard button that was pressed for a click event.#[derive(Hash, PartialEq, Eq, Copy, Clone, Debug, Default)]pub enum KeyboardButton {    /// Enter key was clicked    #[default]    Enter,    /// Space key was clicked    Space,} /// An enum representing the mouse button that was pressed.#[derive(Hash, PartialEq, Eq, Copy, Clone, Debug)]pub enum MouseButton {    /// The left mouse button.    Left,     /// The right mouse button.    Right,     /// The middle mouse button.    Middle,     /// A navigation button, such as back or forward.    Navigate(NavigationDirection),} impl MouseButton {    /// Get all the mouse buttons in a list.    pub fn all() -> Vec<Self> {        vec![            MouseButton::Left,            MouseButton::Right,            MouseButton::Middle,            MouseButton::Navigate(NavigationDirection::Back),            MouseButton::Navigate(NavigationDirection::Forward),        ]    }} impl Default for MouseButton {    fn default() -> Self {        Self::Left    }} /// A navigation direction, such as back or forward.#[derive(Hash, PartialEq, Eq, Copy, Clone, Debug)]pub enum NavigationDirection {    /// The back button.    Back,     /// The forward button.    Forward,} impl Default for NavigationDirection {    fn default() -> Self {        Self::Back    }} /// A mouse move event from the platform.#[derive(Clone, Debug, Default)]pub struct MouseMoveEvent {    /// The position of the mouse on the window.    pub position: Point<Pixels>,     /// The mouse button that was pressed, if any.    pub pressed_button: Option<MouseButton>,     /// The modifiers that were held down when the mouse was moved.    pub modifiers: Modifiers,} impl Sealed for MouseMoveEvent {}impl InputEvent for MouseMoveEvent {    fn to_platform_input(self) -> PlatformInput {        PlatformInput::MouseMove(self)    }}impl MouseEvent for MouseMoveEvent {} impl MouseMoveEvent {    /// Returns true if the left mouse button is currently held down.    pub fn dragging(&self) -> bool {        self.pressed_button == Some(MouseButton::Left)    }} /// A mouse wheel event from the platform.#[derive(Clone, Debug, Default)]pub struct ScrollWheelEvent {    /// The position of the mouse on the window.    pub position: Point<Pixels>,     /// The change in scroll wheel position for this event.    pub delta: ScrollDelta,     /// The modifiers that were held down when the mouse was moved.    pub modifiers: Modifiers,     /// The phase of the touch event.    pub touch_phase: TouchPhase,} impl Sealed for ScrollWheelEvent {}impl InputEvent for ScrollWheelEvent {    fn to_platform_input(self) -> PlatformInput {        PlatformInput::ScrollWheel(self)    }}impl MouseEvent for ScrollWheelEvent {} impl Deref for ScrollWheelEvent {    type Target = Modifiers;     fn deref(&self) -> &Self::Target {        &self.modifiers    }} /// The scroll delta for a scroll wheel event.#[derive(Clone, Copy, Debug)]pub enum ScrollDelta {    /// An exact scroll delta in pixels.    Pixels(Point<Pixels>),    /// An inexact scroll delta in lines.    Lines(Point<f32>),} impl Default for ScrollDelta {    fn default() -> Self {        Self::Lines(Default::default())    }} impl ScrollDelta {    /// Returns true if this is a precise scroll delta in pixels.    pub fn precise(&self) -> bool {        match self {            ScrollDelta::Pixels(_) => true,            ScrollDelta::Lines(_) => false,        }    }     /// Converts this scroll event into exact pixels.    pub fn pixel_delta(&self, line_height: Pixels) -> Point<Pixels> {        match self {            ScrollDelta::Pixels(delta) => *delta,            ScrollDelta::Lines(delta) => point(line_height * delta.x, line_height * delta.y),        }    }     /// Combines two scroll deltas into one.    /// If the signs of the deltas are the same (both positive or both negative),    /// the deltas are added together. If the signs are opposite, the second delta    /// (other) is used, effectively overriding the first delta.    pub fn coalesce(self, other: ScrollDelta) -> ScrollDelta {        match (self, other) {            (ScrollDelta::Pixels(a), ScrollDelta::Pixels(b)) => {                let x = if a.x.signum() == b.x.signum() {                    a.x + b.x                } else {                    b.x                };                 let y = if a.y.signum() == b.y.signum() {                    a.y + b.y                } else {                    b.y                };                 ScrollDelta::Pixels(point(x, y))            }             (ScrollDelta::Lines(a), ScrollDelta::Lines(b)) => {                let x = if a.x.signum() == b.x.signum() {                    a.x + b.x                } else {                    b.x                };                 let y = if a.y.signum() == b.y.signum() {                    a.y + b.y                } else {                    b.y                };                 ScrollDelta::Lines(point(x, y))            }             _ => other,        }    }} /// A mouse exit event from the platform, generated when the mouse leaves the window.#[derive(Clone, Debug, Default)]pub struct MouseExitEvent {    /// The position of the mouse relative to the window.    pub position: Point<Pixels>,    /// The mouse button that was pressed, if any.    pub pressed_button: Option<MouseButton>,    /// The modifiers that were held down when the mouse was moved.

Lines 1–500 of 696. Load more