xkb

package module
v0.1.8 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 28, 2026 License: MIT Imports: 14 Imported by: 0

README

xkb-go

A pure Go implementation of the XKB (X Keyboard Extension) library, compatible with libxkbcommon.

Why?

libxkbcommon is the standard library for keyboard handling in Wayland. However, using it from Go requires:

  • CGO bindings: Breaks cross-compilation, requires C toolchain
  • purego: Still requires libxkbcommon.so at runtime

xkb-go provides the same functionality in pure Go:

  • No CGO, no C dependencies
  • Cross-compile to any platform
  • Single static binary
  • Native Go error handling and types

Installation

go get github.com/unxed/xkb-go

Quick Start

package main

import (
    "context"
    "fmt"
    "github.com/unxed/xkb-go"
)

func main() {
    // Create context
    ctx := xkb.NewContext(context.Background(), xkb.ContextNoFlags)

    // Load keymap from Wayland compositor (wl_keyboard.keymap event)
    keymap, err := ctx.NewKeymapFromString(keymapData, xkb.KeymapFormatTextV1)
    if err != nil {
        panic(err)
    }

    // Create state for tracking keyboard
    state := keymap.NewState()

    // Update modifier state (from wl_keyboard.modifiers)
    state.UpdateMask(shiftPressed, 0, capsLockOn, 0, 0, 0)

    // Translate keycode to keysym
    sym := state.KeyGetOneSym(keycode)

    // Get Unicode character
    char := state.KeyGetUTF32(keycode)
    fmt.Printf("Key: %s (%c)\n", xkb.KeysymGetName(sym), char)
}
Loading from RMLVO Names

Build keymaps from system XKB data without a Wayland compositor:

// Load US layout
keymap, err := ctx.NewKeymapFromNames(&xkb.RuleNames{
    Layout: "us",
})

// With variant
keymap, err := ctx.NewKeymapFromNames(&xkb.RuleNames{
    Layout:  "us",
    Variant: "intl",
})

// Full RMLVO specification
keymap, err := ctx.NewKeymapFromNames(&xkb.RuleNames{
    Rules:   "evdev",      // default: "evdev"
    Model:   "pc105",      // default: "pc105"
    Layout:  "us,ru",      // required
    Variant: ",phonetic",  // optional
    Options: "ctrl:nocaps",// optional
})
Compose/Dead Keys
// Load compose table for locale
table, err := ctx.NewComposeTableFromLocale("en_US.UTF-8", xkb.ComposeCompileNoFlags)
composeState := table.NewState(xkb.ComposeStateNoFlags)

// Feed keysyms
composeState.Feed(xkb.KeyDeadAcute)
composeState.Feed(xkb.KeyA)

if composeState.GetStatus() == xkb.ComposeComposed {
    result := composeState.GetUTF8() // "á"
}

Features

  • Keymap parsing (XKB text format v1)
  • Keyboard state tracking (modifiers, groups)
  • Key translation (keycode → keysym → Unicode)
  • Compose/dead key sequences
  • RMLVO compilation (NewKeymapFromNames)
  • Keymap serialization (GetAsString)
  • Full keysym tables (~2500 keysyms)

XKB Concepts

Keycode: Physical key identifier. Linux evdev keycode = scancode + 8.

Keysym: Abstract symbol a key produces (e.g., XKB_KEY_a, XKB_KEY_Shift_L).

Modifiers: Keys that modify others. 8 real modifiers: Shift, Lock, Control, Mod1-5.

Groups: Different layouts (e.g., Group1=English, Group2=Russian). Max 4.

Levels: Different outputs based on modifiers (e.g., Level1=a, Level2=A with Shift).

Thread Safety

  • Context: Safe for concurrent use
  • Keymap: Immutable after creation, safe to share
  • State: NOT safe for concurrent use (one per keyboard)
  • ComposeState: NOT safe for concurrent use

API Reference

libxkbcommon xkb-go
xkb_context_new() xkb.NewContext(ctx, flags)
xkb_context_unref() (garbage collected)
xkb_keymap_new_from_string() ctx.NewKeymapFromString()
xkb_keymap_new_from_file() ctx.NewKeymapFromFile()
xkb_keymap_new_from_names() ctx.NewKeymapFromNames()
xkb_keymap_get_as_string() keymap.GetAsString()
xkb_state_new() keymap.NewState()
xkb_state_key_get_one_sym() state.KeyGetOneSym()
xkb_state_key_get_utf8() state.KeyGetUTF8()
xkb_state_key_get_utf32() state.KeyGetUTF32()
xkb_state_update_mask() state.UpdateMask()
xkb_state_update_key() state.UpdateKey()
xkb_keysym_get_name() xkb.KeysymGetName()
xkb_keysym_from_name() xkb.KeysymFromName()
xkb_keysym_to_utf32() xkb.KeysymToUTF32()
xkb_compose_table_new_from_locale() ctx.NewComposeTableFromLocale()
xkb_compose_state_feed() composeState.Feed()
xkb_compose_state_get_status() composeState.GetStatus()
xkb_compose_state_get_utf8() composeState.GetUTF8()

Documentation

License

MIT License - see LICENSE

Documentation

Overview

Package xkb provides a pure Go implementation of the X Keyboard Extension (XKB).

This package enables keyboard handling for Wayland compositors and other applications that need XKB functionality without CGO dependencies. It supports:

  • Loading keymaps from RMLVO names (rules, model, layout, variant, options)
  • Parsing XKB text format keymaps
  • Key translation with modifier state tracking
  • Compose sequence handling
  • LED indicator state

Basic usage: 

ctx := xkb.NewContext(context.Background(), xkb.ContextNoFlags)
keymap, err := ctx.NewKeymapFromNames(&xkb.RuleNames{
    Layout: "us",
})
if err != nil {
    log.Fatal(err)
}
state := keymap.NewState()

// Translate a key press
sym := state.KeyGetOneSym(keycode)
utf8 := state.KeyGetUTF8(keycode)

Index

Examples

Constants

View Source 
const (
	// Navigation key aliases
	KeyPageUp   = KeyPrior // 0xff55
	KeyPageDown = KeyNext  // 0xff56

	// Keypad navigation aliases
	KeyKPPageUp   = KeyKPPrior // 0xff9a
	KeyKPPageDown = KeyKPNext  // 0xff9b
)
View Source 
const StateGroups = StateGroupDepressed | StateGroupLatched | StateGroupLocked | StateGroupEffective

StateGroups combines all group state components.

View Source 
const StateMods = StateModDepressed | StateModLatched | StateModLocked | StateModEffective

StateMods combines all modifier state components.

Variables

View Source 
var (
	// ErrNotImplemented indicates a feature is not yet implemented.
	ErrNotImplemented = errors.New("not implemented")

	// ErrUnsupportedFormat indicates an unsupported keymap or compose format.
	// Returned when a format other than [KeymapFormatTextV1] is specified.
	ErrUnsupportedFormat = errors.New("unsupported format")

	// ErrInvalidKeymap indicates the keymap data is invalid or malformed.
	ErrInvalidKeymap = errors.New("invalid keymap")

	// ErrInvalidSyntax indicates a syntax error in the input.
	// [SyntaxError] provides more details about the location.
	ErrInvalidSyntax = errors.New("invalid syntax")

	// ErrFileNotFound indicates a required file was not found.
	ErrFileNotFound = errors.New("file not found")

	// ErrInvalidKeycode indicates an invalid [Keycode].
	ErrInvalidKeycode = errors.New("invalid keycode")

	// ErrInvalidKeysym indicates an invalid [Keysym].
	ErrInvalidKeysym = errors.New("invalid keysym")
)

Sentinel errors for xkb operations.

Use errors.Is to check for these errors: 

if errors.Is(err, xkb.ErrInvalidSyntax) { ... }

Functions

func KeysymGetName 

func KeysymGetName(keysym Keysym) string

KeysymGetName returns the name of a Keysym (e.g., "Return", "a", "Shift_L").

Returns empty string if the keysym is not recognized. See also KeysymFromName for the reverse lookup.

Example 
package main

import (
	"fmt"

	"github.com/unxed/xkb-go"
)

func main() {
	// Get the name of a keysym
	fmt.Println(xkb.KeysymGetName(xkb.KeyReturn))
	fmt.Println(xkb.KeysymGetName(xkb.KeyShiftL))
	fmt.Println(xkb.KeysymGetName(xkb.KeyDeadAcute))
	fmt.Println(xkb.KeysymGetName(xkb.Keysym('a')))
}

Output:
Return
Shift_L
dead_acute
a

func KeysymIsFunctionKey 

func KeysymIsFunctionKey(keysym Keysym) bool

KeysymIsFunctionKey returns true if the Keysym is a function key (F1-F35).

func KeysymIsKeypad 

func KeysymIsKeypad(keysym Keysym) bool

KeysymIsKeypad returns true if the Keysym is a keypad (numpad) key.

func KeysymIsModifier 

func KeysymIsModifier(keysym Keysym) bool

KeysymIsModifier returns true if the Keysym is a modifier key.

Modifier keys include Shift, Control, Alt, Super, Caps Lock, Num Lock, etc.

Example 
package main

import (
	"fmt"

	"github.com/unxed/xkb-go"
)

func main() {
	// Check if keysyms are modifiers
	fmt.Printf("Shift_L is modifier: %v\n", xkb.KeysymIsModifier(xkb.KeyShiftL))
	fmt.Printf("Control_L is modifier: %v\n", xkb.KeysymIsModifier(xkb.KeyControlL))
	fmt.Printf("Return is modifier: %v\n", xkb.KeysymIsModifier(xkb.KeyReturn))
	fmt.Printf("'a' is modifier: %v\n", xkb.KeysymIsModifier(xkb.Keysym('a')))
}

Output:
Shift_L is modifier: true
Control_L is modifier: true
Return is modifier: false
'a' is modifier: false

func KeysymToUTF8 

func KeysymToUTF8(keysym Keysym) string

KeysymToUTF8 converts a Keysym to a UTF-8 string.

Returns empty string if the keysym doesn't represent a printable character. See also KeysymToUTF32 for the raw codepoint.

func KeysymToUTF32 

func KeysymToUTF32(keysym Keysym) rune

KeysymToUTF32 converts a Keysym to a Unicode codepoint.

Returns 0 if the keysym doesn't represent a printable character (e.g., modifier keys, function keys). See also KeysymToUTF8 for the UTF-8 encoded string.

Example 
package main

import (
	"fmt"

	"github.com/unxed/xkb-go"
)

func main() {
	// Convert keysyms to Unicode codepoints
	fmt.Printf("a -> %c\n", xkb.KeysymToUTF32(xkb.Keysym('a')))
	fmt.Printf("A -> %c\n", xkb.KeysymToUTF32(xkb.Keysym('A')))

	// Latin-1 characters
	fmt.Printf("0xe4 -> %c\n", xkb.KeysymToUTF32(xkb.Keysym(0xe4))) // ä

	// Function keys don't produce characters
	r := xkb.KeysymToUTF32(xkb.KeyReturn)
	fmt.Printf("Return -> %d (no char)\n", r)
}

Output:
a -> a
A -> A
0xe4 -> ä
Return -> 0 (no char)

Types

type ComposeCompileFlags 

type ComposeCompileFlags uint32

ComposeCompileFlags controls compose table compilation.

Used with Context.NewComposeTableFromLocale and Context.NewComposeTableFromFile. 

const (
	// ComposeCompileNoFlags is the default compose table compilation flags.
	ComposeCompileNoFlags ComposeCompileFlags = 0
)

type ComposeFeedResult 

type ComposeFeedResult int

ComposeFeedResult indicates how ComposeState.Feed handled a keysym. 

const (
	// ComposeFeedIgnored means the keysym was ignored (not a valid compose starter).
	ComposeFeedIgnored ComposeFeedResult = iota
	// ComposeFeedAccepted means the keysym was consumed by the compose sequence.
	ComposeFeedAccepted
)

type ComposeState 

type ComposeState struct {
	// contains filtered or unexported fields
}

ComposeState tracks the state of an ongoing compose sequence.

Feed keysyms with ComposeState.Feed, then check ComposeState.GetStatus. If status is ComposeComposed, retrieve the result with ComposeState.GetUTF8 or ComposeState.GetOneSym.

ComposeState is NOT safe for concurrent use.

func (*ComposeState) Feed 

func (cs *ComposeState) Feed(keysym Keysym) ComposeFeedResult

Feed processes a Keysym through the compose state machine.

Returns ComposeFeedAccepted if the keysym was consumed, or ComposeFeedIgnored if it doesn't start a compose sequence.

After calling Feed, check ComposeState.GetStatus to determine the state:

func (*ComposeState) GetOneSym 

func (cs *ComposeState) GetOneSym() Keysym

GetOneSym returns the composed Keysym after a successful sequence.

Returns KeyNoSymbol if status is not ComposeComposed.

func (*ComposeState) GetStatus 

func (cs *ComposeState) GetStatus() ComposeStatus

GetStatus returns the current ComposeStatus.

func (*ComposeState) GetUTF8 

func (cs *ComposeState) GetUTF8() string

GetUTF8 returns the composed UTF-8 string after a successful sequence.

Returns empty string if status is not ComposeComposed.

func (*ComposeState) Reset 

func (cs *ComposeState) Reset()

Reset resets the compose state to the initial state.

Call this to cancel an in-progress sequence (e.g., when Escape is pressed).

Example 
package main

import (
	"fmt"

	"github.com/unxed/xkb-go"
)

func main() {
	ct := xkb.TestComposeTable()
	cs := ct.NewState(xkb.ComposeStateNoFlags)

	// Start a compose sequence
	cs.Feed(xkb.KeyDeadAcute)

	// User presses Escape - cancel the sequence
	cs.Reset()

	fmt.Printf("Status after reset: %v (ComposeNothing)\n", cs.GetStatus())
}

Output:
Status after reset: 0 (ComposeNothing)

func (*ComposeState) Table 

func (cs *ComposeState) Table() *ComposeTable

Table returns the ComposeTable this state is for.

type ComposeStateFlags 

type ComposeStateFlags uint32

ComposeStateFlags controls compose state creation.

Used with ComposeTable.NewState. 

const (
	// ComposeStateNoFlags is the default compose state flags.
	ComposeStateNoFlags ComposeStateFlags = 0
)

type ComposeStatus 

type ComposeStatus int

ComposeStatus indicates the state of a compose sequence.

Retrieved via ComposeState.GetStatus after calling ComposeState.Feed. 

const (
	// ComposeNothing means no compose sequence is in progress.
	ComposeNothing ComposeStatus = iota
	// ComposeComposing means a compose sequence is in progress, waiting for more input.
	ComposeComposing
	// ComposeComposed means a compose sequence completed successfully.
	// Call [ComposeState.GetOneSym] or [ComposeState.GetUTF8] to get the result.
	ComposeComposed
	// ComposeCancelled means a compose sequence was cancelled by an invalid keysym.
	ComposeCancelled
)

type ComposeTable 

type ComposeTable struct {
	// contains filtered or unexported fields
}

ComposeTable holds compose sequence definitions for dead key handling.

Create a ComposeTable with Context.NewComposeTableFromLocale or Context.NewComposeTableFromFile. It is immutable after creation and safe to share across goroutines.

Use ComposeTable.NewState to create a ComposeState for processing input.

func TestComposeTable 

func TestComposeTable() *ComposeTable

TestComposeTable creates a minimal ComposeTable for testing.

Includes common dead key sequences like dead_acute + a = á. Useful for unit tests that need compose functionality without loading system compose files.

func (*ComposeTable) Locale 

func (ct *ComposeTable) Locale() string

Locale returns the locale this compose table was created for.

func (*ComposeTable) NewState 

func (ct *ComposeTable) NewState(flags ComposeStateFlags) *ComposeState

NewState creates a new ComposeState for this table.

Each input context should have its own ComposeState.

Example 
package main

import (
	"fmt"

	"github.com/unxed/xkb-go"
)

func main() {
	// Create a test compose table
	ct := xkb.TestComposeTable()
	cs := ct.NewState(xkb.ComposeStateNoFlags)

	// Simulate dead_acute + a = á
	cs.Feed(xkb.KeyDeadAcute)
	fmt.Printf("After dead_acute: %v\n", cs.GetStatus())

	cs.Feed(xkb.Keysym('a'))
	fmt.Printf("After 'a': %v\n", cs.GetStatus())
	fmt.Printf("Result: %s\n", cs.GetUTF8())
}

Output:
After dead_acute: 1
After 'a': 2
Result: á

type Context 

type Context struct {
	// contains filtered or unexported fields
}

Context is the top-level xkb object that holds shared configuration.

A Context manages include paths for loading XKB data files and provides factory methods for creating Keymap and ComposeTable instances. Context is safe for concurrent use.

Create a Context with NewContext, then use methods like Context.NewKeymapFromString or Context.NewKeymapFromNames to create keymaps.

func NewContext 

func NewContext(ctx context.Context, flags ContextFlags) *Context

NewContext creates a new xkb context with the given flags.

The provided context.Context is used for cancellation and logging. Pass ContextNoFlags for default behavior, which includes adding standard system XKB data paths.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/unxed/xkb-go"
)

func main() {
	// Create a context with default settings
	ctx := xkb.NewContext(context.Background(), xkb.ContextNoFlags)

	// The context manages include paths and logging
	paths := ctx.IncludePaths()
	fmt.Printf("Include paths: %d\n", len(paths))
}

Output:
Include paths: 1

func (*Context) AppendIncludePath 

func (c *Context) AppendIncludePath(path string)

AppendIncludePath adds a path to the end of the include path list.

Later paths have lower priority when resolving includes. See also Context.PrependIncludePath to add high-priority paths.

func (*Context) ClearIncludePaths 

func (c *Context) ClearIncludePaths()

ClearIncludePaths removes all include paths.

func (*Context) Context 

func (c *Context) Context() context.Context

Context returns the context.Context associated with this xkb Context.

func (*Context) Flags 

func (c *Context) Flags() ContextFlags

Flags returns the ContextFlags this context was created with.

func (*Context) IncludePaths 

func (c *Context) IncludePaths() []string

IncludePaths returns a copy of the current include paths.

These paths are searched when loading XKB data files for Context.NewKeymapFromNames.

func (*Context) Logger 

func (c *Context) Logger() *slog.Logger

Logger returns the current logger.

func (*Context) NewComposeTableFromFile 

func (c *Context) NewComposeTableFromFile(path string, locale string, flags ComposeCompileFlags) (*ComposeTable, error)

NewComposeTableFromFile loads a compose table from a specific file.

The locale parameter is used for resolving %L and similar substitutions in include directives. The flags parameter is currently unused.

See also Context.NewComposeTableFromLocale for automatic locale detection.

func (*Context) NewComposeTableFromLocale 

func (c *Context) NewComposeTableFromLocale(locale string, flags ComposeCompileFlags) (*ComposeTable, error)

NewComposeTableFromLocale loads a compose table for the given locale.

The locale string should be in the form "language_TERRITORY.encoding" (e.g., "en_US.UTF-8"). If empty, the locale is read from environment variables (LC_ALL, LC_CTYPE, LANG).

The compose table is searched for in:

  1. $XCOMPOSEFILE environment variable
  2. ~/.XCompose
  3. System locale compose file (/usr/share/X11/locale/<locale>/Compose)

Returns a ComposeTable that can be used to create a ComposeState.

func (*Context) NewKeymapFromFile 

func (c *Context) NewKeymapFromFile(path string, format KeymapFormat) (*Keymap, error)

NewKeymapFromFile loads and parses a keymap from a file.

The format parameter must be KeymapFormatTextV1. See also Context.NewKeymapFromString for parsing from a byte slice.

func (*Context) NewKeymapFromNames 

