vYxFfwcuKvCGlozZ7mzoMPwrsonTwoIS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_delay;
	unsigned short	debounce_delay;
	unsigned short	mk_delay;
	unsigned short	mk_interval;
	unsigned short	mk_time_to_max;
	unsigned short	mk_max_speed;
		 short	mk_curve;
	unsigned short	ax_options;
	unsigned short	ax_timeout;
	unsigned short	axt_opts_mask;
	unsigned short	axt_opts_values;
	unsigned int	axt_ctrls_mask;
	unsigned int	axt_ctrls_values;
	unsigned char	per_key_repeat[XkbPerKeyBitArraySize];
} XkbControlsRec, *XkbControlsPtr;

#define	XkbAX_AnyFeedback(c)	((c)->enabled_ctrls&XkbAccessXFeedbackMask)
#define	XkbAX_NeedOption(c,w)	((c)->ax_options&(w))
#define	XkbAX_NeedFeedback(c,w)	(XkbAX_AnyFeedback(c)&&XkbAX_NeedOption(c,w))

typedef struct _XkbServerMapRec {
	unsigned short		 num_acts;
	unsigned short		 size_acts;
	XkbAction		*acts;

	XkbBehavior		*behaviors;
	unsigned short		*key_acts;
#if defined(__cplusplus) || defined(c_plusplus)
	/* explicit is a C++ reserved word */
	unsigned char		*c_explicit;
#else
	unsigned char		*explicit;
#endif
	unsigned char		 vmods[XkbNumVirtualMods];
	unsigned short		*vmodmap;
} XkbServerMapRec, *XkbServerMapPtr;

#define	XkbSMKeyActionsPtr(m,k) (&(m)->acts[(m)->key_acts[k]])

	/*
	 * Structures and access macros used primarily by clients
	 */

typedef	struct _XkbSymMapRec {
	unsigned char	 kt_index[XkbNumKbdGroups];
	unsigned char	 group_info;
	unsigned char	 width;
	unsigned short	 offset;
} XkbSymMapRec, *XkbSymMapPtr;

typedef struct _XkbClientMapRec {
	unsigned char		 size_types;
	unsigned char		 num_types;
	XkbKeyTypePtr		 types;

	unsigned short		 size_syms;
	unsigned short		 num_syms;
	KeySym			*syms;
	XkbSymMapPtr		 key_sym_map;

	unsigned char		*modmap;
} XkbClientMapRec, *XkbClientMapPtr;

#define	XkbCMKeyGroupInfo(m,k)  ((m)->key_sym_map[k].group_info)
#define	XkbCMKeyNumGroups(m,k)	 (XkbNumGroups((m)->key_sym_map[k].group_info))
#define	XkbCMKeyGroupWidth(m,k,g) (XkbCMKeyType(m,k,g)->num_levels)
#define	XkbCMKeyGroupsWidth(m,k) ((m)->key_sym_map[k].width)
#define	XkbCMKeyTypeIndex(m,k,g) ((m)->key_sym_map[k].kt_index[g&0x3])
#define	XkbCMKeyType(m,k,g)	 (&(m)->types[XkbCMKeyTypeIndex(m,k,g)])
#define	XkbCMKeyNumSyms(m,k) (XkbCMKeyGroupsWidth(m,k)*XkbCMKeyNumGroups(m,k))
#define	XkbCMKeySymsOffset(m,k)	((m)->key_sym_map[k].offset)
#define	XkbCMKeySymsPtr(m,k)	(&(m)->syms[XkbCMKeySymsOffset(m,k)])

	/*
	 * Compatibility structures and access macros
	 */

typedef struct _XkbSymInterpretRec {
	KeySym		sym;
	unsigned char	flags;
	unsigned char	match;
	unsigned char	mods;
	unsigned char	virtual_mod;
	XkbAnyAction	act;
} XkbSymInterpretRec,*XkbSymInterpretPtr;

typedef struct _XkbCompatMapRec {
	XkbSymInterpretPtr	 sym_interpret;
	XkbModsRec		 groups[XkbNumKbdGroups];
	unsigned short		 num_si;
	unsigned short		 size_si;
} XkbCompatMapRec, *XkbCompatMapPtr;

typedef struct _XkbIndicatorMapRec {
	unsigned char	flags;
	unsigned char	which_groups;
	unsigned char	groups;
	unsigned char	which_mods;
	XkbModsRec	mods;
	unsigned int	ctrls;
} XkbIndicatorMapRec, *XkbIndicatorMapPtr;

#define	XkbIM_IsAuto(i)	((((i)->flags&XkbIM_NoAutomatic)==0)&&\
			    (((i)->which_groups&&(i)->groups)||\
			     ((i)->which_mods&&(i)->mods.mask)||\
			     ((i)->ctrls)))
#define	XkbIM_InUse(i)	(((i)->flags)||((i)->which_groups)||\
					((i)->which_mods)||((i)->ctrls))
	

