#
# $Xorg: XKB.h,v 1.3 2000/08/18 04:05:45 coskrey Exp $
#************************************************************
# $Xorg: XKBstr.h,v 1.3 2000/08/18 04:05:45 coskrey Exp $
#************************************************************
# $Xorg: XKBgeom.h,v 1.3 2000/08/18 04:05:45 coskrey 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/include/extensions/XKB.h,v 1.5 2002/11/20 04:49:01 dawes Exp $
# $XFree86: xc/include/extensions/XKBgeom.h,v 3.9 2002/09/18 17:11:40 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/04 - 06      - Convertion from the c header of XKBgeom.h.
#        2004/10/03           - Removed the XKBstr_UNIT compiler decleration. Afther the joined files,
#                                                                                     There is no need for it anymore.
#                                                                             - There is a need to define (for now) XKBgeom (compiler define) in order
#                                                                               to use the code of it. At this moment, I did not yet converted it to Pascal.
#
#        2004/09/17 - 10/04   - Convertion from the c header of XKBstr.
#
#        2004/10/03           - Joined xkbstr.pas into xkb.pas because of the circular calls problems.
#                             - Added the history of xkbstr.pas above this addition.
#
#        2004/09/17           - Fixed a wrong convertion number of XkbPerKeyBitArraySize, insted
#                               of float, it's now converted into integer (as it should have been).
#
#        2004/09/15 - 16      - Convertion from the c header of XKB.h.
#

import
  x, xlib

include "x11pragma.nim"

proc XkbcharToInt*(v: int8): int16
proc XkbIntTo2chars*(i: int16, h, L: var int8)
proc Xkb2charsToInt*(h, L: int8): int16
  #
  #          Common data structures and access macros
  #
type
  PWord* = ptr array[0..64_000, int16]
  PByte* = ptr byte
  PXkbStatePtr* = ptr XkbStateRec
  XkbStateRec*{.final.} = object
    group*: int8
    locked_group*: int8
    base_group*: int16
    latched_group*: int16
    mods*: int8
    base_mods*: int8
    latched_mods*: int8
    locked_mods*: int8
    compat_state*: int8
    grab_mods*: int8
    compat_grab_mods*: int8
    lookup_mods*: int8
    compat_lookup_mods*: int8
    ptr_buttons*: int16



proc XkbModLocks*(s: PXkbStatePtr): int8
proc XkbStateMods*(s: PXkbStatePtr): int16
proc XkbGroupLock*(s: PXkbStatePtr): int8
proc XkbStateGroup*(s: PXkbStatePtr): int16
proc XkbStateFieldFromRec*(s: PXkbStatePtr): int
proc XkbGrabStateFromRec*(s: PXkbStatePtr): int
type
  PXkbModsPtr* = ptr XkbModsRec
  XkbModsRec*{.final.} = object
    mask*: int8 # effective mods
    real_mods*: int8
    vmods*: int16



type
  PXkbKTMapEntryPtr* = ptr XkbKTMapEntryRec
  XkbKTMapEntryRec*{.final.} = object
    active*: bool
    level*: int8
    mods*: XkbModsRec



type
  PXkbKeyTypePtr* = ptr XkbKeyTypeRec
  XkbKeyTypeRec*{.final.} = object
    mods*: XkbModsRec
    num_levels*: int8
    map_count*: int8
    map*: PXkbKTMapEntryPtr
    preserve*: PXkbModsPtr
    name*: Atom
    level_names*: Atom



proc XkbNumGroups*(g: int16): int16
proc XkbOutOfRangeGroupInfo*(g: int16): int16
proc XkbOutOfRangeGroupAction*(g: int16): int16
proc XkbOutOfRangeGroupNumber*(g: int16): int16
proc XkbSetGroupInfo*(g, w, n: int16): int16
proc XkbSetNumGroups*(g, n: int16): int16
  #
  #          Structures and access macros used primarily by the server
  #
type
  PXkbBehavior* = ptr XkbBehavior
  XkbBehavior*{.final.} = object
    theType*: int8
    data*: int8



type
  PXkbModAction* = ptr XkbModAction
  XkbModAction*{.final.} = object
    theType*: int8
    flags*: int8
    mask*: int8
    real_mods*: int8
    vmods1*: int8
    vmods2*: int8



proc XkbModActionVMods*(a: PXkbModAction): int16
proc XkbSetModActionVMods*(a: PXkbModAction, v: int8)
type
  PXkbGroupAction* = ptr XkbGroupAction
  XkbGroupAction*{.final.} = object
    theType*: int8
    flags*: int8
    group_XXX*: int8



proc XkbSAGroup*(a: PXkbGroupAction): int8
proc XkbSASetGroupProc*(a: PXkbGroupAction, g: int8)
type
  PXkbISOAction* = ptr XkbISOAction
  XkbISOAction*{.final.} = object
    theType*: int8
    flags*: int8
    mask*: int8
    real_mods*: int8
    group_XXX*: int8
    affect*: int8
    vmods1*: int8
    vmods2*: int8



type
  PXkbPtrAction* = ptr XkbPtrAction
  XkbPtrAction*{.final.} = object
    theType*: int8
    flags*: int8
    high_XXX*: int8
    low_XXX*: int8
    high_YYY*: int8
    low_YYY*: int8



proc XkbPtrActionX*(a: PXkbPtrAction): int16
proc XkbPtrActionY*(a: PXkbPtrAction): int16
proc XkbSetPtrActionX*(a: PXkbPtrAction, x: int8)
proc XkbSetPtrActionY*(a: PXkbPtrAction, y: int8)
type
  PXkbPtrBtnAction* = ptr XkbPtrBtnAction
  XkbPtrBtnAction*{.final.} = object
    theType*: int8
    flags*: int8
    count*: int8
    button*: int8



type
  PXkbPtrDfltAction* = ptr XkbPtrDfltAction
  XkbPtrDfltAction*{.final.} = object
    theType*: int8
    flags*: int8
    affect*: int8
    valueXXX*: int8



proc XkbSAPtrDfltValue*(a: PXkbPtrDfltAction): int8
proc XkbSASetPtrDfltValue*(a: PXkbPtrDfltAction, c: pointer)
type
  PXkbSwitchScreenAction* = ptr XkbSwitchScreenAction
  XkbSwitchScreenAction*{.final.} = object
    theType*: int8
    flags*: int8
    screenXXX*: int8



proc XkbSAScreen*(a: PXkbSwitchScreenAction): int8
proc XkbSASetScreen*(a: PXkbSwitchScreenAction, s: pointer)
type
  PXkbCtrlsAction* = ptr XkbCtrlsAction
  XkbCtrlsAction*{.final.} = object
    theType*: int8
    flags*: int8
    ctrls3*: int8
    ctrls2*: int8
    ctrls1*: int8
    ctrls0*: int8



proc XkbActionSetCtrls*(a: PXkbCtrlsAction, c: int8)
proc XkbActionCtrls*(a: PXkbCtrlsAction): int16
type
  PXkbMessageAction* = ptr XkbMessageAction
  XkbMessageAction*{.final.} = object
    theType*: int8
    flags*: int8
    message*: array[0..5, char]



type
  PXkbRedirectKeyAction* = ptr XkbRedirectKeyAction
  XkbRedirectKeyAction*{.final.} = object
    theType*: int8
    new_key*: int8
    mods_mask*: int8
    mods*: int8
    vmods_mask0*: int8
    vmods_mask1*: int8
    vmods0*: int8
    vmods1*: int8



proc XkbSARedirectVMods*(a: PXkbRedirectKeyAction): int16
proc XkbSARedirectSetVMods*(a: PXkbRedirectKeyAction, m: int8)
proc XkbSARedirectVModsMask*(a: PXkbRedirectKeyAction): int16
proc XkbSARedirectSetVModsMask*(a: PXkbRedirectKeyAction, m: int8)
type
  PXkbDeviceBtnAction* = ptr XkbDeviceBtnAction
  XkbDeviceBtnAction*{.final.} = object
    theType*: int8
    flags*: int8
    count*: int8
    button*: int8
    device*: int8



type
  PXkbDeviceValuatorAction* = ptr XkbDeviceValuatorAction
  XkbDeviceValuatorAction*{.final.} = object #
                                             #      Macros to classify key actions
                                             #
    theType*: int8
    device*: int8
    v1_what*: int8
    v1_ndx*: int8
    v1_value*: int8
    v2_what*: int8
    v2_ndx*: int8
    v2_value*: int8



const
  XkbAnyActionDataSize* = 7

type
  PXkbAnyAction* = ptr XkbAnyAction
  XkbAnyAction*{.final.} = object
    theType*: int8
    data*: array[0..XkbAnyActionDataSize - 1, int8]



proc XkbIsModAction*(a: PXkbAnyAction): bool
proc XkbIsGroupAction*(a: PXkbAnyAction): bool
proc XkbIsPtrAction*(a: PXkbAnyAction): bool
type
  PXkbAction* = ptr XkbAction
  XkbAction*{.final.} = object #
                               #      XKB request codes, used in:
                               #      -  xkbReqType field of all requests
                               #      -  requestMinor field of some events
                               #
    any*: XkbAnyAction
    mods*: XkbModAction
    group*: XkbGroupAction
    iso*: XkbISOAction
    thePtr*: XkbPtrAction
    btn*: XkbPtrBtnAction
    dflt*: XkbPtrDfltAction
    screen*: XkbSwitchScreenAction
    ctrls*: XkbCtrlsAction
    msg*: XkbMessageAction
    redirect*: XkbRedirectKeyAction
    devbtn*: XkbDeviceBtnAction
    devval*: XkbDeviceValuatorAction
    theType*: int8



const
  X_kbUseExtension* = 0
  X_kbSelectEvents* = 1
  X_kbBell* = 3
  X_kbGetState* = 4
  X_kbLatchLockState* = 5
  X_kbGetControls* = 6
  X_kbSetControls* = 7
  X_kbGetMap* = 8
  X_kbSetMap* = 9
  X_kbGetCompatMap* = 10
  X_kbSetCompatMap* = 11
  X_kbGetIndicatorState* = 12
  X_kbGetIndicatorMap* = 13
  X_kbSetIndicatorMap* = 14
  X_kbGetNamedIndicator* = 15
  X_kbSetNamedIndicator* = 16
  X_kbGetNames* = 17
  X_kbSetNames* = 18
  X_kbGetGeometry* = 19
  X_kbSetGeometry* = 20
  X_kbPerClientFlags* = 21
  X_kbListComponents* = 22
  X_kbGetKbdByName* = 23
  X_kbGetDeviceInfo* = 24
  X_kbSetDeviceInfo* = 25
  X_kbSetDebuggingFlags* = 101 #
                               #      In the X sense, XKB reports only one event.
                               #      The type field of all XKB events is XkbEventCode
                               #

const
  XkbEventCode* = 0
  XkbNumberEvents* = XkbEventCode + 1 #
                                      #      XKB has a minor event code so it can use one X event code for
                                      #      multiple purposes.
                                      #       - reported in the xkbType field of all XKB events.
                                      #       - XkbSelectEventDetails: Indicates the event for which event details
                                      #         are being changed
                                      #

const
  XkbNewKeyboardNotify* = 0
  XkbMapNotify* = 1
  XkbStateNotify* = 2
  XkbControlsNotify* = 3
  XkbIndicatorStateNotify* = 4
  XkbIndicatorMapNotify* = 5
  XkbNamesNotify* = 6
  XkbCompatMapNotify* = 7
  XkbBellNotify* = 8
  XkbActionMessage* = 9
  XkbAccessXNotify* = 10
  XkbExtensionDeviceNotify* = 11 #
                                 #      Event Mask:
                                 #       - XkbSelectEvents:  Specifies event interest.
                                 #

const
  XkbNewKeyboardNotifyMask* = int(1) shl 0
  XkbMapNotifyMask* = int(1) shl 1
  XkbStateNotifyMask* = int(1) shl 2
  XkbControlsNotifyMask* = int(1) shl 3
  XkbIndicatorStateNotifyMask* = int(1) shl 4
  XkbIndicatorMapNotifyMask* = int(1) shl 5
  XkbNamesNotifyMask* = int(1) shl 6
  XkbCompatMapNotifyMask* = int(1) shl 7
  XkbBellNotifyMask* = int(1) shl 8
  XkbActionMessageMask* = int(1) shl 9
  XkbAccessXNotifyMask* = int(1) shl 10
  XkbExtensionDeviceNotifyMask* = int(1) shl 11
  XkbAllEventsMask* = 0x00000FFF #
                                 #      NewKeyboardNotify event details:
                                 #

const
  XkbNKN_KeycodesMask* = int(1) shl 0
  XkbNKN_GeometryMask* = int(1) shl 1
  XkbNKN_DeviceIDMask* = int(1) shl 2
  XkbAllNewKeyboardEventsMask* = 0x00000007 #
                                            #      AccessXNotify event types:
                                            #       - The 'what' field of AccessXNotify events reports the
                                            #         reason that the event was generated.
                                            #

const
  XkbAXN_SKPress* = 0
  XkbAXN_SKAccept* = 1
  XkbAXN_SKReject* = 2
  XkbAXN_SKRelease* = 3
  XkbAXN_BKAccept* = 4
  XkbAXN_BKReject* = 5
  XkbAXN_AXKWarning* = 6 #
                         #      AccessXNotify details:
                         #      - Used as an event detail mask to limit the conditions under which
                         #        AccessXNotify events are reported
                         #

const
  XkbAXN_SKPressMask* = int(1) shl 0
  XkbAXN_SKAcceptMask* = int(1) shl 1
  XkbAXN_SKRejectMask* = int(1) shl 2
  XkbAXN_SKReleaseMask* = int(1) shl 3
  XkbAXN_BKAcceptMask* = int(1) shl 4
  XkbAXN_BKRejectMask* = int(1) shl 5
  XkbAXN_AXKWarningMask* = int(1) shl 6
  XkbAllAccessXEventsMask* = 0x0000000F #
                                        #      State detail mask:
                                        #       - The 'changed' field of StateNotify events reports which of
                                        #         the keyboard state components have changed.
                                        #       - Used as an event detail mask to limit the conditions under
                                        #         which StateNotify events are reported.
                                        #