func (c *Context) NewKeymapFromNames(names *RuleNames) (*Keymap, error)

NewKeymapFromNames builds a keymap from RMLVO names.

This looks up the rules file and assembles keymap components from the system XKB data directories. Useful for building keymaps without a Wayland compositor.

If names is nil, default values are used (Rules="evdev", Model="pc105", Layout="us"). Empty fields in RuleNames fall back to these defaults.

func (*Context) NewKeymapFromString 

func (c *Context) NewKeymapFromString(text []byte, format KeymapFormat) (*Keymap, error)

NewKeymapFromString parses a keymap from XKB text format.

This is the primary method for Wayland clients, which receive the complete keymap as a string from the compositor via wl_keyboard.keymap.

The format parameter must be KeymapFormatTextV1. Returns a Keymap that can be used to create a State for key translation.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/unxed/xkb-go"
)

func main() {
	ctx := xkb.NewContext(context.Background(), xkb.ContextNoFlags)

	// In real usage, this would be the keymap string from Wayland
	// received via wl_keyboard.keymap event
	keymapData := []byte(`xkb_keymap { ... }`) // Simplified

	_, err := ctx.NewKeymapFromString(keymapData, xkb.KeymapFormatTextV1)
	if err != nil {
		// Handle error - parser not yet implemented
		fmt.Println("Keymap parsing not yet implemented")
	}
}

Output:
Keymap parsing not yet implemented

func (*Context) NumIncludePaths 

func (c *Context) NumIncludePaths() int

NumIncludePaths returns the number of include paths.

func (*Context) PrependIncludePath 

func (c *Context) PrependIncludePath(path string)

PrependIncludePath adds a path to the front of the include path list.

Earlier paths have higher priority when resolving includes. See also Context.AppendIncludePath to add low-priority paths.

func (*Context) SetLogger 

func (c *Context) SetLogger(logger *slog.Logger)

SetLogger sets the logger for this context.

If logger is nil, a no-op logger is used. The logger is called for warnings and errors during keymap parsing and compilation.

type ContextFlags 

type ContextFlags uint32

ContextFlags controls Context behavior. 

const (
	// ContextNoFlags is the default context flags.
	ContextNoFlags ContextFlags = 0

	// ContextNoDefaultIncludes prevents adding default include paths.
	// By default, the context includes system XKB data paths like /usr/share/X11/xkb.
	ContextNoDefaultIncludes ContextFlags = 1 << 0

	// ContextNoEnvironmentNames prevents reading RMLVO names from environment variables.
	// Affects XKB_DEFAULT_RULES, XKB_DEFAULT_MODEL, XKB_DEFAULT_LAYOUT, etc.
	ContextNoEnvironmentNames ContextFlags = 1 << 1
)

type Error 

type Error struct {
	Op   string // Operation that failed (e.g., "NewKeymapFromString")
	Path string // File path, if applicable
	Line int    // Line number, if applicable
	Col  int    // Column number, if applicable
	Err  error  // Underlying error
}

Error wraps an underlying error with operation context.

Use errors.Is to check the underlying error type, or errors.Unwrap to access it directly.

func (*Error) Error 

func (e *Error) Error() string

func (*Error) Is 

func (e *Error) Is(target error) bool

Is implements errors.Is for Error.

func (*Error) Unwrap 

func (e *Error) Unwrap() error

type Group 

type Group uint8

Group represents a keyboard layout index.

Most keyboards have 1-4 groups (e.g., Group 0 = English, Group 1 = Russian). Use State.SerializeGroup to get the current group and Keymap.NumGroups to query the number of groups.

type Interpret 

type Interpret struct {
	// contains filtered or unexported fields
}

Interpret represents an interpret statement from xkb_compat.

It maps keysyms (optionally with modifier conditions) to actions and properties. This is an internal type used during keymap compilation.

type Key 

type Key struct {
	// contains filtered or unexported fields
}

Key holds per-key information including symbols for each group and level.

type KeyDirection 

type KeyDirection int

KeyDirection indicates whether a key was pressed or released.

Used with State.UpdateKey to update keyboard state based on key events. 

const (
	// KeyReleased indicates a key release event.
	KeyReleased KeyDirection = 0
	// KeyPressed indicates a key press event.
	KeyPressed KeyDirection = 1
)

type KeyGroup 

type KeyGroup struct {
	// contains filtered or unexported fields
}

KeyGroup holds key symbols for one group (layout) of a Key.

type KeyLevel 

type KeyLevel struct {
	// contains filtered or unexported fields
}

KeyLevel holds keysyms for one shift level of a KeyGroup.

type KeyType 

type KeyType struct {
	// contains filtered or unexported fields
}

KeyType defines how modifiers affect the shift level of a key.

For example, the "ALPHABETIC" type considers Shift and Lock modifiers, mapping them to different levels (lowercase, uppercase).

type KeyTypeEntry 

type KeyTypeEntry struct {
	// contains filtered or unexported fields
}

KeyTypeEntry maps a modifier combination to a level within a KeyType.

type Keycode 

type Keycode uint32

Keycode is a physical key identifier.

In evdev (Linux), keycode = scancode + 8. Keycodes are translated to keysyms using State.KeyGetOneSym or State.KeyGetSyms.

type Keymap 

type Keymap struct {
	// contains filtered or unexported fields
}

Keymap is an immutable compiled keyboard mapping.

It contains all information about keys, layouts, types, and modifiers. Create a Keymap using Context.NewKeymapFromString, Context.NewKeymapFromFile, or Context.NewKeymapFromNames.

Keymap is safe to share across goroutines after creation. Use Keymap.NewState to create a mutable State for key translation.

func TestKeymap 

func TestKeymap() *Keymap

TestKeymap creates a minimal US QWERTY Keymap for testing.

This keymap includes basic alphanumeric keys and modifiers. It is useful for unit tests that need a valid keymap without loading from system files.

func (*Keymap) Context 

func (km *Keymap) Context() *Context

Context returns the Context this keymap was created from.

func (*Keymap) GetAsString 

func (km *Keymap) GetAsString(format KeymapFormat) (string, error)

GetAsString serializes the keymap to XKB text format.

The format parameter must be KeymapFormatTextV1. The returned string can be passed to Context.NewKeymapFromString.

func (*Keymap) GroupName 

func (km *Keymap) GroupName(group Group) string

GroupName returns the name of a Group (layout).

Returns empty string if group index is out of range.

func (*Keymap) KeyByName 

func (km *Keymap) KeyByName(name string) Keycode

KeyByName returns the Keycode for a symbolic name.

Returns 0 if name is not found. See also Keymap.KeyGetName for the reverse lookup.

func (*Keymap) KeyGetName 

func (km *Keymap) KeyGetName(keycode Keycode) string

KeyGetName returns the symbolic name for a keycode (e.g., "AD01" for Q).

Returns empty string if keycode is not found. See also Keymap.KeyByName for the reverse lookup.

func (*Keymap) KeyRepeats 

func (km *Keymap) KeyRepeats(keycode Keycode) bool

KeyRepeats returns whether a key should repeat when held.

Keys like letters and numbers repeat, while modifiers do not.

func (*Keymap) LEDGetIndex 

func (km *Keymap) LEDGetIndex(name string) int

LEDGetIndex returns the index of an LED by name.

Returns -1 if not found. See also Keymap.LEDGetName.

func (*Keymap) LEDGetName 

func (km *Keymap) LEDGetName(index int) string

LEDGetName returns the name of an LED by index.

Returns empty string if index is out of range. See also Keymap.LEDGetIndex.

func (*Keymap) MaxKeycode 

func (km *Keymap) MaxKeycode() Keycode

MaxKeycode returns the maximum Keycode in the keymap.

func (*Keymap) MinKeycode 

func (km *Keymap) MinKeycode() Keycode

MinKeycode returns the minimum Keycode in the keymap.

func (*Keymap) ModGetIndex 

func (km *Keymap) ModGetIndex(name string) int

ModGetIndex returns the index of a modifier by name.

Returns -1 if not found. Works for both real modifiers (Shift, Lock, Control, Mod1-5) and virtual modifiers (Alt, Super, etc.).

Use with State.ModIndexIsActive to check modifier state.

func (*Keymap) NewState 

func (km *Keymap) NewState() *State

NewState creates a new keyboard State for this keymap.

Each keyboard device should have its own State instance. The State tracks modifier and group state for key translation.

Example 
package main

import (
	"fmt"

	"github.com/unxed/xkb-go"
)

func main() {
	// Create a test keymap (in real usage, parse from string)
	km := xkb.TestKeymap()

	// Create state for tracking keyboard
	state := km.NewState()

	// Simulate pressing 'a' with no modifiers
	state.UpdateMask(0, 0, 0, 0, 0, 0)
	sym := state.KeyGetOneSym(38) // keycode 38 = 'a' on US keyboard
	fmt.Printf("No mods: %s\n", xkb.KeysymGetName(sym))

	// Simulate pressing 'a' with Shift held
	state.UpdateMask(xkb.ModShift, 0, 0, 0, 0, 0)
	sym = state.KeyGetOneSym(38)
	fmt.Printf("With Shift: %s\n", xkb.KeysymGetName(sym))

	// Simulate pressing 'a' with Caps Lock on
	state.UpdateMask(0, 0, xkb.ModLock, 0, 0, 0)
	sym = state.KeyGetOneSym(38)
	fmt.Printf("With Caps Lock: %s\n", xkb.KeysymGetName(sym))
}

Output:
No mods: a
With Shift: A
With Caps Lock: A

func (*Keymap) NumGroups 

func (km *Keymap) NumGroups() int

NumGroups returns the number of groups (layouts) in the keymap.

Most keymaps have 1-4 groups.

func (*Keymap) NumLEDs 

func (km *Keymap) NumLEDs() int

NumLEDs returns the number of LED indicators in the keymap.

func (*Keymap) NumTypes 

func (km *Keymap) NumTypes() int

NumTypes returns the number of KeyType definitions in the keymap.

type KeymapCompileFlags 

type KeymapCompileFlags uint32

KeymapCompileFlags controls keymap compilation.

Currently no flags are defined; pass KeymapCompileNoFlags. 

const (
	// KeymapCompileNoFlags is the default keymap compilation flags.
	KeymapCompileNoFlags KeymapCompileFlags = 0
)

type KeymapFormat 

type KeymapFormat uint32

KeymapFormat specifies the format of a keymap string.

Used with Context.NewKeymapFromString, Context.NewKeymapFromFile, and Keymap.GetAsString. 

const (
	// KeymapFormatTextV1 is the XKB text format, version 1.
	// This is the format used by Wayland compositors in wl_keyboard.keymap events.
	KeymapFormatTextV1 KeymapFormat = 1
)

type Keysym 

type Keysym uint32

Keysym is an XKB key symbol.

Keysyms are 32-bit values that represent the symbols on keyboard keys. Values below 0x01000000 are defined in X11 keysym headers. Values 0x01000000-0x0110FFFF are Unicode codepoints + 0x01000000.

Use KeysymGetName to get the name of a keysym, KeysymFromName to look up by name, and KeysymToUTF32 to convert to a Unicode codepoint.

See keysym_generated.go for keysym constants (KeyBackSpace, KeyReturn, etc.) 

