--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/semiconginev2/old/thirdparty/x11/xkblib.nim	Wed Jul 17 21:01:37 2024 +0700
@@ -0,0 +1,661 @@
+# $Xorg: XKBlib.h,v 1.6 2000/08/17 19:45:03 cpqbld Exp $
+#************************************************************
+#Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
+#
+#Permission to use, copy, modify, and distribute this
+#software and its documentation for any purpose and without
+#fee is hereby granted, provided that the above copyright
+#notice appear in all copies and that both that copyright
+#notice and this permission notice appear in supporting
+#documentation, and that the name of Silicon Graphics not be
+#used in advertising or publicity pertaining to distribution
+#of the software without specific prior written permission.
+#Silicon Graphics makes no representation about the suitability
+#of this software for any purpose. It is provided "as is"
+#without any express or implied warranty.
+#
+#SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+#SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+#AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+#GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+#DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING `from` LOSS OF USE,
+#DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+#OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+#THE USE OR PERFORMANCE OF THIS SOFTWARE.
+#
+#********************************************************/
+# $XFree86: xc/lib/X11/XKBlib.h,v 3.3 2001/08/01 00:44:38 tsi Exp $
+#
+# Pascal Convertion was made by Ido Kannner - kanerido@actcom.net.il
+#
+#Thanks:
+#         I want to thanks to oliebol for putting up with all of the problems that was found
+#         while translating this code. ;)
+#
+#         I want to thanks #fpc channel in freenode irc, for helping me, and to put up with my
+#         wierd questions ;)
+#
+#         Thanks for mmc in #xlib on freenode irc And so for the channel itself for the helping me to
+#         understanding some of the problems I had converting this headers and pointing me to resources
+#         that helped translating this headers.
+#
+# Ido
+#
+#History:
+#        2004/10/15        - Fixed a bug of accessing second based records by removing "paced record" and
+#                            chnaged it to "reocrd" only.
+#        2004/10/10        - Added to XkbGetAtomNameFunc and XkbInternAtomFunc the cdecl call.
+#        2004/10/06 - 09   - Convertion `from` the c header of XKBlib.h
+#
+#
+
+import
+  x, xlib, xkb
+
+
+include "x11pragma.nim"
+
+
+type
+  PXkbAnyEvent* = ptr XkbAnyEvent
+  XkbAnyEvent*{.final.} = object
+    theType*: int16    # XkbAnyEvent
+    serial*: int32     # # of last req processed by server
+    send_event*: bool  # is this `from` a SendEvent request?
+    display*: PDisplay # Display the event was read `from`
+    time*: Time        # milliseconds;
+    xkb_type*: int16   # XKB event minor code
+    device*: int16     # device ID
+
+
+type
+  PXkbNewKeyboardNotifyEvent* = ptr XkbNewKeyboardNotifyEvent
+  XkbNewKeyboardNotifyEvent*{.final.} = object
+    theType*: int16          # XkbAnyEvent
+    serial*: int32           # of last req processed by server
+    send_event*: bool        # is this `from` a SendEvent request?
+    display*: PDisplay       # Display the event was read `from`
+    time*: Time              # milliseconds
+    xkb_type*: int16         # XkbNewKeyboardNotify
+    device*: int16           # device ID
+    old_device*: int16       # device ID of previous keyboard
+    min_key_code*: int16     # minimum key code
+    max_key_code*: int16     # maximum key code
+    old_min_key_code*: int16 # min key code of previous kbd
+    old_max_key_code*: int16 # max key code of previous kbd
+    changed*: int16          # changed aspects of the keyboard
+    req_major*: int8         # major and minor opcode of req
+    req_minor*: int8         # that caused change, if applicable
+
+
+type
+  PXkbMapNotifyEvent* = ptr XkbMapNotifyEvent
+  XkbMapNotifyEvent*{.final.} = object
+    theType*: int16    # XkbAnyEvent
+    serial*: int32     # of last req processed by server
+    send_event*: bool  # is this `from` a SendEvent request
+    display*: PDisplay # Display the event was read `from`
+    time*: Time        # milliseconds
+    xkb_type*: int16   # XkbMapNotify
+    device*: int16     # device ID
+    changed*: int16    # fields which have been changed
+    flags*: int16      # reserved
+    first_type*: int16 # first changed key type
+    num_types*: int16  # number of changed key types
+    min_key_code*: KeyCode
+    max_key_code*: KeyCode
+    first_key_sym*: KeyCode
+    first_key_act*: KeyCode
+    first_key_behavior*: KeyCode
+    first_key_explicit*: KeyCode
+    first_modmap_key*: KeyCode
+    first_vmodmap_key*: KeyCode
+    num_key_syms*: int16
+    num_key_acts*: int16
+    num_key_behaviors*: int16
+    num_key_explicit*: int16
+    num_modmap_keys*: int16
+    num_vmodmap_keys*: int16
+    vmods*: int16      # mask of changed virtual mods
+
+
+type
+  PXkbStateNotifyEvent* = ptr XkbStateNotifyEvent
+  XkbStateNotifyEvent*{.final.} = object
+    theType*: int16           # XkbAnyEvent
+    serial*: int32            # # of last req processed by server
+    send_event*: bool         # is this `from` a SendEvent request?
+    display*: PDisplay        # Display the event was read `from`
+    time*: Time               # milliseconds
+    xkb_type*: int16          # XkbStateNotify
+    device*: int16            # device ID
+    changed*: int16           # mask of changed state components
+    group*: int16             # keyboard group
+    base_group*: int16        # base keyboard group
+    latched_group*: int16     # latched keyboard group
+    locked_group*: int16      # locked keyboard group
+    mods*: int16              # modifier state
+    base_mods*: int16         # base modifier state
+    latched_mods*: int16      # latched modifiers
+    locked_mods*: int16       # locked modifiers
+    compat_state*: int16      # compatibility state
+    grab_mods*: int8          # mods used for grabs
+    compat_grab_mods*: int8   # grab mods for non-XKB clients
+    lookup_mods*: int8        # mods sent to clients
+    compat_lookup_mods*: int8 # mods sent to non-XKB clients
+    ptr_buttons*: int16       # pointer button state
+    keycode*: KeyCode         # keycode that caused the change
+    event_type*: int8         # KeyPress or KeyRelease
+    req_major*: int8          # Major opcode of request
+    req_minor*: int8          # Minor opcode of request
+
+
+type
+  PXkbControlsNotifyEvent* = ptr XkbControlsNotifyEvent
+  XkbControlsNotifyEvent*{.final.} = object
+    theType*: int16              # XkbAnyEvent
+    serial*: int32               # of last req processed by server
+    send_event*: bool            # is this `from` a SendEvent request?
+    display*: PDisplay           # Display the event was read `from`
+    time*: Time                  # milliseconds
+    xkb_type*: int16             # XkbControlsNotify
+    device*: int16               # device ID
+    changed_ctrls*: int16        # controls with changed sub-values
+    enabled_ctrls*: int16        # controls currently enabled
+    enabled_ctrl_changes*: int16 # controls just {en,dis}abled
+    num_groups*: int16           # total groups on keyboard
+    keycode*: KeyCode            # key that caused change or 0
+    event_type*: int8            # type of event that caused change
+    req_major*: int8             # if keycode==0, major and minor
+    req_minor*: int8             # opcode of req that caused change
+
+
+type
+  PXkbIndicatorNotifyEvent* = ptr XkbIndicatorNotifyEvent
+  XkbIndicatorNotifyEvent*{.final.} = object
+    theType*: int16    # XkbAnyEvent
+    serial*: int32     # of last req processed by server
+    send_event*: bool  # is this `from` a SendEvent request?
+    display*: PDisplay # Display the event was read `from`
+    time*: Time        # milliseconds
+    xkb_type*: int16   # XkbIndicatorNotify
+    device*: int16     # device
+    changed*: int16    # indicators with new state or map
+    state*: int16      # current state of all indicators
+
+
+type
+  PXkbNamesNotifyEvent* = ptr XkbNamesNotifyEvent
+  XkbNamesNotifyEvent*{.final.} = object
+    theType*: int16            # XkbAnyEvent
+    serial*: int32             # of last req processed by server
+    send_event*: bool          # is this `from` a SendEvent request?
+    display*: PDisplay         # Display the event was read `from`
+    time*: Time                # milliseconds
+    xkb_type*: int16           # XkbNamesNotify
+    device*: int16             # device ID
+    changed*: int32            # names that have changed
+    first_type*: int16         # first key type with new name
+    num_types*: int16          # number of key types with new names
+    first_lvl*: int16          # first key type new new level names
+    num_lvls*: int16           # # of key types w/new level names
+    num_aliases*: int16        # total number of key aliases
+    num_radio_groups*: int16   # total number of radio groups
+    changed_vmods*: int16      # virtual modifiers with new names
+    changed_groups*: int16     # groups with new names
+    changed_indicators*: int16 # indicators with new names
+    first_key*: int16          # first key with new name
+    num_keys*: int16           # number of keys with new names
+
+
+type
+  PXkbCompatMapNotifyEvent* = ptr XkbCompatMapNotifyEvent
+  XkbCompatMapNotifyEvent*{.final.} = object
+    theType*: int16        # XkbAnyEvent
+    serial*: int32         # of last req processed by server
+    send_event*: bool      # is this `from` a SendEvent request?
+    display*: PDisplay     # Display the event was read `from`
+    time*: Time            # milliseconds
+    xkb_type*: int16       # XkbCompatMapNotify
+    device*: int16         # device ID
+    changed_groups*: int16 # groups with new compat maps
+    first_si*: int16       # first new symbol interp
+    num_si*: int16         # number of new symbol interps
+    num_total_si*: int16   # total # of symbol interps
+
+
+type
+  PXkbBellNotifyEvent* = ptr XkbBellNotifyEvent
+  XkbBellNotifyEvent*{.final.} = object
+    theType*: int16    # XkbAnyEvent
+    serial*: int32     # of last req processed by server
+    send_event*: bool  # is this `from` a SendEvent request?
+    display*: PDisplay # Display the event was read `from`
+    time*: Time        # milliseconds
+    xkb_type*: int16   # XkbBellNotify
+    device*: int16     # device ID
+    percent*: int16    # requested volume as a % of maximum
+    pitch*: int16      # requested pitch in Hz
+    duration*: int16   # requested duration in useconds
+    bell_class*: int16 # (input extension) feedback class
+    bell_id*: int16    # (input extension) ID of feedback
+    name*: Atom        # "name" of requested bell
+    window*: Window    # window associated with event
+    event_only*: bool  # "event only" requested
+
+
+type
+  PXkbActionMessageEvent* = ptr XkbActionMessageEvent
+  XkbActionMessageEvent*{.final.} = object
+    theType*: int16                                  # XkbAnyEvent
+    serial*: int32                                   # of last req processed by server
+    send_event*: bool                                # is this `from` a SendEvent request?
+    display*: PDisplay                               # Display the event was read `from`
+    time*: Time                                      # milliseconds
+    xkb_type*: int16                                 # XkbActionMessage
+    device*: int16                                   # device ID
+    keycode*: KeyCode                                # key that generated the event
+    press*: bool                                     # true if act caused by key press
+    key_event_follows*: bool                         # true if key event also generated
+    group*: int16                                    # effective group
+    mods*: int16                                     # effective mods
+    message*: array[0..XkbActionMessageLength, char] # message -- leave space for NUL
+
+
+type
+  PXkbAccessXNotifyEvent* = ptr XkbAccessXNotifyEvent
+  XkbAccessXNotifyEvent*{.final.} = object
+    theType*: int16        # XkbAnyEvent
+    serial*: int32         # of last req processed by server
+    send_event*: bool      # is this `from` a SendEvent request?
+    display*: PDisplay     # Display the event was read `from`
+    time*: Time            # milliseconds
+    xkb_type*: int16       # XkbAccessXNotify
+    device*: int16         # device ID
+    detail*: int16         # XkbAXN_*
+    keycode*: int16        # key of event
+    sk_delay*: int16       # current slow keys delay
+    debounce_delay*: int16 # current debounce delay
+
+
+type
+  PXkbExtensionDeviceNotifyEvent* = ptr XkbExtensionDeviceNotifyEvent
+  XkbExtensionDeviceNotifyEvent*{.final.} = object
+    theType*: int16      # XkbAnyEvent
+    serial*: int32       # of last req processed by server
+    send_event*: bool    # is this `from` a SendEvent request?
+    display*: PDisplay   # Display the event was read `from`
+    time*: Time          # milliseconds
+    xkb_type*: int16     # XkbExtensionDeviceNotify
+    device*: int16       # device ID
+    reason*: int16       # reason for the event
+    supported*: int16    # mask of supported features
+    unsupported*: int16  # mask of unsupported features
+                         # that some app tried to use
+    first_btn*: int16    # first button that changed
+    num_btns*: int16     # range of buttons changed
+    leds_defined*: int16 # indicators with names or maps
+    led_state*: int16    # current state of the indicators
+    led_class*: int16    # feedback class for led changes
+    led_id*: int16       # feedback id for led changes
+
+
+type
+  PXkbEvent* = ptr XkbEvent
+  XkbEvent*{.final.} = object
+    theType*: int16
+    any*: XkbAnyEvent
+    new_kbd*: XkbNewKeyboardNotifyEvent
+    map*: XkbMapNotifyEvent
+    state*: XkbStateNotifyEvent
+    ctrls*: XkbControlsNotifyEvent
+    indicators*: XkbIndicatorNotifyEvent
+    names*: XkbNamesNotifyEvent
+    compat*: XkbCompatMapNotifyEvent
+    bell*: XkbBellNotifyEvent
+    message*: XkbActionMessageEvent
+    accessx*: XkbAccessXNotifyEvent
+    device*: XkbExtensionDeviceNotifyEvent
+    core*: XEvent
+
+
+type
+  PXkbKbdDpyStatePtr* = ptr XkbKbdDpyStateRec
+  XkbKbdDpyStateRec*{.final.} = object # XkbOpenDisplay error codes
+
+const
+  XkbOD_Success* = 0
+  XkbOD_BadLibraryVersion* = 1
+  XkbOD_ConnectionRefused* = 2
+  XkbOD_NonXkbServer* = 3
+  XkbOD_BadServerVersion* = 4 # Values for XlibFlags
+
+const
+  XkbLC_ForceLatin1Lookup* = 1 shl 0
+  XkbLC_ConsumeLookupMods* = 1 shl 1
+  XkbLC_AlwaysConsumeShiftAndLock* = 1 shl 2
+  XkbLC_IgnoreNewKeyboards* = 1 shl 3
+  XkbLC_ControlFallback* = 1 shl 4
+  XkbLC_ConsumeKeysOnComposeFail* = 1 shl 29
+  XkbLC_ComposeLED* = 1 shl 30
+  XkbLC_BeepOnComposeFail* = 1 shl 31
+  XkbLC_AllComposeControls* = 0xC0000000
+  XkbLC_AllControls* = 0xC000001F
+
+proc XkbIgnoreExtension*(ignore: bool): bool{.libx11c,
+    importc: "XkbIgnoreExtension".}
+proc XkbOpenDisplay*(name: cstring, ev_rtrn, err_rtrn, major_rtrn, minor_rtrn,
+                                    reason: ptr int16): PDisplay{.libx11c, importc: "XkbOpenDisplay".}
+proc XkbQueryExtension*(dpy: PDisplay, opcodeReturn, eventBaseReturn,
+                                       errorBaseReturn, majorRtrn, minorRtrn: ptr int16): bool{.
+    libx11c, importc: "XkbQueryExtension".}
+proc XkbUseExtension*(dpy: PDisplay, major_rtrn, minor_rtrn: ptr int16): bool{.
+    libx11c, importc: "XkbUseExtension".}
+proc XkbLibraryVersion*(libMajorRtrn, libMinorRtrn: ptr int16): bool{.libx11c, importc: "XkbLibraryVersion".}
+proc XkbSetXlibControls*(dpy: PDisplay, affect, values: int16): int16{.libx11c, importc: "XkbSetXlibControls".}
+proc XkbGetXlibControls*(dpy: PDisplay): int16{.libx11c,
+    importc: "XkbGetXlibControls".}
+type
+  XkbInternAtomFunc* = proc (dpy: PDisplay, name: cstring, only_if_exists: bool): Atom{.
+      cdecl.}
+
+type
+  XkbGetAtomNameFunc* = proc (dpy: PDisplay, atom: Atom): cstring{.cdecl.}
+
+proc XkbSetAtomFuncs*(getAtom: XkbInternAtomFunc, getName: XkbGetAtomNameFunc){.
+    libx11c, importc: "XkbSetAtomFuncs".}
+proc XkbKeycodeToKeysym*(dpy: PDisplay, kc: KeyCode, group, level: int16): KeySym{.
+    libx11c, importc: "XkbKeycodeToKeysym".}
+proc XkbKeysymToModifiers*(dpy: PDisplay, ks: KeySym): int16{.libx11c, importc: "XkbKeysymToModifiers".}
+proc XkbLookupKeySym*(dpy: PDisplay, keycode: KeyCode,
+                      modifiers, modifiers_return: int16, keysym_return: PKeySym): bool{.
+    libx11c, importc: "XkbLookupKeySym".}
+proc XkbLookupKeyBinding*(dpy: PDisplay, sym_rtrn: KeySym, mods: int16,
+                          buffer: cstring, nbytes: int16, extra_rtrn: ptr int16): int16{.
+    libx11c, importc: "XkbLookupKeyBinding".}
+proc XkbTranslateKeyCode*(xkb: PXkbDescPtr, keycode: KeyCode,
+                          modifiers, modifiers_return: int16,
+                          keysym_return: PKeySym): bool{.libx11c,
+    importc: "XkbTranslateKeyCode".}
+proc XkbTranslateKeySym*(dpy: PDisplay, sym_return: KeySym, modifiers: int16,
+                         buffer: cstring, nbytes: int16, extra_rtrn: ptr int16): int16{.
+    libx11c, importc: "XkbTranslateKeySym".}
+proc XkbSetAutoRepeatRate*(dpy: PDisplay, deviceSpec, delay, interval: int16): bool{.
+    libx11c, importc: "XkbSetAutoRepeatRate".}
+proc XkbGetAutoRepeatRate*(dpy: PDisplay, deviceSpec: int16,
+                           delayRtrn, intervalRtrn: PWord): bool{.libx11c, importc: "XkbGetAutoRepeatRate".}
+proc XkbChangeEnabledControls*(dpy: PDisplay, deviceSpec, affect, values: int16): bool{.
+    libx11c, importc: "XkbChangeEnabledControls".}
+proc XkbDeviceBell*(dpy: PDisplay, win: Window,
+                    deviceSpec, bellClass, bellID, percent: int16, name: Atom): bool{.
+    libx11c, importc: "XkbDeviceBell".}
+proc XkbForceDeviceBell*(dpy: PDisplay,
+                         deviceSpec, bellClass, bellID, percent: int16): bool{.
+    libx11c, importc: "XkbForceDeviceBell".}
+proc XkbDeviceBellEvent*(dpy: PDisplay, win: Window,
+                         deviceSpec, bellClass, bellID, percent: int16,
+                         name: Atom): bool{.libx11c,
+    importc: "XkbDeviceBellEvent".}
+proc XkbBell*(dpy: PDisplay, win: Window, percent: int16, name: Atom): bool{.
+    libx11c, importc: "XkbBell".}
+proc XkbForceBell*(dpy: PDisplay, percent: int16): bool{.libx11c,
+    importc: "XkbForceBell".}
+proc XkbBellEvent*(dpy: PDisplay, win: Window, percent: int16, name: Atom): bool{.
+    libx11c, importc: "XkbBellEvent".}
+proc XkbSelectEvents*(dpy: PDisplay, deviceID, affect, values: int16): bool{.
+    libx11c, importc: "XkbSelectEvents".}
+proc XkbSelectEventDetails*(dpy: PDisplay, deviceID, eventType: int16,
+                            affect, details: int32): bool{.libx11c, importc: "XkbSelectEventDetails".}
+proc XkbNoteMapChanges*(old: PXkbMapChangesPtr, new: PXkbMapNotifyEvent,
+                        wanted: int16){.libx11c,
+                                        importc: "XkbNoteMapChanges".}
+proc XkbNoteNameChanges*(old: PXkbNameChangesPtr, new: PXkbNamesNotifyEvent,
+                         wanted: int16){.libx11c,
+    importc: "XkbNoteNameChanges".}
+proc XkbGetIndicatorState*(dpy: PDisplay, deviceSpec: int16, pStateRtrn: PWord): Status{.
+    libx11c, importc: "XkbGetIndicatorState".}
+proc XkbGetDeviceIndicatorState*(dpy: PDisplay,
+                                 deviceSpec, ledClass, ledID: int16,
+                                 pStateRtrn: PWord): Status{.libx11c, importc: "XkbGetDeviceIndicatorState".}
+proc XkbGetIndicatorMap*(dpy: PDisplay, which: int32, desc: PXkbDescPtr): Status{.
+    libx11c, importc: "XkbGetIndicatorMap".}
+proc XkbSetIndicatorMap*(dpy: PDisplay, which: int32, desc: PXkbDescPtr): bool{.
+    libx11c, importc: "XkbSetIndicatorMap".}
+proc XkbNoteIndicatorMapChanges*(o, n: PXkbIndicatorChangesPtr, w: int16)
+proc XkbNoteIndicatorStateChanges*(o, n: PXkbIndicatorChangesPtr, w: int16)
+proc XkbGetIndicatorMapChanges*(d: PDisplay, x: PXkbDescPtr,
+                                c: PXkbIndicatorChangesPtr): Status
+proc XkbChangeIndicatorMaps*(d: PDisplay, x: PXkbDescPtr,
+                             c: PXkbIndicatorChangesPtr): bool
+proc XkbGetNamedIndicator*(dpy: PDisplay, name: Atom, pNdxRtrn: ptr int16,
+                           pStateRtrn: ptr bool, pMapRtrn: PXkbIndicatorMapPtr,
+                           pRealRtrn: ptr bool): bool{.libx11c,
+    importc: "XkbGetNamedIndicator".}
+proc XkbGetNamedDeviceIndicator*(dpy: PDisplay,
+                                 deviceSpec, ledClass, ledID: int16,
+                                 name: Atom, pNdxRtrn: ptr int16,
+                                 pStateRtrn: ptr bool,
+                                 pMapRtrn: PXkbIndicatorMapPtr,
+                                 pRealRtrn: ptr bool): bool{.libx11c, importc: "XkbGetNamedDeviceIndicator".}
+proc XkbSetNamedIndicator*(dpy: PDisplay, name: Atom,
+                           changeState, state, createNewMap: bool,
+                           pMap: PXkbIndicatorMapPtr): bool{.libx11c, importc: "XkbSetNamedIndicator".}
+proc XkbSetNamedDeviceIndicator*(dpy: PDisplay,
+                                 deviceSpec, ledClass, ledID: int16,
+                                 name: Atom,
+                                 changeState, state, createNewMap: bool,
+                                 pMap: PXkbIndicatorMapPtr): bool{.libx11c, importc: "XkbSetNamedDeviceIndicator".}
+proc XkbLockModifiers*(dpy: PDisplay, deviceSpec, affect, values: int16): bool{.
+    libx11c, importc: "XkbLockModifiers".}
+proc XkbLatchModifiers*(dpy: PDisplay, deviceSpec, affect, values: int16): bool{.
+    libx11c, importc: "XkbLatchModifiers".}
+proc XkbLockGroup*(dpy: PDisplay, deviceSpec, group: int16): bool{.libx11c, importc: "XkbLockGroup".}
+proc XkbLatchGroup*(dpy: PDisplay, deviceSpec, group: int16): bool{.libx11c, importc: "XkbLatchGroup".}
+proc XkbSetServerInternalMods*(dpy: PDisplay, deviceSpec, affectReal,
+    realValues, affectVirtual, virtualValues: int16): bool{.libx11c, importc: "XkbSetServerInternalMods".}
+proc XkbSetIgnoreLockMods*(dpy: PDisplay, deviceSpec, affectReal, realValues,
+    affectVirtual, virtualValues: int16): bool{.libx11c,
+    importc: "XkbSetIgnoreLockMods".}
+proc XkbVirtualModsToReal*(dpy: PDisplay, virtual_mask: int16, mask_rtrn: PWord): bool{.
+    libx11c, importc: "XkbVirtualModsToReal".}
+proc XkbComputeEffectiveMap*(xkb: PXkbDescPtr, theType: PXkbKeyTypePtr,
+                             map_rtrn: PByte): bool{.libx11c,
+    importc: "XkbComputeEffectiveMap".}
+proc XkbInitCanonicalKeyTypes*(xkb: PXkbDescPtr, which: int16, keypadVMod: int16): Status{.
+    libx11c, importc: "XkbInitCanonicalKeyTypes".}
+proc XkbAllocKeyboard*(): PXkbDescPtr{.libx11c,
+                                       importc: "XkbAllocKeyboard".}
+proc XkbFreeKeyboard*(xkb: PXkbDescPtr, which: int16, freeDesc: bool){.libx11c, importc: "XkbFreeKeyboard".}
+proc XkbAllocClientMap*(xkb: PXkbDescPtr, which, nTypes: int16): Status{.libx11c, importc: "XkbAllocClientMap".}
+proc XkbAllocServerMap*(xkb: PXkbDescPtr, which, nActions: int16): Status{.
+    libx11c, importc: "XkbAllocServerMap".}
+proc XkbFreeClientMap*(xkb: PXkbDescPtr, what: int16, freeMap: bool){.libx11c, importc: "XkbFreeClientMap".}
+proc XkbFreeServerMap*(xkb: PXkbDescPtr, what: int16, freeMap: bool){.libx11c, importc: "XkbFreeServerMap".}
+proc XkbAddKeyType*(xkb: PXkbDescPtr, name: Atom, map_count: int16,
+                    want_preserve: bool, num_lvls: int16): PXkbKeyTypePtr{.
+    libx11c, importc: "XkbAddKeyType".}
+proc XkbAllocIndicatorMaps*(xkb: PXkbDescPtr): Status{.libx11c,
+    importc: "XkbAllocIndicatorMaps".}
+proc XkbFreeIndicatorMaps*(xkb: PXkbDescPtr){.libx11c,
+    importc: "XkbFreeIndicatorMaps".}
+proc XkbGetMap*(dpy: PDisplay, which, deviceSpec: int16): PXkbDescPtr{.libx11c, importc: "XkbGetMap".}
+proc XkbGetUpdatedMap*(dpy: PDisplay, which: int16, desc: PXkbDescPtr): Status{.
+    libx11c, importc: "XkbGetUpdatedMap".}
+proc XkbGetMapChanges*(dpy: PDisplay, xkb: PXkbDescPtr,
+                       changes: PXkbMapChangesPtr): Status{.libx11c, importc: "XkbGetMapChanges".}
+proc XkbRefreshKeyboardMapping*(event: PXkbMapNotifyEvent): Status{.libx11c, importc: "XkbRefreshKeyboardMapping".}
+proc XkbGetKeyTypes*(dpy: PDisplay, first, num: int16, xkb: PXkbDescPtr): Status{.
+    libx11c, importc: "XkbGetKeyTypes".}
+proc XkbGetKeySyms*(dpy: PDisplay, first, num: int16, xkb: PXkbDescPtr): Status{.
+    libx11c, importc: "XkbGetKeySyms".}
+proc XkbGetKeyActions*(dpy: PDisplay, first, num: int16, xkb: PXkbDescPtr): Status{.
+    libx11c, importc: "XkbGetKeyActions".}
+proc XkbGetKeyBehaviors*(dpy: PDisplay, firstKey, nKeys: int16,
+                         desc: PXkbDescPtr): Status{.libx11c,
+    importc: "XkbGetKeyBehaviors".}
+proc XkbGetVirtualMods*(dpy: PDisplay, which: int16, desc: PXkbDescPtr): Status{.
+    libx11c, importc: "XkbGetVirtualMods".}
+proc XkbGetKeyExplicitComponents*(dpy: PDisplay, firstKey, nKeys: int16,
+                                  desc: PXkbDescPtr): Status{.libx11c, importc: "XkbGetKeyExplicitComponents".}
+proc XkbGetKeyModifierMap*(dpy: PDisplay, firstKey, nKeys: int16,
+                           desc: PXkbDescPtr): Status{.libx11c,
+    importc: "XkbGetKeyModifierMap".}
+proc XkbAllocControls*(xkb: PXkbDescPtr, which: int16): Status{.libx11c, importc: "XkbAllocControls".}
+proc XkbFreeControls*(xkb: PXkbDescPtr, which: int16, freeMap: bool){.libx11c, importc: "XkbFreeControls".}
+proc XkbGetControls*(dpy: PDisplay, which: int32, desc: PXkbDescPtr): Status{.
+    libx11c, importc: "XkbGetControls".}
+proc XkbSetControls*(dpy: PDisplay, which: int32, desc: PXkbDescPtr): bool{.
+    libx11c, importc: "XkbSetControls".}
+proc XkbNoteControlsChanges*(old: PXkbControlsChangesPtr,
+                             new: PXkbControlsNotifyEvent, wanted: int16){.
+    libx11c, importc: "XkbNoteControlsChanges".}
+proc XkbGetControlsChanges*(d: PDisplay, x: PXkbDescPtr,
+                            c: PXkbControlsChangesPtr): Status
+proc XkbChangeControls*(d: PDisplay, x: PXkbDescPtr, c: PXkbControlsChangesPtr): bool
+proc XkbAllocCompatMap*(xkb: PXkbDescPtr, which, nInterpret: int16): Status{.
+    libx11c, importc: "XkbAllocCompatMap".}
+proc XkbFreeCompatMap*(xkib: PXkbDescPtr, which: int16, freeMap: bool){.libx11c, importc: "XkbFreeCompatMap".}
+proc XkbGetCompatMap*(dpy: PDisplay, which: int16, xkb: PXkbDescPtr): Status{.
+    libx11c, importc: "XkbGetCompatMap".}
+proc XkbSetCompatMap*(dpy: PDisplay, which: int16, xkb: PXkbDescPtr,
+                      updateActions: bool): bool{.libx11c,
+    importc: "XkbSetCompatMap".}
+proc XkbAddSymInterpret*(xkb: PXkbDescPtr, si: PXkbSymInterpretPtr,
+                         updateMap: bool, changes: PXkbChangesPtr): PXkbSymInterpretPtr{.
+    libx11c, importc: "XkbAddSymInterpret".}
+proc XkbAllocNames*(xkb: PXkbDescPtr, which: int16,
+                    nTotalRG, nTotalAliases: int16): Status{.libx11c, importc: "XkbAllocNames".}
+proc XkbGetNames*(dpy: PDisplay, which: int16, desc: PXkbDescPtr): Status{.
+    libx11c, importc: "XkbGetNames".}
+proc XkbSetNames*(dpy: PDisplay, which, firstType, nTypes: int16,
+                  desc: PXkbDescPtr): bool{.libx11c,
+    importc: "XkbSetNames".}
+proc XkbChangeNames*(dpy: PDisplay, xkb: PXkbDescPtr,
+                     changes: PXkbNameChangesPtr): bool{.libx11c,
+    importc: "XkbChangeNames".}
+proc XkbFreeNames*(xkb: PXkbDescPtr, which: int16, freeMap: bool){.libx11c, importc: "XkbFreeNames".}
+proc XkbGetState*(dpy: PDisplay, deviceSpec: int16, rtrnState: PXkbStatePtr): Status{.
+    libx11c, importc: "XkbGetState".}
+proc XkbSetMap*(dpy: PDisplay, which: int16, desc: PXkbDescPtr): bool{.libx11c, importc: "XkbSetMap".}
+proc XkbChangeMap*(dpy: PDisplay, desc: PXkbDescPtr, changes: PXkbMapChangesPtr): bool{.
+    libx11c, importc: "XkbChangeMap".}
+proc XkbSetDetectableAutoRepeat*(dpy: PDisplay, detectable: bool,
+                                 supported: ptr bool): bool{.libx11c, importc: "XkbSetDetectableAutoRepeat".}
+proc XkbGetDetectableAutoRepeat*(dpy: PDisplay, supported: ptr bool): bool{.
+    libx11c, importc: "XkbGetDetectableAutoRepeat".}
+proc XkbSetAutoResetControls*(dpy: PDisplay, changes: int16,
+                              auto_ctrls, auto_values: PWord): bool{.libx11c, importc: "XkbSetAutoResetControls".}
+proc XkbGetAutoResetControls*(dpy: PDisplay, auto_ctrls, auto_ctrl_values: PWord): bool{.
+    libx11c, importc: "XkbGetAutoResetControls".}
+proc XkbSetPerClientControls*(dpy: PDisplay, change: int16, values: PWord): bool{.
+    libx11c, importc: "XkbSetPerClientControls".}
+proc XkbGetPerClientControls*(dpy: PDisplay, ctrls: PWord): bool{.libx11c, importc: "XkbGetPerClientControls".}
+proc XkbCopyKeyType*(`from`, into: PXkbKeyTypePtr): Status{.libx11c, importc: "XkbCopyKeyType".}
+proc XkbCopyKeyTypes*(`from`, into: PXkbKeyTypePtr, num_types: int16): Status{.
+    libx11c, importc: "XkbCopyKeyTypes".}
+proc XkbResizeKeyType*(xkb: PXkbDescPtr, type_ndx, map_count: int16,
+                       want_preserve: bool, new_num_lvls: int16): Status{.
+    libx11c, importc: "XkbResizeKeyType".}
+proc XkbResizeKeySyms*(desc: PXkbDescPtr, forKey, symsNeeded: int16): PKeySym{.
+    libx11c, importc: "XkbResizeKeySyms".}
+proc XkbResizeKeyActions*(desc: PXkbDescPtr, forKey, actsNeeded: int16): PXkbAction{.
+    libx11c, importc: "XkbResizeKeyActions".}
+proc XkbChangeTypesOfKey*(xkb: PXkbDescPtr, key, num_groups: int16,
+                          groups: int16, newTypes: ptr int16,
+                          pChanges: PXkbMapChangesPtr): Status{.libx11c, importc: "XkbChangeTypesOfKey".}
+
+proc XkbListComponents*(dpy: PDisplay, deviceSpec: int16,
+                        ptrns: PXkbComponentNamesPtr, max_inout: ptr int16): PXkbComponentListPtr{.
+    libx11c, importc: "XkbListComponents".}
+proc XkbFreeComponentList*(list: PXkbComponentListPtr){.libx11c,
+    importc: "XkbFreeComponentList".}
+proc XkbGetKeyboard*(dpy: PDisplay, which, deviceSpec: int16): PXkbDescPtr{.
+    libx11c, importc: "XkbGetKeyboard".}
+proc XkbGetKeyboardByName*(dpy: PDisplay, deviceSpec: int16,
+                           names: PXkbComponentNamesPtr, want, need: int16,
+                           load: bool): PXkbDescPtr{.libx11c,
+    importc: "XkbGetKeyboardByName".}
+
+proc XkbKeyTypesForCoreSymbols*(xkb: PXkbDescPtr,
+                                map_width: int16, # keyboard device
+                                core_syms: PKeySym, # always mapWidth symbols
+                                protected: int16, # explicit key types
+                                types_inout: ptr int16, # always four type indices
+                                xkb_syms_rtrn: PKeySym): int16{.libx11c, importc: "XkbKeyTypesForCoreSymbols".}
+  # must have enough space
+proc XkbApplyCompatMapToKey*(xkb: PXkbDescPtr,
+                             key: KeyCode, # key to be updated
+                             changes: PXkbChangesPtr): bool{.libx11c, importc: "XkbApplyCompatMapToKey".}
+  # resulting changes to map
+proc XkbUpdateMapFromCore*(xkb: PXkbDescPtr,
+                           first_key: KeyCode, # first changed key
+                           num_keys,
+                           map_width: int16,
+                           core_keysyms: PKeySym, # symbols `from` core keymap
+                           changes: PXkbChangesPtr): bool{.libx11c, importc: "XkbUpdateMapFromCore".}
+
+proc XkbAddDeviceLedInfo*(devi: PXkbDeviceInfoPtr, ledClass, ledId: int16): PXkbDeviceLedInfoPtr{.
+    libx11c, importc: "XkbAddDeviceLedInfo".}
+proc XkbResizeDeviceButtonActions*(devi: PXkbDeviceInfoPtr, newTotal: int16): Status{.
+    libx11c, importc: "XkbResizeDeviceButtonActions".}
+proc XkbAllocDeviceInfo*(deviceSpec, nButtons, szLeds: int16): PXkbDeviceInfoPtr{.
+    libx11c, importc: "XkbAllocDeviceInfo".}
+proc XkbFreeDeviceInfo*(devi: PXkbDeviceInfoPtr, which: int16, freeDevI: bool){.
+    libx11c, importc: "XkbFreeDeviceInfo".}
+proc XkbNoteDeviceChanges*(old: PXkbDeviceChangesPtr,
+                           new: PXkbExtensionDeviceNotifyEvent, wanted: int16){.
+    libx11c, importc: "XkbNoteDeviceChanges".}
+proc XkbGetDeviceInfo*(dpy: PDisplay, which, deviceSpec, ledClass, ledID: int16): PXkbDeviceInfoPtr{.
+    libx11c, importc: "XkbGetDeviceInfo".}
+proc XkbGetDeviceInfoChanges*(dpy: PDisplay, devi: PXkbDeviceInfoPtr,
+                              changes: PXkbDeviceChangesPtr): Status{.libx11c, importc: "XkbGetDeviceInfoChanges".}
+proc XkbGetDeviceButtonActions*(dpy: PDisplay, devi: PXkbDeviceInfoPtr,
+                                all: bool, first, nBtns: int16): Status{.libx11c, importc: "XkbGetDeviceButtonActions".}
+proc XkbGetDeviceLedInfo*(dpy: PDisplay, devi: PXkbDeviceInfoPtr,
+                          ledClass, ledId, which: int16): Status{.libx11c, importc: "XkbGetDeviceLedInfo".}
+proc XkbSetDeviceInfo*(dpy: PDisplay, which: int16, devi: PXkbDeviceInfoPtr): bool{.
+    libx11c, importc: "XkbSetDeviceInfo".}
+proc XkbChangeDeviceInfo*(dpy: PDisplay, desc: PXkbDeviceInfoPtr,
+                          changes: PXkbDeviceChangesPtr): bool{.libx11c, importc: "XkbChangeDeviceInfo".}
+proc XkbSetDeviceLedInfo*(dpy: PDisplay, devi: PXkbDeviceInfoPtr,
+                          ledClass, ledID, which: int16): bool{.libx11c, importc: "XkbSetDeviceLedInfo".}
+proc XkbSetDeviceButtonActions*(dpy: PDisplay, devi: PXkbDeviceInfoPtr,
+                                first, nBtns: int16): bool{.libx11c, importc: "XkbSetDeviceButtonActions".}
+
+proc XkbToControl*(c: int8): int8{.libx11c,
+                                   importc: "XkbToControl".}
+
+proc XkbSetDebuggingFlags*(dpy: PDisplay, mask, flags: int16, msg: cstring,
+                           ctrls_mask, ctrls, rtrn_flags, rtrn_ctrls: int16): bool{.
+    libx11c, importc: "XkbSetDebuggingFlags".}
+proc XkbApplyVirtualModChanges*(xkb: PXkbDescPtr, changed: int16,
+                                changes: PXkbChangesPtr): bool{.libx11c, importc: "XkbApplyVirtualModChanges".}
+
+# implementation
+
+proc XkbNoteIndicatorMapChanges(o, n: PXkbIndicatorChangesPtr, w: int16) =
+  ##define XkbNoteIndicatorMapChanges(o,n,w) ((o)->map_changes|=((n)->map_changes&(w)))
+  o.map_changes = o.map_changes or (n.map_changes and w)
+
+proc XkbNoteIndicatorStateChanges(o, n: PXkbIndicatorChangesPtr, w: int16) =
+  ##define XkbNoteIndicatorStateChanges(o,n,w) ((o)->state_changes|=((n)->state_changes&(w)))
+  o.state_changes = o.state_changes or (n.state_changes and (w))
+
+proc XkbGetIndicatorMapChanges(d: PDisplay, x: PXkbDescPtr,
+                               c: PXkbIndicatorChangesPtr): Status =
+  ##define XkbGetIndicatorMapChanges(d,x,c) (XkbGetIndicatorMap((d),(c)->map_changes,x)
+  result = XkbGetIndicatorMap(d, c.map_changes, x)
+
+proc XkbChangeIndicatorMaps(d: PDisplay, x: PXkbDescPtr,
+                            c: PXkbIndicatorChangesPtr): bool =
+  ##define XkbChangeIndicatorMaps(d,x,c) (XkbSetIndicatorMap((d),(c)->map_changes,x))
+  result = XkbSetIndicatorMap(d, c.map_changes, x)
+
+proc XkbGetControlsChanges(d: PDisplay, x: PXkbDescPtr,
+                           c: PXkbControlsChangesPtr): Status =
+  ##define XkbGetControlsChanges(d,x,c) XkbGetControls(d,(c)->changed_ctrls,x)
+  result = XkbGetControls(d, c.changed_ctrls, x)
+
+proc XkbChangeControls(d: PDisplay, x: PXkbDescPtr, c: PXkbControlsChangesPtr): bool =
+  ##define XkbChangeControls(d,x,c) XkbSetControls(d,(c)->changed_ctrls,x)
+  result = XkbSetControls(d, c.changed_ctrls, x)