github.com/as/shiny@v0.8.2/event/key/key.go (about) 1 // Copyright 2015 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 //go:generate stringer -type=Code 6 7 package key 8 9 import ( 10 "fmt" 11 "strings" 12 ) 13 14 // Event is a key event. 15 type Event struct { 16 // Rune is the meaning of the key event as determined by the 17 // operating system. The mapping is determined by system-dependent 18 // current layout, modifiers, lock-states, etc. 19 // 20 // If non-negative, it is a Unicode codepoint: pressing the 'a' key 21 // generates different Runes 'a' or 'A' (but the same Code) depending on 22 // the state of the shift key. 23 // 24 // If -1, the key does not generate a Unicode codepoint. To distinguish 25 // them, look at Code. 26 Rune rune 27 28 // Code is the identity of the physical key relative to a notional 29 // "standard" keyboard, independent of current layout, modifiers, 30 // lock-states, etc 31 // 32 // For standard key codes, its value matches USB HID key codes. 33 // Compare its value to uint32-typed constants in this package, such 34 // as CodeLeftShift and CodeEscape. 35 // 36 // Pressing the regular '2' key and number-pad '2' key (with Num-Lock) 37 // generate different Codes (but the same Rune). 38 Code Code 39 40 // Modifiers is a bitmask representing a set of modifier keys: ModShift, 41 // ModAlt, etc. 42 Modifiers Modifiers 43 44 // Direction is the direction of the key event: DirPress, DirRelease, 45 // or DirNone (for key repeats). 46 Direction Direction 47 48 // TODO: add a Device ID, for multiple input devices? 49 // TODO: add a time.Time? 50 } 51 52 func (e Event) String() string { 53 if e.Rune >= 0 { 54 return fmt.Sprintf("key.Event{%q (%v), %v, %v}", e.Rune, e.Code, e.Modifiers, e.Direction) 55 } 56 return fmt.Sprintf("key.Event{(%v), %v, %v}", e.Code, e.Modifiers, e.Direction) 57 } 58 59 // Direction is the direction of the key event. 60 type Direction uint8 61 62 const ( 63 DirNone Direction = 0 64 DirPress Direction = 1 65 DirRelease Direction = 2 66 ) 67 68 // Modifiers is a bitmask representing a set of modifier keys. 69 type Modifiers uint32 70 71 const ( 72 ModShift Modifiers = 1 << 0 73 ModControl Modifiers = 1 << 1 74 ModAlt Modifiers = 1 << 2 75 ModMeta Modifiers = 1 << 3 // called "Command" on OS X 76 ) 77 78 // Code is the identity of a key relative to a notional "standard" keyboard. 79 type Code uint32 80 81 // Physical key codes. 82 // 83 // For standard key codes, its value matches USB HID key codes. 84 // TODO: add missing codes. 85 const ( 86 CodeUnknown Code = 0 87 88 CodeA Code = 4 89 CodeB Code = 5 90 CodeC Code = 6 91 CodeD Code = 7 92 CodeE Code = 8 93 CodeF Code = 9 94 CodeG Code = 10 95 CodeH Code = 11 96 CodeI Code = 12 97 CodeJ Code = 13 98 CodeK Code = 14 99 CodeL Code = 15 100 CodeM Code = 16 101 CodeN Code = 17 102 CodeO Code = 18 103 CodeP Code = 19 104 CodeQ Code = 20 105 CodeR Code = 21 106 CodeS Code = 22 107 CodeT Code = 23 108 CodeU Code = 24 109 CodeV Code = 25 110 CodeW Code = 26 111 CodeX Code = 27 112 CodeY Code = 28 113 CodeZ Code = 29 114 115 Code1 Code = 30 116 Code2 Code = 31 117 Code3 Code = 32 118 Code4 Code = 33 119 Code5 Code = 34 120 Code6 Code = 35 121 Code7 Code = 36 122 Code8 Code = 37 123 Code9 Code = 38 124 Code0 Code = 39 125 126 CodeReturnEnter Code = 40 127 CodeEscape Code = 41 128 CodeDeleteBackspace Code = 42 129 CodeTab Code = 43 130 CodeSpacebar Code = 44 131 CodeHyphenMinus Code = 45 // - 132 CodeEqualSign Code = 46 // = 133 CodeLeftSquareBracket Code = 47 // [ 134 CodeRightSquareBracket Code = 48 // ] 135 CodeBackslash Code = 49 // \ 136 CodeSemicolon Code = 51 // ; 137 CodeApostrophe Code = 52 // ' 138 CodeGraveAccent Code = 53 // ` 139 CodeComma Code = 54 // , 140 CodeFullStop Code = 55 // . 141 CodeSlash Code = 56 // / 142 CodeCapsLock Code = 57 143 144 CodeF1 Code = 58 145 CodeF2 Code = 59 146 CodeF3 Code = 60 147 CodeF4 Code = 61 148 CodeF5 Code = 62 149 CodeF6 Code = 63 150 CodeF7 Code = 64 151 CodeF8 Code = 65 152 CodeF9 Code = 66 153 CodeF10 Code = 67 154 CodeF11 Code = 68 155 CodeF12 Code = 69 156 157 CodePause Code = 72 158 CodeInsert Code = 73 159 CodeHome Code = 74 160 CodePageUp Code = 75 161 CodeDeleteForward Code = 76 162 CodeEnd Code = 77 163 CodePageDown Code = 78 164 165 CodeRightArrow Code = 79 166 CodeLeftArrow Code = 80 167 CodeDownArrow Code = 81 168 CodeUpArrow Code = 82 169 170 CodeKeypadNumLock Code = 83 171 CodeKeypadSlash Code = 84 // / 172 CodeKeypadAsterisk Code = 85 // * 173 CodeKeypadHyphenMinus Code = 86 // - 174 CodeKeypadPlusSign Code = 87 // + 175 CodeKeypadEnter Code = 88 176 CodeKeypad1 Code = 89 177 CodeKeypad2 Code = 90 178 CodeKeypad3 Code = 91 179 CodeKeypad4 Code = 92 180 CodeKeypad5 Code = 93 181 CodeKeypad6 Code = 94 182 CodeKeypad7 Code = 95 183 CodeKeypad8 Code = 96 184 CodeKeypad9 Code = 97 185 CodeKeypad0 Code = 98 186 CodeKeypadFullStop Code = 99 // . 187 CodeKeypadEqualSign Code = 103 // = 188 189 CodeF13 Code = 104 190 CodeF14 Code = 105 191 CodeF15 Code = 106 192 CodeF16 Code = 107 193 CodeF17 Code = 108 194 CodeF18 Code = 109 195 CodeF19 Code = 110 196 CodeF20 Code = 111 197 CodeF21 Code = 112 198 CodeF22 Code = 113 199 CodeF23 Code = 114 200 CodeF24 Code = 115 201 202 CodeHelp Code = 117 203 204 CodeMute Code = 127 205 CodeVolumeUp Code = 128 206 CodeVolumeDown Code = 129 207 208 CodeLeftControl Code = 224 209 CodeLeftShift Code = 225 210 CodeLeftAlt Code = 226 211 CodeLeftGUI Code = 227 212 CodeRightControl Code = 228 213 CodeRightShift Code = 229 214 CodeRightAlt Code = 230 215 CodeRightGUI Code = 231 216 217 // The following codes are not part of the standard USB HID Usage IDs for 218 // keyboards. See http://www.usb.org/developers/hidpage/Hut1_12v2.pdf 219 // 220 // Usage IDs are uint16s, so these non-standard values start at 0x10000. 221 222 // CodeCompose is the Code for a compose key, sometimes called a multi key, 223 // used to input non-ASCII characters such as ñ being composed of n and ~. 224 // 225 // See https://en.wikipedia.org/wiki/Compose_key 226 CodeCompose Code = 0x10000 227 ) 228 229 // TODO: Given we use runes outside the unicode space, should we provide a 230 // printing function? Related: it's a little unfortunate that printing a 231 // key.Event with %v gives not very readable output like: 232 // {100 7 key.Modifiers() Press} 233 234 var mods = [...]struct { 235 m Modifiers 236 s string 237 }{ 238 {ModShift, "Shift"}, 239 {ModControl, "Control"}, 240 {ModAlt, "Alt"}, 241 {ModMeta, "Meta"}, 242 } 243 244 func (m Modifiers) String() string { 245 var match []string 246 for _, mod := range mods { 247 if mod.m&m != 0 { 248 match = append(match, mod.s) 249 } 250 } 251 return "key.Modifiers(" + strings.Join(match, "|") + ")" 252 } 253 254 func (d Direction) String() string { 255 switch d { 256 case DirNone: 257 return "None" 258 case DirPress: 259 return "Press" 260 case DirRelease: 261 return "Release" 262 default: 263 return fmt.Sprintf("key.Direction(%d)", d) 264 } 265 }