const (
	KeyNoSymbol Keysym = 0

	// Latin-1 (ASCII)
	KeySpace        Keysym = 0x0020
	KeyExclam       Keysym = 0x0021
	KeyQuotedbl     Keysym = 0x0022
	KeyNumbersign   Keysym = 0x0023
	KeyDollar       Keysym = 0x0024
	KeyPercent      Keysym = 0x0025
	KeyAmpersand    Keysym = 0x0026
	KeyApostrophe   Keysym = 0x0027
	KeyParenleft    Keysym = 0x0028
	KeyParenright   Keysym = 0x0029
	KeyAsterisk     Keysym = 0x002a
	KeyPlus         Keysym = 0x002b
	KeyComma        Keysym = 0x002c
	KeyMinus        Keysym = 0x002d
	KeyPeriod       Keysym = 0x002e
	KeySlash        Keysym = 0x002f
	KeyColon        Keysym = 0x003a
	KeySemicolon    Keysym = 0x003b
	KeyLess         Keysym = 0x003c
	KeyEqual        Keysym = 0x003d
	KeyGreater      Keysym = 0x003e
	KeyQuestion     Keysym = 0x003f
	KeyAt           Keysym = 0x0040
	KeyBracketleft  Keysym = 0x005b
	KeyBackslash    Keysym = 0x005c
	KeyBracketright Keysym = 0x005d
	KeyAsciicircum  Keysym = 0x005e
	KeyUnderscore   Keysym = 0x005f
	KeyGrave        Keysym = 0x0060
	KeyBraceleft    Keysym = 0x007b
	KeyBar          Keysym = 0x007c
	KeyBraceright   Keysym = 0x007d
	KeyAsciitilde   Keysym = 0x007e

	// Latin-1 Supplement
	KeyNobreakspace   Keysym = 0x00a0
	KeyExclamdown     Keysym = 0x00a1
	KeyCent           Keysym = 0x00a2
	KeySterling       Keysym = 0x00a3
	KeyCurrency       Keysym = 0x00a4
	KeyYen            Keysym = 0x00a5
	KeyBrokenbar      Keysym = 0x00a6
	KeySection        Keysym = 0x00a7
	KeyDiaeresis      Keysym = 0x00a8
	KeyCopyright      Keysym = 0x00a9
	KeyOrdfeminine    Keysym = 0x00aa
	KeyGuillemetleft  Keysym = 0x00ab
	KeyNotsign        Keysym = 0x00ac
	KeyHyphen         Keysym = 0x00ad
	KeyRegistered     Keysym = 0x00ae
	KeyMacron         Keysym = 0x00af
	KeyDegree         Keysym = 0x00b0
	KeyPlusminus      Keysym = 0x00b1
	KeyTwosuperior    Keysym = 0x00b2
	KeyThreesuperior  Keysym = 0x00b3
	KeyAcute          Keysym = 0x00b4
	KeyMu             Keysym = 0x00b5
	KeyParagraph      Keysym = 0x00b6
	KeyPeriodcentered Keysym = 0x00b7
	KeyCedilla        Keysym = 0x00b8
	KeyOnesuperior    Keysym = 0x00b9
	KeyOrdmasculine   Keysym = 0x00ba
	KeyGuillemetright Keysym = 0x00bb
	KeyOnequarter     Keysym = 0x00bc
	KeyOnehalf        Keysym = 0x00bd
	KeyThreequarters  Keysym = 0x00be
	KeyQuestiondown   Keysym = 0x00bf
	KeyAgrave         Keysym = 0x00c0
	KeyAacute         Keysym = 0x00c1
	KeyAcircumflex    Keysym = 0x00c2
	KeyAtilde         Keysym = 0x00c3
	KeyAdiaeresis     Keysym = 0x00c4
	KeyAring          Keysym = 0x00c5
	KeyAE             Keysym = 0x00c6
	KeyCcedilla       Keysym = 0x00c7
	KeyEgrave         Keysym = 0x00c8
	KeyEacute         Keysym = 0x00c9
	KeyEcircumflex    Keysym = 0x00ca
	KeyEdiaeresis     Keysym = 0x00cb
	KeyIgrave         Keysym = 0x00cc
	KeyIacute         Keysym = 0x00cd
	KeyIcircumflex    Keysym = 0x00ce
	KeyIdiaeresis     Keysym = 0x00cf
	KeyETH            Keysym = 0x00d0
	KeyNtilde         Keysym = 0x00d1
	KeyOgrave         Keysym = 0x00d2
	KeyOacute         Keysym = 0x00d3
	KeyOcircumflex    Keysym = 0x00d4
	KeyOtilde         Keysym = 0x00d5
	KeyOdiaeresis     Keysym = 0x00d6
	KeyMultiply       Keysym = 0x00d7
	KeyOslash         Keysym = 0x00d8
	KeyUgrave         Keysym = 0x00d9
	KeyUacute         Keysym = 0x00da
	KeyUcircumflex    Keysym = 0x00db
	KeyUdiaeresis     Keysym = 0x00dc
	KeyYacute         Keysym = 0x00dd
	KeyTHORN          Keysym = 0x00de
	KeySsharp         Keysym = 0x00df
	KeyAe             Keysym = 0x00e6
	KeyEth            Keysym = 0x00f0
	KeyDivision       Keysym = 0x00f7
	KeyThorn          Keysym = 0x00fe
	KeyYdiaeresis     Keysym = 0x00ff

	// Latin Extended-A
	KeyAogonek      Keysym = 0x01a1
	KeyBreve        Keysym = 0x01a2
	KeyLstroke      Keysym = 0x01a3
	KeyLcaron       Keysym = 0x01a5
	KeySacute       Keysym = 0x01a6
	KeyScaron       Keysym = 0x01a9
	KeyScedilla     Keysym = 0x01aa
	KeyTcaron       Keysym = 0x01ab
	KeyZacute       Keysym = 0x01ac
	KeyZcaron       Keysym = 0x01ae
	KeyZabovedot    Keysym = 0x01af
	KeyOgonek       Keysym = 0x01b2
	KeyCaron        Keysym = 0x01b7
	KeyDoubleacute  Keysym = 0x01bd
	KeyRacute       Keysym = 0x01c0
	KeyAbreve       Keysym = 0x01c3
	KeyLacute       Keysym = 0x01c5
	KeyCacute       Keysym = 0x01c6
	KeyCcaron       Keysym = 0x01c8
	KeyEogonek      Keysym = 0x01ca
	KeyEcaron       Keysym = 0x01cc
	KeyDcaron       Keysym = 0x01cf
	KeyDstroke      Keysym = 0x01d0
	KeyNacute       Keysym = 0x01d1
	KeyNcaron       Keysym = 0x01d2
	KeyOdoubleacute Keysym = 0x01d5
	KeyRcaron       Keysym = 0x01d8
	KeyUring        Keysym = 0x01d9
	KeyUdoubleacute Keysym = 0x01db
	KeyTcedilla     Keysym = 0x01de
	KeyAbovedot     Keysym = 0x01ff

	// Latin Extended-B
	KeyHstroke     Keysym = 0x02a1
	KeyHcircumflex Keysym = 0x02a6
	KeyIabovedot   Keysym = 0x02a9
	KeyGbreve      Keysym = 0x02ab
	KeyJcircumflex Keysym = 0x02ac
	KeyIdotless    Keysym = 0x02b9
	KeyCabovedot   Keysym = 0x02c5
	KeyCcircumflex Keysym = 0x02c6
	KeyGabovedot   Keysym = 0x02d5
	KeyGcircumflex Keysym = 0x02d8
	KeyUbreve      Keysym = 0x02dd
	KeyScircumflex Keysym = 0x02de

	// Latin Extended Additional
	KeyKra       Keysym = 0x03a2
	KeyRcedilla  Keysym = 0x03a3
	KeyItilde    Keysym = 0x03a5
	KeyLcedilla  Keysym = 0x03a6
	KeyEmacron   Keysym = 0x03aa
	KeyGcedilla  Keysym = 0x03ab
	KeyTslash    Keysym = 0x03ac
	KeyENG       Keysym = 0x03bd
	KeyEng       Keysym = 0x03bf
	KeyAmacron   Keysym = 0x03c0
	KeyIogonek   Keysym = 0x03c7
	KeyEabovedot Keysym = 0x03cc
	KeyImacron   Keysym = 0x03cf
	KeyNcedilla  Keysym = 0x03d1
	KeyOmacron   Keysym = 0x03d2
	KeyKcedilla  Keysym = 0x03d3
	KeyUogonek   Keysym = 0x03d9
	KeyUtilde    Keysym = 0x03dd
	KeyUmacron   Keysym = 0x03de

	// Katakana
	KeyOverline           Keysym = 0x047e
	KeyKanaFullstop       Keysym = 0x04a1
	KeyKanaOpeningbracket Keysym = 0x04a2
	KeyKanaClosingbracket Keysym = 0x04a3
	KeyKanaComma          Keysym = 0x04a4
	KeyKanaConjunctive    Keysym = 0x04a5
	KeyKanaWO             Keysym = 0x04a6
	KeyKanaA              Keysym = 0x04a7
	KeyKanaI              Keysym = 0x04a8
	KeyKanaU              Keysym = 0x04a9
	KeyKanaE              Keysym = 0x04aa
	KeyKanaO              Keysym = 0x04ab
	KeyKanaYa             Keysym = 0x04ac
	KeyKanaYu             Keysym = 0x04ad
	KeyKanaYo             Keysym = 0x04ae
	KeyKanaTsu            Keysym = 0x04af
	KeyProlongedsound     Keysym = 0x04b0
	KeyKanaKA             Keysym = 0x04b6
	KeyKanaKI             Keysym = 0x04b7
	KeyKanaKU             Keysym = 0x04b8
	KeyKanaKE             Keysym = 0x04b9
	KeyKanaKO             Keysym = 0x04ba
	KeyKanaSA             Keysym = 0x04bb
	KeyKanaSHI            Keysym = 0x04bc
	KeyKanaSU             Keysym = 0x04bd
	KeyKanaSE             Keysym = 0x04be
	KeyKanaSO             Keysym = 0x04bf
	KeyKanaTA             Keysym = 0x04c0
	KeyKanaCHI            Keysym = 0x04c1
	KeyKanaTSU            Keysym = 0x04c2
	KeyKanaTE             Keysym = 0x04c3
	KeyKanaTO             Keysym = 0x04c4
	KeyKanaNA             Keysym = 0x04c5
	KeyKanaNI             Keysym = 0x04c6
	KeyKanaNU             Keysym = 0x04c7
	KeyKanaNE             Keysym = 0x04c8
	KeyKanaNO             Keysym = 0x04c9
	KeyKanaHA             Keysym = 0x04ca
	KeyKanaHI             Keysym = 0x04cb
	KeyKanaFU             Keysym = 0x04cc
	KeyKanaHE             Keysym = 0x04cd
	KeyKanaHO             Keysym = 0x04ce
	KeyKanaMA             Keysym = 0x04cf
	KeyKanaMI             Keysym = 0x04d0
	KeyKanaMU             Keysym = 0x04d1
	KeyKanaME             Keysym = 0x04d2
	KeyKanaMO             Keysym = 0x04d3
	KeyKanaYA             Keysym = 0x04d4
	KeyKanaYU             Keysym = 0x04d5
	KeyKanaYO             Keysym = 0x04d6
	KeyKanaRA             Keysym = 0x04d7
	KeyKanaRI             Keysym = 0x04d8
	KeyKanaRU             Keysym = 0x04d9
	KeyKanaRE             Keysym = 0x04da
	KeyKanaRO             Keysym = 0x04db
	KeyKanaWA             Keysym = 0x04dc
	KeyKanaN              Keysym = 0x04dd
	KeyVoicedsound        Keysym = 0x04de
	KeySemivoicedsound    Keysym = 0x04df

	// Arabic
	KeyArabicComma          Keysym = 0x05ac
	KeyArabicSemicolon      Keysym = 0x05bb
	KeyArabicQuestionMark   Keysym = 0x05bf
	KeyArabicHamza          Keysym = 0x05c1
	KeyArabicMaddaonalef    Keysym = 0x05c2
	KeyArabicHamzaonalef    Keysym = 0x05c3
	KeyArabicHamzaonwaw     Keysym = 0x05c4
	KeyArabicHamzaunderalef Keysym = 0x05c5
	KeyArabicHamzaonyeh     Keysym = 0x05c6
	KeyArabicAlef           Keysym = 0x05c7
	KeyArabicBeh            Keysym = 0x05c8
	KeyArabicTehmarbuta     Keysym = 0x05c9
	KeyArabicTeh            Keysym = 0x05ca
	KeyArabicTheh           Keysym = 0x05cb
	KeyArabicJeem           Keysym = 0x05cc
	KeyArabicHah            Keysym = 0x05cd
	KeyArabicKhah           Keysym = 0x05ce
	KeyArabicDal            Keysym = 0x05cf
	KeyArabicThal           Keysym = 0x05d0
	KeyArabicRa             Keysym = 0x05d1
	KeyArabicZain           Keysym = 0x05d2
	KeyArabicSeen           Keysym = 0x05d3
	KeyArabicSheen          Keysym = 0x05d4
	KeyArabicSad            Keysym = 0x05d5
	KeyArabicDad            Keysym = 0x05d6
	KeyArabicTah            Keysym = 0x05d7
	KeyArabicZah            Keysym = 0x05d8
	KeyArabicAin            Keysym = 0x05d9
	KeyArabicGhain          Keysym = 0x05da
	KeyArabicTatweel        Keysym = 0x05e0
	KeyArabicFeh            Keysym = 0x05e1
	KeyArabicQaf            Keysym = 0x05e2
	KeyArabicKaf            Keysym = 0x05e3
	KeyArabicLam            Keysym = 0x05e4
	KeyArabicMeem           Keysym = 0x05e5
	KeyArabicNoon           Keysym = 0x05e6
	KeyArabicHa             Keysym = 0x05e7
	KeyArabicWaw            Keysym = 0x05e8
	KeyArabicAlefmaksura    Keysym = 0x05e9
	KeyArabicYeh            Keysym = 0x05ea
	KeyArabicFathatan       Keysym = 0x05eb
	KeyArabicDammatan       Keysym = 0x05ec
	KeyArabicKasratan       Keysym = 0x05ed
	KeyArabicFatha          Keysym = 0x05ee
	KeyArabicDamma          Keysym = 0x05ef
	KeyArabicKasra          Keysym = 0x05f0
	KeyArabicShadda         Keysym = 0x05f1
	KeyArabicSukun          Keysym = 0x05f2

	// Cyrillic
	KeySerbianDje             Keysym = 0x06a1
	KeyMacedoniaGje           Keysym = 0x06a2
	KeyCyrillicIo             Keysym = 0x06a3
	KeyUkrainianIe            Keysym = 0x06a4
	KeyMacedoniaDse           Keysym = 0x06a5
	KeyUkrainianI             Keysym = 0x06a6
	KeyUkrainianYi            Keysym = 0x06a7
	KeyCyrillicJe             Keysym = 0x06a8
	KeyCyrillicLje            Keysym = 0x06a9
	KeyCyrillicNje            Keysym = 0x06aa
	KeySerbianTshe            Keysym = 0x06ab
	KeyMacedoniaKje           Keysym = 0x06ac
	KeyUkrainianGheWithUpturn Keysym = 0x06ad
	KeyByelorussianShortu     Keysym = 0x06ae
	KeyCyrillicDzhe           Keysym = 0x06af
	KeyNumerosign             Keysym = 0x06b0
	KeySerbianDJE             Keysym = 0x06b1
	KeyMacedoniaGJE           Keysym = 0x06b2
	KeyCyrillicIO             Keysym = 0x06b3
	KeyUkrainianIE            Keysym = 0x06b4
	KeyMacedoniaDSE           Keysym = 0x06b5
	KeyUkrainianYI            Keysym = 0x06b7
	KeyCyrillicJE             Keysym = 0x06b8
	KeyCyrillicLJE            Keysym = 0x06b9
	KeyCyrillicNJE            Keysym = 0x06ba
	KeySerbianTSHE            Keysym = 0x06bb
	KeyMacedoniaKJE           Keysym = 0x06bc
	KeyUkrainianGHEWITHUPTURN Keysym = 0x06bd
	KeyByelorussianSHORTU     Keysym = 0x06be
	KeyCyrillicDZHE           Keysym = 0x06bf
	KeyCyrillicYu             Keysym = 0x06c0
	KeyCyrillicA              Keysym = 0x06c1
	KeyCyrillicBe             Keysym = 0x06c2
	KeyCyrillicTse            Keysym = 0x06c3
	KeyCyrillicDe             Keysym = 0x06c4
	KeyCyrillicIe             Keysym = 0x06c5
	KeyCyrillicEf             Keysym = 0x06c6
	KeyCyrillicGhe            Keysym = 0x06c7
	KeyCyrillicHa             Keysym = 0x06c8
	KeyCyrillicI              Keysym = 0x06c9
	KeyCyrillicShorti         Keysym = 0x06ca
	KeyCyrillicKa             Keysym = 0x06cb
	KeyCyrillicEl             Keysym = 0x06cc
	KeyCyrillicEm             Keysym = 0x06cd
	KeyCyrillicEn             Keysym = 0x06ce
	KeyCyrillicO              Keysym = 0x06cf
	KeyCyrillicPe             Keysym = 0x06d0
	KeyCyrillicYa             Keysym = 0x06d1
	KeyCyrillicEr             Keysym = 0x06d2
	KeyCyrillicEs             Keysym = 0x06d3
	KeyCyrillicTe             Keysym = 0x06d4
	KeyCyrillicU              Keysym = 0x06d5
	KeyCyrillicZhe            Keysym = 0x06d6
	KeyCyrillicVe             Keysym = 0x06d7
	KeyCyrillicSoftsign       Keysym = 0x06d8
	KeyCyrillicYeru           Keysym = 0x06d9
	KeyCyrillicZe             Keysym = 0x06da
	KeyCyrillicSha            Keysym = 0x06db
	KeyCyrillicE              Keysym = 0x06dc
	KeyCyrillicShcha          Keysym = 0x06dd
	KeyCyrillicChe            Keysym = 0x06de
	KeyCyrillicHardsign       Keysym = 0x06df
	KeyCyrillicYU             Keysym = 0x06e0
	KeyCyrillicBE             Keysym = 0x06e2
	KeyCyrillicTSE            Keysym = 0x06e3
	KeyCyrillicDE             Keysym = 0x06e4
	KeyCyrillicIE             Keysym = 0x06e5
	KeyCyrillicEF             Keysym = 0x06e6
	KeyCyrillicGHE            Keysym = 0x06e7
	KeyCyrillicHA             Keysym = 0x06e8
	KeyCyrillicSHORTI         Keysym = 0x06ea
	KeyCyrillicKA             Keysym = 0x06eb
	KeyCyrillicEL             Keysym = 0x06ec
	KeyCyrillicEM             Keysym = 0x06ed
	KeyCyrillicEN             Keysym = 0x06ee
	KeyCyrillicPE             Keysym = 0x06f0
	KeyCyrillicYA             Keysym = 0x06f1
	KeyCyrillicER             Keysym = 0x06f2
	KeyCyrillicES             Keysym = 0x06f3
	KeyCyrillicTE             Keysym = 0x06f4
	KeyCyrillicZHE            Keysym = 0x06f6
	KeyCyrillicVE             Keysym = 0x06f7
	KeyCyrillicSOFTSIGN       Keysym = 0x06f8
	KeyCyrillicYERU           Keysym = 0x06f9
	KeyCyrillicZE             Keysym = 0x06fa
	KeyCyrillicSHA            Keysym = 0x06fb
	KeyCyrillicSHCHA          Keysym = 0x06fd
	KeyCyrillicCHE            Keysym = 0x06fe
	KeyCyrillicHARDSIGN       Keysym = 0x06ff

	// Greek
	KeyGreekALPHAaccent           Keysym = 0x07a1
	KeyGreekEPSILONaccent         Keysym = 0x07a2
	KeyGreekETAaccent             Keysym = 0x07a3
	KeyGreekIOTAaccent            Keysym = 0x07a4
	KeyGreekIOTAdieresis          Keysym = 0x07a5
	KeyGreekOMICRONaccent         Keysym = 0x07a7
	KeyGreekUPSILONaccent         Keysym = 0x07a8
	KeyGreekUPSILONdieresis       Keysym = 0x07a9
	KeyGreekOMEGAaccent           Keysym = 0x07ab
	KeyGreekAccentdieresis        Keysym = 0x07ae
	KeyGreekHorizbar              Keysym = 0x07af
	KeyGreekAlphaaccent           Keysym = 0x07b1
	KeyGreekEpsilonaccent         Keysym = 0x07b2
	KeyGreekEtaaccent             Keysym = 0x07b3
	KeyGreekIotaaccent            Keysym = 0x07b4
	KeyGreekIotadieresis          Keysym = 0x07b5
	KeyGreekIotaaccentdieresis    Keysym = 0x07b6
	KeyGreekOmicronaccent         Keysym = 0x07b7
	KeyGreekUpsilonaccent         Keysym = 0x07b8
	KeyGreekUpsilondieresis       Keysym = 0x07b9
	KeyGreekUpsilonaccentdieresis Keysym = 0x07ba
	KeyGreekOmegaaccent           Keysym = 0x07bb
	KeyGreekALPHA                 Keysym = 0x07c1
	KeyGreekBETA                  Keysym = 0x07c2
	KeyGreekGAMMA                 Keysym = 0x07c3
	KeyGreekDELTA                 Keysym = 0x07c4
	KeyGreekEPSILON               Keysym = 0x07c5
	KeyGreekZETA                  Keysym = 0x07c6
	KeyGreekETA                   Keysym = 0x07c7
	KeyGreekTHETA                 Keysym = 0x07c8
	KeyGreekIOTA                  Keysym = 0x07c9
	KeyGreekKAPPA                 Keysym = 0x07ca
	KeyGreekLAMDA                 Keysym = 0x07cb
	KeyGreekMU                    Keysym = 0x07cc
	KeyGreekNU                    Keysym = 0x07cd
	KeyGreekXI                    Keysym = 0x07ce
	KeyGreekOMICRON               Keysym = 0x07cf
	KeyGreekPI                    Keysym = 0x07d0
	KeyGreekRHO                   Keysym = 0x07d1
	KeyGreekSIGMA                 Keysym = 0x07d2
	KeyGreekTAU                   Keysym = 0x07d4
	KeyGreekUPSILON               Keysym = 0x07d5
	KeyGreekPHI                   Keysym = 0x07d6
	KeyGreekCHI                   Keysym = 0x07d7
	KeyGreekPSI                   Keysym = 0x07d8
	KeyGreekOMEGA                 Keysym = 0x07d9
	KeyGreekAlpha                 Keysym = 0x07e1
	KeyGreekBeta                  Keysym = 0x07e2
	KeyGreekGamma                 Keysym = 0x07e3
	KeyGreekDelta                 Keysym = 0x07e4
	KeyGreekEpsilon               Keysym = 0x07e5
	KeyGreekZeta                  Keysym = 0x07e6
	KeyGreekEta                   Keysym = 0x07e7
	KeyGreekTheta                 Keysym = 0x07e8
	KeyGreekIota                  Keysym = 0x07e9
	KeyGreekKappa                 Keysym = 0x07ea
	KeyGreekLamda                 Keysym = 0x07eb
	KeyGreekMu                    Keysym = 0x07ec
	KeyGreekNu                    Keysym = 0x07ed
	KeyGreekXi                    Keysym = 0x07ee
	KeyGreekOmicron               Keysym = 0x07ef
	KeyGreekPi                    Keysym = 0x07f0
	KeyGreekRho                   Keysym = 0x07f1
	KeyGreekSigma                 Keysym = 0x07f2
	KeyGreekFinalsmallsigma       Keysym = 0x07f3
	KeyGreekTau                   Keysym = 0x07f4
	KeyGreekUpsilon               Keysym = 0x07f5
	KeyGreekPhi                   Keysym = 0x07f6
	KeyGreekChi                   Keysym = 0x07f7
	KeyGreekPsi                   Keysym = 0x07f8
	KeyGreekOmega                 Keysym = 0x07f9

	// Technical
	KeyLeftradical               Keysym = 0x08a1
	KeyTopleftradical            Keysym = 0x08a2
	KeyHorizconnector            Keysym = 0x08a3
	KeyTopintegral               Keysym = 0x08a4
	KeyBotintegral               Keysym = 0x08a5
	KeyVertconnector             Keysym = 0x08a6
	KeyTopleftsqbracket          Keysym = 0x08a7
	KeyBotleftsqbracket          Keysym = 0x08a8
	KeyToprightsqbracket         Keysym = 0x08a9
	KeyBotrightsqbracket         Keysym = 0x08aa
	KeyTopleftparens             Keysym = 0x08ab
	KeyBotleftparens             Keysym = 0x08ac
	KeyToprightparens            Keysym = 0x08ad
	KeyBotrightparens            Keysym = 0x08ae
	KeyLeftmiddlecurlybrace      Keysym = 0x08af
	KeyRightmiddlecurlybrace     Keysym = 0x08b0
	KeyTopleftsummation          Keysym = 0x08b1
	KeyBotleftsummation          Keysym = 0x08b2
	KeyTopvertsummationconnector Keysym = 0x08b3
	KeyBotvertsummationconnector Keysym = 0x08b4
	KeyToprightsummation         Keysym = 0x08b5
	KeyBotrightsummation         Keysym = 0x08b6
	KeyRightmiddlesummation      Keysym = 0x08b7
	KeyLessthanequal             Keysym = 0x08bc
	KeyNotequal                  Keysym = 0x08bd
	KeyGreaterthanequal          Keysym = 0x08be
	KeyIntegral                  Keysym = 0x08bf
	KeyTherefore                 Keysym = 0x08c0
	KeyVariation                 Keysym = 0x08c1
	KeyInfinity                  Keysym = 0x08c2
	KeyNabla                     Keysym = 0x08c5
	KeyApproximate               Keysym = 0x08c8
	KeySimilarequal              Keysym = 0x08c9
	KeyIfonlyif                  Keysym = 0x08cd
	KeyImplies                   Keysym = 0x08ce
	KeyIdentical                 Keysym = 0x08cf
	KeyRadical                   Keysym = 0x08d6
	KeyIncludedin                Keysym = 0x08da
	KeyIncludes                  Keysym = 0x08db
	KeyIntersection              Keysym = 0x08dc
	KeyUnion                     Keysym = 0x08dd
	KeyLogicaland                Keysym = 0x08de
	KeyLogicalor                 Keysym = 0x08df
	KeyPartialderivative         Keysym = 0x08ef
	KeyFunction                  Keysym = 0x08f6
	KeyLeftarrow                 Keysym = 0x08fb
	KeyUparrow                   Keysym = 0x08fc
	KeyRightarrow                Keysym = 0x08fd
	KeyDownarrow                 Keysym = 0x08fe

	// Special
	KeyBlank          Keysym = 0x09df
	KeySoliddiamond   Keysym = 0x09e0
	KeyCheckerboard   Keysym = 0x09e1
	KeyHt             Keysym = 0x09e2
	KeyFf             Keysym = 0x09e3
	KeyCr             Keysym = 0x09e4
	KeyLf             Keysym = 0x09e5
	KeyNl             Keysym = 0x09e8
	KeyVt             Keysym = 0x09e9
	KeyLowrightcorner Keysym = 0x09ea
	KeyUprightcorner  Keysym = 0x09eb
	KeyUpleftcorner   Keysym = 0x09ec
	KeyLowleftcorner  Keysym = 0x09ed
	KeyCrossinglines  Keysym = 0x09ee
	KeyHorizlinescan1 Keysym = 0x09ef
	KeyHorizlinescan3 Keysym = 0x09f0
	KeyHorizlinescan5 Keysym = 0x09f1
	KeyHorizlinescan7 Keysym = 0x09f2
	KeyHorizlinescan9 Keysym = 0x09f3
	KeyLeftt          Keysym = 0x09f4
	KeyRightt         Keysym = 0x09f5
	KeyBott           Keysym = 0x09f6
	KeyTopt           Keysym = 0x09f7
	KeyVertbar        Keysym = 0x09f8

	// Publishing
	KeyEmspace              Keysym = 0x0aa1
	KeyEnspace              Keysym = 0x0aa2
	KeyEm3space             Keysym = 0x0aa3
	KeyEm4space             Keysym = 0x0aa4
	KeyDigitspace           Keysym = 0x0aa5
	KeyPunctspace           Keysym = 0x0aa6
	KeyThinspace            Keysym = 0x0aa7
	KeyHairspace            Keysym = 0x0aa8
	KeyEmdash               Keysym = 0x0aa9
	KeyEndash               Keysym = 0x0aaa
	KeySignifblank          Keysym = 0x0aac
	KeyEllipsis             Keysym = 0x0aae
	KeyDoubbaselinedot      Keysym = 0x0aaf
	KeyOnethird             Keysym = 0x0ab0
	KeyTwothirds            Keysym = 0x0ab1
	KeyOnefifth             Keysym = 0x0ab2
	KeyTwofifths            Keysym = 0x0ab3
	KeyThreefifths          Keysym = 0x0ab4
	KeyFourfifths           Keysym = 0x0ab5
	KeyOnesixth             Keysym = 0x0ab6
	KeyFivesixths           Keysym = 0x0ab7
	KeyCareof               Keysym = 0x0ab8
	KeyFigdash              Keysym = 0x0abb
	KeyLeftanglebracket     Keysym = 0x0abc
	KeyDecimalpoint         Keysym = 0x0abd
	KeyRightanglebracket    Keysym = 0x0abe
	KeyMarker               Keysym = 0x0abf
	KeyOneeighth            Keysym = 0x0ac3
	KeyThreeeighths         Keysym = 0x0ac4
	KeyFiveeighths          Keysym = 0x0ac5
	KeySeveneighths         Keysym = 0x0ac6
	KeyTrademark            Keysym = 0x0ac9
	KeySignaturemark        Keysym = 0x0aca
	KeyTrademarkincircle    Keysym = 0x0acb
	KeyLeftopentriangle     Keysym = 0x0acc
	KeyRightopentriangle    Keysym = 0x0acd
	KeyEmopencircle         Keysym = 0x0ace
	KeyEmopenrectangle      Keysym = 0x0acf
	KeyLeftsinglequotemark  Keysym = 0x0ad0
	KeyRightsinglequotemark Keysym = 0x0ad1
	KeyLeftdoublequotemark  Keysym = 0x0ad2
	KeyRightdoublequotemark Keysym = 0x0ad3
	KeyPrescription         Keysym = 0x0ad4
	KeyPermille             Keysym = 0x0ad5
	KeyMinutes              Keysym = 0x0ad6
	KeySeconds              Keysym = 0x0ad7
	KeyLatincross           Keysym = 0x0ad9
	KeyHexagram             Keysym = 0x0ada
	KeyFilledrectbullet     Keysym = 0x0adb
	KeyFilledlefttribullet  Keysym = 0x0adc
	KeyFilledrighttribullet Keysym = 0x0add
	KeyEmfilledcircle       Keysym = 0x0ade
	KeyEmfilledrect         Keysym = 0x0adf
	KeyEnopencircbullet     Keysym = 0x0ae0
	KeyEnopensquarebullet   Keysym = 0x0ae1
	KeyOpenrectbullet       Keysym = 0x0ae2
	KeyOpentribulletup      Keysym = 0x0ae3
	KeyOpentribulletdown    Keysym = 0x0ae4
	KeyOpenstar             Keysym = 0x0ae5
	KeyEnfilledcircbullet   Keysym = 0x0ae6
	KeyEnfilledsqbullet     Keysym = 0x0ae7
	KeyFilledtribulletup    Keysym = 0x0ae8
	KeyFilledtribulletdown  Keysym = 0x0ae9
	KeyLeftpointer          Keysym = 0x0aea
	KeyRightpointer         Keysym = 0x0aeb
	KeyClub                 Keysym = 0x0aec
	KeyDiamond              Keysym = 0x0aed
	KeyHeart                Keysym = 0x0aee
	KeyMaltesecross         Keysym = 0x0af0
	KeyDagger               Keysym = 0x0af1
	KeyDoubledagger         Keysym = 0x0af2
	KeyCheckmark            Keysym = 0x0af3
	KeyBallotcross          Keysym = 0x0af4
	KeyMusicalsharp         Keysym = 0x0af5
	KeyMusicalflat          Keysym = 0x0af6
	KeyMalesymbol           Keysym = 0x0af7
	KeyFemalesymbol         Keysym = 0x0af8
	KeyTelephone            Keysym = 0x0af9
	KeyTelephonerecorder    Keysym = 0x0afa
	KeyPhonographcopyright  Keysym = 0x0afb
	KeyCaret                Keysym = 0x0afc
	KeySinglelowquotemark   Keysym = 0x0afd
	KeyDoublelowquotemark   Keysym = 0x0afe
	KeyCursor               Keysym = 0x0aff

	// APL
	KeyLeftcaret  Keysym = 0x0ba3
	KeyRightcaret Keysym = 0x0ba6
	KeyDowncaret  Keysym = 0x0ba8
	KeyUpcaret    Keysym = 0x0ba9
	KeyOverbar    Keysym = 0x0bc0
	KeyDowntack   Keysym = 0x0bc2
	KeyUpshoe     Keysym = 0x0bc3
	KeyDownstile  Keysym = 0x0bc4
	KeyUnderbar   Keysym = 0x0bc6
	KeyJot        Keysym = 0x0bca
	KeyQuad       Keysym = 0x0bcc
	KeyUptack     Keysym = 0x0bce
	KeyCircle     Keysym = 0x0bcf
	KeyUpstile    Keysym = 0x0bd3
	KeyDownshoe   Keysym = 0x0bd6
	KeyRightshoe  Keysym = 0x0bd8
	KeyLeftshoe   Keysym = 0x0bda
	KeyLefttack   Keysym = 0x0bdc
	KeyRighttack  Keysym = 0x0bfc

	// Hebrew
	KeyHebrewDoublelowline Keysym = 0x0cdf
	KeyHebrewAleph         Keysym = 0x0ce0
	KeyHebrewBet           Keysym = 0x0ce1
	KeyHebrewGimel         Keysym = 0x0ce2
	KeyHebrewDalet         Keysym = 0x0ce3
	KeyHebrewHe            Keysym = 0x0ce4
	KeyHebrewWaw           Keysym = 0x0ce5
	KeyHebrewZain          Keysym = 0x0ce6
	KeyHebrewChet          Keysym = 0x0ce7
	KeyHebrewTet           Keysym = 0x0ce8
	KeyHebrewYod           Keysym = 0x0ce9
	KeyHebrewFinalkaph     Keysym = 0x0cea
	KeyHebrewKaph          Keysym = 0x0ceb
	KeyHebrewLamed         Keysym = 0x0cec
	KeyHebrewFinalmem      Keysym = 0x0ced
	KeyHebrewMem           Keysym = 0x0cee
	KeyHebrewFinalnun      Keysym = 0x0cef
	KeyHebrewNun           Keysym = 0x0cf0
	KeyHebrewSamech        Keysym = 0x0cf1
	KeyHebrewAyin          Keysym = 0x0cf2
	KeyHebrewFinalpe       Keysym = 0x0cf3
	KeyHebrewPe            Keysym = 0x0cf4
	KeyHebrewFinalzade     Keysym = 0x0cf5
	KeyHebrewZade          Keysym = 0x0cf6
	KeyHebrewQoph          Keysym = 0x0cf7
	KeyHebrewResh          Keysym = 0x0cf8
	KeyHebrewShin          Keysym = 0x0cf9
	KeyHebrewTaw           Keysym = 0x0cfa

	// Thai
	KeyThaiKokai            Keysym = 0x0da1
	KeyThaiKhokhai          Keysym = 0x0da2
	KeyThaiKhokhuat         Keysym = 0x0da3
	KeyThaiKhokhwai         Keysym = 0x0da4
	KeyThaiKhokhon          Keysym = 0x0da5
	KeyThaiKhorakhang       Keysym = 0x0da6
	KeyThaiNgongu           Keysym = 0x0da7
	KeyThaiChochan          Keysym = 0x0da8
	KeyThaiChoching         Keysym = 0x0da9
	KeyThaiChochang         Keysym = 0x0daa
	KeyThaiSoso             Keysym = 0x0dab
	KeyThaiChochoe          Keysym = 0x0dac
	KeyThaiYoying           Keysym = 0x0dad
	KeyThaiDochada          Keysym = 0x0dae
	KeyThaiTopatak          Keysym = 0x0daf
	KeyThaiThothan          Keysym = 0x0db0
	KeyThaiThonangmontho    Keysym = 0x0db1
	KeyThaiThophuthao       Keysym = 0x0db2
	KeyThaiNonen            Keysym = 0x0db3
	KeyThaiDodek            Keysym = 0x0db4
	KeyThaiTotao            Keysym = 0x0db5
	KeyThaiThothung         Keysym = 0x0db6
	KeyThaiThothahan        Keysym = 0x0db7
	KeyThaiThothong         Keysym = 0x0db8
	KeyThaiNonu             Keysym = 0x0db9
	KeyThaiBobaimai         Keysym = 0x0dba
	KeyThaiPopla            Keysym = 0x0dbb
	KeyThaiPhophung         Keysym = 0x0dbc
	KeyThaiFofa             Keysym = 0x0dbd
	KeyThaiPhophan          Keysym = 0x0dbe
	KeyThaiFofan            Keysym = 0x0dbf
	KeyThaiPhosamphao       Keysym = 0x0dc0
	KeyThaiMoma             Keysym = 0x0dc1
	KeyThaiYoyak            Keysym = 0x0dc2
	KeyThaiRorua            Keysym = 0x0dc3
	KeyThaiRu               Keysym = 0x0dc4
	KeyThaiLoling           Keysym = 0x0dc5
	KeyThaiLu               Keysym = 0x0dc6
	KeyThaiWowaen           Keysym = 0x0dc7
	KeyThaiSosala           Keysym = 0x0dc8
	KeyThaiSorusi           Keysym = 0x0dc9
	KeyThaiSosua            Keysym = 0x0dca
	KeyThaiHohip            Keysym = 0x0dcb
	KeyThaiLochula          Keysym = 0x0dcc
	KeyThaiOang             Keysym = 0x0dcd
	KeyThaiHonokhuk         Keysym = 0x0dce
	KeyThaiPaiyannoi        Keysym = 0x0dcf
	KeyThaiSaraa            Keysym = 0x0dd0
	KeyThaiMaihanakat       Keysym = 0x0dd1
	KeyThaiSaraaa           Keysym = 0x0dd2
	KeyThaiSaraam           Keysym = 0x0dd3
	KeyThaiSarai            Keysym = 0x0dd4
	KeyThaiSaraii           Keysym = 0x0dd5
	KeyThaiSaraue           Keysym = 0x0dd6
	KeyThaiSarauee          Keysym = 0x0dd7
	KeyThaiSarau            Keysym = 0x0dd8
	KeyThaiSarauu           Keysym = 0x0dd9
	KeyThaiPhinthu          Keysym = 0x0dda
	KeyThaiMaihanakatMaitho Keysym = 0x0dde
	KeyThaiBaht             Keysym = 0x0ddf
	KeyThaiSarae            Keysym = 0x0de0
	KeyThaiSaraae           Keysym = 0x0de1
	KeyThaiSarao            Keysym = 0x0de2
	KeyThaiSaraaimaimuan    Keysym = 0x0de3
	KeyThaiSaraaimaimalai   Keysym = 0x0de4
	KeyThaiLakkhangyao      Keysym = 0x0de5
	KeyThaiMaiyamok         Keysym = 0x0de6
	KeyThaiMaitaikhu        Keysym = 0x0de7
	KeyThaiMaiek            Keysym = 0x0de8
	KeyThaiMaitho           Keysym = 0x0de9
	KeyThaiMaitri           Keysym = 0x0dea
	KeyThaiMaichattawa      Keysym = 0x0deb
	KeyThaiThanthakhat      Keysym = 0x0dec
	KeyThaiNikhahit         Keysym = 0x0ded
	KeyThaiLeksun           Keysym = 0x0df0
	KeyThaiLeknung          Keysym = 0x0df1
	KeyThaiLeksong          Keysym = 0x0df2
	KeyThaiLeksam           Keysym = 0x0df3
	KeyThaiLeksi            Keysym = 0x0df4
	KeyThaiLekha            Keysym = 0x0df5
	KeyThaiLekhok           Keysym = 0x0df6
	KeyThaiLekchet          Keysym = 0x0df7
	KeyThaiLekpaet          Keysym = 0x0df8
	KeyThaiLekkao           Keysym = 0x0df9

	// Korean
	KeyHangulKiyeog             Keysym = 0x0ea1
	KeyHangulSsangKiyeog        Keysym = 0x0ea2
	KeyHangulKiyeogSios         Keysym = 0x0ea3
	KeyHangulNieun              Keysym = 0x0ea4
	KeyHangulNieunJieuj         Keysym = 0x0ea5
	KeyHangulNieunHieuh         Keysym = 0x0ea6
	KeyHangulDikeud             Keysym = 0x0ea7
	KeyHangulSsangDikeud        Keysym = 0x0ea8
	KeyHangulRieul              Keysym = 0x0ea9
	KeyHangulRieulKiyeog        Keysym = 0x0eaa
	KeyHangulRieulMieum         Keysym = 0x0eab
	KeyHangulRieulPieub         Keysym = 0x0eac
	KeyHangulRieulSios          Keysym = 0x0ead
	KeyHangulRieulTieut         Keysym = 0x0eae
	KeyHangulRieulPhieuf        Keysym = 0x0eaf
	KeyHangulRieulHieuh         Keysym = 0x0eb0
	KeyHangulMieum              Keysym = 0x0eb1
	KeyHangulPieub              Keysym = 0x0eb2
	KeyHangulSsangPieub         Keysym = 0x0eb3
	KeyHangulPieubSios          Keysym = 0x0eb4
	KeyHangulSios               Keysym = 0x0eb5
	KeyHangulSsangSios          Keysym = 0x0eb6
	KeyHangulIeung              Keysym = 0x0eb7
	KeyHangulJieuj              Keysym = 0x0eb8
	KeyHangulSsangJieuj         Keysym = 0x0eb9
	KeyHangulCieuc              Keysym = 0x0eba
	KeyHangulKhieuq             Keysym = 0x0ebb
	KeyHangulTieut              Keysym = 0x0ebc
	KeyHangulPhieuf             Keysym = 0x0ebd
	KeyHangulHieuh              Keysym = 0x0ebe
	KeyHangulA                  Keysym = 0x0ebf
	KeyHangulAE                 Keysym = 0x0ec0
	KeyHangulYA                 Keysym = 0x0ec1
	KeyHangulYAE                Keysym = 0x0ec2
	KeyHangulEO                 Keysym = 0x0ec3
	KeyHangulE                  Keysym = 0x0ec4
	KeyHangulYEO                Keysym = 0x0ec5
	KeyHangulYE                 Keysym = 0x0ec6
	KeyHangulO                  Keysym = 0x0ec7
	KeyHangulWA                 Keysym = 0x0ec8
	KeyHangulWAE                Keysym = 0x0ec9
	KeyHangulOE                 Keysym = 0x0eca
	KeyHangulYO                 Keysym = 0x0ecb
	KeyHangulU                  Keysym = 0x0ecc
	KeyHangulWEO                Keysym = 0x0ecd
	KeyHangulWE                 Keysym = 0x0ece
	KeyHangulWI                 Keysym = 0x0ecf
	KeyHangulYU                 Keysym = 0x0ed0
	KeyHangulEU                 Keysym = 0x0ed1
	KeyHangulYI                 Keysym = 0x0ed2
	KeyHangulI                  Keysym = 0x0ed3
	KeyHangulJKiyeog            Keysym = 0x0ed4
	KeyHangulJSsangKiyeog       Keysym = 0x0ed5
	KeyHangulJKiyeogSios        Keysym = 0x0ed6
	KeyHangulJNieun             Keysym = 0x0ed7
	KeyHangulJNieunJieuj        Keysym = 0x0ed8
	KeyHangulJNieunHieuh        Keysym = 0x0ed9
	KeyHangulJDikeud            Keysym = 0x0eda
	KeyHangulJRieul             Keysym = 0x0edb
	KeyHangulJRieulKiyeog       Keysym = 0x0edc
	KeyHangulJRieulMieum        Keysym = 0x0edd
	KeyHangulJRieulPieub        Keysym = 0x0ede
	KeyHangulJRieulSios         Keysym = 0x0edf
	KeyHangulJRieulTieut        Keysym = 0x0ee0
	KeyHangulJRieulPhieuf       Keysym = 0x0ee1
	KeyHangulJRieulHieuh        Keysym = 0x0ee2
	KeyHangulJMieum             Keysym = 0x0ee3
	KeyHangulJPieub             Keysym = 0x0ee4
	KeyHangulJPieubSios         Keysym = 0x0ee5
	KeyHangulJSios              Keysym = 0x0ee6
	KeyHangulJSsangSios         Keysym = 0x0ee7
	KeyHangulJIeung             Keysym = 0x0ee8
	KeyHangulJJieuj             Keysym = 0x0ee9
	KeyHangulJCieuc             Keysym = 0x0eea
	KeyHangulJKhieuq            Keysym = 0x0eeb
	KeyHangulJTieut             Keysym = 0x0eec
	KeyHangulJPhieuf            Keysym = 0x0eed
	KeyHangulJHieuh             Keysym = 0x0eee
	KeyHangulRieulYeorinHieuh   Keysym = 0x0eef
	KeyHangulSunkyeongeumMieum  Keysym = 0x0ef0
	KeyHangulSunkyeongeumPieub  Keysym = 0x0ef1
	KeyHangulPanSios            Keysym = 0x0ef2
	KeyHangulKkogjiDalrinIeung  Keysym = 0x0ef3
	KeyHangulSunkyeongeumPhieuf Keysym = 0x0ef4
	KeyHangulYeorinHieuh        Keysym = 0x0ef5
	KeyHangulAraeA              Keysym = 0x0ef6
	KeyHangulAraeAE             Keysym = 0x0ef7
	KeyHangulJPanSios           Keysym = 0x0ef8
	KeyHangulJKkogjiDalrinIeung Keysym = 0x0ef9
	KeyHangulJYeorinHieuh       Keysym = 0x0efa
	KeyKoreanWon                Keysym = 0x0eff

	// Other
	KeyOE               Keysym = 0x13bc
	KeyOe               Keysym = 0x13bd
	KeyEuroSign         Keysym = 0x20ac
	Key3270Duplicate    Keysym = 0xfd01
	Key3270FieldMark    Keysym = 0xfd02
	Key3270Right2       Keysym = 0xfd03
	Key3270Left2        Keysym = 0xfd04
	Key3270BackTab      Keysym = 0xfd05
	Key3270EraseEOF     Keysym = 0xfd06
	Key3270EraseInput   Keysym = 0xfd07
	Key3270Reset        Keysym = 0xfd08
	Key3270Quit         Keysym = 0xfd09
	Key3270PA1          Keysym = 0xfd0a
	Key3270PA2          Keysym = 0xfd0b
	Key3270PA3          Keysym = 0xfd0c
	Key3270Test         Keysym = 0xfd0d
	Key3270Attn         Keysym = 0xfd0e
	Key3270CursorBlink  Keysym = 0xfd0f
	Key3270AltCursor    Keysym = 0xfd10
	Key3270KeyClick     Keysym = 0xfd11
	Key3270Jump         Keysym = 0xfd12
	Key3270Ident        Keysym = 0xfd13
	Key3270Rule         Keysym = 0xfd14
	Key3270Copy         Keysym = 0xfd15
	Key3270Play         Keysym = 0xfd16
	Key3270Setup        Keysym = 0xfd17
	Key3270Record       Keysym = 0xfd18
	Key3270ChangeScreen Keysym = 0xfd19
	Key3270DeleteWord   Keysym = 0xfd1a
	Key3270ExSelect     Keysym = 0xfd1b
	Key3270CursorSelect Keysym = 0xfd1c
	Key3270PrintScreen  Keysym = 0xfd1d
	Key3270Enter        Keysym = 0xfd1e

	// ISO 9995 / Dead Keys
	KeyISOLock                   Keysym = 0xfe01
	KeyISOLevel2Latch            Keysym = 0xfe02
	KeyISOLevel3Shift            Keysym = 0xfe03
	KeyISOLevel3Latch            Keysym = 0xfe04
	KeyISOLevel3Lock             Keysym = 0xfe05
	KeyISOGroupLatch             Keysym = 0xfe06
	KeyISOGroupLock              Keysym = 0xfe07
	KeyISONextGroup              Keysym = 0xfe08
	KeyISONextGroupLock          Keysym = 0xfe09
	KeyISOPrevGroup              Keysym = 0xfe0a
	KeyISOPrevGroupLock          Keysym = 0xfe0b
	KeyISOFirstGroup             Keysym = 0xfe0c
	KeyISOFirstGroupLock         Keysym = 0xfe0d
	KeyISOLastGroup              Keysym = 0xfe0e
	KeyISOLastGroupLock          Keysym = 0xfe0f
	KeyISOLevel5Shift            Keysym = 0xfe11
	KeyISOLevel5Latch            Keysym = 0xfe12
	KeyISOLevel5Lock             Keysym = 0xfe13
	KeyISOLeftTab                Keysym = 0xfe20
	KeyISOMoveLineUp             Keysym = 0xfe21
	KeyISOMoveLineDown           Keysym = 0xfe22
	KeyISOPartialLineUp          Keysym = 0xfe23
	KeyISOPartialLineDown        Keysym = 0xfe24
	KeyISOPartialSpaceLeft       Keysym = 0xfe25
	KeyISOPartialSpaceRight      Keysym = 0xfe26
	KeyISOSetMarginLeft          Keysym = 0xfe27
	KeyISOSetMarginRight         Keysym = 0xfe28
	KeyISOReleaseMarginLeft      Keysym = 0xfe29
	KeyISOReleaseMarginRight     Keysym = 0xfe2a
	KeyISOReleaseBothMargins     Keysym = 0xfe2b
	KeyISOFastCursorLeft         Keysym = 0xfe2c
	KeyISOFastCursorRight        Keysym = 0xfe2d
	KeyISOFastCursorUp           Keysym = 0xfe2e
	KeyISOFastCursorDown         Keysym = 0xfe2f
	KeyISOContinuousUnderline    Keysym = 0xfe30
	KeyISODiscontinuousUnderline Keysym = 0xfe31
	KeyISOEmphasize              Keysym = 0xfe32
	KeyISOCenterObject           Keysym = 0xfe33
	KeyISOEnter                  Keysym = 0xfe34
	KeyDeadGrave                 Keysym = 0xfe50
	KeyDeadAcute                 Keysym = 0xfe51
	KeyDeadCircumflex            Keysym = 0xfe52
	KeyDeadTilde                 Keysym = 0xfe53
	KeyDeadMacron                Keysym = 0xfe54
	KeyDeadBreve                 Keysym = 0xfe55
	KeyDeadAbovedot              Keysym = 0xfe56
	KeyDeadDiaeresis             Keysym = 0xfe57
	KeyDeadAbovering             Keysym = 0xfe58
	KeyDeadDoubleacute           Keysym = 0xfe59
	KeyDeadCaron                 Keysym = 0xfe5a
	KeyDeadCedilla               Keysym = 0xfe5b
	KeyDeadOgonek                Keysym = 0xfe5c
	KeyDeadIota                  Keysym = 0xfe5d
	KeyDeadVoicedSound           Keysym = 0xfe5e
	KeyDeadSemivoicedSound       Keysym = 0xfe5f
	KeyDeadBelowdot              Keysym = 0xfe60
	KeyDeadHook                  Keysym = 0xfe61
	KeyDeadHorn                  Keysym = 0xfe62
	KeyDeadStroke                Keysym = 0xfe63
	KeyDeadAbovecomma            Keysym = 0xfe64
	KeyDeadAbovereversedcomma    Keysym = 0xfe65
	KeyDeadDoublegrave           Keysym = 0xfe66
	KeyDeadBelowring             Keysym = 0xfe67
	KeyDeadBelowmacron           Keysym = 0xfe68
	KeyDeadBelowcircumflex       Keysym = 0xfe69
	KeyDeadBelowtilde            Keysym = 0xfe6a
	KeyDeadBelowbreve            Keysym = 0xfe6b
	KeyDeadBelowdiaeresis        Keysym = 0xfe6c
	KeyDeadInvertedbreve         Keysym = 0xfe6d
	KeyDeadBelowcomma            Keysym = 0xfe6e
	KeyDeadCurrency              Keysym = 0xfe6f
	KeyAccessXEnable             Keysym = 0xfe70
	KeyAccessXFeedbackEnable     Keysym = 0xfe71
	KeyRepeatKeysEnable          Keysym = 0xfe72
	KeySlowKeysEnable            Keysym = 0xfe73
	KeyBounceKeysEnable          Keysym = 0xfe74
	KeyStickyKeysEnable          Keysym = 0xfe75
	KeyMouseKeysEnable           Keysym = 0xfe76
	KeyMouseKeysAccelEnable      Keysym = 0xfe77
	KeyOverlay1Enable            Keysym = 0xfe78
	KeyOverlay2Enable            Keysym = 0xfe79
	KeyAudibleBellEnable         Keysym = 0xfe7a
	KeyDeadA                     Keysym = 0xfe80
	KeyDeadE                     Keysym = 0xfe82
	KeyDeadI                     Keysym = 0xfe84
	KeyDeadO                     Keysym = 0xfe86
	KeyDeadU                     Keysym = 0xfe88
	KeyDeadSchwa                 Keysym = 0xfe8a
	KeyDeadSCHWA                 Keysym = 0xfe8b
	KeyDeadGreek                 Keysym = 0xfe8c
	KeyDeadHamza                 Keysym = 0xfe8d
	KeyDeadLowline               Keysym = 0xfe90
	KeyDeadAboveverticalline     Keysym = 0xfe91
	KeyDeadBelowverticalline     Keysym = 0xfe92
	KeyDeadLongsolidusoverlay    Keysym = 0xfe93
	KeyCh                        Keysym = 0xfea0
	KeyCH                        Keysym = 0xfea2
	KeyFirstVirtualScreen        Keysym = 0xfed0
	KeyPrevVirtualScreen         Keysym = 0xfed1
	KeyNextVirtualScreen         Keysym = 0xfed2
	KeyLastVirtualScreen         Keysym = 0xfed4
	KeyTerminateServer           Keysym = 0xfed5
	KeyPointerLeft               Keysym = 0xfee0
	KeyPointerRight              Keysym = 0xfee1
	KeyPointerUp                 Keysym = 0xfee2
	KeyPointerDown               Keysym = 0xfee3
	KeyPointerUpLeft             Keysym = 0xfee4
	KeyPointerUpRight            Keysym = 0xfee5
	KeyPointerDownLeft           Keysym = 0xfee6
	KeyPointerDownRight          Keysym = 0xfee7
	KeyPointerButtonDflt         Keysym = 0xfee8
	KeyPointerButton1            Keysym = 0xfee9
	KeyPointerButton2            Keysym = 0xfeea
	KeyPointerButton3            Keysym = 0xfeeb
	KeyPointerButton4            Keysym = 0xfeec
	KeyPointerButton5            Keysym = 0xfeed
	KeyPointerDblClickDflt       Keysym = 0xfeee
	KeyPointerDblClick1          Keysym = 0xfeef
	KeyPointerDblClick2          Keysym = 0xfef0
	KeyPointerDblClick3          Keysym = 0xfef1
	KeyPointerDblClick4          Keysym = 0xfef2
	KeyPointerDblClick5          Keysym = 0xfef3
	KeyPointerDragDflt           Keysym = 0xfef4
	KeyPointerDrag1              Keysym = 0xfef5
	KeyPointerDrag2              Keysym = 0xfef6
	KeyPointerDrag3              Keysym = 0xfef7
	KeyPointerDrag4              Keysym = 0xfef8
	KeyPointerEnableKeys         Keysym = 0xfef9
	KeyPointerAccelerate         Keysym = 0xfefa
	KeyPointerDfltBtnNext        Keysym = 0xfefb
	KeyPointerDfltBtnPrev        Keysym = 0xfefc
	KeyPointerDrag5              Keysym = 0xfefd

	// TTY Function Keys
	KeyBackSpace  Keysym = 0xff08
	KeyTab        Keysym = 0xff09
	KeyLinefeed   Keysym = 0xff0a
	KeyClear      Keysym = 0xff0b
	KeyReturn     Keysym = 0xff0d
	KeyPause      Keysym = 0xff13
	KeyScrollLock Keysym = 0xff14
	KeySysReq     Keysym = 0xff15
	KeyEscape     Keysym = 0xff1b

	// Misc Function Keys
	KeyMultiKey          Keysym = 0xff20
	KeyKanji             Keysym = 0xff21
	KeyMuhenkan          Keysym = 0xff22
	KeyHenkanMode        Keysym = 0xff23
	KeyRomaji            Keysym = 0xff24
	KeyHiragana          Keysym = 0xff25
	KeyKatakana          Keysym = 0xff26
	KeyHiraganaKatakana  Keysym = 0xff27
	KeyZenkaku           Keysym = 0xff28
	KeyHankaku           Keysym = 0xff29
	KeyZenkakuHankaku    Keysym = 0xff2a
	KeyTouroku           Keysym = 0xff2b
	KeyMassyo            Keysym = 0xff2c
	KeyKanaLock          Keysym = 0xff2d
	KeyKanaShift         Keysym = 0xff2e
	KeyEisuShift         Keysym = 0xff2f
	KeyEisuToggle        Keysym = 0xff30
	KeyHangul            Keysym = 0xff31
	KeyHangulStart       Keysym = 0xff32
	KeyHangulEnd         Keysym = 0xff33
	KeyHangulHanja       Keysym = 0xff34
	KeyHangulJamo        Keysym = 0xff35
	KeyHangulRomaja      Keysym = 0xff36
	KeyCodeinput         Keysym = 0xff37
	KeyHangulJeonja      Keysym = 0xff38
	KeyHangulBanja       Keysym = 0xff39
	KeyHangulPreHanja    Keysym = 0xff3a
	KeyHangulPostHanja   Keysym = 0xff3b
	KeySingleCandidate   Keysym = 0xff3c
	KeyMultipleCandidate Keysym = 0xff3d
	KeyPreviousCandidate Keysym = 0xff3e
	KeyHangulSpecial     Keysym = 0xff3f

	// Cursor Control
	KeyHome  Keysym = 0xff50
	KeyLeft  Keysym = 0xff51
	KeyUp    Keysym = 0xff52
	KeyRight Keysym = 0xff53
	KeyDown  Keysym = 0xff54
	KeyPrior Keysym = 0xff55
	KeyNext  Keysym = 0xff56
	KeyEnd   Keysym = 0xff57
	KeyBegin Keysym = 0xff58

	// Misc Functions
	KeySelect  Keysym = 0xff60
	KeyPrint   Keysym = 0xff61
	KeyExecute Keysym = 0xff62
	KeyInsert  Keysym = 0xff63
	KeyUndo    Keysym = 0xff65
	KeyRedo    Keysym = 0xff66
	KeyMenu    Keysym = 0xff67
	KeyFind    Keysym = 0xff68
	KeyCancel  Keysym = 0xff69
	KeyHelp    Keysym = 0xff6a
	KeyBreak   Keysym = 0xff6b

	// Japanese Keyboard
	KeyModeSwitch Keysym = 0xff7e
	KeyNumLock    Keysym = 0xff7f

	// Keypad
	KeyKPSpace     Keysym = 0xff80
	KeyKPTab       Keysym = 0xff89
	KeyKPEnter     Keysym = 0xff8d
	KeyKPF1        Keysym = 0xff91
	KeyKPF2        Keysym = 0xff92
	KeyKPF3        Keysym = 0xff93
	KeyKPF4        Keysym = 0xff94
	KeyKPHome      Keysym = 0xff95
	KeyKPLeft      Keysym = 0xff96
	KeyKPUp        Keysym = 0xff97
	KeyKPRight     Keysym = 0xff98
	KeyKPDown      Keysym = 0xff99
	KeyKPPrior     Keysym = 0xff9a
	KeyKPNext      Keysym = 0xff9b
	KeyKPEnd       Keysym = 0xff9c
	KeyKPBegin     Keysym = 0xff9d
	KeyKPInsert    Keysym = 0xff9e
	KeyKPDelete    Keysym = 0xff9f
	KeyKPMultiply  Keysym = 0xffaa
	KeyKPAdd       Keysym = 0xffab
	KeyKPSeparator Keysym = 0xffac
	KeyKPSubtract  Keysym = 0xffad
	KeyKPDecimal   Keysym = 0xffae
	KeyKPDivide    Keysym = 0xffaf
	KeyKP0         Keysym = 0xffb0
	KeyKP1         Keysym = 0xffb1
	KeyKP2         Keysym = 0xffb2
	KeyKP3         Keysym = 0xffb3
	KeyKP4         Keysym = 0xffb4
	KeyKP5         Keysym = 0xffb5
	KeyKP6         Keysym = 0xffb6
	KeyKP7         Keysym = 0xffb7
	KeyKP8         Keysym = 0xffb8
	KeyKP9         Keysym = 0xffb9
	KeyKPEqual     Keysym = 0xffbd
	KeyF1          Keysym = 0xffbe
	KeyF2          Keysym = 0xffbf

	// Function Keys (F1-F12)
	KeyF3  Keysym = 0xffc0
	KeyF4  Keysym = 0xffc1
	KeyF5  Keysym = 0xffc2
	KeyF6  Keysym = 0xffc3
	KeyF7  Keysym = 0xffc4
	KeyF8  Keysym = 0xffc5
	KeyF9  Keysym = 0xffc6
	KeyF10 Keysym = 0xffc7
	KeyF11 Keysym = 0xffc8
	KeyF12 Keysym = 0xffc9
	KeyF13 Keysym = 0xffca
	KeyF14 Keysym = 0xffcb
	KeyF15 Keysym = 0xffcc
	KeyF16 Keysym = 0xffcd
	KeyF17 Keysym = 0xffce
	KeyF18 Keysym = 0xffcf

	// Function Keys (F13-F35)
	KeyF19 Keysym = 0xffd0
	KeyF20 Keysym = 0xffd1
	KeyF21 Keysym = 0xffd2
	KeyF22 Keysym = 0xffd3
	KeyF23 Keysym = 0xffd4
	KeyF24 Keysym = 0xffd5
	KeyF25 Keysym = 0xffd6
	KeyF26 Keysym = 0xffd7
	KeyF27 Keysym = 0xffd8
	KeyF28 Keysym = 0xffd9
	KeyF29 Keysym = 0xffda
	KeyF30 Keysym = 0xffdb
	KeyF31 Keysym = 0xffdc
	KeyF32 Keysym = 0xffdd
	KeyF33 Keysym = 0xffde
	KeyF34 Keysym = 0xffdf

	// Modifiers
	KeyF35       Keysym = 0xffe0
	KeyShiftL    Keysym = 0xffe1
	KeyShiftR    Keysym = 0xffe2
	KeyControlL  Keysym = 0xffe3
	KeyControlR  Keysym = 0xffe4
	KeyCapsLock  Keysym = 0xffe5
	KeyShiftLock Keysym = 0xffe6
	KeyMetaL     Keysym = 0xffe7
	KeyMetaR     Keysym = 0xffe8
	KeyAltL      Keysym = 0xffe9
	KeyAltR      Keysym = 0xffea
	KeySuperL    Keysym = 0xffeb
	KeySuperR    Keysym = 0xffec
	KeyHyperL    Keysym = 0xffed
	KeyHyperR    Keysym = 0xffee

	// Keyboard (Alarm Keys)
	KeyBrailleDot1  Keysym = 0xfff1
	KeyBrailleDot2  Keysym = 0xfff2
	KeyBrailleDot3  Keysym = 0xfff3
	KeyBrailleDot4  Keysym = 0xfff4
	KeyBrailleDot5  Keysym = 0xfff5
	KeyBrailleDot6  Keysym = 0xfff6
	KeyBrailleDot7  Keysym = 0xfff7
	KeyBrailleDot8  Keysym = 0xfff8
	KeyBrailleDot9  Keysym = 0xfff9
	KeyBrailleDot10 Keysym = 0xfffa
	KeyDelete       Keysym = 0xffff

	// Other
	KeyVoidSymbol Keysym = 0xffffff

	// Unicode
	KeyIbreve                 Keysym = 0x100012c
	KeyWcircumflex            Keysym = 0x1000174
	KeyYcircumflex            Keysym = 0x1000176
	KeySCHWA                  Keysym = 0x100018f
	KeyObarred                Keysym = 0x100019f
	KeyOhorn                  Keysym = 0x10001a0
	KeyUhorn                  Keysym = 0x10001af
	KeyZstroke                Keysym = 0x10001b5
	KeyEZH                    Keysym = 0x10001b7
	KeyOcaron                 Keysym = 0x10001d1
	KeyGcaron                 Keysym = 0x10001e6
	KeySchwa                  Keysym = 0x1000259
	KeyEzh                    Keysym = 0x1000292
	KeyCombiningGrave         Keysym = 0x1000300
	KeyCombiningAcute         Keysym = 0x1000301
	KeyCombiningTilde         Keysym = 0x1000303
	KeyCombiningHook          Keysym = 0x1000309
	KeyCombiningBelowdot      Keysym = 0x1000323
	KeyCyrillicGHEBar         Keysym = 0x1000492
	KeyCyrillicGheBar         Keysym = 0x1000493
	KeyCyrillicZHEDescender   Keysym = 0x1000496
	KeyCyrillicZheDescender   Keysym = 0x1000497
	KeyCyrillicKADescender    Keysym = 0x100049a
	KeyCyrillicKaDescender    Keysym = 0x100049b
	KeyCyrillicKAVertstroke   Keysym = 0x100049c
	KeyCyrillicKaVertstroke   Keysym = 0x100049d
	KeyCyrillicENDescender    Keysym = 0x10004a2
	KeyCyrillicEnDescender    Keysym = 0x10004a3
	KeyCyrillicUStraight      Keysym = 0x10004ae
	KeyCyrillicUStraightBar   Keysym = 0x10004b0
	KeyCyrillicHADescender    Keysym = 0x10004b2
	KeyCyrillicHaDescender    Keysym = 0x10004b3
	KeyCyrillicCHEDescender   Keysym = 0x10004b6
	KeyCyrillicCheDescender   Keysym = 0x10004b7
	KeyCyrillicCHEVertstroke  Keysym = 0x10004b8
	KeyCyrillicCheVertstroke  Keysym = 0x10004b9
	KeyCyrillicSHHA           Keysym = 0x10004ba
	KeyCyrillicShha           Keysym = 0x10004bb
	KeyCyrillicSCHWA          Keysym = 0x10004d8
	KeyCyrillicSchwa          Keysym = 0x10004d9
	KeyCyrillicIMacron        Keysym = 0x10004e2
	KeyCyrillicOBar           Keysym = 0x10004e8
	KeyCyrillicUMacron        Keysym = 0x10004ee
	KeyArmenianAYB            Keysym = 0x1000531
	KeyArmenianBEN            Keysym = 0x1000532
	KeyArmenianGIM            Keysym = 0x1000533
	KeyArmenianDA             Keysym = 0x1000534
	KeyArmenianYECH           Keysym = 0x1000535
	KeyArmenianZA             Keysym = 0x1000536
	KeyArmenianE              Keysym = 0x1000537
	KeyArmenianAT             Keysym = 0x1000538
	KeyArmenianTO             Keysym = 0x1000539
	KeyArmenianZHE            Keysym = 0x100053a
	KeyArmenianINI            Keysym = 0x100053b
	KeyArmenianLYUN           Keysym = 0x100053c
	KeyArmenianKHE            Keysym = 0x100053d
	KeyArmenianTSA            Keysym = 0x100053e
	KeyArmenianKEN            Keysym = 0x100053f
	KeyArmenianHO             Keysym = 0x1000540
	KeyArmenianDZA            Keysym = 0x1000541
	KeyArmenianGHAT           Keysym = 0x1000542
	KeyArmenianTCHE           Keysym = 0x1000543
	KeyArmenianMEN            Keysym = 0x1000544
	KeyArmenianHI             Keysym = 0x1000545
	KeyArmenianNU             Keysym = 0x1000546
	KeyArmenianSHA            Keysym = 0x1000547
	KeyArmenianVO             Keysym = 0x1000548
	KeyArmenianCHA            Keysym = 0x1000549
	KeyArmenianPE             Keysym = 0x100054a
	KeyArmenianJE             Keysym = 0x100054b
	KeyArmenianRA             Keysym = 0x100054c
	KeyArmenianSE             Keysym = 0x100054d
	KeyArmenianVEV            Keysym = 0x100054e
	KeyArmenianTYUN           Keysym = 0x100054f
	KeyArmenianRE             Keysym = 0x1000550
	KeyArmenianTSO            Keysym = 0x1000551
	KeyArmenianVYUN           Keysym = 0x1000552
	KeyArmenianPYUR           Keysym = 0x1000553
	KeyArmenianKE             Keysym = 0x1000554
	KeyArmenianO              Keysym = 0x1000555
	KeyArmenianFE             Keysym = 0x1000556
	KeyArmenianApostrophe     Keysym = 0x100055a
	KeyArmenianAccent         Keysym = 0x100055b
	KeyArmenianExclam         Keysym = 0x100055c
	KeyArmenianSeparationMark Keysym = 0x100055d
	KeyArmenianQuestion       Keysym = 0x100055e
	KeyArmenianAyb            Keysym = 0x1000561
	KeyArmenianBen            Keysym = 0x1000562
	KeyArmenianGim            Keysym = 0x1000563
	KeyArmenianDa             Keysym = 0x1000564
	KeyArmenianYech           Keysym = 0x1000565
	KeyArmenianZa             Keysym = 0x1000566
	KeyArmenianAt             Keysym = 0x1000568
	KeyArmenianTo             Keysym = 0x1000569
	KeyArmenianZhe            Keysym = 0x100056a
	KeyArmenianIni            Keysym = 0x100056b
	KeyArmenianLyun           Keysym = 0x100056c
	KeyArmenianKhe            Keysym = 0x100056d
	KeyArmenianTsa            Keysym = 0x100056e
	KeyArmenianKen            Keysym = 0x100056f
	KeyArmenianHo             Keysym = 0x1000570
	KeyArmenianDza            Keysym = 0x1000571
	KeyArmenianGhat           Keysym = 0x1000572
	KeyArmenianTche           Keysym = 0x1000573
	KeyArmenianMen            Keysym = 0x1000574
	KeyArmenianHi             Keysym = 0x1000575
	KeyArmenianNu             Keysym = 0x1000576
	KeyArmenianSha            Keysym = 0x1000577
	KeyArmenianVo             Keysym = 0x1000578
	KeyArmenianCha            Keysym = 0x1000579
	KeyArmenianPe             Keysym = 0x100057a
	KeyArmenianJe             Keysym = 0x100057b
	KeyArmenianRa             Keysym = 0x100057c
	KeyArmenianSe             Keysym = 0x100057d
	KeyArmenianVev            Keysym = 0x100057e
	KeyArmenianTyun           Keysym = 0x100057f
	KeyArmenianRe             Keysym = 0x1000580
	KeyArmenianTso            Keysym = 0x1000581
	KeyArmenianVyun           Keysym = 0x1000582
	KeyArmenianPyur           Keysym = 0x1000583
	KeyArmenianKe             Keysym = 0x1000584
	KeyArmenianFe             Keysym = 0x1000586
	KeyArmenianLigatureEw     Keysym = 0x1000587
	KeyArmenianFullStop       Keysym = 0x1000589
	KeyArmenianHyphen         Keysym = 0x100058a
	KeyArabicMaddaAbove       Keysym = 0x1000653
	KeyArabicHamzaAbove       Keysym = 0x1000654
	KeyArabicHamzaBelow       Keysym = 0x1000655
	KeyArabic0                Keysym = 0x1000660
	KeyArabic1                Keysym = 0x1000661
	KeyArabic2                Keysym = 0x1000662
	KeyArabic3                Keysym = 0x1000663
	KeyArabic4                Keysym = 0x1000664
	KeyArabic5                Keysym = 0x1000665
	KeyArabic6                Keysym = 0x1000666
	KeyArabic7                Keysym = 0x1000667
	KeyArabic8                Keysym = 0x1000668
	KeyArabic9                Keysym = 0x1000669
	KeyArabicPercent          Keysym = 0x100066a
	KeyArabicSuperscriptAlef  Keysym = 0x1000670
	KeyArabicTteh             Keysym = 0x1000679
	KeyArabicPeh              Keysym = 0x100067e
	KeyArabicTcheh            Keysym = 0x1000686
	KeyArabicDdal             Keysym = 0x1000688
	KeyArabicRreh             Keysym = 0x1000691
	KeyArabicJeh              Keysym = 0x1000698
	KeyArabicVeh              Keysym = 0x10006a4
	KeyArabicKeheh            Keysym = 0x10006a9
	KeyArabicGaf              Keysym = 0x10006af
	KeyArabicNoonGhunna       Keysym = 0x10006ba
	KeyArabicHehDoachashmee   Keysym = 0x10006be
	KeyArabicHehGoal          Keysym = 0x10006c1
	KeyFarsiYeh               Keysym = 0x10006cc
	KeyArabicYehBaree         Keysym = 0x10006d2
	KeyArabicFullstop         Keysym = 0x10006d4
	KeyFarsi0                 Keysym = 0x10006f0
	KeyFarsi1                 Keysym = 0x10006f1
	KeyFarsi2                 Keysym = 0x10006f2
	KeyFarsi3                 Keysym = 0x10006f3
	KeyFarsi4                 Keysym = 0x10006f4
	KeyFarsi5                 Keysym = 0x10006f5
	KeyFarsi6                 Keysym = 0x10006f6
	KeyFarsi7                 Keysym = 0x10006f7
	KeyFarsi8                 Keysym = 0x10006f8
	KeyFarsi9                 Keysym = 0x10006f9
	KeySinhNg                 Keysym = 0x1000d82
	KeySinhH2                 Keysym = 0x1000d83
	KeySinhA                  Keysym = 0x1000d85
	KeySinhAa                 Keysym = 0x1000d86
	KeySinhAe                 Keysym = 0x1000d87
	KeySinhAee                Keysym = 0x1000d88
	KeySinhI                  Keysym = 0x1000d89
	KeySinhIi                 Keysym = 0x1000d8a
	KeySinhU                  Keysym = 0x1000d8b
	KeySinhUu                 Keysym = 0x1000d8c
	KeySinhRi                 Keysym = 0x1000d8d
	KeySinhRii                Keysym = 0x1000d8e
	KeySinhLu                 Keysym = 0x1000d8f
	KeySinhLuu                Keysym = 0x1000d90
	KeySinhE                  Keysym = 0x1000d91
	KeySinhEe                 Keysym = 0x1000d92
	KeySinhAi                 Keysym = 0x1000d93
	KeySinhO                  Keysym = 0x1000d94
	KeySinhOo                 Keysym = 0x1000d95
	KeySinhAu                 Keysym = 0x1000d96
	KeySinhKa                 Keysym = 0x1000d9a
	KeySinhKha                Keysym = 0x1000d9b
	KeySinhGa                 Keysym = 0x1000d9c
	KeySinhGha                Keysym = 0x1000d9d
	KeySinhNg2                Keysym = 0x1000d9e
	KeySinhNga                Keysym = 0x1000d9f
	KeySinhCa                 Keysym = 0x1000da0
	KeySinhCha                Keysym = 0x1000da1
	KeySinhJa                 Keysym = 0x1000da2
	KeySinhJha                Keysym = 0x1000da3
	KeySinhNya                Keysym = 0x1000da4
	KeySinhJnya               Keysym = 0x1000da5
	KeySinhNja                Keysym = 0x1000da6
	KeySinhTta                Keysym = 0x1000da7
	KeySinhTtha               Keysym = 0x1000da8
	KeySinhDda                Keysym = 0x1000da9
	KeySinhDdha               Keysym = 0x1000daa
	KeySinhNna                Keysym = 0x1000dab
	KeySinhNdda               Keysym = 0x1000dac
	KeySinhTha                Keysym = 0x1000dad
	KeySinhThha               Keysym = 0x1000dae
	KeySinhDha                Keysym = 0x1000daf
	KeySinhDhha               Keysym = 0x1000db0
	KeySinhNa                 Keysym = 0x1000db1
	KeySinhNdha               Keysym = 0x1000db3
	KeySinhPa                 Keysym = 0x1000db4
	KeySinhPha                Keysym = 0x1000db5
	KeySinhBa                 Keysym = 0x1000db6
	KeySinhBha                Keysym = 0x1000db7
	KeySinhMa                 Keysym = 0x1000db8
	KeySinhMba                Keysym = 0x1000db9
	KeySinhYa                 Keysym = 0x1000dba
	KeySinhRa                 Keysym = 0x1000dbb
	KeySinhLa                 Keysym = 0x1000dbd
	KeySinhVa                 Keysym = 0x1000dc0
	KeySinhSha                Keysym = 0x1000dc1
	KeySinhSsha               Keysym = 0x1000dc2
	KeySinhSa                 Keysym = 0x1000dc3
	KeySinhHa                 Keysym = 0x1000dc4
	KeySinhLla                Keysym = 0x1000dc5
	KeySinhFa                 Keysym = 0x1000dc6
	KeySinhAl                 Keysym = 0x1000dca
	KeySinhAa2                Keysym = 0x1000dcf
	KeySinhAe2                Keysym = 0x1000dd0
	KeySinhAee2               Keysym = 0x1000dd1
	KeySinhI2                 Keysym = 0x1000dd2
	KeySinhIi2                Keysym = 0x1000dd3
	KeySinhU2                 Keysym = 0x1000dd4
	KeySinhUu2                Keysym = 0x1000dd6
	KeySinhRu2                Keysym = 0x1000dd8
	KeySinhE2                 Keysym = 0x1000dd9
	KeySinhEe2                Keysym = 0x1000dda
	KeySinhAi2                Keysym = 0x1000ddb
	KeySinhO2                 Keysym = 0x1000ddc
	KeySinhOo2                Keysym = 0x1000ddd
	KeySinhAu2                Keysym = 0x1000dde
	KeySinhLu2                Keysym = 0x1000ddf
	KeySinhRuu2               Keysym = 0x1000df2
	KeySinhLuu2               Keysym = 0x1000df3
	KeySinhKunddaliya         Keysym = 0x1000df4
	KeyGeorgianAn             Keysym = 0x10010d0
	KeyGeorgianBan            Keysym = 0x10010d1
	KeyGeorgianGan            Keysym = 0x10010d2
	KeyGeorgianDon            Keysym = 0x10010d3
	KeyGeorgianEn             Keysym = 0x10010d4
	KeyGeorgianVin            Keysym = 0x10010d5
	KeyGeorgianZen            Keysym = 0x10010d6
	KeyGeorgianTan            Keysym = 0x10010d7
	KeyGeorgianIn             Keysym = 0x10010d8
	KeyGeorgianKan            Keysym = 0x10010d9
	KeyGeorgianLas            Keysym = 0x10010da
	KeyGeorgianMan            Keysym = 0x10010db
	KeyGeorgianNar            Keysym = 0x10010dc
	KeyGeorgianOn             Keysym = 0x10010dd
	KeyGeorgianPar            Keysym = 0x10010de
	KeyGeorgianZhar           Keysym = 0x10010df
	KeyGeorgianRae            Keysym = 0x10010e0
	KeyGeorgianSan            Keysym = 0x10010e1
	KeyGeorgianTar            Keysym = 0x10010e2
	KeyGeorgianUn             Keysym = 0x10010e3
	KeyGeorgianPhar           Keysym = 0x10010e4
	KeyGeorgianKhar           Keysym = 0x10010e5
	KeyGeorgianGhan           Keysym = 0x10010e6
	KeyGeorgianQar            Keysym = 0x10010e7
	KeyGeorgianShin           Keysym = 0x10010e8
	KeyGeorgianChin           Keysym = 0x10010e9
	KeyGeorgianCan            Keysym = 0x10010ea
	KeyGeorgianJil            Keysym = 0x10010eb
	KeyGeorgianCil            Keysym = 0x10010ec
	KeyGeorgianChar           Keysym = 0x10010ed
	KeyGeorgianXan            Keysym = 0x10010ee
	KeyGeorgianJhan           Keysym = 0x10010ef
	KeyGeorgianHae            Keysym = 0x10010f0
	KeyGeorgianHe             Keysym = 0x10010f1
	KeyGeorgianHie            Keysym = 0x10010f2
	KeyGeorgianWe             Keysym = 0x10010f3
	KeyGeorgianHar            Keysym = 0x10010f4
	KeyGeorgianHoe            Keysym = 0x10010f5
	KeyGeorgianFi             Keysym = 0x10010f6
	KeyBabovedot              Keysym = 0x1001e02
	KeyDabovedot              Keysym = 0x1001e0a
	KeyFabovedot              Keysym = 0x1001e1e
	KeyLbelowdot              Keysym = 0x1001e36
	KeyMabovedot              Keysym = 0x1001e40
	KeyPabovedot              Keysym = 0x1001e56
	KeySabovedot              Keysym = 0x1001e60
	KeyTabovedot              Keysym = 0x1001e6a
	KeyWgrave                 Keysym = 0x1001e80
	KeyWacute                 Keysym = 0x1001e82
	KeyWdiaeresis             Keysym = 0x1001e84
	KeyXabovedot              Keysym = 0x1001e8a
	KeyAbelowdot              Keysym = 0x1001ea0
	KeyAhook                  Keysym = 0x1001ea2
	KeyAcircumflexacute       Keysym = 0x1001ea4
	KeyAcircumflexgrave       Keysym = 0x1001ea6
	KeyAcircumflexhook        Keysym = 0x1001ea8
	KeyAcircumflextilde       Keysym = 0x1001eaa
	KeyAcircumflexbelowdot    Keysym = 0x1001eac
	KeyAbreveacute            Keysym = 0x1001eae
	KeyAbrevegrave            Keysym = 0x1001eb0
	KeyAbrevehook             Keysym = 0x1001eb2
	KeyAbrevetilde            Keysym = 0x1001eb4
	KeyAbrevebelowdot         Keysym = 0x1001eb6
	KeyEbelowdot              Keysym = 0x1001eb8
	KeyEhook                  Keysym = 0x1001eba
	KeyEtilde                 Keysym = 0x1001ebc
	KeyEcircumflexacute       Keysym = 0x1001ebe
	KeyEcircumflexgrave       Keysym = 0x1001ec0
	KeyEcircumflexhook        Keysym = 0x1001ec2
	KeyEcircumflextilde       Keysym = 0x1001ec4
	KeyEcircumflexbelowdot    Keysym = 0x1001ec6
	KeyIhook                  Keysym = 0x1001ec8
	KeyIbelowdot              Keysym = 0x1001eca
	KeyObelowdot              Keysym = 0x1001ecc
	KeyOhook                  Keysym = 0x1001ece
	KeyOcircumflexacute       Keysym = 0x1001ed0
	KeyOcircumflexgrave       Keysym = 0x1001ed2
	KeyOcircumflexhook        Keysym = 0x1001ed4
	KeyOcircumflextilde       Keysym = 0x1001ed6
	KeyOcircumflexbelowdot    Keysym = 0x1001ed8
	KeyOhornacute             Keysym = 0x1001eda
	KeyOhorngrave             Keysym = 0x1001edc
	KeyOhornhook              Keysym = 0x1001ede
	KeyOhorntilde             Keysym = 0x1001ee0
	KeyOhornbelowdot          Keysym = 0x1001ee2
	KeyUbelowdot              Keysym = 0x1001ee4
	KeyUhook                  Keysym = 0x1001ee6
	KeyUhornacute             Keysym = 0x1001ee8
	KeyUhorngrave             Keysym = 0x1001eea
	KeyUhornhook              Keysym = 0x1001eec
	KeyUhorntilde             Keysym = 0x1001eee
	KeyUhornbelowdot          Keysym = 0x1001ef0
	KeyYgrave                 Keysym = 0x1001ef2
	KeyYbelowdot              Keysym = 0x1001ef4
	KeyYhook                  Keysym = 0x1001ef6
	KeyYtilde                 Keysym = 0x1001ef8
	KeyZerosuperior           Keysym = 0x1002070
	KeyFoursuperior           Keysym = 0x1002074
	KeyFivesuperior           Keysym = 0x1002075
	KeySixsuperior            Keysym = 0x1002076
	KeySevensuperior          Keysym = 0x1002077
	KeyEightsuperior          Keysym = 0x1002078
	KeyNinesuperior           Keysym = 0x1002079
	KeyZerosubscript          Keysym = 0x1002080
	KeyOnesubscript           Keysym = 0x1002081
	KeyTwosubscript           Keysym = 0x1002082
	KeyThreesubscript         Keysym = 0x1002083
	KeyFoursubscript          Keysym = 0x1002084
	KeyFivesubscript          Keysym = 0x1002085
	KeySixsubscript           Keysym = 0x1002086
	KeySevensubscript         Keysym = 0x1002087
	KeyEightsubscript         Keysym = 0x1002088
	KeyNinesubscript          Keysym = 0x1002089
	KeyEcuSign                Keysym = 0x10020a0
	KeyColonSign              Keysym = 0x10020a1
	KeyCruzeiroSign           Keysym = 0x10020a2
	KeyFFrancSign             Keysym = 0x10020a3
	KeyLiraSign               Keysym = 0x10020a4
	KeyMillSign               Keysym = 0x10020a5
	KeyNairaSign              Keysym = 0x10020a6
	KeyPesetaSign             Keysym = 0x10020a7
	KeyRupeeSign              Keysym = 0x10020a8
	KeyWonSign                Keysym = 0x10020a9
	KeyNewSheqelSign          Keysym = 0x10020aa
	KeyDongSign               Keysym = 0x10020ab
	KeyPartdifferential       Keysym = 0x1002202
	KeyEmptyset               Keysym = 0x1002205
	KeyElementof              Keysym = 0x1002208
	KeyNotelementof           Keysym = 0x1002209
	KeyContainsas             Keysym = 0x100220b
	KeySquareroot             Keysym = 0x100221a
	KeyCuberoot               Keysym = 0x100221b
	KeyFourthroot             Keysym = 0x100221c
	KeyDintegral              Keysym = 0x100222c
	KeyTintegral              Keysym = 0x100222d
	KeyBecause                Keysym = 0x1002235
	KeyNotapproxeq            Keysym = 0x1002247
	KeyApproxeq               Keysym = 0x1002248
	KeyNotidentical           Keysym = 0x1002262
	KeyStricteq               Keysym = 0x1002263
	KeyBrailleBlank           Keysym = 0x1002800
	KeyBrailleDots1           Keysym = 0x1002801
	KeyBrailleDots2           Keysym = 0x1002802
	KeyBrailleDots12          Keysym = 0x1002803
	KeyBrailleDots3           Keysym = 0x1002804
	KeyBrailleDots13          Keysym = 0x1002805
	KeyBrailleDots23          Keysym = 0x1002806
	KeyBrailleDots123         Keysym = 0x1002807
	KeyBrailleDots4           Keysym = 0x1002808
	KeyBrailleDots14          Keysym = 0x1002809
	KeyBrailleDots24          Keysym = 0x100280a
	KeyBrailleDots124         Keysym = 0x100280b
	KeyBrailleDots34          Keysym = 0x100280c
	KeyBrailleDots134         Keysym = 0x100280d
	KeyBrailleDots234         Keysym = 0x100280e
	KeyBrailleDots1234        Keysym = 0x100280f
	KeyBrailleDots5           Keysym = 0x1002810
	KeyBrailleDots15          Keysym = 0x1002811
	KeyBrailleDots25          Keysym = 0x1002812
	KeyBrailleDots125         Keysym = 0x1002813
	KeyBrailleDots35          Keysym = 0x1002814
	KeyBrailleDots135         Keysym = 0x1002815
	KeyBrailleDots235         Keysym = 0x1002816
	KeyBrailleDots1235        Keysym = 0x1002817
	KeyBrailleDots45          Keysym = 0x1002818
	KeyBrailleDots145         Keysym = 0x1002819
	KeyBrailleDots245         Keysym = 0x100281a
	KeyBrailleDots1245        Keysym = 0x100281b
	KeyBrailleDots345         Keysym = 0x100281c
	KeyBrailleDots1345        Keysym = 0x100281d
	KeyBrailleDots2345        Keysym = 0x100281e
	KeyBrailleDots12345       Keysym = 0x100281f
	KeyBrailleDots6           Keysym = 0x1002820
	KeyBrailleDots16          Keysym = 0x1002821
	KeyBrailleDots26          Keysym = 0x1002822
	KeyBrailleDots126         Keysym = 0x1002823
	KeyBrailleDots36          Keysym = 0x1002824
	KeyBrailleDots136         Keysym = 0x1002825
	KeyBrailleDots236         Keysym = 0x1002826
	KeyBrailleDots1236        Keysym = 0x1002827
	KeyBrailleDots46          Keysym = 0x1002828
	KeyBrailleDots146         Keysym = 0x1002829
	KeyBrailleDots246         Keysym = 0x100282a
	KeyBrailleDots1246        Keysym = 0x100282b
	KeyBrailleDots346         Keysym = 0x100282c
	KeyBrailleDots1346        Keysym = 0x100282d
	KeyBrailleDots2346        Keysym = 0x100282e
	KeyBrailleDots12346       Keysym = 0x100282f
	KeyBrailleDots56          Keysym = 0x1002830
	KeyBrailleDots156         Keysym = 0x1002831
	KeyBrailleDots256         Keysym = 0x1002832
	KeyBrailleDots1256        Keysym = 0x1002833
	KeyBrailleDots356         Keysym = 0x1002834
	KeyBrailleDots1356        Keysym = 0x1002835
	KeyBrailleDots2356        Keysym = 0x1002836
	KeyBrailleDots12356       Keysym = 0x1002837
	KeyBrailleDots456         Keysym = 0x1002838
	KeyBrailleDots1456        Keysym = 0x1002839
	KeyBrailleDots2456        Keysym = 0x100283a
	KeyBrailleDots12456       Keysym = 0x100283b
	KeyBrailleDots3456        Keysym = 0x100283c
	KeyBrailleDots13456       Keysym = 0x100283d
	KeyBrailleDots23456       Keysym = 0x100283e
	KeyBrailleDots123456      Keysym = 0x100283f
	KeyBrailleDots7           Keysym = 0x1002840
	KeyBrailleDots17          Keysym = 0x1002841
	KeyBrailleDots27          Keysym = 0x1002842
	KeyBrailleDots127         Keysym = 0x1002843
	KeyBrailleDots37          Keysym = 0x1002844
	KeyBrailleDots137         Keysym = 0x1002845
	KeyBrailleDots237         Keysym = 0x1002846
	KeyBrailleDots1237        Keysym = 0x1002847
	KeyBrailleDots47          Keysym = 0x1002848
	KeyBrailleDots147         Keysym = 0x1002849
	KeyBrailleDots247         Keysym = 0x100284a
	KeyBrailleDots1247        Keysym = 0x100284b
	KeyBrailleDots347         Keysym = 0x100284c
	KeyBrailleDots1347        Keysym = 0x100284d
	KeyBrailleDots2347        Keysym = 0x100284e
	KeyBrailleDots12347       Keysym = 0x100284f
	KeyBrailleDots57          Keysym = 0x1002850
	KeyBrailleDots157         Keysym = 0x1002851
	KeyBrailleDots257         Keysym = 0x1002852
	KeyBrailleDots1257        Keysym = 0x1002853
	KeyBrailleDots357         Keysym = 0x1002854
	KeyBrailleDots1357        Keysym = 0x1002855
	KeyBrailleDots2357        Keysym = 0x1002856
	KeyBrailleDots12357       Keysym = 0x1002857
	KeyBrailleDots457         Keysym = 0x1002858
	KeyBrailleDots1457        Keysym = 0x1002859
	KeyBrailleDots2457        Keysym = 0x100285a
	KeyBrailleDots12457       Keysym = 0x100285b
	KeyBrailleDots3457        Keysym = 0x100285c
	KeyBrailleDots13457       Keysym = 0x100285d
	KeyBrailleDots23457       Keysym = 0x100285e
	KeyBrailleDots123457      Keysym = 0x100285f
	KeyBrailleDots67          Keysym = 0x1002860
	KeyBrailleDots167         Keysym = 0x1002861
	KeyBrailleDots267         Keysym = 0x1002862
	KeyBrailleDots1267        Keysym = 0x1002863
	KeyBrailleDots367         Keysym = 0x1002864
	KeyBrailleDots1367        Keysym = 0x1002865
	KeyBrailleDots2367        Keysym = 0x1002866
	KeyBrailleDots12367       Keysym = 0x1002867
	KeyBrailleDots467         Keysym = 0x1002868
	KeyBrailleDots1467        Keysym = 0x1002869
	KeyBrailleDots2467        Keysym = 0x100286a
	KeyBrailleDots12467       Keysym = 0x100286b
	KeyBrailleDots3467        Keysym = 0x100286c
	KeyBrailleDots13467       Keysym = 0x100286d
	KeyBrailleDots23467       Keysym = 0x100286e
	KeyBrailleDots123467      Keysym = 0x100286f
	KeyBrailleDots567         Keysym = 0x1002870
	KeyBrailleDots1567        Keysym = 0x1002871
	KeyBrailleDots2567        Keysym = 0x1002872
	KeyBrailleDots12567       Keysym = 0x1002873
	KeyBrailleDots3567        Keysym = 0x1002874
	KeyBrailleDots13567       Keysym = 0x1002875
	KeyBrailleDots23567       Keysym = 0x1002876
	KeyBrailleDots123567      Keysym = 0x1002877
	KeyBrailleDots4567        Keysym = 0x1002878
	KeyBrailleDots14567       Keysym = 0x1002879
	KeyBrailleDots24567       Keysym = 0x100287a
	KeyBrailleDots124567      Keysym = 0x100287b
	KeyBrailleDots34567       Keysym = 0x100287c
	KeyBrailleDots134567      Keysym = 0x100287d
	KeyBrailleDots234567      Keysym = 0x100287e
	KeyBrailleDots1234567     Keysym = 0x100287f
	KeyBrailleDots8           Keysym = 0x1002880
	KeyBrailleDots18          Keysym = 0x1002881
	KeyBrailleDots28          Keysym = 0x1002882
	KeyBrailleDots128         Keysym = 0x1002883
	KeyBrailleDots38          Keysym = 0x1002884
	KeyBrailleDots138         Keysym = 0x1002885
	KeyBrailleDots238         Keysym = 0x1002886
	KeyBrailleDots1238        Keysym = 0x1002887
	KeyBrailleDots48          Keysym = 0x1002888
	KeyBrailleDots148         Keysym = 0x1002889
	KeyBrailleDots248         Keysym = 0x100288a
	KeyBrailleDots1248        Keysym = 0x100288b
	KeyBrailleDots348         Keysym = 0x100288c
	KeyBrailleDots1348        Keysym = 0x100288d
	KeyBrailleDots2348        Keysym = 0x100288e
	KeyBrailleDots12348       Keysym = 0x100288f
	KeyBrailleDots58          Keysym = 0x1002890
	KeyBrailleDots158         Keysym = 0x1002891
	KeyBrailleDots258         Keysym = 0x1002892
	KeyBrailleDots1258        Keysym = 0x1002893
	KeyBrailleDots358         Keysym = 0x1002894
	KeyBrailleDots1358        Keysym = 0x1002895
	KeyBrailleDots2358        Keysym = 0x1002896
	KeyBrailleDots12358       Keysym = 0x1002897
	KeyBrailleDots458         Keysym = 0x1002898
	KeyBrailleDots1458        Keysym = 0x1002899
	KeyBrailleDots2458        Keysym = 0x100289a
	KeyBrailleDots12458       Keysym = 0x100289b
	KeyBrailleDots3458        Keysym = 0x100289c
	KeyBrailleDots13458       Keysym = 0x100289d
	KeyBrailleDots23458       Keysym = 0x100289e
	KeyBrailleDots123458      Keysym = 0x100289f
	KeyBrailleDots68          Keysym = 0x10028a0
	KeyBrailleDots168         Keysym = 0x10028a1
	KeyBrailleDots268         Keysym = 0x10028a2
	KeyBrailleDots1268        Keysym = 0x10028a3
	KeyBrailleDots368         Keysym = 0x10028a4
	KeyBrailleDots1368        Keysym = 0x10028a5
	KeyBrailleDots2368        Keysym = 0x10028a6
	KeyBrailleDots12368       Keysym = 0x10028a7
	KeyBrailleDots468         Keysym = 0x10028a8
	KeyBrailleDots1468        Keysym = 0x10028a9
	KeyBrailleDots2468        Keysym = 0x10028aa
	KeyBrailleDots12468       Keysym = 0x10028ab
	KeyBrailleDots3468        Keysym = 0x10028ac
	KeyBrailleDots13468       Keysym = 0x10028ad
	KeyBrailleDots23468       Keysym = 0x10028ae
	KeyBrailleDots123468      Keysym = 0x10028af
	KeyBrailleDots568         Keysym = 0x10028b0
	KeyBrailleDots1568        Keysym = 0x10028b1
	KeyBrailleDots2568        Keysym = 0x10028b2
	KeyBrailleDots12568       Keysym = 0x10028b3
	KeyBrailleDots3568        Keysym = 0x10028b4
	KeyBrailleDots13568       Keysym = 0x10028b5
	KeyBrailleDots23568       Keysym = 0x10028b6
	KeyBrailleDots123568      Keysym = 0x10028b7
	KeyBrailleDots4568        Keysym = 0x10028b8
	KeyBrailleDots14568       Keysym = 0x10028b9
	KeyBrailleDots24568       Keysym = 0x10028ba
	KeyBrailleDots124568      Keysym = 0x10028bb
	KeyBrailleDots34568       Keysym = 0x10028bc
	KeyBrailleDots134568      Keysym = 0x10028bd
	KeyBrailleDots234568      Keysym = 0x10028be
	KeyBrailleDots1234568     Keysym = 0x10028bf
	KeyBrailleDots78          Keysym = 0x10028c0
	KeyBrailleDots178         Keysym = 0x10028c1
	KeyBrailleDots278         Keysym = 0x10028c2
	KeyBrailleDots1278        Keysym = 0x10028c3
	KeyBrailleDots378         Keysym = 0x10028c4
	KeyBrailleDots1378        Keysym = 0x10028c5
	KeyBrailleDots2378        Keysym = 0x10028c6
	KeyBrailleDots12378       Keysym = 0x10028c7
	KeyBrailleDots478         Keysym = 0x10028c8
	KeyBrailleDots1478        Keysym = 0x10028c9
	KeyBrailleDots2478        Keysym = 0x10028ca
	KeyBrailleDots12478       Keysym = 0x10028cb
	KeyBrailleDots3478        Keysym = 0x10028cc
	KeyBrailleDots13478       Keysym = 0x10028cd
	KeyBrailleDots23478       Keysym = 0x10028ce
	KeyBrailleDots123478      Keysym = 0x10028cf
	KeyBrailleDots578         Keysym = 0x10028d0
	KeyBrailleDots1578        Keysym = 0x10028d1
	KeyBrailleDots2578        Keysym = 0x10028d2
	KeyBrailleDots12578       Keysym = 0x10028d3
	KeyBrailleDots3578        Keysym = 0x10028d4
	KeyBrailleDots13578       Keysym = 0x10028d5
	KeyBrailleDots23578       Keysym = 0x10028d6
	KeyBrailleDots123578      Keysym = 0x10028d7
	KeyBrailleDots4578        Keysym = 0x10028d8
	KeyBrailleDots14578       Keysym = 0x10028d9
	KeyBrailleDots24578       Keysym = 0x10028da
	KeyBrailleDots124578      Keysym = 0x10028db
	KeyBrailleDots34578       Keysym = 0x10028dc
	KeyBrailleDots134578      Keysym = 0x10028dd
	KeyBrailleDots234578      Keysym = 0x10028de
	KeyBrailleDots1234578     Keysym = 0x10028df
	KeyBrailleDots678         Keysym = 0x10028e0
	KeyBrailleDots1678        Keysym = 0x10028e1
	KeyBrailleDots2678        Keysym = 0x10028e2
	KeyBrailleDots12678       Keysym = 0x10028e3
	KeyBrailleDots3678        Keysym = 0x10028e4
	KeyBrailleDots13678       Keysym = 0x10028e5
	KeyBrailleDots23678       Keysym = 0x10028e6
	KeyBrailleDots123678      Keysym = 0x10028e7
	KeyBrailleDots4678        Keysym = 0x10028e8
	KeyBrailleDots14678       Keysym = 0x10028e9
	KeyBrailleDots24678       Keysym = 0x10028ea
	KeyBrailleDots124678      Keysym = 0x10028eb
	KeyBrailleDots34678       Keysym = 0x10028ec
	KeyBrailleDots134678      Keysym = 0x10028ed
	KeyBrailleDots234678      Keysym = 0x10028ee
	KeyBrailleDots1234678     Keysym = 0x10028ef
	KeyBrailleDots5678        Keysym = 0x10028f0
	KeyBrailleDots15678       Keysym = 0x10028f1
	KeyBrailleDots25678       Keysym = 0x10028f2
	KeyBrailleDots125678      Keysym = 0x10028f3
	KeyBrailleDots35678       Keysym = 0x10028f4
	KeyBrailleDots135678      Keysym = 0x10028f5
	KeyBrailleDots235678      Keysym = 0x10028f6
	KeyBrailleDots1235678     Keysym = 0x10028f7
	KeyBrailleDots45678       Keysym = 0x10028f8
	KeyBrailleDots145678      Keysym = 0x10028f9
	KeyBrailleDots245678      Keysym = 0x10028fa
	KeyBrailleDots1245678     Keysym = 0x10028fb
	KeyBrailleDots345678      Keysym = 0x10028fc
	KeyBrailleDots1345678     Keysym = 0x10028fd
	KeyBrailleDots2345678     Keysym = 0x10028fe
	KeyBrailleDots12345678    Keysym = 0x10028ff

	// Other
	KeySwitchVT1     Keysym = 0x1008fe01
	KeySwitchVT2     Keysym = 0x1008fe02
	KeySwitchVT3     Keysym = 0x1008fe03
	KeySwitchVT4     Keysym = 0x1008fe04
	KeySwitchVT5     Keysym = 0x1008fe05
	KeySwitchVT6     Keysym = 0x1008fe06
	KeySwitchVT7     Keysym = 0x1008fe07
	KeySwitchVT8     Keysym = 0x1008fe08
	KeySwitchVT9     Keysym = 0x1008fe09
	KeySwitchVT10    Keysym = 0x1008fe0a
	KeySwitchVT11    Keysym = 0x1008fe0b
	KeySwitchVT12    Keysym = 0x1008fe0c
	KeyUngrab        Keysym = 0x1008fe20
	KeyClearGrab     Keysym = 0x1008fe21
	KeyNextVMode     Keysym = 0x1008fe22
	KeyPrevVMode     Keysym = 0x1008fe23
	KeyLogWindowTree Keysym = 0x1008fe24
	KeyLogGrabInfo   Keysym = 0x1008fe25

	// XF86 Keys (Multimedia/Special)
	KeyModeLock           Keysym = 0x1008ff01
	KeyMonBrightnessUp    Keysym = 0x1008ff02
	KeyMonBrightnessDown  Keysym = 0x1008ff03
	KeyKbdLightOnOff      Keysym = 0x1008ff04
	KeyKbdBrightnessUp    Keysym = 0x1008ff05
	KeyKbdBrightnessDown  Keysym = 0x1008ff06
	KeyMonBrightnessCycle Keysym = 0x1008ff07
	KeyStandby            Keysym = 0x1008ff10
	KeyAudioLowerVolume   Keysym = 0x1008ff11
	KeyAudioMute          Keysym = 0x1008ff12
	KeyAudioRaiseVolume   Keysym = 0x1008ff13
	KeyAudioPlay          Keysym = 0x1008ff14
	KeyAudioStop          Keysym = 0x1008ff15
	KeyAudioPrev          Keysym = 0x1008ff16
	KeyAudioNext          Keysym = 0x1008ff17
	KeyHomePage           Keysym = 0x1008ff18
	KeyMail               Keysym = 0x1008ff19
	KeyStart              Keysym = 0x1008ff1a
	KeySearch             Keysym = 0x1008ff1b
	KeyAudioRecord        Keysym = 0x1008ff1c
	KeyCalculator         Keysym = 0x1008ff1d
	KeyMemo               Keysym = 0x1008ff1e
	KeyToDoList           Keysym = 0x1008ff1f
	KeyCalendar           Keysym = 0x1008ff20
	KeyPowerDown          Keysym = 0x1008ff21
	KeyContrastAdjust     Keysym = 0x1008ff22
	KeyRockerUp           Keysym = 0x1008ff23
	KeyRockerDown         Keysym = 0x1008ff24
	KeyRockerEnter        Keysym = 0x1008ff25
	KeyBack               Keysym = 0x1008ff26
	KeyForward            Keysym = 0x1008ff27
	KeyStop               Keysym = 0x1008ff28
	KeyRefresh            Keysym = 0x1008ff29
	KeyPowerOff           Keysym = 0x1008ff2a
	KeyWakeUp             Keysym = 0x1008ff2b
	KeyEject              Keysym = 0x1008ff2c
	KeyScreenSaver        Keysym = 0x1008ff2d
	KeyWWW                Keysym = 0x1008ff2e
	KeySleep              Keysym = 0x1008ff2f
	KeyFavorites          Keysym = 0x1008ff30
	KeyAudioPause         Keysym = 0x1008ff31
	KeyAudioMedia         Keysym = 0x1008ff32
	KeyMyComputer         Keysym = 0x1008ff33
	KeyVendorHome         Keysym = 0x1008ff34
	KeyLightBulb          Keysym = 0x1008ff35
	KeyShop               Keysym = 0x1008ff36
	KeyHistory            Keysym = 0x1008ff37
	KeyOpenURL            Keysym = 0x1008ff38
	KeyAddFavorite        Keysym = 0x1008ff39
	KeyHotLinks           Keysym = 0x1008ff3a
	KeyBrightnessAdjust   Keysym = 0x1008ff3b
	KeyFinance            Keysym = 0x1008ff3c
	KeyCommunity          Keysym = 0x1008ff3d
	KeyAudioRewind        Keysym = 0x1008ff3e
	KeyBackForward        Keysym = 0x1008ff3f
	KeyLaunch0            Keysym = 0x1008ff40
	KeyLaunch1            Keysym = 0x1008ff41
	KeyLaunch2            Keysym = 0x1008ff42
	KeyLaunch3            Keysym = 0x1008ff43
	KeyLaunch4            Keysym = 0x1008ff44
	KeyLaunch5            Keysym = 0x1008ff45
	KeyLaunch6            Keysym = 0x1008ff46
	KeyLaunch7            Keysym = 0x1008ff47
	KeyLaunch8            Keysym = 0x1008ff48
	KeyLaunch9            Keysym = 0x1008ff49
	KeyLaunchA            Keysym = 0x1008ff4a
	KeyLaunchB            Keysym = 0x1008ff4b
	KeyLaunchC            Keysym = 0x1008ff4c
	KeyLaunchD            Keysym = 0x1008ff4d
	KeyLaunchE            Keysym = 0x1008ff4e
	KeyLaunchF            Keysym = 0x1008ff4f
	KeyApplicationLeft    Keysym = 0x1008ff50
	KeyApplicationRight   Keysym = 0x1008ff51
	KeyBook               Keysym = 0x1008ff52
	KeyCD                 Keysym = 0x1008ff53
	KeyCalculater         Keysym = 0x1008ff54
	KeyClose              Keysym = 0x1008ff56
	KeyCopy               Keysym = 0x1008ff57
	KeyCut                Keysym = 0x1008ff58
	KeyDisplay            Keysym = 0x1008ff59
	KeyDOS                Keysym = 0x1008ff5a
	KeyDocuments          Keysym = 0x1008ff5b
	KeyExcel              Keysym = 0x1008ff5c
	KeyExplorer           Keysym = 0x1008ff5d
	KeyGame               Keysym = 0x1008ff5e
	KeyGo                 Keysym = 0x1008ff5f
	KeyITouch             Keysym = 0x1008ff60
	KeyLogOff             Keysym = 0x1008ff61
	KeyMarket             Keysym = 0x1008ff62
	KeyMeeting            Keysym = 0x1008ff63
	KeyMenuKB             Keysym = 0x1008ff65
	KeyMenuPB             Keysym = 0x1008ff66
	KeyMySites            Keysym = 0x1008ff67
	KeyNew                Keysym = 0x1008ff68
	KeyNews               Keysym = 0x1008ff69
	KeyOfficeHome         Keysym = 0x1008ff6a
	KeyOpen               Keysym = 0x1008ff6b
	KeyOption             Keysym = 0x1008ff6c
	KeyPaste              Keysym = 0x1008ff6d
	KeyPhone              Keysym = 0x1008ff6e
	KeyReply              Keysym = 0x1008ff72
	KeyReload             Keysym = 0x1008ff73
	KeyRotateWindows      Keysym = 0x1008ff74
	KeyRotationPB         Keysym = 0x1008ff75
	KeyRotationKB         Keysym = 0x1008ff76
	KeySave               Keysym = 0x1008ff77
	KeyScrollUp           Keysym = 0x1008ff78
	KeyScrollDown         Keysym = 0x1008ff79
	KeyScrollClick        Keysym = 0x1008ff7a
	KeySend               Keysym = 0x1008ff7b
	KeySpell              Keysym = 0x1008ff7c
	KeySplitScreen        Keysym = 0x1008ff7d
	KeySupport            Keysym = 0x1008ff7e
	KeyTaskPane           Keysym = 0x1008ff7f
	KeyTerminal           Keysym = 0x1008ff80
	KeyTools              Keysym = 0x1008ff81
	KeyTravel             Keysym = 0x1008ff82
	KeyUserPB             Keysym = 0x1008ff84
	KeyUser1KB            Keysym = 0x1008ff85
	KeyUser2KB            Keysym = 0x1008ff86
	KeyVideo              Keysym = 0x1008ff87
	KeyWheelButton        Keysym = 0x1008ff88
	KeyWord               Keysym = 0x1008ff89
	KeyXfer               Keysym = 0x1008ff8a
	KeyZoomIn             Keysym = 0x1008ff8b
	KeyZoomOut            Keysym = 0x1008ff8c
	KeyAway               Keysym = 0x1008ff8d
	KeyMessenger          Keysym = 0x1008ff8e
	KeyWebCam             Keysym = 0x1008ff8f
	KeyMailForward        Keysym = 0x1008ff90
	KeyPictures           Keysym = 0x1008ff91
	KeyMusic              Keysym = 0x1008ff92
	KeyBattery            Keysym = 0x1008ff93
	KeyBluetooth          Keysym = 0x1008ff94
	KeyWLAN               Keysym = 0x1008ff95
	KeyUWB                Keysym = 0x1008ff96
	KeyAudioForward       Keysym = 0x1008ff97
	KeyAudioRepeat        Keysym = 0x1008ff98
	KeyAudioRandomPlay    Keysym = 0x1008ff99
	KeySubtitle           Keysym = 0x1008ff9a
	KeyAudioCycleTrack    Keysym = 0x1008ff9b
	KeyCycleAngle         Keysym = 0x1008ff9c
	KeyFrameBack          Keysym = 0x1008ff9d
	KeyFrameForward       Keysym = 0x1008ff9e
	KeyTime               Keysym = 0x1008ff9f
	KeyView               Keysym = 0x1008ffa1
	KeyTopMenu            Keysym = 0x1008ffa2
	KeyRed                Keysym = 0x1008ffa3
	KeyGreen              Keysym = 0x1008ffa4
	KeyYellow             Keysym = 0x1008ffa5
	KeyBlue               Keysym = 0x1008ffa6
	KeySuspend            Keysym = 0x1008ffa7
	KeyHibernate          Keysym = 0x1008ffa8
	KeyTouchpadToggle     Keysym = 0x1008ffa9
	KeyTouchpadOn         Keysym = 0x1008ffb0
	KeyTouchpadOff        Keysym = 0x1008ffb1
	KeyAudioMicMute       Keysym = 0x1008ffb2
	KeyKeyboard           Keysym = 0x1008ffb3
	KeyWWAN               Keysym = 0x1008ffb4
	KeyRFKill             Keysym = 0x1008ffb5
	KeyAudioPreset        Keysym = 0x1008ffb6
	KeyRotationLockToggle Keysym = 0x1008ffb7
	KeyFullScreen         Keysym = 0x1008ffb8
)