const
  XkbModifierStateMask* = int(1) shl 0
  XkbModifierBaseMask* = int(1) shl 1
  XkbModifierLatchMask* = int(1) shl 2
  XkbModifierLockMask* = int(1) shl 3
  XkbGroupStateMask* = int(1) shl 4
  XkbGroupBaseMask* = int(1) shl 5
  XkbGroupLatchMask* = int(1) shl 6
  XkbGroupLockMask* = int(1) shl 7
  XkbCompatStateMask* = int(1) shl 8
  XkbGrabModsMask* = int(1) shl 9
  XkbCompatGrabModsMask* = int(1) shl 10
  XkbLookupModsMask* = int(1) shl 11
  XkbCompatLookupModsMask* = int(1) shl 12
  XkbPointerButtonMask* = int(1) shl 13
  XkbAllStateComponentsMask* = 0x00003FFF #
                                          #      Controls detail masks:
                                          #       The controls specified in XkbAllControlsMask:
                                          #       - The 'changed' field of ControlsNotify events reports which of
                                          #         the keyboard controls have changed.
                                          #       - The 'changeControls' field of the SetControls request specifies
                                          #         the controls for which values are to be changed.
                                          #       - Used as an event detail mask to limit the conditions under
                                          #         which ControlsNotify events are reported.
                                          #
                                          #       The controls specified in the XkbAllBooleanCtrlsMask:
                                          #       - The 'enabledControls' field of ControlsNotify events reports the
                                          #         current status of the boolean controls.
                                          #       - The 'enabledControlsChanges' field of ControlsNotify events reports
                                          #         any boolean controls that have been turned on or off.
                                          #       - The 'affectEnabledControls' and 'enabledControls' fields of the
                                          #         kbSetControls request change the set of enabled controls.
                                          #       - The 'accessXTimeoutMask' and 'accessXTimeoutValues' fields of
                                          #         an XkbControlsRec specify the controls to be changed if the keyboard
                                          #         times out and the values to which they should be changed.
                                          #       - The 'autoCtrls' and 'autoCtrlsValues' fields of the PerClientFlags
                                          #         request specifies the specify the controls to be reset when the
                                          #         client exits and the values to which they should be reset.
                                          #       - The 'ctrls' field of an indicator map specifies the controls
                                          #         that drive the indicator.
                                          #       - Specifies the boolean controls affected by the SetControls and
                                          #         LockControls key actions.
                                          #

const
  XkbRepeatKeysMask* = int(1) shl 0
  XkbSlowKeysMask* = int(1) shl 1
  XkbBounceKeysMask* = int(1) shl 2
  XkbStickyKeysMask* = int(1) shl 3
  XkbMouseKeysMask* = int(1) shl 4
  XkbMouseKeysAccelMask* = int(1) shl 5
  XkbAccessXKeysMask* = int(1) shl 6
  XkbAccessXTimeoutMask* = int(1) shl 7
  XkbAccessXFeedbackMask* = int(1) shl 8
  XkbAudibleBellMask* = int(1) shl 9
  XkbOverlay1Mask* = int(1) shl 10
  XkbOverlay2Mask* = int(1) shl 11
  XkbIgnoreGroupLockMask* = int(1) shl 12
  XkbGroupsWrapMask* = int(1) shl 27
  XkbInternalModsMask* = int(1) shl 28
  XkbIgnoreLockModsMask* = int(1) shl 29
  XkbPerKeyRepeatMask* = int(1) shl 30
  XkbControlsEnabledMask* = int(1) shl 31
  XkbAccessXOptionsMask* = XkbStickyKeysMask or XkbAccessXFeedbackMask
  XkbAllBooleanCtrlsMask* = 0x00001FFF
  XkbAllControlsMask* = 0xF8001FFF #
                                   #      Compatibility Map Compontents:
                                   #       - Specifies the components to be allocated in XkbAllocCompatMap.
                                   #

const
  XkbSymInterpMask* = 1 shl 0
  XkbGroupCompatMask* = 1 shl 1
  XkbAllCompatMask* = 0x00000003 #
                                 #      Assorted constants and limits.
                                 #

const
  XkbAllIndicatorsMask* = 0xFFFFFFFF #
                                     #      Map components masks:
                                     #      Those in AllMapComponentsMask:
                                     #       - Specifies the individual fields to be loaded or changed for the
                                     #         GetMap and SetMap requests.
                                     #      Those in ClientInfoMask:
                                     #       - Specifies the components to be allocated by XkbAllocClientMap.
                                     #      Those in ServerInfoMask:
                                     #       - Specifies the components to be allocated by XkbAllocServerMap.
                                     #

const
  XkbKeyTypesMask* = 1 shl 0
  XkbKeySymsMask* = 1 shl 1
  XkbModifierMapMask* = 1 shl 2
  XkbExplicitComponentsMask* = 1 shl 3
  XkbKeyActionsMask* = 1 shl 4
  XkbKeyBehaviorsMask* = 1 shl 5
  XkbVirtualModsMask* = 1 shl 6
  XkbVirtualModMapMask* = 1 shl 7
  XkbAllClientInfoMask* = XkbKeyTypesMask or XkbKeySymsMask or
      XkbModifierMapMask
  XkbAllServerInfoMask* = XkbExplicitComponentsMask or XkbKeyActionsMask or
      XkbKeyBehaviorsMask or XkbVirtualModsMask or XkbVirtualModMapMask
  XkbAllMapComponentsMask* = XkbAllClientInfoMask or XkbAllServerInfoMask #
                                                                          #      Names component mask:
                                                                          #       - Specifies the names to be loaded or changed for the GetNames and
                                                                          #         SetNames requests.
                                                                          #       - Specifies the names that have changed in a NamesNotify event.
                                                                          #       - Specifies the names components to be allocated by XkbAllocNames.
                                                                          #

const
  XkbKeycodesNameMask* = 1 shl 0
  XkbGeometryNameMask* = 1 shl 1
  XkbSymbolsNameMask* = 1 shl 2
  XkbPhysSymbolsNameMask* = 1 shl 3
  XkbTypesNameMask* = 1 shl 4
  XkbCompatNameMask* = 1 shl 5
  XkbKeyTypeNamesMask* = 1 shl 6
  XkbKTLevelNamesMask* = 1 shl 7
  XkbIndicatorNamesMask* = 1 shl 8
  XkbKeyNamesMask* = 1 shl 9
  XkbKeyAliasesMask* = 1 shl 10
  XkbVirtualModNamesMask* = 1 shl 11
  XkbGroupNamesMask* = 1 shl 12
  XkbRGNamesMask* = 1 shl 13
  XkbComponentNamesMask* = 0x0000003F
  XkbAllNamesMask* = 0x00003FFF #
                                #      Miscellaneous event details:
                                #      - event detail masks for assorted events that don't reall
                                #        have any details.
                                #

const
  XkbAllStateEventsMask* = XkbAllStateComponentsMask
  XkbAllMapEventsMask* = XkbAllMapComponentsMask
  XkbAllControlEventsMask* = XkbAllControlsMask
  XkbAllIndicatorEventsMask* = XkbAllIndicatorsMask
  XkbAllNameEventsMask* = XkbAllNamesMask
  XkbAllCompatMapEventsMask* = XkbAllCompatMask
  XkbAllBellEventsMask* = int(1) shl 0
  XkbAllActionMessagesMask* = int(1) shl 0 #
                                           #      XKB reports one error:  BadKeyboard
                                           #      A further reason for the error is encoded into to most significant
                                           #      byte of the resourceID for the error:
                                           #         XkbErr_BadDevice - the device in question was not found
                                           #         XkbErr_BadClass  - the device was found but it doesn't belong to
                                           #                            the appropriate class.
                                           #         XkbErr_BadId     - the device was found and belongs to the right
                                           #                            class, but not feedback with a matching id was
                                           #                            found.
                                           #      The low byte of the resourceID for this error contains the device
                                           #      id, class specifier or feedback id that failed.
                                           #

const
  XkbKeyboard* = 0
  XkbNumberErrors* = 1
  XkbErr_BadDevice* = 0x000000FF
  XkbErr_BadClass* = 0x000000FE
  XkbErr_BadId* = 0x000000FD #
                             #      Keyboard Components Mask:
                             #      - Specifies the components that follow a GetKeyboardByNameReply
                             #

const
  XkbClientMapMask* = int(1) shl 0
  XkbServerMapMask* = int(1) shl 1
  XkbCompatMapMask* = int(1) shl 2
  XkbIndicatorMapMask* = int(1) shl 3
  XkbNamesMask* = int(1) shl 4
  XkbGeometryMask* = int(1) shl 5
  XkbControlsMask* = int(1) shl 6
  XkbAllComponentsMask* = 0x0000007F #
                                     #      AccessX Options Mask
                                     #       - The 'accessXOptions' field of an XkbControlsRec specifies the
                                     #         AccessX options that are currently in effect.
                                     #       - The 'accessXTimeoutOptionsMask' and 'accessXTimeoutOptionsValues'
                                     #         fields of an XkbControlsRec specify the Access X options to be
                                     #         changed if the keyboard times out and the values to which they
                                     #         should be changed.
                                     #

const
  XkbAX_SKPressFBMask* = int(1) shl 0
  XkbAX_SKAcceptFBMask* = int(1) shl 1
  XkbAX_FeatureFBMask* = int(1) shl 2
  XkbAX_SlowWarnFBMask* = int(1) shl 3
  XkbAX_IndicatorFBMask* = int(1) shl 4
  XkbAX_StickyKeysFBMask* = int(1) shl 5
  XkbAX_TwoKeysMask* = int(1) shl 6
  XkbAX_LatchToLockMask* = int(1) shl 7
  XkbAX_SKReleaseFBMask* = int(1) shl 8
  XkbAX_SKRejectFBMask* = int(1) shl 9
  XkbAX_BKRejectFBMask* = int(1) shl 10
  XkbAX_DumbBellFBMask* = int(1) shl 11
  XkbAX_FBOptionsMask* = 0x00000F3F
  XkbAX_SKOptionsMask* = 0x000000C0
  XkbAX_AllOptionsMask* = 0x00000FFF #
                                     #      XkbUseCoreKbd is used to specify the core keyboard without having
                                     #                        to look up its X input extension identifier.
                                     #      XkbUseCorePtr is used to specify the core pointer without having
                                     #                        to look up its X input extension identifier.
                                     #      XkbDfltXIClass is used to specify "don't care" any place that the
                                     #                        XKB protocol is looking for an X Input Extension
                                     #                        device class.
                                     #      XkbDfltXIId is used to specify "don't care" any place that the
                                     #                        XKB protocol is looking for an X Input Extension
                                     #                        feedback identifier.
                                     #      XkbAllXIClasses is used to get information about all device indicators,
                                     #                        whether they're part of the indicator feedback class
                                     #                        or the keyboard feedback class.
                                     #      XkbAllXIIds is used to get information about all device indicator
                                     #                        feedbacks without having to list them.
                                     #      XkbXINone is used to indicate that no class or id has been specified.
                                     #      XkbLegalXILedClass(c)  True if 'c' specifies a legal class with LEDs
                                     #      XkbLegalXIBellClass(c) True if 'c' specifies a legal class with bells
                                     #      XkbExplicitXIDevice(d) True if 'd' explicitly specifies a device
                                     #      XkbExplicitXIClass(c)  True if 'c' explicitly specifies a device class
                                     #      XkbExplicitXIId(c)     True if 'i' explicitly specifies a device id
                                     #      XkbSingleXIClass(c)    True if 'c' specifies exactly one device class,
                                     #                             including the default.
                                     #      XkbSingleXIId(i)       True if 'i' specifies exactly one device
                                     #                              identifier, including the default.
                                     #

const
  XkbUseCoreKbd* = 0x00000100
  XkbUseCorePtr* = 0x00000200
  XkbDfltXIClass* = 0x00000300
  XkbDfltXIId* = 0x00000400
  XkbAllXIClasses* = 0x00000500
  XkbAllXIIds* = 0x00000600
  XkbXINone* = 0x0000FF00

proc XkbLegalXILedClass*(c: int): bool
proc XkbLegalXIBellClass*(c: int): bool
proc XkbExplicitXIDevice*(c: int): bool
proc XkbExplicitXIClass*(c: int): bool
proc XkbExplicitXIId*(c: int): bool
proc XkbSingleXIClass*(c: int): bool
proc XkbSingleXIId*(c: int): bool
const
  XkbNoModifier* = 0x000000FF
  XkbNoShiftLevel* = 0x000000FF
  XkbNoShape* = 0x000000FF
  XkbNoIndicator* = 0x000000FF
  XkbNoModifierMask* = 0
  XkbAllModifiersMask* = 0x000000FF
  XkbAllVirtualModsMask* = 0x0000FFFF
  XkbNumKbdGroups* = 4
  XkbMaxKbdGroup* = XkbNumKbdGroups - 1
  XkbMaxMouseKeysBtn* = 4 #
                          #      Group Index and Mask:
                          #       - Indices into the kt_index array of a key type.
                          #       - Mask specifies types to be changed for XkbChangeTypesOfKey
                          #

const
  XkbGroup1Index* = 0
  XkbGroup2Index* = 1
  XkbGroup3Index* = 2
  XkbGroup4Index* = 3
  XkbAnyGroup* = 254
  XkbAllGroups* = 255
  XkbGroup1Mask* = 1 shl 0
  XkbGroup2Mask* = 1 shl 1
  XkbGroup3Mask* = 1 shl 2
  XkbGroup4Mask* = 1 shl 3
  XkbAnyGroupMask* = 1 shl 7
  XkbAllGroupsMask* = 0x0000000F #
                                 #      BuildCoreState: Given a keyboard group and a modifier state,
                                 #                      construct the value to be reported an event.
                                 #      GroupForCoreState:  Given the state reported in an event,
                                 #                      determine the keyboard group.
                                 #      IsLegalGroup:   Returns TRUE if 'g' is a valid group index.
                                 #

proc XkbBuildCoreState*(m, g: int): int
proc XkbGroupForCoreState*(s: int): int
proc XkbIsLegalGroup*(g: int): bool
  #
  #      GroupsWrap values:
  #       - The 'groupsWrap' field of an XkbControlsRec specifies the
  #         treatment of out of range groups.
  #       - Bits 6 and 7 of the group info field of a key symbol map
  #         specify the interpretation of out of range groups for the
  #         corresponding key.
  #
