Skip to content
Permalink
master
Switch branches/tags
Go to file
 
 
Cannot retrieve contributors at this time
323 lines (295 sloc) 7.78 KB
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
//go:generate go run gen.go
// x11key contains X11 numeric codes for the keyboard and mouse.
package x11key // import "golang.org/x/exp/shiny/driver/internal/x11key"
import (
"unicode"
"golang.org/x/mobile/event/key"
)
// These constants come from /usr/include/X11/X.h
const (
ShiftMask = 1 << 0
LockMask = 1 << 1
ControlMask = 1 << 2
Mod1Mask = 1 << 3
Mod2Mask = 1 << 4
Mod3Mask = 1 << 5
Mod4Mask = 1 << 6
Mod5Mask = 1 << 7
Button1Mask = 1 << 8
Button2Mask = 1 << 9
Button3Mask = 1 << 10
Button4Mask = 1 << 11
Button5Mask = 1 << 12
)
type KeysymTable struct {
Table [256][6]uint32
NumLockMod, ModeSwitchMod, ISOLevel3ShiftMod uint16
}
func (t *KeysymTable) Lookup(detail uint8, state uint16) (rune, key.Code) {
te := t.Table[detail][0:2]
if state&t.ModeSwitchMod != 0 {
te = t.Table[detail][2:4]
}
if state&t.ISOLevel3ShiftMod != 0 {
te = t.Table[detail][4:6]
}
// The key event's rune depends on whether the shift key is down.
unshifted := rune(te[0])
r := unshifted
if state&t.NumLockMod != 0 && isKeypad(te[1]) {
if state&ShiftMask == 0 {
r = rune(te[1])
}
} else if state&ShiftMask != 0 {
r = rune(te[1])
// In X11, a zero keysym when shift is down means to use what the
// keysym is when shift is up.
if r == 0 {
r = unshifted
}
}
// The key event's code is independent of whether the shift key is down.
var c key.Code
if 0 <= unshifted && unshifted < 0x80 {
c = asciiKeycodes[unshifted]
if state&LockMask != 0 {
r = unicode.ToUpper(r)
}
} else if kk, isKeypad := keypadKeysyms[r]; isKeypad {
r, c = kk.rune, kk.code
} else if nuk := nonUnicodeKeycodes[unshifted]; nuk != key.CodeUnknown {
r, c = -1, nuk
} else {
r = keysymCodePoints[r]
if state&LockMask != 0 {
r = unicode.ToUpper(r)
}
}
return r, c
}
func isKeypad(keysym uint32) bool {
return keysym >= 0xff80 && keysym <= 0xffbd
}
func KeyModifiers(state uint16) (m key.Modifiers) {
if state&ShiftMask != 0 {
m |= key.ModShift
}
if state&ControlMask != 0 {
m |= key.ModControl
}
if state&Mod1Mask != 0 {
m |= key.ModAlt
}
if state&Mod4Mask != 0 {
m |= key.ModMeta
}
return m
}
// These constants come from /usr/include/X11/{keysymdef,XF86keysym}.h
const (
xkISOLeftTab = 0xfe20
xkBackSpace = 0xff08
xkTab = 0xff09
xkReturn = 0xff0d
xkEscape = 0xff1b
xkMultiKey = 0xff20
xkHome = 0xff50
xkLeft = 0xff51
xkUp = 0xff52
xkRight = 0xff53
xkDown = 0xff54
xkPageUp = 0xff55
xkPageDown = 0xff56
xkEnd = 0xff57
xkInsert = 0xff63
xkMenu = 0xff67
xkHelp = 0xff6a
xkNumLock = 0xff7f
xkKeypadEnter = 0xff8d
xkKeypadHome = 0xff95
xkKeypadLeft = 0xff96
xkKeypadUp = 0xff97
xkKeypadRight = 0xff98
xkKeypadDown = 0xff99
xkKeypadPageUp = 0xff9a
xkKeypadPageDown = 0xff9b
xkKeypadEnd = 0xff9c
xkKeypadInsert = 0xff9e
xkKeypadDelete = 0xff9f
xkKeypadEqual = 0xffbd
xkKeypadMultiply = 0xffaa
xkKeypadAdd = 0xffab
xkKeypadSubtract = 0xffad
xkKeypadDecimal = 0xffae
xkKeypadDivide = 0xffaf
xkKeypad0 = 0xffb0
xkKeypad1 = 0xffb1
xkKeypad2 = 0xffb2
xkKeypad3 = 0xffb3
xkKeypad4 = 0xffb4
xkKeypad5 = 0xffb5
xkKeypad6 = 0xffb6
xkKeypad7 = 0xffb7
xkKeypad8 = 0xffb8
xkKeypad9 = 0xffb9
xkF1 = 0xffbe
xkF2 = 0xffbf
xkF3 = 0xffc0
xkF4 = 0xffc1
xkF5 = 0xffc2
xkF6 = 0xffc3
xkF7 = 0xffc4
xkF8 = 0xffc5
xkF9 = 0xffc6
xkF10 = 0xffc7
xkF11 = 0xffc8
xkF12 = 0xffc9
xkShiftL = 0xffe1
xkShiftR = 0xffe2
xkControlL = 0xffe3
xkControlR = 0xffe4
xkCapsLock = 0xffe5
xkAltL = 0xffe9
xkAltR = 0xffea
xkSuperL = 0xffeb
xkSuperR = 0xffec
xkDelete = 0xffff
xf86xkAudioLowerVolume = 0x1008ff11
xf86xkAudioMute = 0x1008ff12
xf86xkAudioRaiseVolume = 0x1008ff13
)
// nonUnicodeKeycodes maps from those xproto.Keysym values (converted to runes)
// that do not correspond to a Unicode code point, such as "Page Up", "F1" or
// "Left Shift", to key.Code values.
var nonUnicodeKeycodes = map[rune]key.Code{
xkISOLeftTab: key.CodeTab,
xkBackSpace: key.CodeDeleteBackspace,
xkTab: key.CodeTab,
xkReturn: key.CodeReturnEnter,
xkEscape: key.CodeEscape,
xkHome: key.CodeHome,
xkLeft: key.CodeLeftArrow,
xkUp: key.CodeUpArrow,
xkRight: key.CodeRightArrow,
xkDown: key.CodeDownArrow,
xkPageUp: key.CodePageUp,
xkPageDown: key.CodePageDown,
xkEnd: key.CodeEnd,
xkInsert: key.CodeInsert,
xkMenu: key.CodeRightGUI, // TODO: CodeRightGUI or CodeMenu??
xkHelp: key.CodeHelp,
xkNumLock: key.CodeKeypadNumLock,
xkMultiKey: key.CodeCompose,
xkKeypadEnter: key.CodeKeypadEnter,
xkKeypadHome: key.CodeHome,
xkKeypadLeft: key.CodeLeftArrow,
xkKeypadUp: key.CodeUpArrow,
xkKeypadRight: key.CodeRightArrow,
xkKeypadDown: key.CodeDownArrow,
xkKeypadPageUp: key.CodePageUp,
xkKeypadPageDown: key.CodePageDown,
xkKeypadEnd: key.CodeEnd,
xkKeypadInsert: key.CodeInsert,
xkKeypadDelete: key.CodeDeleteForward,
xkF1: key.CodeF1,
xkF2: key.CodeF2,
xkF3: key.CodeF3,
xkF4: key.CodeF4,
xkF5: key.CodeF5,
xkF6: key.CodeF6,
xkF7: key.CodeF7,
xkF8: key.CodeF8,
xkF9: key.CodeF9,
xkF10: key.CodeF10,
xkF11: key.CodeF11,
xkF12: key.CodeF12,
xkShiftL: key.CodeLeftShift,
xkShiftR: key.CodeRightShift,
xkControlL: key.CodeLeftControl,
xkControlR: key.CodeRightControl,
xkCapsLock: key.CodeCapsLock,
xkAltL: key.CodeLeftAlt,
xkAltR: key.CodeRightAlt,
xkSuperL: key.CodeLeftGUI,
xkSuperR: key.CodeRightGUI,
xkDelete: key.CodeDeleteForward,
xf86xkAudioRaiseVolume: key.CodeVolumeUp,
xf86xkAudioLowerVolume: key.CodeVolumeDown,
xf86xkAudioMute: key.CodeMute,
}
// asciiKeycodes maps lower-case ASCII runes to key.Code values.
var asciiKeycodes = [0x80]key.Code{
'a': key.CodeA,
'b': key.CodeB,
'c': key.CodeC,
'd': key.CodeD,
'e': key.CodeE,
'f': key.CodeF,
'g': key.CodeG,
'h': key.CodeH,
'i': key.CodeI,
'j': key.CodeJ,
'k': key.CodeK,
'l': key.CodeL,
'm': key.CodeM,
'n': key.CodeN,
'o': key.CodeO,
'p': key.CodeP,
'q': key.CodeQ,
'r': key.CodeR,
's': key.CodeS,
't': key.CodeT,
'u': key.CodeU,
'v': key.CodeV,
'w': key.CodeW,
'x': key.CodeX,
'y': key.CodeY,
'z': key.CodeZ,
'1': key.Code1,
'2': key.Code2,
'3': key.Code3,
'4': key.Code4,
'5': key.Code5,
'6': key.Code6,
'7': key.Code7,
'8': key.Code8,
'9': key.Code9,
'0': key.Code0,
' ': key.CodeSpacebar,
'-': key.CodeHyphenMinus,
'=': key.CodeEqualSign,
'[': key.CodeLeftSquareBracket,
']': key.CodeRightSquareBracket,
'\\': key.CodeBackslash,
';': key.CodeSemicolon,
'\'': key.CodeApostrophe,
'`': key.CodeGraveAccent,
',': key.CodeComma,
'.': key.CodeFullStop,
'/': key.CodeSlash,
}
type keypadKeysym struct {
rune rune
code key.Code
}
var keypadKeysyms = map[rune]keypadKeysym{
xkKeypadEqual: {'=', key.CodeKeypadEqualSign},
xkKeypadMultiply: {'*', key.CodeKeypadAsterisk},
xkKeypadAdd: {'+', key.CodeKeypadPlusSign},
xkKeypadSubtract: {'-', key.CodeKeypadHyphenMinus},
xkKeypadDecimal: {'.', key.CodeKeypadFullStop},
xkKeypadDivide: {'/', key.CodeKeypadSlash},
xkKeypad0: {'0', key.CodeKeypad0},
xkKeypad1: {'1', key.CodeKeypad1},
xkKeypad2: {'2', key.CodeKeypad2},
xkKeypad3: {'3', key.CodeKeypad3},
xkKeypad4: {'4', key.CodeKeypad4},
xkKeypad5: {'5', key.CodeKeypad5},
xkKeypad6: {'6', key.CodeKeypad6},
xkKeypad7: {'7', key.CodeKeypad7},
xkKeypad8: {'8', key.CodeKeypad8},
xkKeypad9: {'9', key.CodeKeypad9},
}