Keysym constants generated from X11 header files.

func KeysymFromName 

func KeysymFromName(name string, flags KeysymNameFlags) Keysym

KeysymFromName returns the Keysym for a name.

Returns KeyNoSymbol if the name is not recognized. Use KeysymNameCaseInsensitive flag for case-insensitive matching. See also KeysymGetName for the reverse lookup.

Example 
package main

import (
	"fmt"

	"github.com/unxed/xkb-go"
)

func main() {
	// Look up keysym by name
	ks := xkb.KeysymFromName("Return", xkb.KeysymNameNoFlags)
	fmt.Printf("Return = 0x%04x\n", ks)

	ks = xkb.KeysymFromName("Shift_L", xkb.KeysymNameNoFlags)
	fmt.Printf("Shift_L = 0x%04x\n", ks)

	ks = xkb.KeysymFromName("nonexistent", xkb.KeysymNameNoFlags)
	fmt.Printf("nonexistent = 0x%04x (NoSymbol)\n", ks)
}

Output:
Return = 0xff0d
Shift_L = 0xffe1
nonexistent = 0x0000 (NoSymbol)

func UTF32ToKeysym 

func UTF32ToKeysym(r rune) Keysym

UTF32ToKeysym converts a Unicode codepoint to a Keysym.

For codepoints outside the basic keysym range (Latin-1), returns Unicode keysym format (0x01000000 + codepoint). Returns KeyNoSymbol if the codepoint is invalid.