typedef struct _XkbIndicatorRec {
	unsigned long	  	phys_indicators;
	XkbIndicatorMapRec	maps[XkbNumIndicators];
} XkbIndicatorRec,*XkbIndicatorPtr;

typedef	struct _XkbKeyNameRec {
	char	name[XkbKeyNameLength];
} XkbKeyNameRec,*XkbKeyNamePtr;

typedef struct _XkbKeyAliasRec {
	char	real[XkbKeyNameLength];
	char	alias[XkbKeyNameLength];
} XkbKeyAliasRec,*XkbKeyAliasPtr;

	/*
	 * Names for everything 
	 */
typedef struct _XkbNamesRec {
	Atom		  keycodes;
	Atom		  geometry;
	Atom		  symbols;
	Atom              types;
	Atom		  compat;
	Atom		  vmods[XkbNumVirtualMods];
	Atom		  indicators[XkbNumIndicators];
	Atom		  groups[XkbNumKbdGroups];
	XkbKeyNamePtr	  keys;
	XkbKeyAliasPtr	  key_aliases;
	Atom		 *radio_groups;
	Atom		  phys_symbols;

	unsigned char	  num_keys;
	unsigned char	  num_key_aliases;
	unsigned short	  num_rg;
} XkbNamesRec,*XkbNamesPtr;

typedef	struct _XkbGeometry	*XkbGeometryPtr;
	/*
	 * Tie it all together into one big keyboard description
	 */
typedef	struct _XkbDesc {
	struct _XDisplay *	dpy;
	unsigned short	 	flags;
	unsigned short		device_spec;
	KeyCode			min_key_code;
	KeyCode			max_key_code;

	XkbControlsPtr		ctrls;
	XkbServerMapPtr		server;
	XkbClientMapPtr		map;
	XkbIndicatorPtr		indicators;
	XkbNamesPtr		names;
	XkbCompatMapPtr		compat;
	XkbGeometryPtr		geom;
} XkbDescRec, *XkbDescPtr;
#define	XkbKeyKeyTypeIndex(d,k,g)	(XkbCMKeyTypeIndex((d)->map,k,g))
#define	XkbKeyKeyType(d,k,g)		(XkbCMKeyType((d)->map,k,g))
#define	XkbKeyGroupWidth(d,k,g)		(XkbCMKeyGroupWidth((d)->map,k,g))
#define	XkbKeyGroupsWidth(d,k)		(XkbCMKeyGroupsWidth((d)->map,k))
#define	XkbKeyGroupInfo(d,k)		(XkbCMKeyGroupInfo((d)->map,(k)))
#define	XkbKeyNumGroups(d,k)		(XkbCMKeyNumGroups((d)->map,(k)))
#define	XkbKeyNumSyms(d,k)		(XkbCMKeyNumSyms((d)->map,(k)))
#define	XkbKeySymsPtr(d,k)		(XkbCMKeySymsPtr((d)->map,(k)))
#define	XkbKeySym(d,k,n)		(XkbKeySymsPtr(d,k)[n])
#define	XkbKeySymEntry(d,k,sl,g) \
	(XkbKeySym(d,k,((XkbKeyGroupsWidth(d,k)*(g))+(sl))))
#define	XkbKeyAction(d,k,n) \
	(XkbKeyHasActions(d,k)?&XkbKeyActionsPtr(d,k)[n]:NULL)
#define	XkbKeyActionEntry(d,k,sl,g) \
	(XkbKeyHasActions(d,k)?\
		XkbKeyAction(d,k,((XkbKeyGroupsWidth(d,k)*(g))+(sl))):NULL)

#define	XkbKeyHasActions(d,k)	((d)->server->key_acts[k]!=0)
#define	XkbKeyNumActions(d,k)	(XkbKeyHasActions(d,k)?XkbKeyNumSyms(d,k):1)
#define	XkbKeyActionsPtr(d,k)	(XkbSMKeyActionsPtr((d)->server,k))
#define	XkbKeycodeInRange(d,k)	(((k)>=(d)->min_key_code)&&\
				 ((k)<=(d)->max_key_code))
#define	XkbNumKeys(d)		((d)->max_key_code-(d)->min_key_code+1)


	/*
	 * The following structures can be used to track changes
	 * to a keyboard device
	 */
typedef struct _XkbMapChanges {
	unsigned short		 changed;
	KeyCode			 min_key_code;
	KeyCode			 max_key_code;
	unsigned char		 first_type;
	unsigned char		 num_types;
	KeyCode			 first_key_sym;
	unsigned char		 num_key_syms;
	KeyCode			 first_key_act;
	unsigned char		 num_key_acts;
	KeyCode			 first_key_behavior;
	unsigned char		 num_key_behaviors;
	KeyCode 		 first_key_explicit;
	unsigned char		 num_key_explicit;
	KeyCode			 first_modmap_key;
	unsigned char		 num_modmap_keys;
	KeyCode			 first_vmodmap_key;
	unsigned char		 num_vmodmap_keys;
	unsigned char		 pad;
	unsigned short		 vmods;
} XkbMapChangesRec,*XkbMapChangesPtr;

