Mercurial > games > semicongine
diff semiconginev2/old/thirdparty/x11/xkb.nim @ 1218:56781cc0fc7c compiletime-tests
did: renamge main package
| author | sam <sam@basx.dev> |
|---|---|
| date | Wed, 17 Jul 2024 21:01:37 +0700 |
| parents | semicongine/old/thirdparty/x11/xkb.nim@239adab121a3 |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/semiconginev2/old/thirdparty/x11/xkb.nim Wed Jul 17 21:01:37 2024 +0700 @@ -0,0 +1,2446 @@ +# +# $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))