type KeysymNameFlags 

type KeysymNameFlags uint32

KeysymNameFlags controls KeysymFromName lookup behavior. 

const (
	// KeysymNameNoFlags is the default (case-sensitive) lookup.
	KeysymNameNoFlags KeysymNameFlags = 0

	// KeysymNameCaseInsensitive performs case-insensitive lookup.
	// This is slower but matches names regardless of case.
	KeysymNameCaseInsensitive KeysymNameFlags = 1 << 0
)

type LED 

type LED struct {
	// contains filtered or unexported fields
}

LED represents a keyboard LED indicator (e.g., Caps Lock, Num Lock).

Use State.LEDNameIsActive to check if an LED should be lit.

type Level 

type Level uint8

Level is a shift level within a key group.

Level 0 is the base level, Level 1 is typically Shift, etc. The active level is determined by the key type and current modifier state.

type Lexer 

type Lexer struct {
	// contains filtered or unexported fields
}

Lexer tokenizes XKB source text into Token values.

Create with NewLexer, then call Lexer.NextToken repeatedly.

func NewLexer 

func NewLexer(input []byte) *Lexer

NewLexer creates a new Lexer for the given XKB source input.

func (*Lexer) NextToken 

func (l *Lexer) NextToken() Token

NextToken returns the next token from the input.

