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]
xkb_keysym_t* = uint32
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
{.deprecated: [TXkbStateRec: XkbStateRec].}
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
{.deprecated: [TXkbModsRec: XkbModsRec].}
type
PXkbKTMapEntryPtr* = ptr XkbKTMapEntryRec
XkbKTMapEntryRec*{.final.} = object
active*: bool
level*: int8
mods*: XkbModsRec
{.deprecated: [TXkbKTMapEntryRec: XkbKTMapEntryRec].}
type
PXkbKeyTypePtr* = ptr XkbKeyTypeRec
XkbKeyTypeRec*{.final.} = object
mods*: XkbModsRec
num_levels*: int8
map_count*: int8
map*: PXkbKTMapEntryPtr
preserve*: PXkbModsPtr
name*: Atom
level_names*: Atom
{.deprecated: [TXkbKeyTypeRec: XkbKeyTypeRec].}
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
{.deprecated: [TXkbBehavior: XkbBehavior].}
type
PXkbModAction* = ptr XkbModAction
XkbModAction*{.final.} = object
theType*: int8
flags*: int8
mask*: int8
real_mods*: int8
vmods1*: int8
vmods2*: int8
{.deprecated: [TXkbModAction: XkbModAction].}
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
{.deprecated: [TXkbGroupAction: XkbGroupAction].}
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
{.deprecated: [TXkbISOAction: XkbISOAction].}
type
PXkbPtrAction* = ptr XkbPtrAction
XkbPtrAction*{.final.} = object
theType*: int8
flags*: int8
high_XXX*: int8
low_XXX*: int8
high_YYY*: int8
low_YYY*: int8
{.deprecated: [TXkbPtrAction: XkbPtrAction].}
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
{.deprecated: [TXkbPtrBtnAction: XkbPtrBtnAction].}
type
PXkbPtrDfltAction* = ptr XkbPtrDfltAction
XkbPtrDfltAction*{.final.} = object
theType*: int8
flags*: int8
affect*: int8
valueXXX*: int8
{.deprecated: [TXkbPtrDfltAction: XkbPtrDfltAction].}
proc XkbSAPtrDfltValue*(a: PXkbPtrDfltAction): int8
proc XkbSASetPtrDfltValue*(a: PXkbPtrDfltAction, c: pointer)
type
PXkbSwitchScreenAction* = ptr XkbSwitchScreenAction
XkbSwitchScreenAction*{.final.} = object
theType*: int8
flags*: int8
screenXXX*: int8
{.deprecated: [TXkbSwitchScreenAction: XkbSwitchScreenAction].}
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
{.deprecated: [TXkbCtrlsAction: XkbCtrlsAction].}
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]
{.deprecated: [TXkbMessageAction: XkbMessageAction].}
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
{.deprecated: [TXkbRedirectKeyAction: XkbRedirectKeyAction].}
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
{.deprecated: [TXkbDeviceBtnAction: XkbDeviceBtnAction].}
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
{.deprecated: [TXkbDeviceValuatorAction: XkbDeviceValuatorAction].}
const
XkbAnyActionDataSize* = 7
type
PXkbAnyAction* = ptr XkbAnyAction
XkbAnyAction*{.final.} = object
theType*: int8
data*: array[0..XkbAnyActionDataSize - 1, int8]
{.deprecated: [TXkbAnyAction: XkbAnyAction].}
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
{.deprecated: [TXkbAction: XkbAction].}
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]
{.deprecated: [TXkbControlsRec: XkbControlsRec].}
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
{.deprecated: [TXkbServerMapRec: XkbServerMapRec].}
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
{.deprecated: [TXkbSymMapRec: XkbSymMapRec].}
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
{.deprecated: [TXkbClientMapRec: XkbClientMapRec].}
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
{.deprecated: [TXkbSymInterpretRec: XkbSymInterpretRec].}
type
PXkbCompatMapPtr* = ptr XkbCompatMapRec
XkbCompatMapRec*{.final.} = object
sym_interpret*: PXkbSymInterpretPtr
groups*: array[0..XkbNumKbdGroups - 1, XkbModsRec]
num_si*: int16
size_si*: int16
{.deprecated: [TXkbCompatMapRec: XkbCompatMapRec].}
type
PXkbIndicatorMapPtr* = ptr XkbIndicatorMapRec
XkbIndicatorMapRec*{.final.} = object
flags*: int8
which_groups*: int8
groups*: int8
which_mods*: int8
mods*: XkbModsRec
ctrls*: int16
{.deprecated: [TXkbIndicatorMapRec: XkbIndicatorMapRec].}
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]
{.deprecated: [TXkbIndicatorRec: XkbIndicatorRec].}
type
PXkbKeyNamePtr* = ptr XkbKeyNameRec
XkbKeyNameRec*{.final.} = object
name*: array[0..XkbKeyNameLength - 1, char]
{.deprecated: [TXkbKeyNameRec: XkbKeyNameRec].}
type
PXkbKeyAliasPtr* = ptr XkbKeyAliasRec
XkbKeyAliasRec*{.final.} = object #
# Names for everything
#
real*: array[0..XkbKeyNameLength - 1, char]
alias*: array[0..XkbKeyNameLength - 1, char]
{.deprecated: [TXkbKeyAliasRec: XkbKeyAliasRec].}
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
{.deprecated: [TXkbNamesRec: XkbNamesRec].}
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
{.deprecated: [TXkbPropertyRec: XkbPropertyRec].}
type
PXkbColorPtr* = ptr XkbColorRec
XkbColorRec*{.final.} = object
pixel*: int16
spec*: cstring
{.deprecated: [TXkbColorRec: XkbColorRec].}
type
PXkbPointPtr* = ptr XkbPointRec
XkbPointRec*{.final.} = object
x*: int16
y*: int16
{.deprecated: [TXkbPointRec: XkbPointRec].}
type
PXkbBoundsPtr* = ptr XkbBoundsRec
XkbBoundsRec*{.final.} = object
x1*: int16
y1*: int16
x2*: int16
y2*: int16
{.deprecated: [TXkbBoundsRec: XkbBoundsRec].}
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
{.deprecated: [TXkbOutlineRec: XkbOutlineRec].}
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
{.deprecated: [TXkbShapeRec: XkbShapeRec].}
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
{.deprecated: [TXkbShapeDoodadRec: XkbShapeDoodadRec].}
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
{.deprecated: [TXkbTextDoodadRec: XkbTextDoodadRec].}
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
{.deprecated: [TXkbIndicatorDoodadRec: XkbIndicatorDoodadRec].}
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
{.deprecated: [TXkbLogoDoodadRec: XkbLogoDoodadRec].}
type
PXkbAnyDoodadPtr* = ptr XkbAnyDoodadRec
XkbAnyDoodadRec*{.final.} = object
name*: Atom
theType*: int8
priority*: int8
top*: int16
left*: int16
angle*: int16
{.deprecated: [TXkbAnyDoodadRec: XkbAnyDoodadRec].}
type
PXkbDoodadPtr* = ptr XkbDoodadRec
XkbDoodadRec*{.final.} = object
any*: XkbAnyDoodadRec
shape*: XkbShapeDoodadRec
text*: XkbTextDoodadRec
indicator*: XkbIndicatorDoodadRec
logo*: XkbLogoDoodadRec
{.deprecated: [TXkbDoodadRec: XkbDoodadRec].}
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
{.deprecated: [TXkbKeyRec: XkbKeyRec].}
type
PXkbRowPtr* = ptr XkbRowRec
XkbRowRec*{.final.} = object
top*: int16
left*: int16
num_keys*: int16
sz_keys*: int16
vertical*: int16
Keys*: PXkbKeyPtr
bounds*: XkbBoundsRec
{.deprecated: [TXkbRowRec: XkbRowRec].}
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
{.deprecated: [TXkbSectionRec: XkbSectionRec].}
{.deprecated: [TXkbOverlayKeyRec: XkbOverlayKeyRec].}
{.deprecated: [TXkbOverlayRowRec: XkbOverlayRowRec].}
{.deprecated: [TXkbOverlayRec: XkbOverlayRec].}
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]
{.deprecated: [TXkbGeometryRec: XkbGeometryRec].}
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
{.deprecated: [TXkbGeometrySizesRec: XkbGeometrySizesRec].}
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
{.deprecated: [TXkbDescRec: XkbDescRec].}
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
{.deprecated: [TXkbMapChangesRec: XkbMapChangesRec].}
type
PXkbControlsChangesPtr* = ptr XkbControlsChangesRec
XkbControlsChangesRec*{.final.} = object
changed_ctrls*: int16
enabled_ctrls_changes*: int16
num_groups_changed*: bool
{.deprecated: [TXkbControlsChangesRec: XkbControlsChangesRec].}
type
PXkbIndicatorChangesPtr* = ptr XkbIndicatorChangesRec
XkbIndicatorChangesRec*{.final.} = object
state_changes*: int16
map_changes*: int16
{.deprecated: [TXkbIndicatorChangesRec: XkbIndicatorChangesRec].}
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
{.deprecated: [TXkbNameChangesRec: XkbNameChangesRec].}
type
PXkbCompatChangesPtr* = ptr XkbCompatChangesRec
XkbCompatChangesRec*{.final.} = object
changed_groups*: int8
first_si*: int16
num_si*: int16
{.deprecated: [TXkbCompatChangesRec: XkbCompatChangesRec].}
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
{.deprecated: [TXkbChangesRec: XkbChangesRec].}
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
{.deprecated: [TXkbComponentNamesRec: XkbComponentNamesRec].}
type
PXkbComponentNamePtr* = ptr XkbComponentNameRec
XkbComponentNameRec*{.final.} = object
flags*: int16
name*: cstring
{.deprecated: [TXkbComponentNameRec: XkbComponentNameRec].}
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
{.deprecated: [TXkbComponentListRec: XkbComponentListRec].}
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]
{.deprecated: [TXkbDeviceLedInfoRec: XkbDeviceLedInfoRec].}
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
{.deprecated: [TXkbDeviceInfoRec: XkbDeviceInfoRec].}
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
{.deprecated: [TXkbDeviceChangesRec: XkbDeviceChangesRec].}
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[ByteAddress](o) - cast[ByteAddress](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[ByteAddress](c) - cast[ByteAddress](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[ByteAddress](s) - cast[ByteAddress](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[ByteAddress](c) - cast[ByteAddress](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[ByteAddress](c) - cast[ByteAddress](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[ByteAddress](c) - cast[ByteAddress](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[ByteAddress](s) - (cast[ByteAddress](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[ByteAddress](c) - cast[ByteAddress](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[ByteAddress](s) - cast[ByteAddress](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[ByteAddress](s) - cast[ByteAddress](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[ByteAddress](c) - cast[ByteAddress](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[ByteAddress](c) - (cast[ByteAddress](addr(g.colors[0])))) div sizeof(XkbColorRec))
proc xkb_keysym_get_name*( keysym: xkb_keysym_t
, buffer: cstring
, size: csize_t
): int {.importc, cdecl.}