1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
//! User-input events and their effects. //! //! * Every user input the application receives is converted to an //! [`Event`](./enum.Event.html). //! * Each event is then given to the root, and descends the view tree down to //! the view currently in focus, through the //! [`on_event`](../view/trait.View.html#method.on_event) method. //! * If the view consumes the event, it may return a callback to be //! executed. //! * Otherwise, it ignores the event, and the view parent can in turn //! choose to consume it or not. //! * If no view consumes the event, the //! [global callback](../struct.Cursive.html#method.add_global_callback) //! table is checked. use std::rc::Rc; use Cursive; /// Callback is a function that can be triggered by an event. /// It has a mutable access to the cursive root. pub type Callback = Rc<Fn(&mut Cursive)>; /// Answer to an event notification. /// The event can be consumed or ignored. pub enum EventResult { /// The event was ignored. The parent can keep handling it. Ignored, /// The event was consumed. An optionnal callback to run is attached. Consumed(Option<Callback>), } impl EventResult { /// Convenient method to create `Consumed(Some(f))` pub fn with_cb<F: 'static + Fn(&mut Cursive)>(f: F) -> Self { EventResult::Consumed(Some(Rc::new(f))) } /// Returns `true` if `self` is `EventResult::Consumed`. pub fn is_consumed(&self) -> bool { match *self { EventResult::Consumed(_) => true, EventResult::Ignored => false, } } } /// A non-character key on the keyboard #[derive(PartialEq,Eq,Clone,Copy,Hash,Debug)] pub enum Key { /// Both Enter (or Return) and numpad Enter Enter, /// Tabulation key Tab, /// Backspace key Backspace, /// Escape key Esc, /// Left arrow Left, /// Right arrow Right, /// Up arrow Up, /// Down arrow Down, /// Insert key Ins, /// Delete key Del, /// Home key Home, /// End key End, /// Page Up key PageUp, /// Page Down key PageDown, /// The 5 in the center of the keypad, when numlock is disabled. NumpadCenter, /// F1 key F1, /// F2 key F2, /// F3 key F3, /// F4 key F4, /// F5 key F5, /// F6 key F6, /// F7 key F7, /// F8 key F8, /// F9 key F9, /// F10 key F10, /// F11 key F11, /// F12 key F12, } impl Key { /// Returns the function key corresponding to the given number /// /// 1 -> F1, etc... /// /// # Panics /// /// If `n == 0 || n > 12` pub fn from_f(n: u8) -> Key { match n { 1 => Key::F1, 2 => Key::F2, 3 => Key::F3, 4 => Key::F4, 5 => Key::F5, 6 => Key::F6, 7 => Key::F7, 8 => Key::F8, 9 => Key::F9, 10 => Key::F10, 11 => Key::F11, 12 => Key::F12, _ => panic!("unknown function key: F{}", n), } } } /// Represents an event as seen by the application. #[derive(PartialEq,Eq,Clone,Copy,Hash,Debug)] pub enum Event { /// Event fired when the window is resized WindowResize, /// A character was entered (includes numbers, punctuation, ...) Char(char), /// A character was entered with the Ctrl key pressed CtrlChar(char), /// A character was entered with the Alt key pressed AltChar(char), /// A non-character key was pressed Key(Key), /// A non-character key was pressed with the Shift key pressed Shift(Key), /// A non-character key was pressed with the Alt key pressed Alt(Key), /// A non-character key was pressed with the Shift and Alt keys pressed AltShift(Key), /// A non-character key was pressed with the Ctrl key pressed Ctrl(Key), /// A non-character key was pressed with the Ctrl and Shift keys pressed CtrlShift(Key), /// A non-character key was pressed with the Ctrl and Alt keys pressed CtrlAlt(Key), /// An unknown event was received. Unknown(i32), } impl From<char> for Event { fn from(c: char) -> Event { Event::Char(c) } } impl From<Key> for Event { fn from(k: Key) -> Event { Event::Key(k) } }