func (*Lexer) Tokenize 

func (l *Lexer) Tokenize() []Token

Tokenize returns all tokens from the input.

type ModIndex 

type ModIndex uint8

ModIndex is an index into the modifier array (0-7 for real modifiers).

Use State.ModIndexIsActive to check if a modifier at a given index is active. 

const (
	ModIndexShift   ModIndex = 0
	ModIndexLock    ModIndex = 1
	ModIndexControl ModIndex = 2
	ModIndexMod1    ModIndex = 3
	ModIndexMod2    ModIndex = 4
	ModIndexMod3    ModIndex = 5
	ModIndexMod4    ModIndex = 6
	ModIndexMod5    ModIndex = 7
)

Real modifier indices.

type ModMask 

type ModMask uint32

ModMask is a bitmask of active modifiers.

Use the ModShift, ModLock, ModControl, and ModMod1-5 constants to construct masks. Pass masks to State.UpdateMask to update state. 

const (
	ModShift   ModMask = 1 << 0
	ModLock    ModMask = 1 << 1 // Caps Lock
	ModControl ModMask = 1 << 2
	ModMod1    ModMask = 1 << 3 // Usually Alt
	ModMod2    ModMask = 1 << 4 // Usually Num Lock
	ModMod3    ModMask = 1 << 5
	ModMod4    ModMask = 1 << 6 // Usually Super/Win
	ModMod5    ModMask = 1 << 7 // Usually ISO_Level3_Shift (AltGr)
)