const
  XkbWrapIntoRange* = 0x00000000
  XkbClampIntoRange* = 0x00000040
  XkbRedirectIntoRange* = 0x00000080 #
                                     #      Action flags:  Reported in the 'flags' field of most key actions.
                                     #      Interpretation depends on the type of the action; not all actions
                                     #      accept all flags.
                                     #
                                     #      Option                    Used for Actions
                                     #      ------                    ----------------
                                     #      ClearLocks                SetMods, LatchMods, SetGroup, LatchGroup
                                     #      LatchToLock               SetMods, LatchMods, SetGroup, LatchGroup
                                     #      LockNoLock                LockMods, ISOLock, LockPtrBtn, LockDeviceBtn
                                     #      LockNoUnlock              LockMods, ISOLock, LockPtrBtn, LockDeviceBtn
                                     #      UseModMapMods             SetMods, LatchMods, LockMods, ISOLock
                                     #      GroupAbsolute             SetGroup, LatchGroup, LockGroup, ISOLock
                                     #      UseDfltButton             PtrBtn, LockPtrBtn
                                     #      NoAcceleration            MovePtr
                                     #      MoveAbsoluteX             MovePtr
                                     #      MoveAbsoluteY             MovePtr
                                     #      ISODfltIsGroup            ISOLock
                                     #      ISONoAffectMods           ISOLock
                                     #      ISONoAffectGroup          ISOLock
                                     #      ISONoAffectPtr            ISOLock
                                     #      ISONoAffectCtrls          ISOLock
                                     #      MessageOnPress            ActionMessage
                                     #      MessageOnRelease          ActionMessage
                                     #      MessageGenKeyEvent        ActionMessage
                                     #      AffectDfltBtn             SetPtrDflt
                                     #      DfltBtnAbsolute           SetPtrDflt
                                     #      SwitchApplication SwitchScreen
                                     #      SwitchAbsolute            SwitchScreen
                                     #

const
  XkbSA_ClearLocks* = int(1) shl 0
  XkbSA_LatchToLock* = int(1) shl 1
  XkbSA_LockNoLock* = int(1) shl 0
  XkbSA_LockNoUnlock* = int(1) shl 1
  XkbSA_UseModMapMods* = int(1) shl 2
  XkbSA_GroupAbsolute* = int(1) shl 2
  XkbSA_UseDfltButton* = 0
  XkbSA_NoAcceleration* = int(1) shl 0
  XkbSA_MoveAbsoluteX* = int(1) shl 1
  XkbSA_MoveAbsoluteY* = int(1) shl 2
  XkbSA_ISODfltIsGroup* = int(1) shl 7
  XkbSA_ISONoAffectMods* = int(1) shl 6
  XkbSA_ISONoAffectGroup* = int(1) shl 5
  XkbSA_ISONoAffectPtr* = int(1) shl 4
  XkbSA_ISONoAffectCtrls* = int(1) shl 3
  XkbSA_ISOAffectMask* = 0x00000078
  XkbSA_MessageOnPress* = int(1) shl 0
  XkbSA_MessageOnRelease* = int(1) shl 1
  XkbSA_MessageGenKeyEvent* = int(1) shl 2
  XkbSA_AffectDfltBtn* = 1
  XkbSA_DfltBtnAbsolute* = int(1) shl 2
  XkbSA_SwitchApplication* = int(1) shl 0
  XkbSA_SwitchAbsolute* = int(1) shl 2 #
                                       #      The following values apply to the SA_DeviceValuator
                                       #      action only.  Valuator operations specify the action
                                       #      to be taken.   Values specified in the action are
                                       #      multiplied by 2^scale before they are applied.
                                       #

const
  XkbSA_IgnoreVal* = 0x00000000
  XkbSA_SetValMin* = 0x00000010
  XkbSA_SetValCenter* = 0x00000020
  XkbSA_SetValMax* = 0x00000030
  XkbSA_SetValRelative* = 0x00000040
  XkbSA_SetValAbsolute* = 0x00000050
  XkbSA_ValOpMask* = 0x00000070
  XkbSA_ValScaleMask* = 0x00000007

proc XkbSA_ValOp*(a: int): int
proc XkbSA_ValScale*(a: int): int
  #
  #      Action types: specifies the type of a key action.  Reported in the
  #      type field of all key actions.
  #
const
  XkbSA_NoAction* = 0x00000000
  XkbSA_SetMods* = 0x00000001
  XkbSA_LatchMods* = 0x00000002
  XkbSA_LockMods* = 0x00000003
  XkbSA_SetGroup* = 0x00000004
  XkbSA_LatchGroup* = 0x00000005
  XkbSA_LockGroup* = 0x00000006
  XkbSA_MovePtr* = 0x00000007
  XkbSA_PtrBtn* = 0x00000008
  XkbSA_LockPtrBtn* = 0x00000009
  XkbSA_SetPtrDflt* = 0x0000000A
  XkbSA_ISOLock* = 0x0000000B
  XkbSA_Terminate* = 0x0000000C
  XkbSA_SwitchScreen* = 0x0000000D
  XkbSA_SetControls* = 0x0000000E
  XkbSA_LockControls* = 0x0000000F
  XkbSA_ActionMessage* = 0x00000010
  XkbSA_RedirectKey* = 0x00000011
  XkbSA_DeviceBtn* = 0x00000012
  XkbSA_LockDeviceBtn* = 0x00000013
  XkbSA_DeviceValuator* = 0x00000014
  XkbSA_LastAction* = XkbSA_DeviceValuator
  XkbSA_NumActions* = XkbSA_LastAction + 1

const
  XkbSA_XFree86Private* = 0x00000086
 #
 #      Specifies the key actions that clear latched groups or modifiers.
 #

const                                                        ##define        XkbSA_BreakLatch \
  #        ((1<<XkbSA_NoAction)|(1<<XkbSA_PtrBtn)|(1<<XkbSA_LockPtrBtn)|\
       #        (1<<XkbSA_Terminate)|(1<<XkbSA_SwitchScreen)|(1<<XkbSA_SetControls)|\
       #        (1<<XkbSA_LockControls)|(1<<XkbSA_ActionMessage)|\
       #        (1<<XkbSA_RedirectKey)|(1<<XkbSA_DeviceBtn)|(1<<XkbSA_LockDeviceBtn))
       #
  XkbSA_BreakLatch* = (1 shl XkbSA_PtrBtn) or (1 shl XkbSA_LockPtrBtn) or
      (1 shl XkbSA_Terminate) or (1 shl XkbSA_SwitchScreen) or
      (1 shl XkbSA_SetControls) or (1 shl XkbSA_LockControls) or
      (1 shl XkbSA_ActionMessage) or (1 shl XkbSA_RedirectKey) or
      (1 shl XkbSA_DeviceBtn) or (1 shl XkbSA_LockDeviceBtn) #
                                                             #      Key Behavior Qualifier:
                                                             #         KB_Permanent indicates that the behavior describes an unalterable
                                                             #         characteristic of the keyboard, not an XKB software-simulation of
                                                             #         the listed behavior.
                                                             #      Key Behavior Types:
                                                             #         Specifies the behavior of the underlying key.
                                                             #

const
  XkbKB_Permanent* = 0x00000080
  XkbKB_OpMask* = 0x0000007F
  XkbKB_Default* = 0x00000000
  XkbKB_Lock* = 0x00000001
  XkbKB_RadioGroup* = 0x00000002
  XkbKB_Overlay1* = 0x00000003
  XkbKB_Overlay2* = 0x00000004
  XkbKB_RGAllowNone* = 0x00000080 #
                                  #      Various macros which describe the range of legal keycodes.
                                  #

const
  XkbMinLegalKeyCode* = 8
  XkbMaxLegalKeyCode* = 255
  XkbMaxKeyCount* = XkbMaxLegalKeyCode - XkbMinLegalKeyCode + 1
  XkbPerKeyBitArraySize* = (XkbMaxLegalKeyCode + 1) div 8

proc XkbIsLegalKeycode*(k: int): bool
type
  PXkbControlsPtr* = ptr XkbControlsRec
  XkbControlsRec*{.final.} = object
    mk_dflt_btn*: int8
    num_groups*: int8
    groups_wrap*: int8
    internal*: XkbModsRec
    ignore_lock*: XkbModsRec
    enabled_ctrls*: int16
    repeat_delay*: int16
    repeat_interval*: int16
    slow_keys_delay*: int16
    debounce_delay*: int16
    mk_delay*: int16
    mk_interval*: int16
    mk_time_to_max*: int16
    mk_max_speed*: int16
    mk_curve*: int16
    ax_options*: int16
    ax_timeout*: int16
    axt_opts_mask*: int16
    axt_opts_values*: int16
    axt_ctrls_mask*: int16
    axt_ctrls_values*: int16
    per_key_repeat*: array[0..XkbPerKeyBitArraySize - 1, int8]



proc XkbAX_AnyFeedback*(c: PXkbControlsPtr): int16
proc XkbAX_NeedOption*(c: PXkbControlsPtr, w: int16): int16
proc XkbAX_NeedFeedback*(c: PXkbControlsPtr, w: int16): bool
  #
  #      Assorted constants and limits.
  #
const
  XkbNumModifiers* = 8
  XkbNumVirtualMods* = 16
  XkbNumIndicators* = 32
  XkbMaxRadioGroups* = 32
  XkbAllRadioGroupsMask* = 0xFFFFFFFF
  XkbMaxShiftLevel* = 63
  XkbMaxSymsPerKey* = XkbMaxShiftLevel * XkbNumKbdGroups
  XkbRGMaxMembers* = 12
  XkbActionMessageLength* = 6
  XkbKeyNameLength* = 4
  XkbMaxRedirectCount* = 8
  XkbGeomPtsPerMM* = 10
  XkbGeomMaxColors* = 32
  XkbGeomMaxLabelColors* = 3
  XkbGeomMaxPriority* = 255

type
  PXkbServerMapPtr* = ptr XkbServerMapRec
  XkbServerMapRec*{.final.} = object
    num_acts*: int16
    size_acts*: int16
    acts*: ptr array[0..0xfff, XkbAction]
    behaviors*: PXkbBehavior
    key_acts*: PWord
    explicit*: PByte
    vmods*: array[0..XkbNumVirtualMods - 1, int8]
    vmodmap*: PWord



proc XkbSMKeyActionsPtr*(m: PXkbServerMapPtr, k: int16): PXkbAction
  #
  #          Structures and access macros used primarily by clients
  #
type
  PXkbSymMapPtr* = ptr XkbSymMapRec
  XkbSymMapRec*{.final.} = object
    kt_index*: array[0..XkbNumKbdGroups - 1, int8]
    group_info*: int8
    width*: int8
    offset*: int8



type
  PXkbClientMapPtr* = ptr XkbClientMapRec
  XkbClientMapRec*{.final.} = object
    size_types*: int8
    num_types*: int8
    types*: ptr array[0..0xffff, XkbKeyTypeRec]
    size_syms*: int16
    num_syms*: int16
    syms*: ptr array[0..0xffff, KeySym]
    key_sym_map*: ptr array[0..0xffff, XkbSymMapRec]
    modmap*: PByte



proc XkbCMKeyGroupInfo*(m: PXkbClientMapPtr, k: int16): int8
proc XkbCMKeyNumGroups*(m: PXkbClientMapPtr, k: int16): int8
proc XkbCMKeyGroupWidth*(m: PXkbClientMapPtr, k: int16, g: int8): int8
proc XkbCMKeyGroupsWidth*(m: PXkbClientMapPtr, k: int16): int8
proc XkbCMKeyTypeIndex*(m: PXkbClientMapPtr, k: int16, g: int8): int8
proc XkbCMKeyType*(m: PXkbClientMapPtr, k: int16, g: int8): PXkbKeyTypePtr
proc XkbCMKeyNumSyms*(m: PXkbClientMapPtr, k: int16): int16
proc XkbCMKeySymsOffset*(m: PXkbClientMapPtr, k: int16): int8
  #
  #          Compatibility structures and access macros
  #
type
  PXkbSymInterpretPtr* = ptr XkbSymInterpretRec
  XkbSymInterpretRec*{.final.} = object
    sym*: KeySym
    flags*: int8
    match*: int8
    mods*: int8
    virtual_mod*: int8
    act*: XkbAnyAction



type
  PXkbCompatMapPtr* = ptr XkbCompatMapRec
  XkbCompatMapRec*{.final.} = object
    sym_interpret*: PXkbSymInterpretPtr
    groups*: array[0..XkbNumKbdGroups - 1, XkbModsRec]
    num_si*: int16
    size_si*: int16



type
  PXkbIndicatorMapPtr* = ptr XkbIndicatorMapRec
  XkbIndicatorMapRec*{.final.} = object
    flags*: int8
    which_groups*: int8
    groups*: int8
    which_mods*: int8
    mods*: XkbModsRec
    ctrls*: int16



proc XkbIM_IsAuto*(i: PXkbIndicatorMapPtr): bool
proc XkbIM_InUse*(i: PXkbIndicatorMapPtr): bool
type
  PXkbIndicatorPtr* = ptr XkbIndicatorRec
  XkbIndicatorRec*{.final.} = object
    phys_indicators*: int32
    maps*: array[0..XkbNumIndicators - 1, XkbIndicatorMapRec]



type
  PXkbKeyNamePtr* = ptr XkbKeyNameRec
  XkbKeyNameRec*{.final.} = object
    name*: array[0..XkbKeyNameLength - 1, char]



type
  PXkbKeyAliasPtr* = ptr XkbKeyAliasRec
  XkbKeyAliasRec*{.final.} = object #
                                    #          Names for everything
                                    #
    float*: array[0..XkbKeyNameLength - 1, char]
    alias*: array[0..XkbKeyNameLength - 1, char]



type
  PXkbNamesPtr* = ptr XkbNamesRec
  XkbNamesRec*{.final.} = object #
                                 #      Key Type index and mask for the four standard key types.
                                 #
    keycodes*: Atom
    geometry*: Atom
    symbols*: Atom
    types*: Atom
    compat*: Atom
    vmods*: array[0..XkbNumVirtualMods - 1, Atom]
    indicators*: array[0..XkbNumIndicators - 1, Atom]
    groups*: array[0..XkbNumKbdGroups - 1, Atom]
    keys*: PXkbKeyNamePtr
    key_aliases*: PXkbKeyAliasPtr
    radio_groups*: PAtom
    phys_symbols*: Atom
    num_keys*: int8
    num_key_aliases*: int8
    num_rg*: int16



const
  XkbOneLevelIndex* = 0
  XkbTwoLevelIndex* = 1
  XkbAlphabeticIndex* = 2
  XkbKeypadIndex* = 3
  XkbLastRequiredType* = XkbKeypadIndex
  XkbNumRequiredTypes* = XkbLastRequiredType + 1
  XkbMaxKeyTypes* = 255
  XkbOneLevelMask* = 1 shl 0
  XkbTwoLevelMask* = 1 shl 1
  XkbAlphabeticMask* = 1 shl 2
  XkbKeypadMask* = 1 shl 3
  XkbAllRequiredTypes* = 0x0000000F

proc XkbShiftLevel*(n: int8): int8
proc XkbShiftLevelMask*(n: int8): int8
  #
  #      Extension name and version information
  #
const
  XkbName* = "XKEYBOARD"
  XkbMajorVersion* = 1
  XkbMinorVersion* = 0 #
                       #      Explicit map components:
                       #       - Used in the 'explicit' field of an XkbServerMap.  Specifies
                       #         the keyboard components that should _not_ be updated automatically
                       #         in response to core protocol keyboard mapping requests.
                       #

