event/key.go
Functions
func HasRune
func (e *KeyEvent) HasRune() bool {
return e.Rune != 0
}
func IsAlt
IsAlt returns true if Alt modifier is held.
func (e *KeyEvent) IsAlt() bool {
return e.Modifiers().IsAlt()
}
func IsCtrl
IsCtrl returns true if Ctrl modifier is held.
func (e *KeyEvent) IsCtrl() bool {
return e.Modifiers().IsCtrl()
}
func IsDigit
IsDigit returns true if the key is a digit key (0-9).
func (k Key) IsDigit() bool {
return k >= Key0 && k <= Key9
}
func IsFunction
IsFunction returns true if the key is a function key (F1-F24).
func (k Key) IsFunction() bool {
return k >= KeyF1 && k <= KeyF24
}
func IsLetter
IsLetter returns true if the key is a letter key (A-Z).
func (k Key) IsLetter() bool {
return k >= KeyA && k <= KeyZ
}
func IsModifier
IsModifier returns true if the key is a modifier key.
func (k Key) IsModifier() bool {
return k >= KeyLeftShift && k <= KeyScrollLock
}
func IsNumpad
IsNumpad returns true if the key is a numpad key.
func (k Key) IsNumpad() bool {
return k >= KeyNumpad0 && k <= KeyNumpadDivide
}
func IsPress
IsPress returns true if this is a key press event.
func (e *KeyEvent) IsPress() bool {
return e.KeyType == KeyPress
}
func IsRelease
IsRelease returns true if this is a key release event.
func (e *KeyEvent) IsRelease() bool {
return e.KeyType == KeyRelease
}
func IsRepeat
IsRepeat returns true if this is a key repeat event.
func (e *KeyEvent) IsRepeat() bool {
return e.KeyType == KeyRepeat
}
func IsShift
IsShift returns true if Shift modifier is held.
func (e *KeyEvent) IsShift() bool {
return e.Modifiers().IsShift()
}
func IsSuper
IsSuper returns true if Super modifier is held.
func (e *KeyEvent) IsSuper() bool {
return e.Modifiers().IsSuper()
}
func NewKeyEvent
NewKeyEvent creates a new key event with the current time.
func NewKeyEvent(keyType KeyEventType, key Key, r rune, mods Modifiers) *KeyEvent {
return &KeyEvent{
Base: NewBase(TypeKey, mods),
KeyType: keyType,
Key: key,
Rune: r,
}
}
func NewKeyEventWithTime
NewKeyEventWithTime creates a new key event with a specific timestamp.
func NewKeyEventWithTime(keyType KeyEventType, key Key, r rune, mods Modifiers, t time.Time) *KeyEvent {
return &KeyEvent{
Base: NewBaseWithTime(TypeKey, t, mods),
KeyType: keyType,
Key: key,
Rune: r,
}
}
func String
String returns a human-readable name for the key event type.
func (t KeyEventType) String() string {
switch t {
case KeyPress:
return keyPressStr
case KeyRelease:
return keyReleaseStr
case KeyRepeat:
return keyRepeatStr
default:
return unknownStr
}
}
func String
String returns a human-readable name for the key.
nolint:gocyclo,cyclop,funlen,maintidx // Key mapping requires a large switch statement by design
func (k Key) String() string {
switch k {
case KeyUnknown:
return unknownStr
case KeyA:
return "A"
case KeyB:
return "B"
case KeyC:
return "C"
case KeyD:
return "D"
case KeyE:
return "E"
case KeyF:
return "F"
case KeyG:
return "G"
case KeyH:
return "H"
case KeyI:
return "I"
case KeyJ:
return "J"
case KeyK:
return "K"
case KeyL:
return "L"
case KeyM:
return "M"
case KeyN:
return "N"
case KeyO:
return "O"
case KeyP:
return "P"
case KeyQ:
return "Q"
case KeyR:
return "R"
case KeyS:
return "S"
case KeyT:
return "T"
case KeyU:
return "U"
case KeyV:
return "V"
case KeyW:
return "W"
case KeyX:
return "X"
case KeyY:
return "Y"
case KeyZ:
return "Z"
case Key0:
return "0"
case Key1:
return "1"
case Key2:
return "2"
case Key3:
return "3"
case Key4:
return "4"
case Key5:
return "5"
case Key6:
return "6"
case Key7:
return "7"
case Key8:
return "8"
case Key9:
return "9"
case KeyF1:
return "F1"
case KeyF2:
return "F2"
case KeyF3:
return "F3"
case KeyF4:
return "F4"
case KeyF5:
return "F5"
case KeyF6:
return "F6"
case KeyF7:
return "F7"
case KeyF8:
return "F8"
case KeyF9:
return "F9"
case KeyF10:
return "F10"
case KeyF11:
return "F11"
case KeyF12:
return keyF12Str
case KeyF13:
return "F13"
case KeyF14:
return "F14"
case KeyF15:
return "F15"
case KeyF16:
return "F16"
case KeyF17:
return "F17"
case KeyF18:
return "F18"
case KeyF19:
return "F19"
case KeyF20:
return "F20"
case KeyF21:
return "F21"
case KeyF22:
return "F22"
case KeyF23:
return "F23"
case KeyF24:
return keyF24Str
case KeyUp:
return "Up"
case KeyDown:
return keyDownStr
case KeyLeft:
return keyLeftStr
case KeyRight:
return keyRightStr
case KeyHome:
return keyHomeStr
case KeyEnd:
return keyEndStr
case KeyPageUp:
return keyPageUpStr
case KeyPageDown:
return keyPageDownStr
case KeyEnter:
return keyEnterStr
case KeyTab:
return keyTabStr
case KeyBackspace:
return keyBackspaceStr
case KeyDelete:
return keyDeleteStr
case KeyInsert:
return "Insert"
case KeyEscape:
return keyEscapeStr
case KeySpace:
return keySpaceStr
case KeyLeftShift:
return keyLeftShiftStr
case KeyRightShift:
return keyRightShiftStr
case KeyLeftCtrl:
return keyLeftCtrlStr
case KeyRightCtrl:
return keyRightCtrlStr
case KeyLeftAlt:
return keyLeftAltStr
case KeyRightAlt:
return keyRightAltStr
case KeyLeftSuper:
return keyLeftSuperStr
case KeyRightSuper:
return keyRightSuperStr
case KeyCapsLock:
return keyCapsLockStr
case KeyNumLock:
return keyNumLockStr
case KeyScrollLock:
return keyScrollLockStr
case KeyNumpad0:
return keyNumpad0Str
case KeyNumpad1:
return "Numpad1"
case KeyNumpad2:
return "Numpad2"
case KeyNumpad3:
return "Numpad3"
case KeyNumpad4:
return "Numpad4"
case KeyNumpad5:
return "Numpad5"
case KeyNumpad6:
return "Numpad6"
case KeyNumpad7:
return "Numpad7"
case KeyNumpad8:
return "Numpad8"
case KeyNumpad9:
return keyNumpad9Str
case KeyNumpadDecimal:
return keyNumpadDecimalStr
case KeyNumpadEnter:
return keyNumpadEnterStr
case KeyNumpadAdd:
return keyNumpadAddStr
case KeyNumpadSubtract:
return keyNumpadSubtractStr
case KeyNumpadMultiply:
return keyNumpadMultiplyStr
case KeyNumpadDivide:
return keyNumpadDivideStr
case KeyMinus:
return keyMinusStr
case KeyEqual:
return keyEqualStr
case KeyLeftBracket:
return keyLeftBracketStr
case KeyRightBracket:
return keyRightBracketStr
case KeyBackslash:
return keyBackslashStr
case KeySemicolon:
return keySemicolonStr
case KeyApostrophe:
return keyApostropheStr
case KeyGrave:
return keyGraveStr
case KeyComma:
return keyCommaStr
case KeyPeriod:
return keyPeriodStr
case KeySlash:
return keySlashStr
case KeyPrintScreen:
return keyPrintScreenStr
case KeyPause:
return keyPauseStr
case KeyMenu:
return keyMenuStr
case KeyMute:
return keyMuteStr
case KeyVolumeUp:
return keyVolumeUpStr
case KeyVolumeDown:
return keyVolumeDownStr
case KeyMediaPlay:
return keyMediaPlayStr
case KeyMediaStop:
return keyMediaStopStr
case KeyMediaNext:
return keyMediaNextStr
case KeyMediaPrev:
return keyMediaPrevStr
default:
return fmt.Sprintf("Key(%d)", k)
}
}
func String
String returns a human-readable representation of the event.
func (e *KeyEvent) String() string {
if e.HasRune() {
return fmt.Sprintf("KeyEvent{Type: %s, Key: %s, Rune: %q, Mods: %s}",
e.KeyType, e.Key, e.Rune, e.Modifiers())
}
return fmt.Sprintf("KeyEvent{Type: %s, Key: %s, Mods: %s}",
e.KeyType, e.Key, e.Modifiers())
}
Structs
type KeyEvent struct
KeyEvent represents a keyboard input event.
Key represents the physical key pressed.
Rune contains the character that was typed (if applicable).
type KeyEvent struct {
Base
// KeyType is the specific type of key event.
KeyType KeyEventType
// Key is the key code that was pressed/released.
Key Key
// Rune is the character that was typed, or 0 if not applicable.
// For example, pressing 'A' with Shift produces Rune='A'.
// Pressing 'F1' produces Rune=0.
Rune rune
// ScanCode is the platform-specific scan code.
ScanCode uint32
}
HasRune returns true if a character was typed.