Real modifier indices (0-7).

type ModMatch 

type ModMatch int

ModMatch specifies how to match modifiers in an Interpret statement. 

const (
	// ModMatchNone means no modifier matching is performed.
	ModMatchNone ModMatch = iota
	// ModMatchAnyOfOrNone matches if any of the mods are active, or if none are.
	ModMatchAnyOfOrNone
	// ModMatchAnyOf matches if any of the specified mods are active.
	ModMatchAnyOf
	// ModMatchNoneOf matches if none of the specified mods are active.
	ModMatchNoneOf
	// ModMatchAllOf matches if all of the specified mods are active.
	ModMatchAllOf
	// ModMatchExactly matches if exactly these mods are active (no more, no less).
	ModMatchExactly
)

type Parser 

type Parser struct {
	// contains filtered or unexported fields
}

Parser parses XKB text format into a Keymap.

Create with NewParser, then call Parser.Parse to parse the input. The Parser is used internally by Context.NewKeymapFromString.

func NewParser 

func NewParser(input []byte) *Parser

NewParser creates a new Parser for the given XKB source input.

func (*Parser) Parse 

func (p *Parser) Parse() (*Keymap, error)

Parse parses a complete XKB keymap.

type RuleNames 

type RuleNames struct {
	// Rules is the rules file to use, usually "evdev".
	Rules string
	// Model is the keyboard model, e.g., "pc105", "pc104", "macbook".
	Model string
	// Layout is the keyboard layout, e.g., "us", "de", "us,ru" for multiple.
	Layout string
	// Variant is the layout variant, e.g., "intl", "dvorak", ",phonetic" for multiple.
	Variant string
	// Options are extra options, e.g., "ctrl:nocaps,compose:ralt".
	Options string
}