const
  XkbExplicitKeyTypesMask* = 0x0000000F
  XkbExplicitKeyType1Mask* = 1 shl 0
  XkbExplicitKeyType2Mask* = 1 shl 1
  XkbExplicitKeyType3Mask* = 1 shl 2
  XkbExplicitKeyType4Mask* = 1 shl 3
  XkbExplicitInterpretMask* = 1 shl 4
  XkbExplicitAutoRepeatMask* = 1 shl 5
  XkbExplicitBehaviorMask* = 1 shl 6
  XkbExplicitVModMapMask* = 1 shl 7
  XkbAllExplicitMask* = 0x000000FF #
                                   #      Symbol interpretations flags:
                                   #       - Used in the flags field of a symbol interpretation
                                   #

const
  XkbSI_AutoRepeat* = 1 shl 0
  XkbSI_LockingKey* = 1 shl 1 #
                              #      Symbol interpretations match specification:
                              #       - Used in the match field of a symbol interpretation to specify
                              #         the conditions under which an interpretation is used.
                              #

const
  XkbSI_LevelOneOnly* = 0x00000080
  XkbSI_OpMask* = 0x0000007F
  XkbSI_NoneOf* = 0
  XkbSI_AnyOfOrNone* = 1
  XkbSI_AnyOf* = 2
  XkbSI_AllOf* = 3
  XkbSI_Exactly* = 4 #
                     #      Indicator map flags:
                     #       - Used in the flags field of an indicator map to indicate the
                     #         conditions under which and indicator can be changed and the
                     #         effects of changing the indicator.
                     #

const
  XkbIM_NoExplicit* = int(1) shl 7
  XkbIM_NoAutomatic* = int(1) shl 6
  XkbIM_LEDDrivesKB* = int(1) shl 5 #
                                    #      Indicator map component specifications:
                                    #       - Used by the 'which_groups' and 'which_mods' fields of an indicator
                                    #         map to specify which keyboard components should be used to drive
                                    #         the indicator.
                                    #

const
  XkbIM_UseBase* = int(1) shl 0
  XkbIM_UseLatched* = int(1) shl 1
  XkbIM_UseLocked* = int(1) shl 2
  XkbIM_UseEffective* = int(1) shl 3
  XkbIM_UseCompat* = int(1) shl 4
  XkbIM_UseNone* = 0
  XkbIM_UseAnyGroup* = XkbIM_UseBase or XkbIM_UseLatched or XkbIM_UseLocked or
      XkbIM_UseEffective
  XkbIM_UseAnyMods* = XkbIM_UseAnyGroup or XkbIM_UseCompat #
                                                           #      GetByName components:
                                                           #       - Specifies desired or necessary components to GetKbdByName request.
                                                           #       - Reports the components that were found in a GetKbdByNameReply
                                                           #

const
  XkbGBN_TypesMask* = int(1) shl 0
  XkbGBN_CompatMapMask* = int(1) shl 1
  XkbGBN_ClientSymbolsMask* = int(1) shl 2
  XkbGBN_ServerSymbolsMask* = int(1) shl 3
  XkbGBN_SymbolsMask* = XkbGBN_ClientSymbolsMask or XkbGBN_ServerSymbolsMask
  XkbGBN_IndicatorMapMask* = int(1) shl 4
  XkbGBN_KeyNamesMask* = int(1) shl 5
  XkbGBN_GeometryMask* = int(1) shl 6
  XkbGBN_OtherNamesMask* = int(1) shl 7
  XkbGBN_AllComponentsMask* = 0x000000FF #
                                         #       ListComponents flags
                                         #

const
  XkbLC_Hidden* = int(1) shl 0
  XkbLC_Default* = int(1) shl 1
  XkbLC_Partial* = int(1) shl 2
  XkbLC_AlphanumericKeys* = int(1) shl 8
  XkbLC_ModifierKeys* = int(1) shl 9
  XkbLC_KeypadKeys* = int(1) shl 10
  XkbLC_FunctionKeys* = int(1) shl 11
  XkbLC_AlternateGroup* = int(1) shl 12 #
                                        #      X Input Extension Interactions
                                        #      - Specifies the possible interactions between XKB and the X input
                                        #        extension
                                        #      - Used to request (XkbGetDeviceInfo) or change (XKbSetDeviceInfo)
                                        #        XKB information about an extension device.
                                        #      - Reports the list of supported optional features in the reply to
                                        #        XkbGetDeviceInfo or in an XkbExtensionDeviceNotify event.
                                        #      XkbXI_UnsupportedFeature is reported in XkbExtensionDeviceNotify
                                        #      events to indicate an attempt to use an unsupported feature.
                                        #

const
  XkbXI_KeyboardsMask* = int(1) shl 0
  XkbXI_ButtonActionsMask* = int(1) shl 1
  XkbXI_IndicatorNamesMask* = int(1) shl 2
  XkbXI_IndicatorMapsMask* = int(1) shl 3
  XkbXI_IndicatorStateMask* = int(1) shl 4
  XkbXI_UnsupportedFeatureMask* = int(1) shl 15
  XkbXI_AllFeaturesMask* = 0x0000001F
  XkbXI_AllDeviceFeaturesMask* = 0x0000001E
  XkbXI_IndicatorsMask* = 0x0000001C
  XkbAllExtensionDeviceEventsMask* = 0x0000801F #
                                                #      Per-Client Flags:
                                                #       - Specifies flags to be changed by the PerClientFlags request.
                                                #

const
  XkbPCF_DetectableAutoRepeatMask* = int(1) shl 0
  XkbPCF_GrabsUseXKBStateMask* = int(1) shl 1
  XkbPCF_AutoResetControlsMask* = int(1) shl 2
  XkbPCF_LookupStateWhenGrabbed* = int(1) shl 3
  XkbPCF_SendEventUsesXKBState* = int(1) shl 4
  XkbPCF_AllFlagsMask* = 0x0000001F #
                                    #      Debugging flags and controls
                                    #

const
  XkbDF_DisableLocks* = 1 shl 0

type
  PXkbPropertyPtr* = ptr XkbPropertyRec
  XkbPropertyRec*{.final.} = object
    name*: cstring
    value*: cstring



type
  PXkbColorPtr* = ptr XkbColorRec
  XkbColorRec*{.final.} = object
    pixel*: int16
    spec*: cstring



type
  PXkbPointPtr* = ptr XkbPointRec
  XkbPointRec*{.final.} = object
    x*: int16
    y*: int16



type
  PXkbBoundsPtr* = ptr XkbBoundsRec
  XkbBoundsRec*{.final.} = object
    x1*: int16
    y1*: int16
    x2*: int16
    y2*: int16



proc XkbBoundsWidth*(b: PXkbBoundsPtr): int16
proc XkbBoundsHeight*(b: PXkbBoundsPtr): int16
type
  PXkbOutlinePtr* = ptr XkbOutlineRec
  XkbOutlineRec*{.final.} = object
    num_points*: int16
    sz_points*: int16
    corner_radius*: int16
    points*: PXkbPointPtr



type
  PXkbShapePtr* = ptr XkbShapeRec
  XkbShapeRec*{.final.} = object
    name*: Atom
    num_outlines*: int16
    sz_outlines*: int16
    outlines*: ptr array[0..0xffff, XkbOutlineRec]
    approx*: ptr array[0..0xffff, XkbOutlineRec]
    primary*: ptr array[0..0xffff, XkbOutlineRec]
    bounds*: XkbBoundsRec



proc XkbOutlineIndex*(s: PXkbShapePtr, o: PXkbOutlinePtr): int32
type
  PXkbShapeDoodadPtr* = ptr XkbShapeDoodadRec
  XkbShapeDoodadRec*{.final.} = object
    name*: Atom
    theType*: int8
    priority*: int8
    top*: int16
    left*: int16
    angle*: int16
    color_ndx*: int16
    shape_ndx*: int16



type
  PXkbTextDoodadPtr* = ptr XkbTextDoodadRec
  XkbTextDoodadRec*{.final.} = object
    name*: Atom
    theType*: int8
    priority*: int8
    top*: int16
    left*: int16
    angle*: int16
    width*: int16
    height*: int16
    color_ndx*: int16
    text*: cstring
    font*: cstring



type
  PXkbIndicatorDoodadPtr* = ptr XkbIndicatorDoodadRec
  XkbIndicatorDoodadRec*{.final.} = object
    name*: Atom
    theType*: int8
    priority*: int8
    top*: int16
    left*: int16
    angle*: int16
    shape_ndx*: int16
    on_color_ndx*: int16
    off_color_ndx*: int16



type
  PXkbLogoDoodadPtr* = ptr XkbLogoDoodadRec
  XkbLogoDoodadRec*{.final.} = object
    name*: Atom
    theType*: int8
    priority*: int8
    top*: int16
    left*: int16
    angle*: int16
    color_ndx*: int16
    shape_ndx*: int16
    logo_name*: cstring



type
  PXkbAnyDoodadPtr* = ptr XkbAnyDoodadRec
  XkbAnyDoodadRec*{.final.} = object
    name*: Atom
    theType*: int8
    priority*: int8
    top*: int16
    left*: int16
    angle*: int16



type
  PXkbDoodadPtr* = ptr XkbDoodadRec
  XkbDoodadRec*{.final.} = object
    any*: XkbAnyDoodadRec
    shape*: XkbShapeDoodadRec
    text*: XkbTextDoodadRec
    indicator*: XkbIndicatorDoodadRec
    logo*: XkbLogoDoodadRec



const
  XkbUnknownDoodad* = 0
  XkbOutlineDoodad* = 1
  XkbSolidDoodad* = 2
  XkbTextDoodad* = 3
  XkbIndicatorDoodad* = 4
  XkbLogoDoodad* = 5

type
  PXkbKeyPtr* = ptr XkbKeyRec
  XkbKeyRec*{.final.} = object
    name*: XkbKeyNameRec
    gap*: int16
    shape_ndx*: int8
    color_ndx*: int8



type
  PXkbRowPtr* = ptr XkbRowRec
  XkbRowRec*{.final.} = object
    top*: int16
    left*: int16
    num_keys*: int16
    sz_keys*: int16
    vertical*: int16
    Keys*: PXkbKeyPtr
    bounds*: XkbBoundsRec



type
  PXkbOverlayPtr* = ptr XkbOverlayRec #forward for XkbSectionRec use.
                                       #Do not add more "type"
  PXkbSectionPtr* = ptr XkbSectionRec
  XkbSectionRec*{.final.} = object #Do not add more "type"
    name*: Atom
    priority*: int8
    top*: int16
    left*: int16
    width*: int16
    height*: int16
    angle*: int16
    num_rows*: int16
    num_doodads*: int16
    num_overlays*: int16
    rows*: PXkbRowPtr
    doodads*: PXkbDoodadPtr
    bounds*: XkbBoundsRec
    overlays*: PXkbOverlayPtr

  PXkbOverlayKeyPtr* = ptr XkbOverlayKeyRec
  XkbOverlayKeyRec*{.final.} = object #Do not add more "type"
    over*: XkbKeyNameRec
    under*: XkbKeyNameRec

  PXkbOverlayRowPtr* = ptr XkbOverlayRowRec
  XkbOverlayRowRec*{.final.} = object #Do not add more "type"
    row_under*: int16
    num_keys*: int16
    sz_keys*: int16
    keys*: PXkbOverlayKeyPtr

  XkbOverlayRec*{.final.} = object
    name*: Atom
    section_under*: PXkbSectionPtr
    num_rows*: int16
    sz_rows*: int16
    rows*: PXkbOverlayRowPtr
    bounds*: PXkbBoundsPtr


type
  PXkbGeometryRec* = ptr XkbGeometryRec
  PXkbGeometryPtr* = PXkbGeometryRec
  XkbGeometryRec*{.final.} = object
    name*: Atom
    width_mm*: int16
    height_mm*: int16
    label_font*: cstring
    label_color*: PXkbColorPtr
    base_color*: PXkbColorPtr
    sz_properties*: int16
    sz_colors*: int16
    sz_shapes*: int16
    sz_sections*: int16
    sz_doodads*: int16
    sz_key_aliases*: int16
    num_properties*: int16
    num_colors*: int16
    num_shapes*: int16
    num_sections*: int16
    num_doodads*: int16
    num_key_aliases*: int16
    properties*: ptr array[0..0xffff, XkbPropertyRec]
    colors*: ptr array[0..0xffff, XkbColorRec]
    shapes*: ptr array[0..0xffff, XkbShapeRec]
    sections*: ptr array[0..0xffff, XkbSectionRec]
    key_aliases*: ptr array[0..0xffff, XkbKeyAliasRec]



const
  XkbGeomPropertiesMask* = 1 shl 0
  XkbGeomColorsMask* = 1 shl 1
  XkbGeomShapesMask* = 1 shl 2
  XkbGeomSectionsMask* = 1 shl 3
  XkbGeomDoodadsMask* = 1 shl 4
  XkbGeomKeyAliasesMask* = 1 shl 5
  XkbGeomAllMask* = 0x0000003F

type
  PXkbGeometrySizesPtr* = ptr XkbGeometrySizesRec
  XkbGeometrySizesRec*{.final.} = object #
                                         #          Tie it all together into one big keyboard description
                                         #
    which*: int16
    num_properties*: int16
    num_colors*: int16
    num_shapes*: int16
    num_sections*: int16
    num_doodads*: int16
    num_key_aliases*: int16



type
  PXkbDescPtr* = ptr XkbDescRec
  XkbDescRec*{.final.} = object
    dpy*: PDisplay
    flags*: int16
    device_spec*: int16
    min_key_code*: KeyCode
    max_key_code*: KeyCode
    ctrls*: PXkbControlsPtr
    server*: PXkbServerMapPtr
    map*: PXkbClientMapPtr
    indicators*: PXkbIndicatorPtr
    names*: PXkbNamesPtr
    compat*: PXkbCompatMapPtr
    geom*: PXkbGeometryPtr



proc XkbKeyKeyTypeIndex*(d: PXkbDescPtr, k: int16, g: int8): int8
proc XkbKeyKeyType*(d: PXkbDescPtr, k: int16, g: int8): PXkbKeyTypePtr
proc XkbKeyGroupWidth*(d: PXkbDescPtr, k: int16, g: int8): int8
proc XkbKeyGroupsWidth*(d: PXkbDescPtr, k: int16): int8
proc XkbKeyGroupInfo*(d: PXkbDescPtr, k: int16): int8
proc XkbKeyNumGroups*(d: PXkbDescPtr, k: int16): int8
proc XkbKeyNumSyms*(d: PXkbDescPtr, k: int16): int16
proc XkbKeySym*(d: PXkbDescPtr, k: int16, n: int16): KeySym
proc XkbKeySymEntry*(d: PXkbDescPtr, k: int16, sl: int16, g: int8): KeySym
proc XkbKeyAction*(d: PXkbDescPtr, k: int16, n: int16): PXkbAction
proc XkbKeyActionEntry*(d: PXkbDescPtr, k: int16, sl: int16, g: int8): int8
proc XkbKeyHasActions*(d: PXkbDescPtr, k: int16): bool
proc XkbKeyNumActions*(d: PXkbDescPtr, k: int16): int16
proc XkbKeyActionsPtr*(d: PXkbDescPtr, k: int16): PXkbAction
proc XkbKeycodeInRange*(d: PXkbDescPtr, k: int16): bool
proc XkbNumKeys*(d: PXkbDescPtr): int8
  #
  #          The following structures can be used to track changes
  #          to a keyboard device
  #
