Mercurial > games > semicongine
view semiconginev2/thirdparty/x11/xkb.nim @ 1258:5442d0e9d8ff
did: improve testing lighting, try new glb model (need to add jpeg support first)
| author | sam <sam@basx.dev> |
|---|---|
| date | Sun, 28 Jul 2024 20:42:51 +0700 |
| parents | 56781cc0fc7c |
| children |
line wrap: on
line source
# # $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))