RuleNames specifies RMLVO (Rules, Model, Layout, Variant, Options) for keymap compilation.

Pass to Context.NewKeymapFromNames to build a keymap from system XKB data. Empty fields fall back to defaults: Rules="evdev", Model="pc105", Layout="us".

type State 

type State struct {
	// contains filtered or unexported fields
}

State tracks the active keyboard state for key translation.

State is used to translate keycodes to keysyms based on the current modifier and group state. Create a State with Keymap.NewState.

State is NOT safe for concurrent use. Each keyboard device should have its own State instance.

func (*State) BaseGroup added in v0.1.3 

func (s *State) BaseGroup() Group

func (*State) BaseMods added in v0.1.3 

func (s *State) BaseMods() ModMask

func (*State) KeyGetOneSym 

func (s *State) KeyGetOneSym(keycode Keycode) Keysym

KeyGetOneSym returns a single keysym for a key at the current state.

If the key produces multiple keysyms, returns KeyNoSymbol. If the key produces exactly one keysym, returns it. This is the most commonly used method for key translation.

func (*State) KeyGetSyms 

func (s *State) KeyGetSyms(keycode Keycode) []Keysym

KeyGetSyms returns all keysyms for a key at the current state.

Most keys return a single keysym, but some may return multiple. See also State.KeyGetOneSym for the common single-keysym case.

func (*State) KeyGetUTF8 

func (s *State) KeyGetUTF8(keycode Keycode) string

KeyGetUTF8 returns the UTF-8 string for a key at the current state.

Returns empty string if the key doesn't produce a character. See also State.KeyGetUTF32 for the raw codepoint.

Example 
package main

import (
	"fmt"

	"github.com/unxed/xkb-go"
)

func main() {
	km := xkb.TestKeymap()
	state := km.NewState()

	// Get the character for a key
	char := state.KeyGetUTF8(38) // 'a' key
	fmt.Printf("Key 38 = %q\n", char)

	// With Shift
	state.UpdateMask(xkb.ModShift, 0, 0, 0, 0, 0)
	char = state.KeyGetUTF8(38)
	fmt.Printf("Key 38 + Shift = %q\n", char)
}

Output:
Key 38 = "a"
Key 38 + Shift = "A"

func (*State) KeyGetUTF32 

func (s *State) KeyGetUTF32(keycode Keycode) rune

KeyGetUTF32 returns the Unicode codepoint for a key at the current state.

Returns 0 if the key doesn't produce a character (e.g., modifier keys). See also State.KeyGetUTF8 for the UTF-8 encoded string.

func (*State) Keymap 

func (s *State) Keymap() *Keymap

Keymap returns the Keymap this state is for.

func (*State) LEDNameIsActive 

func (s *State) LEDNameIsActive(name string) bool

LEDNameIsActive checks if an LED indicator should be lit.

Returns true if the LED's associated modifiers or group are active.

func (*State) LatchedGroup added in v0.1.3 

func (s *State) LatchedGroup() Group

func (*State) LatchedMods added in v0.1.3 

func (s *State) LatchedMods() ModMask

func (*State) LockedGroup added in v0.1.3 

func (s *State) LockedGroup() Group

func (*State) LockedMods added in v0.1.3 

func (s *State) LockedMods() ModMask

func (*State) ModIndexIsActive 

func (s *State) ModIndexIsActive(idx ModIndex, typ StateComponent) bool

ModIndexIsActive checks if a modifier at the given ModIndex is active.

See also State.ModNameIsActive for name-based lookup.

func (*State) ModNameIsActive 

func (s *State) ModNameIsActive(name string, typ StateComponent) bool

ModNameIsActive checks if a modifier is active.

The typ parameter specifies which StateComponent to check (e.g., StateModEffective for combined state).

func (*State) SerializeGroup 

func (s *State) SerializeGroup(typ StateComponent) Group

SerializeGroup returns the Group for the specified StateComponent.

Pass StateGroupEffective to get the combined group state.

func (*State) SerializeMods 

func (s *State) SerializeMods(typ StateComponent) ModMask

SerializeMods returns the ModMask for the specified StateComponent.

Pass StateModEffective to get the combined modifier state.

func (*State) UpdateKey 

func (s *State) UpdateKey(keycode Keycode, direction KeyDirection) StateComponent

UpdateKey updates state based on a key press/release.

This is typically used with evdev input where you track key state manually. Wayland clients usually use State.UpdateMask instead, as the compositor provides modifier state directly.

Returns a bitmask of StateComponent flags indicating what changed.

func (*State) UpdateMask 

func (s *State) UpdateMask(
	baseMods, latchedMods, lockedMods ModMask,
	baseGroup, latchedGroup, lockedGroup Group,
) StateComponent

UpdateMask updates the keyboard state from modifier/group masks.

This is called in response to wl_keyboard.modifiers events from a Wayland compositor. The masks correspond to the event parameters.

Returns a bitmask of StateComponent flags indicating what changed.

type StateComponent 

type StateComponent uint32

StateComponent identifies which parts of keyboard state changed.

Returned by State.UpdateMask and State.UpdateKey to indicate what changed. Use with State.ModIndexIsActive and State.SerializeMods to query specific state components. 

const (
	StateModDepressed   StateComponent = 1 << 0
	StateModLatched     StateComponent = 1 << 1
	StateModLocked      StateComponent = 1 << 2
	StateModEffective   StateComponent = 1 << 3
	StateGroupDepressed StateComponent = 1 << 4
	StateGroupLatched   StateComponent = 1 << 5
	StateGroupLocked    StateComponent = 1 << 6
	StateGroupEffective StateComponent = 1 << 7
	StateLEDs           StateComponent = 1 << 8
)

type SyntaxError 

type SyntaxError struct {
	File    string // Source file name
	Line    int    // Line number (1-based)
	Col     int    // Column number (1-based)
	Message string // Error message
}

SyntaxError provides detailed information about a parsing error.

Use errors.Is with ErrInvalidSyntax to check for syntax errors.

func (*SyntaxError) Error 

func (e *SyntaxError) Error() string

func (*SyntaxError) Is 

func (e *SyntaxError) Is(target error) bool

type Token 

type Token struct {
	Type  TokenType
	Value string
	Line  int
	Col   int
}

Token represents a lexical token from XKB source.

Returned by Lexer.NextToken during parsing.

func (Token) String 

func (t Token) String() string

String returns a string representation of the token for debugging.

type TokenType 

type TokenType int

TokenType represents the type of a lexical token in XKB source. 

const (
	TokenEOF TokenType = iota
	TokenError

	// Literals
	TokenIdent   // identifier (xkb_keymap, Shift, AD01)
	TokenString  // "quoted string"
	TokenNumber  // 123, 0x1F, 017
	TokenKeycode // <AD01>

	// Punctuation
	TokenLBrace    // {
	TokenRBrace    // }
	TokenLBracket  // [
	TokenRBracket  // ]
	TokenLParen    // (
	TokenRParen    // )
	TokenSemicolon // ;
	TokenComma     // ,
	TokenEquals    // =
	TokenPlus      // +
	TokenMinus     // -
	TokenBang      // !
	TokenTilde     // ~
	TokenDot       // .
)

func (TokenType) String 

func (t TokenType) String() string

String returns the string representation of the token type.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.