type
  PXkbMapChangesPtr* = ptr XkbMapChangesRec
  XkbMapChangesRec*{.final.} = object
    changed*: int16
    min_key_code*: KeyCode
    max_key_code*: KeyCode
    first_type*: int8
    num_types*: int8
    first_key_sym*: KeyCode
    num_key_syms*: int8
    first_key_act*: KeyCode
    num_key_acts*: int8
    first_key_behavior*: KeyCode
    num_key_behaviors*: int8
    first_key_explicit*: KeyCode
    num_key_explicit*: int8
    first_modmap_key*: KeyCode
    num_modmap_keys*: int8
    first_vmodmap_key*: KeyCode
    num_vmodmap_keys*: int8
    pad*: int8
    vmods*: int16



type
  PXkbControlsChangesPtr* = ptr XkbControlsChangesRec
  XkbControlsChangesRec*{.final.} = object
    changed_ctrls*: int16
    enabled_ctrls_changes*: int16
    num_groups_changed*: bool



type
  PXkbIndicatorChangesPtr* = ptr XkbIndicatorChangesRec
  XkbIndicatorChangesRec*{.final.} = object
    state_changes*: int16
    map_changes*: int16



type
  PXkbNameChangesPtr* = ptr XkbNameChangesRec
  XkbNameChangesRec*{.final.} = object
    changed*: int16
    first_type*: int8
    num_types*: int8
    first_lvl*: int8
    num_lvls*: int8
    num_aliases*: int8
    num_rg*: int8
    first_key*: int8
    num_keys*: int8
    changed_vmods*: int16
    changed_indicators*: int32
    changed_groups*: int8



type
  PXkbCompatChangesPtr* = ptr XkbCompatChangesRec
  XkbCompatChangesRec*{.final.} = object
    changed_groups*: int8
    first_si*: int16
    num_si*: int16



type
  PXkbChangesPtr* = ptr XkbChangesRec
  XkbChangesRec*{.final.} = object #
                                   #          These data structures are used to construct a keymap from
                                   #          a set of components or to list components in the server
                                   #          database.
                                   #
    device_spec*: int16
    state_changes*: int16
    map*: XkbMapChangesRec
    ctrls*: XkbControlsChangesRec
    indicators*: XkbIndicatorChangesRec
    names*: XkbNameChangesRec
    compat*: XkbCompatChangesRec



type
  PXkbComponentNamesPtr* = ptr XkbComponentNamesRec
  XkbComponentNamesRec*{.final.} = object
    keymap*: ptr int16
    keycodes*: ptr int16
    types*: ptr int16
    compat*: ptr int16
    symbols*: ptr int16
    geometry*: ptr int16



type
  PXkbComponentNamePtr* = ptr XkbComponentNameRec
  XkbComponentNameRec*{.final.} = object
    flags*: int16
    name*: cstring



type
  PXkbComponentListPtr* = ptr XkbComponentListRec
  XkbComponentListRec*{.final.} = object #
                                         #          The following data structures describe and track changes to a
                                         #          non-keyboard extension device
                                         #
    num_keymaps*: int16
    num_keycodes*: int16
    num_types*: int16
    num_compat*: int16
    num_symbols*: int16
    num_geometry*: int16
    keymaps*: PXkbComponentNamePtr
    keycodes*: PXkbComponentNamePtr
    types*: PXkbComponentNamePtr
    compat*: PXkbComponentNamePtr
    symbols*: PXkbComponentNamePtr
    geometry*: PXkbComponentNamePtr



type
  PXkbDeviceLedInfoPtr* = ptr XkbDeviceLedInfoRec
  XkbDeviceLedInfoRec*{.final.} = object
    led_class*: int16
    led_id*: int16
    phys_indicators*: int16
    maps_present*: int16
    names_present*: int16
    state*: int16
    names*: array[0..XkbNumIndicators - 1, Atom]
    maps*: array[0..XkbNumIndicators - 1, XkbIndicatorMapRec]



type
  PXkbDeviceInfoPtr* = ptr XkbDeviceInfoRec
  XkbDeviceInfoRec*{.final.} = object
    name*: cstring
    theType*: Atom
    device_spec*: int16
    has_own_state*: bool
    supported*: int16
    unsupported*: int16
    num_btns*: int16
    btn_acts*: PXkbAction
    sz_leds*: int16
    num_leds*: int16
    dflt_kbd_fb*: int16
    dflt_led_fb*: int16
    leds*: PXkbDeviceLedInfoPtr



proc XkbXI_DevHasBtnActs*(d: PXkbDeviceInfoPtr): bool
proc XkbXI_LegalDevBtn*(d: PXkbDeviceInfoPtr, b: int16): bool
proc XkbXI_DevHasLeds*(d: PXkbDeviceInfoPtr): bool
type
  PXkbDeviceLedChangesPtr* = ptr XkbDeviceLedChangesRec
  XkbDeviceLedChangesRec*{.final.} = object
    led_class*: int16
    led_id*: int16
    defined*: int16 #names or maps changed
    next*: PXkbDeviceLedChangesPtr


type
  PXkbDeviceChangesPtr* = ptr XkbDeviceChangesRec
  XkbDeviceChangesRec*{.final.} = object
    changed*: int16
    first_btn*: int16
    num_btns*: int16
    leds*: XkbDeviceLedChangesRec



proc XkbShapeDoodadColor*(g: PXkbGeometryPtr, d: PXkbShapeDoodadPtr): PXkbColorPtr
proc XkbShapeDoodadShape*(g: PXkbGeometryPtr, d: PXkbShapeDoodadPtr): PXkbShapePtr
proc XkbSetShapeDoodadColor*(g: PXkbGeometryPtr, d: PXkbShapeDoodadPtr,
                             c: PXkbColorPtr)
proc XkbSetShapeDoodadShape*(g: PXkbGeometryPtr, d: PXkbShapeDoodadPtr,
                             s: PXkbShapePtr)
proc XkbTextDoodadColor*(g: PXkbGeometryPtr, d: PXkbTextDoodadPtr): PXkbColorPtr
proc XkbSetTextDoodadColor*(g: PXkbGeometryPtr, d: PXkbTextDoodadPtr,
                            c: PXkbColorPtr)
proc XkbIndicatorDoodadShape*(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr): PXkbShapeDoodadPtr
proc XkbIndicatorDoodadOnColor*(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr): PXkbColorPtr
proc XkbIndicatorDoodadOffColor*(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr): PXkbColorPtr
proc XkbSetIndicatorDoodadOnColor*(g: PXkbGeometryPtr,
                                   d: PXkbIndicatorDoodadPtr, c: PXkbColorPtr)
proc XkbSetIndicatorDoodadOffColor*(g: PXkbGeometryPtr,
                                    d: PXkbIndicatorDoodadPtr, c: PXkbColorPtr)
proc XkbSetIndicatorDoodadShape*(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr,
                                 s: PXkbShapeDoodadPtr)
proc XkbLogoDoodadColor*(g: PXkbGeometryPtr, d: PXkbLogoDoodadPtr): PXkbColorPtr
proc XkbLogoDoodadShape*(g: PXkbGeometryPtr, d: PXkbLogoDoodadPtr): PXkbShapeDoodadPtr
proc XkbSetLogoDoodadColor*(g: PXkbGeometryPtr, d: PXkbLogoDoodadPtr,
                            c: PXkbColorPtr)
proc XkbSetLogoDoodadShape*(g: PXkbGeometryPtr, d: PXkbLogoDoodadPtr,
                            s: PXkbShapeDoodadPtr)
proc XkbKeyShape*(g: PXkbGeometryPtr, k: PXkbKeyPtr): PXkbShapeDoodadPtr
proc XkbKeyColor*(g: PXkbGeometryPtr, k: PXkbKeyPtr): PXkbColorPtr
proc XkbSetKeyShape*(g: PXkbGeometryPtr, k: PXkbKeyPtr, s: PXkbShapeDoodadPtr)
proc XkbSetKeyColor*(g: PXkbGeometryPtr, k: PXkbKeyPtr, c: PXkbColorPtr)
proc XkbGeomColorIndex*(g: PXkbGeometryPtr, c: PXkbColorPtr): int32
proc XkbAddGeomProperty*(geom: PXkbGeometryPtr, name: cstring, value: cstring): PXkbPropertyPtr{.
    libx11c, importc: "XkbAddGeomProperty".}
proc XkbAddGeomKeyAlias*(geom: PXkbGeometryPtr, alias: cstring, float: cstring): PXkbKeyAliasPtr{.
    libx11c, importc: "XkbAddGeomKeyAlias".}
proc XkbAddGeomColor*(geom: PXkbGeometryPtr, spec: cstring, pixel: int16): PXkbColorPtr{.
    libx11c, importc: "XkbAddGeomColor".}
proc XkbAddGeomOutline*(shape: PXkbShapePtr, sz_points: int16): PXkbOutlinePtr{.
    libx11c, importc: "XkbAddGeomOutline".}
proc XkbAddGeomShape*(geom: PXkbGeometryPtr, name: Atom, sz_outlines: int16): PXkbShapePtr{.
    libx11c, importc: "XkbAddGeomShape".}
proc XkbAddGeomKey*(row: PXkbRowPtr): PXkbKeyPtr{.libx11c,
    importc: "XkbAddGeomKey".}
proc XkbAddGeomRow*(section: PXkbSectionPtr, sz_keys: int16): PXkbRowPtr{.libx11c, importc: "XkbAddGeomRow".}
proc XkbAddGeomSection*(geom: PXkbGeometryPtr, name: Atom, sz_rows: int16,
                        sz_doodads: int16, sz_overlays: int16): PXkbSectionPtr{.
    libx11c, importc: "XkbAddGeomSection".}
proc XkbAddGeomOverlay*(section: PXkbSectionPtr, name: Atom, sz_rows: int16): PXkbOverlayPtr{.
    libx11c, importc: "XkbAddGeomOverlay".}
proc XkbAddGeomOverlayRow*(overlay: PXkbOverlayPtr, row_under: int16,
                           sz_keys: int16): PXkbOverlayRowPtr{.libx11c, importc: "XkbAddGeomOverlayRow".}
proc XkbAddGeomOverlayKey*(overlay: PXkbOverlayPtr, row: PXkbOverlayRowPtr,
                           over: cstring, under: cstring): PXkbOverlayKeyPtr{.
    libx11c, importc: "XkbAddGeomOverlayKey".}
proc XkbAddGeomDoodad*(geom: PXkbGeometryPtr, section: PXkbSectionPtr,
                       name: Atom): PXkbDoodadPtr{.libx11c,
    importc: "XkbAddGeomDoodad".}
proc XkbFreeGeomKeyAliases*(geom: PXkbGeometryPtr, first: int16, count: int16,
                            freeAll: bool){.libx11c,
    importc: "XkbFreeGeomKeyAliases".}
proc XkbFreeGeomColors*(geom: PXkbGeometryPtr, first: int16, count: int16,
                        freeAll: bool){.libx11c,
                                        importc: "XkbFreeGeomColors".}
proc XkbFreeGeomDoodads*(doodads: PXkbDoodadPtr, nDoodads: int16, freeAll: bool){.
    libx11c, importc: "XkbFreeGeomDoodads".}
proc XkbFreeGeomProperties*(geom: PXkbGeometryPtr, first: int16, count: int16,
                            freeAll: bool){.libx11c,
    importc: "XkbFreeGeomProperties".}
proc XkbFreeGeomOverlayKeys*(row: PXkbOverlayRowPtr, first: int16, count: int16,
                             freeAll: bool){.libx11c,
    importc: "XkbFreeGeomOverlayKeys".}
