use std::path::PathBuf; use {WindowId, DeviceId}; /// Describes a generic event. #[derive(Clone, Debug)] pub enum Event { WindowEvent { window_id: WindowId, event: WindowEvent, }, DeviceEvent { device_id: DeviceId, event: DeviceEvent, }, Awakened, /// The application has been suspended or resumed. /// /// The parameter is true if app was suspended, and false if it has been resumed. Suspended(bool), } /// Describes an event from a `Window`. #[derive(Clone, Debug)] pub enum WindowEvent { /// The size of the window has changed. Contains the client area's new dimensions. Resized(u32, u32), /// The position of the window has changed. Contains the window's new position. Moved(i32, i32), /// The window has been requested to close. CloseRequested, /// The window has been destroyed. Destroyed, /// A file has been dropped into the window. DroppedFile(PathBuf), /// A file is being hovered over the window. HoveredFile(PathBuf), /// A file was hovered, but has exited the window. HoveredFileCancelled, /// The window received a unicode character. ReceivedCharacter(char), /// The window gained or lost focus. /// /// The parameter is true if the window has gained focus, and false if it has lost focus. Focused(bool), /// An event from the keyboard has been received. KeyboardInput { device_id: DeviceId, input: KeyboardInput }, /// The cursor has moved on the window. CursorMoved { device_id: DeviceId, /// (x,y) coords in pixels relative to the top-left corner of the window. Because the range of this data is /// limited by the display area and it may have been transformed by the OS to implement effects such as cursor /// acceleration, it should not be used to implement non-cursor-like interactions such as 3D camera control. position: (f64, f64), modifiers: ModifiersState }, /// The cursor has entered the window. CursorEntered { device_id: DeviceId }, /// The cursor has left the window. CursorLeft { device_id: DeviceId }, /// A mouse wheel movement or touchpad scroll occurred. MouseWheel { device_id: DeviceId, delta: MouseScrollDelta, phase: TouchPhase, modifiers: ModifiersState }, /// An mouse button press has been received. MouseInput { device_id: DeviceId, state: ElementState, button: MouseButton, modifiers: ModifiersState }, /// Touchpad pressure event. /// /// At the moment, only supported on Apple forcetouch-capable macbooks. /// The parameters are: pressure level (value between 0 and 1 representing how hard the touchpad /// is being pressed) and stage (integer representing the click level). TouchpadPressure { device_id: DeviceId, pressure: f32, stage: i64 }, /// Motion on some analog axis. May report data redundant to other, more specific events. AxisMotion { device_id: DeviceId, axis: AxisId, value: f64 }, /// The window needs to be redrawn. Refresh, /// Touch event has been received Touch(Touch), /// DPI scaling factor of the window has changed. /// /// The following actions cause DPI changes: /// /// * A user changes the resolution. /// * A user changes the desktop scaling value (e.g. in Control Panel on Windows). /// * A user moves the application window to a display with a different DPI. HiDPIFactorChanged(f32), } /// Represents raw hardware events that are not associated with any particular window. /// /// Useful for interactions that diverge significantly from a conventional 2D GUI, such as 3D camera or first-person /// game controls. Many physical actions, such as mouse movement, can produce both device and window events. Because /// window events typically arise from virtual devices (corresponding to GUI cursors and keyboard focus) the device IDs /// may not match. /// /// Note that these events are delivered regardless of input focus. #[derive(Clone, Debug)] pub enum DeviceEvent { Added, Removed, /// Change in physical position of a pointing device. /// /// This represents raw, unfiltered physical motion. Not to be confused with `WindowEvent::CursorMoved`. MouseMotion { /// (x, y) change in position in unspecified units. /// /// Different devices may use different units. delta: (f64, f64), }, /// Physical scroll event MouseWheel { delta: MouseScrollDelta, }, /// Motion on some analog axis. This event will be reported for all arbitrary input devices /// that winit supports on this platform, including mouse devices. If the device is a mouse /// device then this will be reported alongside the MouseMotion event. Motion { axis: AxisId, value: f64 }, Button { button: ButtonId, state: ElementState }, Key(KeyboardInput), Text { codepoint: char }, } /// Describes a keyboard input event. #[derive(Debug, Clone, Copy)] pub struct KeyboardInput { /// Identifies the physical key pressed /// /// This should not change if the user adjusts the host's keyboard map. Use when the physical location of the /// key is more important than the key's host GUI semantics, such as for movement controls in a first-person /// game. pub scancode: ScanCode, pub state: ElementState, /// Identifies the semantic meaning of the key /// /// Use when the semantics of the key are more important than the physical location of the key, such as when /// implementing appropriate behavior for "page up." pub virtual_keycode: Option, /// Modifier keys active at the time of this input. /// /// This is tracked internally to avoid tracking errors arising from modifier key state changes when events from /// this device are not being delivered to the application, e.g. due to keyboard focus being elsewhere. pub modifiers: ModifiersState } /// Describes touch-screen input state. #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)] pub enum TouchPhase { Started, Moved, Ended, Cancelled } /// Represents touch event /// /// Every time user touches screen new Start event with some finger id is generated. /// When the finger is removed from the screen End event with same id is generated. /// /// For every id there will be at least 2 events with phases Start and End (or Cancelled). /// There may be 0 or more Move events. /// /// /// Depending on platform implementation id may or may not be reused by system after End event. /// /// Gesture regonizer using this event should assume that Start event received with same id /// as previously received End event is a new finger and has nothing to do with an old one. /// /// Touch may be cancelled if for example window lost focus. #[derive(Debug, Clone, Copy)] pub struct Touch { pub device_id: DeviceId, pub phase: TouchPhase, pub location: (f64,f64), /// unique identifier of a finger. pub id: u64 } /// Hardware-dependent keyboard scan code. pub type ScanCode = u32; /// Identifier for a specific analog axis on some device. pub type AxisId = u32; /// Identifier for a specific button on some device. pub type ButtonId = u32; /// Describes the input state of a key. #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)] pub enum ElementState { Pressed, Released, } /// Describes a button of a mouse controller. #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)] pub enum MouseButton { Left, Right, Middle, Other(u8), } /// Describes a difference in the mouse scroll wheel state. #[derive(Debug, Clone, Copy, PartialEq)] pub enum MouseScrollDelta { /// Amount in lines or rows to scroll in the horizontal /// and vertical directions. /// /// Positive values indicate movement forward /// (away from the user) or rightwards. LineDelta(f32, f32), /// Amount in pixels to scroll in the horizontal and /// vertical direction. /// /// Scroll events are expressed as a PixelDelta if /// supported by the device (eg. a touchpad) and /// platform. PixelDelta(f32, f32) } /// Symbolic name for a keyboard key. #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)] #[repr(u32)] pub enum VirtualKeyCode { /// The '1' key over the letters. Key1, /// The '2' key over the letters. Key2, /// The '3' key over the letters. Key3, /// The '4' key over the letters. Key4, /// The '5' key over the letters. Key5, /// The '6' key over the letters. Key6, /// The '7' key over the letters. Key7, /// The '8' key over the letters. Key8, /// The '9' key over the letters. Key9, /// The '0' key over the 'O' and 'P' keys. Key0, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, /// The Escape key, next to F1. Escape, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, /// Print Screen/SysRq. Snapshot, /// Scroll Lock. Scroll, /// Pause/Break key, next to Scroll lock. Pause, /// `Insert`, next to Backspace. Insert, Home, Delete, End, PageDown, PageUp, Left, Up, Right, Down, /// The Backspace key, right over Enter. // TODO: rename Back, /// The Enter key. Return, /// The space bar. Space, /// The "Compose" key on Linux. Compose, Caret, Numlock, Numpad0, Numpad1, Numpad2, Numpad3, Numpad4, Numpad5, Numpad6, Numpad7, Numpad8, Numpad9, AbntC1, AbntC2, Add, Apostrophe, Apps, At, Ax, Backslash, Calculator, Capital, Colon, Comma, Convert, Decimal, Divide, Equals, Grave, Kana, Kanji, LAlt, LBracket, LControl, LMenu, LShift, LWin, Mail, MediaSelect, MediaStop, Minus, Multiply, Mute, MyComputer, NavigateForward, // also called "Prior" NavigateBackward, // also called "Next" NextTrack, NoConvert, NumpadComma, NumpadEnter, NumpadEquals, OEM102, Period, PlayPause, Power, PrevTrack, RAlt, RBracket, RControl, RMenu, RShift, RWin, Semicolon, Slash, Sleep, Stop, Subtract, Sysrq, Tab, Underline, Unlabeled, VolumeDown, VolumeUp, Wake, WebBack, WebFavorites, WebForward, WebHome, WebRefresh, WebSearch, WebStop, Yen, } /// Represents the current state of the keyboard modifiers /// /// Each field of this struct represents a modifier and is `true` if this modifier is active. #[derive(Default, Debug, Hash, PartialEq, Eq, Clone, Copy)] pub struct ModifiersState { /// The "shift" key pub shift: bool, /// The "control" key pub ctrl: bool, /// The "alt" key pub alt: bool, /// The "logo" key /// /// This is the "windows" key on PC and "command" key on Mac. pub logo: bool }