typedef struct _XkbControlsChanges {
	unsigned int 		 changed_ctrls;
	unsigned int		 enabled_ctrls_changes;
	Bool			 num_groups_changed;
} XkbControlsChangesRec,*XkbControlsChangesPtr;

typedef struct _XkbIndicatorChanges {
	unsigned int		 state_changes;
	unsigned int		 map_changes;
} XkbIndicatorChangesRec,*XkbIndicatorChangesPtr;

typedef struct _XkbNameChanges {
	unsigned int 		changed;
	unsigned char		first_type;
	unsigned char		num_types;
	unsigned char		first_lvl;
	unsigned char		num_lvls;
	unsigned char		num_aliases;
	unsigned char		num_rg;
	unsigned char		first_key;
	unsigned char		num_keys;
	unsigned short		changed_vmods;
	unsigned long		changed_indicators;
	unsigned char		changed_groups;
} XkbNameChangesRec,*XkbNameChangesPtr;

typedef struct _XkbCompatChanges {
	unsigned char		changed_groups;
	unsigned short		first_si;
	unsigned short		num_si;
} XkbCompatChangesRec,*XkbCompatChangesPtr;

typedef struct _XkbChanges {
	unsigned short		 device_spec;
	unsigned short		 state_changes;
	XkbMapChangesRec	 map;
	XkbControlsChangesRec	 ctrls;
	XkbIndicatorChangesRec	 indicators;
	XkbNameChangesRec	 names;
	XkbCompatChangesRec	 compat;
} XkbChangesRec, *XkbChangesPtr;

	/*
	 * These data structures are used to construct a keymap from 
	 * a set of components or to list components in the server
	 * database.
	 */
typedef struct _XkbComponentNames {
	char *			 keymap;
	char *			 keycodes;
	char *			 types;
	char *			 compat;
	char *			 symbols;
	char *			 geometry;
} XkbComponentNamesRec, *XkbComponentNamesPtr;

typedef struct _XkbComponentName {
	unsigned short		flags;
	char *			name;
} XkbComponentNameRec,*XkbComponentNamePtr;

typedef struct _XkbComponentList {
	int			num_keymaps;
	int			num_keycodes;
	int			num_types;
	int			num_compat;
	int			num_symbols;
	int			num_geometry;
	XkbComponentNamePtr	keymaps;
	XkbComponentNamePtr 	keycodes;
	XkbComponentNamePtr	types;
	XkbComponentNamePtr	compat;
	XkbComponentNamePtr	symbols;
	XkbComponentNamePtr	geometry;
} XkbComponentListRec, *XkbComponentListPtr;

	/*
	 * The following data structures describe and track changes to a 
	 * non-keyboard extension device 
	 */
typedef struct _XkbDeviceLedInfo {
	unsigned short			led_class;
	unsigned short			led_id;
	unsigned int			phys_indicators;
	unsigned int			maps_present;
	unsigned int			names_present;
	unsigned int			state;
	Atom 				names[XkbNumIndicators];
	XkbIndicatorMapRec		maps[XkbNumIndicators];
} XkbDeviceLedInfoRec,*XkbDeviceLedInfoPtr;

typedef struct _XkbDeviceInfo {
	char *			name;
	Atom			type;
	unsigned short		device_spec;
	Bool			has_own_state;
	unsigned short		supported;
	unsigned short		unsupported;

	unsigned short		num_btns;
	XkbAction *		btn_acts;

	unsigned short		sz_leds;
	unsigned short		num_leds;
	unsigned short		dflt_kbd_fb;
	unsigned short		dflt_led_fb;
	XkbDeviceLedInfoPtr	leds;
} XkbDeviceInfoRec,*XkbDeviceInfoPtr;

#define	XkbXI_DevHasBtnActs(d)	(((d)->num_btns>0)&&((d)->btn_acts!=NULL))
#define	XkbXI_LegalDevBtn(d,b)	(XkbXI_DevHasBtnActs(d)&&((b)<(d)->num_btns))
#define	XkbXI_DevHasLeds(d)	(((d)->num_leds>0)&&((d)->leds!=NULL))

typedef struct _XkbDeviceLedChanges {
	unsigned short		led_class;
	unsigned short		led_id;
	unsigned int		defined; /* names or maps changed */
	struct _XkbDeviceLedChanges *next;
} XkbDeviceLedChangesRec,*XkbDeviceLedChangesPtr;

typedef struct _XkbDeviceChanges {
	unsigned int		changed;
	unsigned short		first_btn;
	unsigned short		num_btns;
	XkbDeviceLedChangesRec 	leds;
} XkbDeviceChangesRec,*XkbDeviceChangesPtr;

#endif /* _XKBSTR_H_ */