proc XkbFreeGeomOverlayRows*(overlay: PXkbOverlayPtr, first: int16,
                             count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomOverlayRows".}
proc XkbFreeGeomOverlays*(section: PXkbSectionPtr, first: int16, count: int16,
                          freeAll: bool){.libx11c,
    importc: "XkbFreeGeomOverlays".}
proc XkbFreeGeomKeys*(row: PXkbRowPtr, first: int16, count: int16, freeAll: bool){.
    libx11c, importc: "XkbFreeGeomKeys".}
proc XkbFreeGeomRows*(section: PXkbSectionPtr, first: int16, count: int16,
                      freeAll: bool){.libx11c,
                                      importc: "XkbFreeGeomRows".}
proc XkbFreeGeomSections*(geom: PXkbGeometryPtr, first: int16, count: int16,
                          freeAll: bool){.libx11c,
    importc: "XkbFreeGeomSections".}
proc XkbFreeGeomPoints*(outline: PXkbOutlinePtr, first: int16, count: int16,
                        freeAll: bool){.libx11c,
                                        importc: "XkbFreeGeomPoints".}
proc XkbFreeGeomOutlines*(shape: PXkbShapePtr, first: int16, count: int16,
                          freeAll: bool){.libx11c,
    importc: "XkbFreeGeomOutlines".}
proc XkbFreeGeomShapes*(geom: PXkbGeometryPtr, first: int16, count: int16,
                        freeAll: bool){.libx11c,
                                        importc: "XkbFreeGeomShapes".}
proc XkbFreeGeometry*(geom: PXkbGeometryPtr, which: int16, freeMap: bool){.
    libx11c, importc: "XkbFreeGeometry".}
proc XkbAllocGeomProps*(geom: PXkbGeometryPtr, nProps: int16): Status{.libx11c, importc: "XkbAllocGeomProps".}
proc XkbAllocGeomKeyAliases*(geom: PXkbGeometryPtr, nAliases: int16): Status{.
    libx11c, importc: "XkbAllocGeomKeyAliases".}
proc XkbAllocGeomColors*(geom: PXkbGeometryPtr, nColors: int16): Status{.libx11c, importc: "XkbAllocGeomColors".}
proc XkbAllocGeomShapes*(geom: PXkbGeometryPtr, nShapes: int16): Status{.libx11c, importc: "XkbAllocGeomShapes".}
proc XkbAllocGeomSections*(geom: PXkbGeometryPtr, nSections: int16): Status{.
    libx11c, importc: "XkbAllocGeomSections".}
proc XkbAllocGeomOverlays*(section: PXkbSectionPtr, num_needed: int16): Status{.
    libx11c, importc: "XkbAllocGeomOverlays".}
proc XkbAllocGeomOverlayRows*(overlay: PXkbOverlayPtr, num_needed: int16): Status{.
    libx11c, importc: "XkbAllocGeomOverlayRows".}
proc XkbAllocGeomOverlayKeys*(row: PXkbOverlayRowPtr, num_needed: int16): Status{.
    libx11c, importc: "XkbAllocGeomOverlayKeys".}
proc XkbAllocGeomDoodads*(geom: PXkbGeometryPtr, nDoodads: int16): Status{.
    libx11c, importc: "XkbAllocGeomDoodads".}
proc XkbAllocGeomSectionDoodads*(section: PXkbSectionPtr, nDoodads: int16): Status{.
    libx11c, importc: "XkbAllocGeomSectionDoodads".}
proc XkbAllocGeomOutlines*(shape: PXkbShapePtr, nOL: int16): Status{.libx11c, importc: "XkbAllocGeomOutlines".}
proc XkbAllocGeomRows*(section: PXkbSectionPtr, nRows: int16): Status{.libx11c, importc: "XkbAllocGeomRows".}
proc XkbAllocGeomPoints*(ol: PXkbOutlinePtr, nPts: int16): Status{.libx11c, importc: "XkbAllocGeomPoints".}
proc XkbAllocGeomKeys*(row: PXkbRowPtr, nKeys: int16): Status{.libx11c, importc: "XkbAllocGeomKeys".}
proc XkbAllocGeometry*(xkb: PXkbDescPtr, sizes: PXkbGeometrySizesPtr): Status{.
    libx11c, importc: "XkbAllocGeometry".}
proc XkbSetGeometryProc*(dpy: PDisplay, deviceSpec: int16, geom: PXkbGeometryPtr): Status{.
    libx11c, importc: "XkbSetGeometry".}
proc XkbComputeShapeTop*(shape: PXkbShapePtr, bounds: PXkbBoundsPtr): bool{.
    libx11c, importc: "XkbComputeShapeTop".}
proc XkbComputeShapeBounds*(shape: PXkbShapePtr): bool{.libx11c,
    importc: "XkbComputeShapeBounds".}
proc XkbComputeRowBounds*(geom: PXkbGeometryPtr, section: PXkbSectionPtr,
                          row: PXkbRowPtr): bool{.libx11c,
    importc: "XkbComputeRowBounds".}
proc XkbComputeSectionBounds*(geom: PXkbGeometryPtr, section: PXkbSectionPtr): bool{.
    libx11c, importc: "XkbComputeSectionBounds".}
proc XkbFindOverlayForKey*(geom: PXkbGeometryPtr, wanted: PXkbSectionPtr,
                           under: cstring): cstring{.libx11c,
    importc: "XkbFindOverlayForKey".}
proc XkbGetGeometryProc*(dpy: PDisplay, xkb: PXkbDescPtr): Status{.libx11c, importc: "XkbGetGeometry".}
proc XkbGetNamedGeometry*(dpy: PDisplay, xkb: PXkbDescPtr, name: Atom): Status{.
    libx11c, importc: "XkbGetNamedGeometry".}
when defined(XKB_IN_SERVER):
  proc SrvXkbAddGeomKeyAlias*(geom: PXkbGeometryPtr, alias: cstring,
                              float: cstring): PXkbKeyAliasPtr{.libx11c, importc: "XkbAddGeomKeyAlias".}
  proc SrvXkbAddGeomColor*(geom: PXkbGeometryPtr, spec: cstring, pixel: int16): PXkbColorPtr{.
      libx11c, importc: "XkbAddGeomColor".}
  proc SrvXkbAddGeomDoodad*(geom: PXkbGeometryPtr, section: PXkbSectionPtr,
                            name: Atom): PXkbDoodadPtr{.libx11c,
      importc: "XkbAddGeomDoodad".}
  proc SrvXkbAddGeomKey*(geom: PXkbGeometryPtr, alias: cstring, float: cstring): PXkbKeyAliasPtr{.
      libx11c, importc: "XkbAddGeomKeyAlias".}
  proc SrvXkbAddGeomOutline*(shape: PXkbShapePtr, sz_points: int16): PXkbOutlinePtr{.
      libx11c, importc: "XkbAddGeomOutline".}
  proc SrvXkbAddGeomOverlay*(overlay: PXkbOverlayPtr, row: PXkbOverlayRowPtr,
                             over: cstring, under: cstring): PXkbOverlayKeyPtr{.
      libx11c, importc: "XkbAddGeomOverlayKey".}
  proc SrvXkbAddGeomOverlayRow*(overlay: PXkbOverlayPtr, row_under: int16,
                                sz_keys: int16): PXkbOverlayRowPtr{.libx11c, importc: "XkbAddGeomOverlayRow".}
  proc SrvXkbAddGeomOverlayKey*(overlay: PXkbOverlayPtr, row: PXkbOverlayRowPtr,
                                over: cstring, under: cstring): PXkbOverlayKeyPtr{.
      libx11c, importc: "XkbAddGeomOverlayKey".}
  proc SrvXkbAddGeomProperty*(geom: PXkbGeometryPtr, name: cstring,
                              value: cstring): PXkbPropertyPtr{.libx11c, importc: "XkbAddGeomProperty".}
  proc SrvXkbAddGeomRow*(section: PXkbSectionPtr, sz_keys: int16): PXkbRowPtr{.
      libx11c, importc: "XkbAddGeomRow".}
  proc SrvXkbAddGeomSection*(geom: PXkbGeometryPtr, name: Atom, sz_rows: int16,
                             sz_doodads: int16, sz_overlays: int16): PXkbSectionPtr{.
      libx11c, importc: "XkbAddGeomSection".}
  proc SrvXkbAddGeomShape*(geom: PXkbGeometryPtr, name: Atom,
                           sz_outlines: int16): PXkbShapePtr{.libx11c, importc: "XkbAddGeomShape".}
  proc SrvXkbAllocGeomKeyAliases*(geom: PXkbGeometryPtr, nAliases: int16): Status{.
      libx11c, importc: "XkbAllocGeomKeyAliases".}
  proc SrvXkbAllocGeomColors*(geom: PXkbGeometryPtr, nColors: int16): Status{.
      libx11c, importc: "XkbAllocGeomColors".}
  proc SrvXkbAllocGeomDoodads*(geom: PXkbGeometryPtr, nDoodads: int16): Status{.
      libx11c, importc: "XkbAllocGeomDoodads".}
  proc SrvXkbAllocGeomKeys*(row: PXkbRowPtr, nKeys: int16): Status{.libx11c, importc: "XkbAllocGeomKeys".}
  proc SrvXkbAllocGeomOutlines*(shape: PXkbShapePtr, nOL: int16): Status{.
      libx11c, importc: "XkbAllocGeomOutlines".}
  proc SrvXkbAllocGeomPoints*(ol: PXkbOutlinePtr, nPts: int16): Status{.libx11c, importc: "XkbAllocGeomPoints".}
  proc SrvXkbAllocGeomProps*(geom: PXkbGeometryPtr, nProps: int16): Status{.
      libx11c, importc: "XkbAllocGeomProps".}
  proc SrvXkbAllocGeomRows*(section: PXkbSectionPtr, nRows: int16): Status{.
      libx11c, importc: "XkbAllocGeomRows".}
  proc SrvXkbAllocGeomSectionDoodads*(section: PXkbSectionPtr, nDoodads: int16): Status{.
      libx11c, importc: "XkbAllocGeomSectionDoodads".}
  proc SrvXkbAllocGeomSections*(geom: PXkbGeometryPtr, nSections: int16): Status{.
      libx11c, importc: "XkbAllocGeomSections".}
  proc SrvXkbAllocGeomOverlays*(section: PXkbSectionPtr, num_needed: int16): Status{.
      libx11c, importc: "XkbAllocGeomOverlays".}
  proc SrvXkbAllocGeomOverlayRows*(overlay: PXkbOverlayPtr, num_needed: int16): Status{.
      libx11c, importc: "XkbAllocGeomOverlayRows".}
  proc SrvXkbAllocGeomOverlayKeys*(row: PXkbOverlayRowPtr, num_needed: int16): Status{.
      libx11c, importc: "XkbAllocGeomOverlayKeys".}
  proc SrvXkbAllocGeomShapes*(geom: PXkbGeometryPtr, nShapes: int16): Status{.
      libx11c, importc: "XkbAllocGeomShapes".}
  proc SrvXkbAllocGeometry*(xkb: PXkbDescPtr, sizes: PXkbGeometrySizesPtr): Status{.
      libx11c, importc: "XkbAllocGeometry".}
  proc SrvXkbFreeGeomKeyAliases*(geom: PXkbGeometryPtr, first: int16,
                                 count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomKeyAliases".}
  proc SrvXkbFreeGeomColors*(geom: PXkbGeometryPtr, first: int16, count: int16,
                             freeAll: bool){.libx11c,
      importc: "XkbFreeGeomColors".}
  proc SrvXkbFreeGeomDoodads*(doodads: PXkbDoodadPtr, nDoodads: int16,
                              freeAll: bool){.libx11c,
      importc: "XkbFreeGeomDoodads".}
  proc SrvXkbFreeGeomProperties*(geom: PXkbGeometryPtr, first: int16,
                                 count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomProperties".}
  proc SrvXkbFreeGeomOverlayKeys*(row: PXkbOverlayRowPtr, first: int16,
                                  count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomOverlayKeys".}
  proc SrvXkbFreeGeomOverlayRows*(overlay: PXkbOverlayPtr, first: int16,
                                  count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomOverlayRows".}
  proc SrvXkbFreeGeomOverlays*(section: PXkbSectionPtr, first: int16,
                               count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomOverlays".}
  proc SrvXkbFreeGeomKeys*(row: PXkbRowPtr, first: int16, count: int16,
                           freeAll: bool){.libx11c,
      importc: "XkbFreeGeomKeys".}
  proc SrvXkbFreeGeomRows*(section: PXkbSectionPtr, first: int16, count: int16,
                           freeAll: bool){.libx11c,
      importc: "XkbFreeGeomRows".}
  proc SrvXkbFreeGeomSections*(geom: PXkbGeometryPtr, first: int16,
                               count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomSections".}
  proc SrvXkbFreeGeomPoints*(outline: PXkbOutlinePtr, first: int16,
                             count: int16, freeAll: bool){.libx11c, importc: "XkbFreeGeomPoints".}
  proc SrvXkbFreeGeomOutlines*(shape: PXkbShapePtr, first: int16, count: int16,
                               freeAll: bool){.libx11c,
      importc: "XkbFreeGeomOutlines".}
  proc SrvXkbFreeGeomShapes*(geom: PXkbGeometryPtr, first: int16, count: int16,
                             freeAll: bool){.libx11c,
      importc: "XkbFreeGeomShapes".}
  proc SrvXkbFreeGeometry*(geom: PXkbGeometryPtr, which: int16, freeMap: bool){.
      libx11c, importc: "XkbFreeGeometry".}
# implementation

import #************************************ xkb ************************************
  xi

proc XkbLegalXILedClass(c: int): bool =
  ##define XkbLegalXILedClass(c) (((c)==KbdFeedbackClass)||((c)==LedFeedbackClass)||
  #                                ((c)==XkbDfltXIClass)||((c)==XkbAllXIClasses))
  result = (c == KbdFeedbackClass) or (c == LedFeedbackClass) or
      (c == XkbDfltXIClass) or (c == XkbAllXIClasses)

proc XkbLegalXIBellClass(c: int): bool =
  ##define XkbLegalXIBellClass(c) (((c)==KbdFeedbackClass)||((c)==BellFeedbackClass)||
  #                                 ((c)==XkbDfltXIClass)||((c)==XkbAllXIClasses))
  result = (c == KbdFeedbackClass) or (c == BellFeedbackClass) or
      (c == XkbDfltXIClass) or (c == XkbAllXIClasses)

proc XkbExplicitXIDevice(c: int): bool =
  ##define XkbExplicitXIDevice(c) (((c)&(~0xff))==0)
  result = (c and (not 0x000000FF)) == 0

proc XkbExplicitXIClass(c: int): bool =
  ##define XkbExplicitXIClass(c) (((c)&(~0xff))==0)
  result = (c and (not 0x000000FF)) == 0

proc XkbExplicitXIId(c: int): bool =
  ##define XkbExplicitXIId(c) (((c)&(~0xff))==0)
  result = (c and (not 0x000000FF)) == 0

proc XkbSingleXIClass(c: int): bool =
  ##define XkbSingleXIClass(c) ((((c)&(~0xff))==0)||((c)==XkbDfltXIClass))
  result = ((c and (not 0x000000FF)) == 0) or (c == XkbDfltXIClass)

proc XkbSingleXIId(c: int): bool =
  ##define XkbSingleXIId(c) ((((c)&(~0xff))==0)||((c)==XkbDfltXIId))
  result = ((c and (not 0x000000FF)) == 0) or (c == XkbDfltXIId)

proc XkbBuildCoreState(m, g: int): int =
  ##define XkbBuildCoreState(m,g) ((((g)&0x3)<<13)|((m)&0xff))
  result = ((g and 0x00000003) shl 13) or (m and 0x000000FF)

proc XkbGroupForCoreState(s: int): int =
  ##define XkbGroupForCoreState(s) (((s)>>13)&0x3)
  result = (s shr 13) and 0x00000003

proc XkbIsLegalGroup(g: int): bool =
  ##define XkbIsLegalGroup(g) (((g)>=0)&&((g)<XkbNumKbdGroups))
  result = (g >= 0) and (g < XkbNumKbdGroups)

proc XkbSA_ValOp(a: int): int =
  ##define XkbSA_ValOp(a) ((a)&XkbSA_ValOpMask)
  result = a and XkbSA_ValOpMask

proc XkbSA_ValScale(a: int): int =
  ##define XkbSA_ValScale(a) ((a)&XkbSA_ValScaleMask)
  result = a and XkbSA_ValScaleMask

proc XkbIsModAction(a: PXkbAnyAction): bool =
  ##define XkbIsModAction(a) (((a)->type>=Xkb_SASetMods)&&((a)->type<=XkbSA_LockMods))
  result = (a.theType) >= XkbSA_SetMods and (a.theType) <= XkbSA_LockMods

proc XkbIsGroupAction(a: PXkbAnyAction): bool =
  ##define XkbIsGroupAction(a) (((a)->type>=XkbSA_SetGroup)&&((a)->type<=XkbSA_LockGroup))
  result = (a.theType >= XkbSA_SetGroup) or (a.theType <= XkbSA_LockGroup)

proc XkbIsPtrAction(a: PXkbAnyAction): bool =
  ##define XkbIsPtrAction(a) (((a)->type>=XkbSA_MovePtr)&&((a)->type<=XkbSA_SetPtrDflt))
  result = (a.theType >= XkbSA_MovePtr) and
      (a.theType <= XkbSA_SetPtrDflt)

proc XkbIsLegalKeycode(k: int): bool =
  ##define        XkbIsLegalKeycode(k)    (((k)>=XkbMinLegalKeyCode)&&((k)<=XkbMaxLegalKeyCode))
  result = (k >= XkbMinLegalKeyCode) and (k <= XkbMaxLegalKeyCode)

proc XkbShiftLevel(n: int8): int8 =
  ##define XkbShiftLevel(n) ((n)-1)
  result = n - 1'i8

proc XkbShiftLevelMask(n: int8): int8 =
  ##define XkbShiftLevelMask(n) (1<<((n)-1))
  result = 1'i8 shl (n - 1'i8)

proc XkbcharToInt(v: int8): int16 =
  ##define XkbcharToInt(v) ((v)&0x80?(int)((v)|(~0xff)):(int)((v)&0x7f))
  if ((v and 0x80'i8) != 0'i8): result = v or (not 0xFF'i16)
  else: result = int16(v and 0x7F'i8)

proc XkbIntTo2chars(i: int16, h, L: var int8) =
  ##define XkbIntTo2chars(i,h,l) (((h)=((i>>8)&0xff)),((l)=((i)&0xff)))
  h = int8((i shr 8'i16) and 0x00FF'i16)
  L = int8(i and 0xFF'i16)

proc Xkb2charsToInt(h, L: int8): int16 =
  when defined(cpu64):
    ##define Xkb2charsToInt(h,l) ((h)&0x80?(int)(((h)<<8)|(l)|(~0xffff)): (int)(((h)<<8)|(l)&0x7fff))
    if (h and 0x80'i8) != 0'i8:
      result = int16((h shl 8) or L or not 0x0000FFFF)
    else:
      result = int16((h shl 8) or L and 0x00007FFF)
  else:
    ##define Xkb2charsToInt(h,l) ((short)(((h)<<8)|(l)))
    result = int16(h shl 8 or L)

proc XkbModLocks(s: PXkbStatePtr): int8 =
  ##define XkbModLocks(s) ((s)->locked_mods)
  result = s.locked_mods

proc XkbStateMods(s: PXkbStatePtr): int16 =
  ##define XkbStateMods(s) ((s)->base_mods|(s)->latched_mods|XkbModLocks(s))
  result = s.base_mods or s.latched_mods or XkbModLocks(s)

proc XkbGroupLock(s: PXkbStatePtr): int8 =
  ##define XkbGroupLock(s) ((s)->locked_group)
  result = s.locked_group

proc XkbStateGroup(s: PXkbStatePtr): int16 =
  ##define XkbStateGroup(s) ((s)->base_group+(s)->latched_group+XkbGroupLock(s))
  result = s.base_group + (s.latched_group) + XkbGroupLock(s)

proc XkbStateFieldFromRec(s: PXkbStatePtr): int =
  ##define XkbStateFieldFromRec(s) XkbBuildCoreState((s)->lookup_mods,(s)->group)
  result = XkbBuildCoreState(s.lookup_mods, s.group)

proc XkbGrabStateFromRec(s: PXkbStatePtr): int =
  ##define XkbGrabStateFromRec(s) XkbBuildCoreState((s)->grab_mods,(s)->group)
  result = XkbBuildCoreState(s.grab_mods, s.group)

proc XkbNumGroups(g: int16): int16 =
  ##define XkbNumGroups(g) ((g)&0x0f)
  result = g and 0x0000000F'i16

proc XkbOutOfRangeGroupInfo(g: int16): int16 =
  ##define XkbOutOfRangeGroupInfo(g) ((g)&0xf0)
  result = g and 0x000000F0'i16

proc XkbOutOfRangeGroupAction(g: int16): int16 =
  ##define XkbOutOfRangeGroupAction(g) ((g)&0xc0)
  result = g and 0x000000C0'i16

proc XkbOutOfRangeGroupNumber(g: int16): int16 =
  ##define XkbOutOfRangeGroupNumber(g) (((g)&0x30)>>4)
  result = (g and 0x00000030'i16) shr 4'i16

proc XkbSetGroupInfo(g, w, n: int16): int16 =
  ##define XkbSetGroupInfo(g,w,n) (((w)&0xc0)|(((n)&3)<<4)|((g)&0x0f))
  result = (w and 0x000000C0'i16) or
    ((n and 3'i16) shl 4'i16) or (g and 0x0000000F'i16)

proc XkbSetNumGroups(g, n: int16): int16 =
  ##define XkbSetNumGroups(g,n) (((g)&0xf0)|((n)&0x0f))
  result = (g and 0x000000F0'i16) or (n and 0x0000000F'i16)

proc XkbModActionVMods(a: PXkbModAction): int16 =
  ##define XkbModActionVMods(a) ((short)(((a)->vmods1<<8)|((a)->vmods2)))
  result = int16((a.vmods1 shl 8) or a.vmods2)

proc XkbSetModActionVMods(a: PXkbModAction, v: int8) =
  ##define XkbSetModActionVMods(a,v) (((a)->vmods1=(((v)>>8)&0xff)),(a)->vmods2=((v)&0xff))
  a.vmods1 = int8((v shr 8) and 0x000000FF)
  a.vmods2 = int8(v and 0x000000FF)

proc XkbSAGroup(a: PXkbGroupAction): int8 =
  ##define XkbSAGroup(a) (XkbcharToInt((a)->group_XXX))
  result = int8(XkbcharToInt(a.group_XXX))

proc XkbSASetGroupProc(a: PXkbGroupAction, g: int8) =
  ##define XkbSASetGroup(a,g) ((a)->group_XXX=(g))
  a.group_XXX = g

proc XkbPtrActionX(a: PXkbPtrAction): int16 =
  ##define XkbPtrActionX(a) (Xkb2charsToInt((a)->high_XXX,(a)->low_XXX))
  result = int16(Xkb2charsToInt(a.high_XXX, a.low_XXX))

proc XkbPtrActionY(a: PXkbPtrAction): int16 =
  ##define XkbPtrActionY(a) (Xkb2charsToInt((a)->high_YYY,(a)->low_YYY))
  result = int16(Xkb2charsToInt(a.high_YYY, a.low_YYY))

proc XkbSetPtrActionX(a: PXkbPtrAction, x: int8) =
  ##define XkbSetPtrActionX(a,x) (XkbIntTo2chars(x,(a)->high_XXX,(a)->low_XXX))
  XkbIntTo2chars(x, a.high_XXX, a.low_XXX)

proc XkbSetPtrActionY(a: PXkbPtrAction, y: int8) =
  ##define XkbSetPtrActionY(a,y) (XkbIntTo2chars(y,(a)->high_YYY,(a)->low_YYY))
  XkbIntTo2chars(y, a.high_YYY, a.low_YYY)

proc XkbSAPtrDfltValue(a: PXkbPtrDfltAction): int8 =
  ##define XkbSAPtrDfltValue(a) (XkbcharToInt((a)->valueXXX))
  result = int8(XkbcharToInt(a.valueXXX))

proc XkbSASetPtrDfltValue(a: PXkbPtrDfltAction, c: pointer) =
  ##define XkbSASetPtrDfltValue(a,c) ((a)->valueXXX= ((c)&0xff))
  a.valueXXX = int8(cast[int](c))

proc XkbSAScreen(a: PXkbSwitchScreenAction): int8 =
  ##define XkbSAScreen(a) (XkbcharToInt((a)->screenXXX))
  result = int8(XkbcharToInt(a.screenXXX))

proc XkbSASetScreen(a: PXkbSwitchScreenAction, s: pointer) =
  ##define XkbSASetScreen(a,s) ((a)->screenXXX= ((s)&0xff))
  a.screenXXX = int8(cast[int](s))

proc XkbActionSetCtrls(a: PXkbCtrlsAction, c: int8) =
  ##define XkbActionSetCtrls(a,c) (((a)->ctrls3=(((c)>>24)&0xff)),((a)->ctrls2=(((c)>>16)&0xff)),
  #                                 ((a)->ctrls1=(((c)>>8)&0xff)),((a)->ctrls0=((c)&0xff)))
  a.ctrls3 = int8((c shr 24) and 0x000000FF)
  a.ctrls2 = int8((c shr 16) and 0x000000FF)
  a.ctrls1 = int8((c shr 8) and 0x000000FF)
  a.ctrls0 = int8(c and 0x000000FF)

proc XkbActionCtrls(a: PXkbCtrlsAction): int16 =
  ##define XkbActionCtrls(a) ((((unsigned int)(a)->ctrls3)<<24)|(((unsigned int)(a)->ctrls2)<<16)|
  #                            (((unsigned int)(a)->ctrls1)<<8)|((unsigned int)((a)->ctrls0)))
  result = int16((a.ctrls3 shl 24) or (a.ctrls2 shl 16) or
     (a.ctrls1 shl 8) or a.ctrls0)

proc XkbSARedirectVMods(a: PXkbRedirectKeyAction): int16 =
  ##define XkbSARedirectVMods(a) ((((unsigned int)(a)->vmods1)<<8)|((unsigned int)(a)->vmods0))
  result = int16((a.vmods1 shl 8) or a.vmods0)

proc XkbSARedirectSetVMods(a: PXkbRedirectKeyAction, m: int8) =
  ##define XkbSARedirectSetVMods(a,m) (((a)->vmods_mask1=(((m)>>8)&0xff)),((a)->vmods_mask0=((m)&0xff)))
  a.vmods_mask1 = int8((m shr 8) and 0x000000FF)
  a.vmods_mask0 = int8(m or 0x000000FF)

proc XkbSARedirectVModsMask(a: PXkbRedirectKeyAction): int16 =
  ##define XkbSARedirectVModsMask(a) ((((unsigned int)(a)->vmods_mask1)<<8)|
  #                                     ((unsigned int)(a)->vmods_mask0))
  result = int16((a.vmods_mask1 shl 8) or a.vmods_mask0)

proc XkbSARedirectSetVModsMask(a: PXkbRedirectKeyAction, m: int8) =
  ##define XkbSARedirectSetVModsMask(a,m) (((a)->vmods_mask1=(((m)>>8)&0xff)),((a)->vmods_mask0=((m)&0xff)))
  a.vmods_mask1 = int8(m shr 8 and 0x000000FF)
  a.vmods_mask0 = int8(m and 0x000000FF)

proc XkbAX_AnyFeedback(c: PXkbControlsPtr): int16 =
  ##define XkbAX_AnyFeedback(c) ((c)->enabled_ctrls&XkbAccessXFeedbackMask)
  result = int16(c.enabled_ctrls and XkbAccessXFeedbackMask)

proc XkbAX_NeedOption(c: PXkbControlsPtr, w: int16): int16 =
  ##define XkbAX_NeedOption(c,w) ((c)->ax_options&(w))
  result = int16(c.ax_options and w)

proc XkbAX_NeedFeedback(c: PXkbControlsPtr, w: int16): bool =
  ##define XkbAX_NeedFeedback(c,w) (XkbAX_AnyFeedback(c)&&XkbAX_NeedOption(c,w))
  result = (XkbAX_AnyFeedback(c) > 0'i16) and (XkbAX_NeedOption(c, w) > 0'i16)

proc XkbSMKeyActionsPtr(m: PXkbServerMapPtr, k: int16): PXkbAction =
  ##define XkbSMKeyActionsPtr(m,k) (&(m)->acts[(m)->key_acts[k]])
  result = addr(m.acts[m.key_acts[k]])

proc XkbCMKeyGroupInfo(m: PXkbClientMapPtr, k: int16): int8 =
  ##define XkbCMKeyGroupInfo(m,k) ((m)->key_sym_map[k].group_info)
  result = m.key_sym_map[k].group_info

proc XkbCMKeyNumGroups(m: PXkbClientMapPtr, k: int16): int8 =
  ##define XkbCMKeyNumGroups(m,k) (XkbNumGroups((m)->key_sym_map[k].group_info))
  result = int8(XkbNumGroups(m.key_sym_map[k].group_info))

proc XkbCMKeyGroupWidth(m: PXkbClientMapPtr, k: int16, g: int8): int8 =
  ##define XkbCMKeyGroupWidth(m,k,g) (XkbCMKeyType(m,k,g)->num_levels)
  result = XkbCMKeyType(m, k, g).num_levels

proc XkbCMKeyGroupsWidth(m: PXkbClientMapPtr, k: int16): int8 =
  ##define XkbCMKeyGroupsWidth(m,k) ((m)->key_sym_map[k].width)
  result = m.key_sym_map[k].width

proc XkbCMKeyTypeIndex(m: PXkbClientMapPtr, k: int16, g: int8): int8 =
  ##define XkbCMKeyTypeIndex(m,k,g) ((m)->key_sym_map[k].kt_index[g&0x3])
  result = m.key_sym_map[k].kt_index[g and 0x00000003]

proc XkbCMKeyType(m: PXkbClientMapPtr, k: int16, g: int8): PXkbKeyTypePtr =
  ##define XkbCMKeyType(m,k,g) (&(m)->types[XkbCMKeyTypeIndex(m,k,g)])
  result = addr(m.types[XkbCMKeyTypeIndex(m, k, g)])

proc XkbCMKeyNumSyms(m: PXkbClientMapPtr, k: int16): int16 =
  ##define XkbCMKeyNumSyms(m,k) (XkbCMKeyGroupsWidth(m,k)*XkbCMKeyNumGroups(m,k))
  result = int16(XkbCMKeyGroupsWidth(m, k) or XkbCMKeyNumGroups(m, k))

proc XkbCMKeySymsOffset(m: PXkbClientMapPtr, k: int16): int8 =
  ##define XkbCMKeySymsOffset(m,k) ((m)->key_sym_map[k].offset)
  result = m.key_sym_map[k].offset

proc XkbCMKeySymsPtr*(m: PXkbClientMapPtr, k: int16): PKeySym =
  ##define XkbCMKeySymsPtr(m,k) (&(m)->syms[XkbCMKeySymsOffset(m,k)])
  result = addr(m.syms[XkbCMKeySymsOffset(m, k)])

proc XkbIM_IsAuto(i: PXkbIndicatorMapPtr): bool =
  ##define XkbIM_IsAuto(i) ((((i)->flags&XkbIM_NoAutomatic)==0)&&(((i)->which_groups&&(i)->groups)||
  #                           ((i)->which_mods&&(i)->mods.mask)||  ((i)->ctrls)))
  result = ((i.flags and XkbIM_NoAutomatic) == 0) and
      (((i.which_groups > 0'i8) and (i.groups > 0'i8)) or
      ((i.which_mods > 0'i8) and (i.mods.mask > 0'i8)) or (i.ctrls > 0'i8))

proc XkbIM_InUse(i: PXkbIndicatorMapPtr): bool =
  ##define XkbIM_InUse(i) (((i)->flags)||((i)->which_groups)||((i)->which_mods)||((i)->ctrls))
  result = (i.flags > 0'i8) or (i.which_groups > 0'i8) or (i.which_mods > 0'i8) or
      (i.ctrls > 0'i8)

proc XkbKeyKeyTypeIndex(d: PXkbDescPtr, k: int16, g: int8): int8 =
  ##define XkbKeyKeyTypeIndex(d,k,g)      (XkbCMKeyTypeIndex((d)->map,k,g))
  result = XkbCMKeyTypeIndex(d.map, k, g)

proc XkbKeyKeyType(d: PXkbDescPtr, k: int16, g: int8): PXkbKeyTypePtr =
  ##define XkbKeyKeyType(d,k,g) (XkbCMKeyType((d)->map,k,g))
  result = XkbCMKeyType(d.map, k, g)

proc XkbKeyGroupWidth(d: PXkbDescPtr, k: int16, g: int8): int8 =
  ##define XkbKeyGroupWidth(d,k,g) (XkbCMKeyGroupWidth((d)->map,k,g))
  result = XkbCMKeyGroupWidth(d.map, k, g)

proc XkbKeyGroupsWidth(d: PXkbDescPtr, k: int16): int8 =
  ##define XkbKeyGroupsWidth(d,k) (XkbCMKeyGroupsWidth((d)->map,k))
  result = XkbCMKeyGroupsWidth(d.map, k)

proc XkbKeyGroupInfo(d: PXkbDescPtr, k: int16): int8 =
  ##define XkbKeyGroupInfo(d,k) (XkbCMKeyGroupInfo((d)->map,(k)))
  result = XkbCMKeyGroupInfo(d.map, k)

proc XkbKeyNumGroups(d: PXkbDescPtr, k: int16): int8 =
  ##define XkbKeyNumGroups(d,k) (XkbCMKeyNumGroups((d)->map,(k)))
  result = XkbCMKeyNumGroups(d.map, k)

proc XkbKeyNumSyms(d: PXkbDescPtr, k: int16): int16 =
  ##define XkbKeyNumSyms(d,k) (XkbCMKeyNumSyms((d)->map,(k)))
  result = XkbCMKeyNumSyms(d.map, k)

proc XkbKeySymsPtr*(d: PXkbDescPtr, k: int16): PKeySym =
  ##define XkbKeySymsPtr(d,k) (XkbCMKeySymsPtr((d)->map,(k)))
  result = XkbCMKeySymsPtr(d.map, k)

proc XkbKeySym(d: PXkbDescPtr, k: int16, n: int16): KeySym =
  ##define XkbKeySym(d,k,n) (XkbKeySymsPtr(d,k)[n])
  result = cast[ptr array[0..0xffff, KeySym]](XkbKeySymsPtr(d, k))[n] # XXX: this seems strange!

proc XkbKeySymEntry(d: PXkbDescPtr, k: int16, sl: int16, g: int8): KeySym =
  ##define XkbKeySymEntry(d,k,sl,g) (XkbKeySym(d,k,((XkbKeyGroupsWidth(d,k)*(g))+(sl))))
  result = XkbKeySym(d, k, int16(XkbKeyGroupsWidth(d, k) * g + sl))

proc XkbKeyAction(d: PXkbDescPtr, k: int16, n: int16): PXkbAction =
  ##define XkbKeyAction(d,k,n) (XkbKeyHasActions(d,k)?&XkbKeyActionsPtr(d,k)[n]:NULL)
  #if (XkbKeyHasActions(d, k)):
  #  result = XkbKeyActionsPtr(d, k)[n] #Buggy !!!
  assert(false)
  result = nil

proc XkbKeyActionEntry(d: PXkbDescPtr, k: int16, sl: int16, g: int8): int8 =
  ##define XkbKeyActionEntry(d,k,sl,g) (XkbKeyHasActions(d,k) ?
  #                                      XkbKeyAction(d, k, ((XkbKeyGroupsWidth(d, k) * (g))+(sl))):NULL)
  if XkbKeyHasActions(d, k):
    result = XkbKeyGroupsWidth(d, k) *% g +% int8(sl)
  else:
    result = 0'i8

proc XkbKeyHasActions(d: PXkbDescPtr, k: int16): bool =
  ##define XkbKeyHasActions(d,k) ((d)->server->key_acts[k]!=0)
  result = d.server.key_acts[k] != 0'i16

proc XkbKeyNumActions(d: PXkbDescPtr, k: int16): int16 =
  ##define XkbKeyNumActions(d,k) (XkbKeyHasActions(d,k)?XkbKeyNumSyms(d,k):1)
  if (XkbKeyHasActions(d, k)): result = XkbKeyNumSyms(d, k)
  else: result = 1'i16

proc XkbKeyActionsPtr(d: PXkbDescPtr, k: int16): PXkbAction =
  ##define XkbKeyActionsPtr(d,k) (XkbSMKeyActionsPtr((d)->server,k))
  result = XkbSMKeyActionsPtr(d.server, k)

proc XkbKeycodeInRange(d: PXkbDescPtr, k: int16): bool =
  ##define XkbKeycodeInRange(d,k) (((k)>=(d)->min_key_code)&& ((k)<=(d)->max_key_code))
  result = (char(int8(k)) >= d.min_key_code) and (char(int8(k)) <= d.max_key_code)

proc XkbNumKeys(d: PXkbDescPtr): int8 =
  ##define XkbNumKeys(d) ((d)->max_key_code-(d)->min_key_code+1)
  result = int8(ord(d.max_key_code) - ord(d.min_key_code) + 1)

proc XkbXI_DevHasBtnActs(d: PXkbDeviceInfoPtr): bool =
  ##define XkbXI_DevHasBtnActs(d) (((d)->num_btns>0)&&((d)->btn_acts!=NULL))
  result = (d.num_btns > 0'i16) and (not (d.btn_acts == nil))

proc XkbXI_LegalDevBtn(d: PXkbDeviceInfoPtr, b: int16): bool =
  ##define XkbXI_LegalDevBtn(d,b) (XkbXI_DevHasBtnActs(d)&&((b)<(d)->num_btns))
  result = XkbXI_DevHasBtnActs(d) and (b <% d.num_btns)

proc XkbXI_DevHasLeds(d: PXkbDeviceInfoPtr): bool =
  ##define XkbXI_DevHasLeds(d) (((d)->num_leds>0)&&((d)->leds!=NULL))
  result = (d.num_leds > 0'i16) and (not (d.leds == nil))

proc XkbBoundsWidth(b: PXkbBoundsPtr): int16 =
  ##define XkbBoundsWidth(b) (((b)->x2)-((b)->x1))
  result = (b.x2) - b.x1

proc XkbBoundsHeight(b: PXkbBoundsPtr): int16 =
  ##define XkbBoundsHeight(b) (((b)->y2)-((b)->y1))
  result = (b.y2) - b.y1

proc XkbOutlineIndex(s: PXkbShapePtr, o: PXkbOutlinePtr): int32 =
  ##define XkbOutlineIndex(s,o) ((int)((o)-&(s)->outlines[0]))
  result = int32((cast[int](o) - cast[int](addr(s.outlines[0]))) div sizeof(PXkbOutlinePtr))

proc XkbShapeDoodadColor(g: PXkbGeometryPtr, d: PXkbShapeDoodadPtr): PXkbColorPtr =
  ##define XkbShapeDoodadColor(g,d) (&(g)->colors[(d)->color_ndx])
  result = addr((g.colors[d.color_ndx]))

proc XkbShapeDoodadShape(g: PXkbGeometryPtr, d: PXkbShapeDoodadPtr): PXkbShapePtr =
  ##define XkbShapeDoodadShape(g,d) (&(g)->shapes[(d)->shape_ndx])
  result = addr(g.shapes[d.shape_ndx])

proc XkbSetShapeDoodadColor(g: PXkbGeometryPtr, d: PXkbShapeDoodadPtr,
                            c: PXkbColorPtr) =
  ##define XkbSetShapeDoodadColor(g,d,c) ((d)->color_ndx= (c)-&(g)->colors[0])
  d.color_ndx = int16((cast[int](c) - cast[int](addr(g.colors[0]))) div sizeof(XkbColorRec))

proc XkbSetShapeDoodadShape(g: PXkbGeometryPtr, d: PXkbShapeDoodadPtr,
                            s: PXkbShapePtr) =
  ##define XkbSetShapeDoodadShape(g,d,s) ((d)->shape_ndx= (s)-&(g)->shapes[0])
  d.shape_ndx = int16((cast[int](s) - cast[int](addr(g.shapes[0]))) div sizeof(XkbShapeRec))

proc XkbTextDoodadColor(g: PXkbGeometryPtr, d: PXkbTextDoodadPtr): PXkbColorPtr =
  ##define XkbTextDoodadColor(g,d) (&(g)->colors[(d)->color_ndx])
  result = addr(g.colors[d.color_ndx])

proc XkbSetTextDoodadColor(g: PXkbGeometryPtr, d: PXkbTextDoodadPtr,
                           c: PXkbColorPtr) =
  ##define XkbSetTextDoodadColor(g,d,c) ((d)->color_ndx= (c)-&(g)->colors[0])
  d.color_ndx = int16((cast[int](c) - cast[int](addr(g.colors[0]))) div sizeof(XkbColorRec))

proc XkbIndicatorDoodadShape(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr): PXkbShapeDoodadPtr =
  ##define XkbIndicatorDoodadShape(g,d) (&(g)->shapes[(d)->shape_ndx])
  result = cast[PXkbShapeDoodadPtr](addr(g.shapes[d.shape_ndx]))

proc XkbIndicatorDoodadOnColor(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr): PXkbColorPtr =
  ##define XkbIndicatorDoodadOnColor(g,d) (&(g)->colors[(d)->on_color_ndx])
  result = addr(g.colors[d.on_color_ndx])

proc XkbIndicatorDoodadOffColor(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr): PXkbColorPtr =
  ##define XkbIndicatorDoodadOffColor(g,d) (&(g)->colors[(d)->off_color_ndx])
  result = addr(g.colors[d.off_color_ndx])

proc XkbSetIndicatorDoodadOnColor(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr,
                                  c: PXkbColorPtr) =
  ##define XkbSetIndicatorDoodadOnColor(g,d,c) ((d)->on_color_ndx= (c)-&(g)->colors[0])
  d.on_color_ndx = int16((cast[int](c) - cast[int](addr(g.colors[0]))) div sizeof(XkbColorRec))

proc XkbSetIndicatorDoodadOffColor(g: PXkbGeometryPtr,
                                   d: PXkbIndicatorDoodadPtr, c: PXkbColorPtr) =
  ##define        XkbSetIndicatorDoodadOffColor(g,d,c) ((d)->off_color_ndx= (c)-&(g)->colors[0])
  d.off_color_ndx = int16((cast[int](c) - cast[int](addr(g.colors[0]))) div sizeof(XkbColorRec))

proc XkbSetIndicatorDoodadShape(g: PXkbGeometryPtr, d: PXkbIndicatorDoodadPtr,
                                s: PXkbShapeDoodadPtr) =
  ##define XkbSetIndicatorDoodadShape(g,d,s) ((d)->shape_ndx= (s)-&(g)->shapes[0])
  d.shape_ndx = int16((cast[int](s) - (cast[int](addr(g.shapes[0])))) div sizeof(XkbShapeRec))

proc XkbLogoDoodadColor(g: PXkbGeometryPtr, d: PXkbLogoDoodadPtr): PXkbColorPtr =
  ##define XkbLogoDoodadColor(g,d) (&(g)->colors[(d)->color_ndx])
  result = addr(g.colors[d.color_ndx])

proc XkbLogoDoodadShape(g: PXkbGeometryPtr, d: PXkbLogoDoodadPtr): PXkbShapeDoodadPtr =
  ##define XkbLogoDoodadShape(g,d) (&(g)->shapes[(d)->shape_ndx])
  result = cast[PXkbShapeDoodadPtr](addr(g.shapes[d.shape_ndx]))

proc XkbSetLogoDoodadColor(g: PXkbGeometryPtr, d: PXkbLogoDoodadPtr,
                           c: PXkbColorPtr) =
  ##define XkbSetLogoDoodadColor(g,d,c) ((d)->color_ndx= (c)-&(g)->colors[0])
  d.color_ndx = int16((cast[int](c) - cast[int](addr(g.colors[0]))) div sizeof(XkbColorRec))

proc XkbSetLogoDoodadShape(g: PXkbGeometryPtr, d: PXkbLogoDoodadPtr,
                           s: PXkbShapeDoodadPtr) =
  ##define XkbSetLogoDoodadShape(g,d,s) ((d)->shape_ndx= (s)-&(g)->shapes[0])
  d.shape_ndx = int16((cast[int](s) - cast[int](addr(g.shapes[0]))) div sizeof(XkbShapeRec))

proc XkbKeyShape(g: PXkbGeometryPtr, k: PXkbKeyPtr): PXkbShapeDoodadPtr =
  ##define XkbKeyShape(g,k) (&(g)->shapes[(k)->shape_ndx])
  result = cast[PXkbShapeDoodadPtr](addr(g.shapes[k.shape_ndx]))

proc XkbKeyColor(g: PXkbGeometryPtr, k: PXkbKeyPtr): PXkbColorPtr =
  ##define XkbKeyColor(g,k) (&(g)->colors[(k)->color_ndx])
  result = addr(g.colors[k.color_ndx])

proc XkbSetKeyShape(g: PXkbGeometryPtr, k: PXkbKeyPtr, s: PXkbShapeDoodadPtr) =
  ##define XkbSetKeyShape(g,k,s) ((k)->shape_ndx= (s)-&(g)->shapes[0])
  k.shape_ndx = int8((cast[int](s) - cast[int](addr(g.shapes[0]))) div sizeof(XkbShapeRec))

proc XkbSetKeyColor(g: PXkbGeometryPtr, k: PXkbKeyPtr, c: PXkbColorPtr) =
  ##define XkbSetKeyColor(g,k,c) ((k)->color_ndx= (c)-&(g)->colors[0])
  k.color_ndx = int8((cast[int](c) - cast[int](addr(g.colors[0]))) div sizeof(XkbColorRec))

proc XkbGeomColorIndex(g: PXkbGeometryPtr, c: PXkbColorPtr): int32 =
  ##define XkbGeomColorIndex(g,c) ((int)((c)-&(g)->colors[0]))
  result = int16((cast[int](c) - (cast[int](addr(g.colors[0])))) div sizeof(XkbColorRec))