summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authordawes <dawes>1996-03-04 04:19:15 +0000
committerdawes <dawes>1996-03-04 04:19:15 +0000
commit452696362c65cbc2e1a28ebaf4cc3cda51768cdb (patch)
tree8af6c55ab1e113b3b1ecb9715f4623d34a0f8b0d
parentda54b06c97668c57466ee892cdfc1dbbae5560b1 (diff)
updates
Diffstat
-rw-r--r--Imakefile5
-rw-r--r--Makefile4
-rw-r--r--lib/X11/XKBBind.c665
-rw-r--r--lib/X11/XKBCompat.c314
-rw-r--r--lib/X11/XKBCvt.c63
-rw-r--r--lib/X11/XKBMAlloc.c222
-rw-r--r--lib/X11/XKBMisc.c22
-rw-r--r--lib/X11/XKBSetGeom.c2
-rw-r--r--lib/X11/XKBSetMap.c652
-rw-r--r--lib/X11/XKBUse.c420
-rw-r--r--lib/X11/XKBlib.h1270
-rw-r--r--lib/xkbfile/XKBfile.h19
12 files changed, 2638 insertions, 1020 deletions
diff --git a/Imakefile b/Imakefile
index 12851b023..b9489d46b 100644
--- a/Imakefile
+++ b/Imakefile
@@ -1,5 +1,5 @@
XCOMM $XConsortium: Imakefile /main/135 1996/02/02 19:03:12 gildea $
-XCOMM $XFree86: xc/Imakefile,v 3.8 1996/01/21 01:47:05 dawes Exp $
+XCOMM $XFree86: xc/Imakefile,v 3.9 1996/02/10 10:35:13 dawes Exp $
#define IHaveSubdirs
#define PassCDebugFlags CDEBUGFLAGS="$(CDEBUGFLAGS)"
@@ -57,6 +57,9 @@ clean::
MAKE_OPTS = -f xmakefile
+World::
+ $(MAKE) $(MFLAGS) $(MAKE_OPTS) $(PARALLELOPTS) all
+
Everything::
@echo ""
@echo Rebuilding $(RELEASE) of the X Window System.
diff --git a/Makefile b/Makefile
index 39c4964ac..b42a30e51 100644
--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,5 @@
# $XConsortium: Makefile /main/33 1996/02/02 19:03:18 gildea $
-# $XFree86: xc/Makefile,v 3.3 1996/01/24 21:51:40 dawes Exp $
+# $XFree86: xc/Makefile,v 3.4 1996/02/10 10:35:14 dawes Exp $
# Luna users will need to either run make as "make MAKE=make"
# or add "MAKE = make" to this file.
@@ -53,7 +53,7 @@ World:
$(MAKE_CMD) $(MFLAGS) clean BOOTSTRAPSUBDIRS=
$(MAKE_CMD) $(MFLAGS) includes
$(MAKE_CMD) $(MFLAGS) depend
- $(MAKE_CMD) $(MFLAGS) $(WORLDOPTS)
+ $(MAKE_CMD) $(MFLAGS) $(WORLDOPTS) World
@echo ""
@date
@echo ""
diff --git a/lib/X11/XKBBind.c b/lib/X11/XKBBind.c
index 977bc6b16..4803dcc40 100644
--- a/lib/X11/XKBBind.c
+++ b/lib/X11/XKBBind.c
@@ -1,4 +1,4 @@
-/* $XConsortium: XKBBind.c,v 1.8 94/04/17 20:21:34 erik Exp $ */
+/* $XConsortium: XKBBind.c /main/19 1996/03/01 14:29:21 kaleb $ */
/*
Copyright (c) 1985, 1987, 1994 X Consortium
@@ -28,8 +28,7 @@ other dealings in this Software without prior written authorization
from the X Consortium.
*/
-
-/* Beware, here be monsters (still under construction... - JG */
+ /* the new monsters ate the old ones */
#define NEED_EVENTS
#include <X11/Xlibint.h>
@@ -42,18 +41,34 @@ from the X Consortium.
#include <X11/extensions/XKBproto.h>
#include "XKBlibint.h"
-#if defined(__sgi) && defined(USE_OWN_COMPOSE)
+#ifdef USE_OWN_COMPOSE
+#define COMPOSE_NO_CONST_MEMBERS
+#include "imComp.h"
+#endif
+
+#ifdef USE_SGI_COMPOSE_SUPPORT
#define COMPOSE_NO_CONST_MEMBERS
+#define USE_OWN_COMPOSE
#include "Compose.h"
+#define XimCompInitTables ComposeInitTables
+#define XimCompLegalStatus ComposeLegalStatus
+#define XimCompIsComposeKey IsComposeKey
+#define XimCompRtrn ComposeRtrn
+#define XimCompProcessSym ComposeProcessSym
+#define XIM_COMP_IGNORE COMPOSE_IGNORE
+#define XIM_COMP_IN_PROGRESS COMPOSE_IN_PROGRESS
+#define XIM_COMP_FAIL COMPOSE_FAIL
+#define XIM_COMP_SUCCEED COMPOSE_SUCCEED
#endif
#define AllMods (ShiftMask|LockMask|ControlMask| \
Mod1Mask|Mod2Mask|Mod3Mask|Mod4Mask|Mod5Mask)
-#define Is_KP_Keysym(k) ((((k) >= XK_KP_0) && ((k) <= XK_KP_9)) || \
- ((k) == XK_KP_Decimal) || ((k)==XK_KP_Separator))
-
-static int _XkbLoadDpy();
+static int _XkbLoadDpy(
+#if NeedFunctionPrototypes
+ Display *dpy
+#endif
+);
struct _XKeytrans {
struct _XKeytrans *next;/* next on list */
@@ -65,22 +80,52 @@ struct _XKeytrans {
int mlen; /* length of modifier list */
};
-#define XKB_UNAVAILABLE(d) \
- (((d)->flags&XlibDisplayNoXkb) ||\
- ((!(d)->xkb_info || (!(d)->xkb_info->desc)) && !_XkbLoadDpy(d)))
-
-#define CHECK_PENDING_REFRESH(d) {\
- if ((d)->xkb_info->flags&XkbMapPending) {\
- if (XkbRefreshMap(dpy,(d)->xkb_info->desc, &dpy->xkb_info->changes)) {\
- LockDisplay(dpy);\
- dpy->xkb_info->changes.changed= 0;\
- UnlockDisplay(dpy);\
- }\
- }\
+KeySym
+#if NeedFunctionPrototypes
+XkbKeycodeToKeysym(Display *dpy,
+#if NeedWidePrototypes
+ unsigned int kc,
+#else
+ KeyCode kc,
+#endif
+ int group,
+ int level)
+#else
+XkbKeycodeToKeysym(dpy, kc, group, level)
+ Display *dpy;
+ KeyCode kc;
+ int group;
+ int level;
+#endif
+{
+ XkbDescRec *xkb;
+
+ if (_XkbUnavailable(dpy))
+ return NoSymbol;
+
+ _XkbCheckPendingRefresh(dpy,dpy->xkb_info);
+
+ xkb = dpy->xkb_info->desc;
+ if ((kc<xkb->min_key_code)||(kc>xkb->max_key_code))
+ return NoSymbol;
+
+ if ((group<0)||(level<0)||(group>=XkbKeyNumGroups(xkb,kc)))
+ return NoSymbol;
+ if (level>=XkbKeyGroupWidth(xkb,kc,group)) {
+ /* for compatibility with the core protocol, _always_ allow */
+ /* two symbols in the first two groups. If either of the */
+ /* two is of type ONE_LEVEL, just replicate the first symbol */
+ if ((group>XkbGroup2Index)||(XkbKeyGroupWidth(xkb,kc,group)!=1)||
+ (level!=1)) {
+ return NoSymbol;
+ }
+ level= 0;
+ }
+ return XkbKeySymEntry(xkb,kc,level,group);
}
-#if NeedFunctionPrototypes
KeySym
+#if NeedFunctionPrototypes
XKeycodeToKeysym(Display *dpy,
#if NeedWidePrototypes
unsigned int kc,
@@ -89,41 +134,68 @@ XKeycodeToKeysym(Display *dpy,
#endif
int col)
#else
-KeySym
XKeycodeToKeysym(dpy, kc, col)
Display *dpy;
KeyCode kc;
int col;
#endif
{
- int offset;
XkbDescRec *xkb;
- if (XKB_UNAVAILABLE(dpy))
- return _XKeycodeToKeysym(dpy,kc,col);
+ if (_XkbUnavailable(dpy))
+ return _XKeycodeToKeysym(dpy, kc, col);
- CHECK_PENDING_REFRESH(dpy);
+ _XkbCheckPendingRefresh(dpy,dpy->xkb_info);
xkb = dpy->xkb_info->desc;
if ((kc<xkb->min_key_code)||(kc>xkb->max_key_code))
return NoSymbol;
-
- if (( col<0 ) || (col>=(int)XkbKeyNumSyms(xkb,kc)))
- return NoSymbol;
- return XkbKeySym(xkb,kc,col);
+ if (col>3) {
+ int lastSym,tmp,nGrp;
+
+ lastSym= 3;
+ nGrp= XkbKeyNumGroups(xkb,kc);
+ if ((nGrp>0)&&((tmp=XkbKeyGroupWidth(xkb,kc,XkbGroup1Index))>2)) {
+ if (col<=(lastSym+tmp-2))
+ return XkbKeycodeToKeysym(dpy,kc,XkbGroup1Index,col-lastSym+2);
+ lastSym+= tmp-2;
+ }
+ if ((nGrp>1)&&((tmp=XkbKeyGroupWidth(xkb,kc,XkbGroup2Index))>2)) {
+ if (col<=(lastSym+tmp-2))
+ return XkbKeycodeToKeysym(dpy,kc,XkbGroup2Index,col-lastSym+2);
+ lastSym+= tmp-2;
+ }
+ if (nGrp>2) {
+ tmp= XkbKeyGroupWidth(xkb,kc,XkbGroup3Index);
+ if (col<=lastSym+tmp)
+ return XkbKeycodeToKeysym(dpy,kc,XkbGroup3Index,col-lastSym);
+ lastSym+= tmp;
+ }
+ if (nGrp>3) {
+ tmp= XkbKeyGroupWidth(xkb,kc,XkbGroup4Index);
+ if (col<=lastSym+tmp)
+ return XkbKeycodeToKeysym(dpy,kc,XkbGroup4Index,col-lastSym);
+ }
+ return NoSymbol;
+ }
+ return XkbKeycodeToKeysym(dpy,kc,(col>>1),(col&1));
}
KeyCode
+#if NeedFunctionPrototypes
+XKeysymToKeycode(Display *dpy, KeySym ks)
+#else
XKeysymToKeycode(dpy, ks)
Display *dpy;
KeySym ks;
+#endif
{
register int i, j, gotOne;
- if (XKB_UNAVAILABLE(dpy))
+ if (_XkbUnavailable(dpy))
return _XKeysymToKeycode(dpy,ks);
- CHECK_PENDING_REFRESH(dpy);
+ _XkbCheckPendingRefresh(dpy,dpy->xkb_info);
j= 0;
do {
@@ -142,50 +214,40 @@ XKeysymToKeycode(dpy, ks)
}
static int
+#if NeedFunctionPrototypes
+_XkbComputeModmap(Display *dpy)
+#else
_XkbComputeModmap(dpy)
Display *dpy;
+#endif
{
-XModifierKeymap *modmap;
-
- if (!dpy->xkb_info) return 0;
- if (dpy->xkb_info->modmap) return 1;
- dpy->xkb_info->modmap= (char *)Xmalloc(dpy->xkb_info->desc->max_key_code+1);
- if (!dpy->xkb_info->modmap) return 0;
- bzero(dpy->xkb_info->modmap,dpy->xkb_info->desc->max_key_code+1);
- modmap = XGetModifierMapping(dpy);
- if (modmap) {
- register int m,k;
- KeyCode *map;
- map= modmap->modifiermap;
- for (m=0;m<8;m++) {
- for (k=0;k<modmap->max_keypermod;k++,map++) {
- if (((*map)>=dpy->xkb_info->desc->min_key_code)&&
- ((*map)<=dpy->xkb_info->desc->max_key_code)) {
- dpy->xkb_info->modmap[*map]|= (1<<m);
- }
- }
- }
- XFreeModifiermap(modmap);
+register XkbDescPtr xkb;
+
+ xkb= dpy->xkb_info->desc;
+ if (XkbGetUpdatedMap(dpy,XkbModifierMapMask,xkb)==Success)
return 1;
- }
return 0;
}
unsigned
+#if NeedFunctionPrototypes
+XkbKeysymToModifiers(Display *dpy,KeySym ks)
+#else
XkbKeysymToModifiers(dpy,ks)
Display *dpy;
KeySym ks;
+#endif
{
XkbDescRec *xkb;
register int i,j;
register KeySym *pSyms;
CARD8 mods;
- if (XKB_UNAVAILABLE(dpy))
+ if (_XkbUnavailable(dpy))
return _XKeysymToModifiers(dpy,ks);
- CHECK_PENDING_REFRESH(dpy);
+ _XkbCheckPendingRefresh(dpy,dpy->xkb_info);
- if ((!dpy->xkb_info->modmap)&&(!_XkbComputeModmap(dpy)))
+ if (_XkbNeedModmap(dpy->xkb_info)&&(!_XkbComputeModmap(dpy)))
return _XKeysymToModifiers(dpy,ks);
xkb= dpy->xkb_info->desc;
@@ -194,7 +256,7 @@ XkbKeysymToModifiers(dpy,ks)
pSyms= XkbKeySymsPtr(xkb,i);
for (j=XkbKeyNumSyms(xkb,i)-1;j>=0;j--) {
if (pSyms[j]==ks) {
- mods|= dpy->xkb_info->modmap[i];
+ mods|= xkb->map->modmap[i];
break;
}
}
@@ -203,71 +265,129 @@ XkbKeysymToModifiers(dpy,ks)
}
KeySym
+#if NeedFunctionPrototypes
+XLookupKeysym(register XKeyEvent *event, int col)
+#else
XLookupKeysym(event, col)
register XKeyEvent *event;
int col;
+#endif
{
Display *dpy = event->display;
- if (XKB_UNAVAILABLE(dpy))
+ if (_XkbUnavailable(dpy))
return _XLookupKeysym(event, col);
- CHECK_PENDING_REFRESH(dpy);
+ _XkbCheckPendingRefresh(dpy,dpy->xkb_info);
return XKeycodeToKeysym(dpy, event->keycode, col);
}
-#define XkbModifiersGroup(m) (((m)>>13)&0x7)
-
+ /*
+ * Not a public entry point -- XkbTranslateKey is an obsolete name
+ * that is preserved here so that functions linked against the old
+ * version will continue to work in a shared library environment.
+ */
int
-XkbTranslateKey(dpy, keycode, modifiers, modifiers_return, keysym_return)
+#if NeedFunctionPrototypes
+XkbTranslateKey( register Display * dpy,
+ KeyCode key,
+ register unsigned int mods,
+ unsigned int * mods_rtrn,
+ KeySym * keysym_rtrn)
+#else
+XkbTranslateKey(dpy, key, mods, mods_rtrn, keysym_rtrn)
+ register Display *dpy;
+ KeyCode key;
+ register unsigned int mods;
+ unsigned int *mods_rtrn;
+ KeySym *keysym_rtrn;
+#endif
+{
+ return XkbLookupKeySym(dpy,key,mods,mods_rtrn,keysym_rtrn);
+}
+
+Bool
+#if NeedFunctionPrototypes
+XkbLookupKeySym( register Display * dpy,
+ KeyCode key,
+ register unsigned int mods,
+ unsigned int * mods_rtrn,
+ KeySym * keysym_rtrn)
+#else
+XkbLookupKeySym(dpy, key, mods, mods_rtrn, keysym_rtrn)
register Display *dpy;
- KeyCode keycode;
- register unsigned int modifiers;
- unsigned int *modifiers_return;
- KeySym *keysym_return;
+ KeyCode key;
+ register unsigned int mods;
+ unsigned int *mods_rtrn;
+ KeySym *keysym_rtrn;
+#endif
+{
+ if (_XkbUnavailable(dpy))
+ return _XTranslateKey(dpy, key, mods, mods_rtrn, keysym_rtrn);
+ _XkbCheckPendingRefresh(dpy,dpy->xkb_info);
+ return XkbTranslateKeyCode(dpy->xkb_info->desc,key,mods,mods_rtrn,
+ keysym_rtrn);
+}
+
+Bool
+#if NeedFunctionPrototypes
+XkbTranslateKeyCode( register XkbDescPtr xkb,
+ KeyCode key,
+ register unsigned int mods,
+ unsigned int * mods_rtrn,
+ KeySym * keysym_rtrn)
+#else
+XkbTranslateKeyCode(xkb, key, mods, mods_rtrn, keysym_rtrn)
+ register XkbDescPtr xkb;
+ KeyCode key;
+ register unsigned int mods;
+ unsigned int *mods_rtrn;
+ KeySym *keysym_rtrn;
+#endif
{
- register XkbInfoPtr xkb;
XkbKeyTypeRec *type;
- int col;
- unsigned preserve;
+ int col,nKeyGroups;
+ unsigned preserve,effectiveGroup;
KeySym *syms;
- if (XKB_UNAVAILABLE(dpy))
- return _XTranslateKey(dpy,keycode,modifiers,
- modifiers_return,keysym_return);
- CHECK_PENDING_REFRESH(dpy);
-
- if (modifiers_return!=NULL)
- *modifiers_return = modifiers;
- if (((int)keycode < dpy->min_keycode) || ((int)keycode > dpy->max_keycode))
- {
- if (keysym_return!=NULL)
- *keysym_return = NoSymbol;
- return 0;
- }
+ if (mods_rtrn!=NULL)
+ *mods_rtrn = 0;
- xkb= dpy->xkb_info;
+ nKeyGroups= XkbKeyNumGroups(xkb,key);
+ if ((!XkbKeycodeInRange(xkb,key))||(nKeyGroups==0)) {
+ if (keysym_rtrn!=NULL)
+ *keysym_rtrn = NoSymbol;
+ return False;
+ }
- /* find the row */
- syms = XkbKeySymsPtr(xkb->desc,keycode);
+ syms = XkbKeySymsPtr(xkb,key);
/* find the offset of the effective group */
col = 0;
- type = XkbKeyKeyType(xkb->desc,keycode);
- if ( XkbModifiersGroup(modifiers)!=0 ) {
- unsigned effectiveGroup = XkbModifiersGroup(modifiers);
- if ( effectiveGroup >= XkbKeyNumGroups(xkb->desc,keycode) ) {
- if ( XkbKeyGroupsWrap(xkb->desc,keycode) )
- effectiveGroup %= XkbKeyNumGroups(xkb->desc,keycode);
- else effectiveGroup = XkbKeyNumGroups(xkb->desc,keycode)-1;
+ effectiveGroup= XkbGroupForCoreState(mods);
+ if ( effectiveGroup>=nKeyGroups ) {
+ unsigned groupInfo= XkbKeyGroupInfo(xkb,key);
+ switch (XkbOutOfRangeGroupAction(groupInfo)) {
+ default:
+ effectiveGroup %= nKeyGroups;
+ break;
+ case XkbClampIntoRange:
+ effectiveGroup = nKeyGroups-1;
+ break;
+ case XkbRedirectIntoRange:
+ effectiveGroup = XkbOutOfRangeGroupNumber(groupInfo);
+ if (effectiveGroup>=nKeyGroups)
+ effectiveGroup= 0;
+ break;
}
- col= effectiveGroup*type->group_width;
}
+ col= effectiveGroup*XkbKeyGroupsWidth(xkb,key);
+ type = XkbKeyKeyType(xkb,key,effectiveGroup);
preserve= 0;
if (type->map) { /* find the column (shift level) within the group */
register int i;
register XkbKTMapEntryPtr entry;
for (i=0,entry=type->map;i<type->map_count;i++,entry++) {
- if ((entry->active)&&((modifiers&type->mask)==entry->mask)) {
+ if ((entry->active)&&((mods&type->mods.mask)==entry->mods.mask)) {
col+= entry->level;
if (type->preserve)
preserve= type->preserve[i].mask;
@@ -276,31 +396,103 @@ XkbTranslateKey(dpy, keycode, modifiers, modifiers_return, keysym_return)
}
}
- if (keysym_return!=NULL)
- *keysym_return= syms[col];
- if (modifiers_return)
- *modifiers_return&= ~(type->mask&(~preserve));
+ if (keysym_rtrn!=NULL)
+ *keysym_rtrn= syms[col];
+ if (mods_rtrn) {
+ *mods_rtrn= type->mods.mask&(~preserve);
+ /* The Motif VTS doesn't get the help callback called if help
+ * is bound to Shift+<whatever>, and it appears as though it
+ * is XkbTranslateKeyCode that is causing the problem. The
+ * core X version of XTranslateKey always OR's in ShiftMask
+ * and LockMask for mods_rtrn, so this "fix" keeps this behavior
+ * and solves the VTS problem.
+ */
+ if ((xkb->dpy)&&(xkb->dpy->xkb_info)&&
+ (xkb->dpy->xkb_info->xlib_ctrls&XkbLC_AlwaysConsumeShiftAndLock)) {
+ *mods_rtrn|= (ShiftMask|LockMask);
+ }
+ }
return (syms[col]!=NoSymbol);
}
+Status
+#if NeedFunctionPrototypes
+XkbRefreshKeyboardMapping(register XkbMapNotifyEvent *event)
+#else
+XkbRefreshKeyboardMapping(event)
+ register XkbMapNotifyEvent *event;
+#endif
+{
+ Display *dpy = event->display;
+ XkbInfoPtr xkbi;
+
+ if (_XkbUnavailable(dpy)) {
+ _XRefreshKeyboardMapping((XMappingEvent *)event);
+ return Success;
+ }
+ xkbi= dpy->xkb_info;
+
+ if (((event->type&0x7f)-xkbi->codes->first_event)!=XkbEventCode)
+ return BadMatch;
+ if (event->xkb_type==XkbNewKeyboardNotify) {
+ _XkbReloadDpy(dpy);
+ return Success;
+ }
+ if (event->xkb_type==XkbMapNotify) {
+ XkbMapChangesRec changes;
+ Status rtrn;
+
+ if (xkbi->flags&XkbMapPending)
+ changes= xkbi->changes;
+ else bzero(&changes,sizeof(XkbChangesRec));
+ XkbNoteMapChanges(&changes,event,XKB_XLIB_MAP_MASK);
+ LockDisplay(dpy);
+ if ((rtrn=XkbGetMapChanges(dpy,xkbi->desc,&changes))!=Success) {
+#ifdef DEBUG
+ fprintf(stderr,"Internal Error! XkbGetMapChanges failed:\n");
+#endif
+ xkbi->changes= changes;
+ }
+ else if (xkbi->flags&XkbMapPending) {
+ xkbi->flags&= ~XkbMapPending;
+ bzero(&xkbi->changes,sizeof(XkbMapChangesRec));
+ }
+ UnlockDisplay(dpy);
+ return rtrn;
+ }
+ return BadMatch;
+}
+
+int
+#if NeedFunctionPrototypes
+XRefreshKeyboardMapping(register XMappingEvent *event)
+#else
XRefreshKeyboardMapping(event)
register XMappingEvent *event;
+#endif
{
- XkbAnyEvent *xkbevent = (XkbAnyEvent *)event;
+ XkbEvent *xkbevent = (XkbEvent *)event;
Display *dpy = event->display;
XkbMapChangesRec changes;
XkbInfoPtr xkbi;
- int modsChanged;
- if (XKB_UNAVAILABLE(dpy))
+ if (_XkbUnavailable(dpy))
return _XRefreshKeyboardMapping(event);
xkbi = dpy->xkb_info;
+ if (((event->type&0x7f)-xkbi->codes->first_event)==XkbEventCode)
+ return XkbRefreshKeyboardMapping(&xkbevent->map);
+
+ if (xkbi->flags&XkbXlibNewKeyboard) {
+ _XkbReloadDpy(dpy);
+ return 1;
+ }
+
if ((xkbi->flags&XkbMapPending)||(event->request==MappingKeyboard)) {
if (xkbi->flags&XkbMapPending) {
changes= xkbi->changes;
- XkbNoteCoreMapChanges(&changes,event,XKB_XLIB_MAP_MASK);
+ _XkbNoteCoreMapChanges(&changes,event,XKB_XLIB_MAP_MASK);
}
else {
bzero(&changes,sizeof(changes));
@@ -316,9 +508,9 @@ XRefreshKeyboardMapping(event)
}
}
- if (!XkbRefreshMap(dpy,xkbi->desc, &changes)){
- fprintf(stderr,"Internal Error! XkbRefreshMap failed:\n");
+ if (XkbGetMapChanges(dpy,xkbi->desc, &changes)!=Success) {
#ifdef DEBUG
+ fprintf(stderr,"Internal Error! XkbGetMapChanges failed:\n");
if (changes.changed&XkbKeyTypesMask) {
int first= changes.first_type;
int last= changes.first_type+changes.num_types-1;
@@ -358,9 +550,9 @@ XRefreshKeyboardMapping(event)
UnlockDisplay(dpy);
}
if (event->request==MappingModifier) {
- if (xkbi->modmap) {
- Xfree(xkbi->modmap);
- xkbi->modmap= NULL;
+ if (xkbi->desc->map->modmap) {
+ _XkbFree(xkbi->desc->map->modmap);
+ xkbi->desc->map->modmap= NULL;
}
if (dpy->key_bindings) {
register struct _XKeytrans *p;
@@ -375,22 +567,26 @@ XRefreshKeyboardMapping(event)
}
UnlockDisplay(dpy);
}
- return;
+ return 1;
}
static int
+#if NeedFunctionPrototypes
+_XkbLoadDpy(Display *dpy)
+#else
_XkbLoadDpy(dpy)
Display *dpy;
+#endif
{
XkbInfoPtr xkbi;
unsigned query,oldEvents;
XkbDescRec *desc;
- if (!XkbUseExtension(dpy))
+ if (!XkbUseExtension(dpy,NULL,NULL))
return 0;
xkbi = dpy->xkb_info;
- query = XkbFullClientInfoMask;
+ query = XkbAllClientInfoMask;
desc = XkbGetMap(dpy,query,XkbUseCoreKbd);
if (!desc) {
#ifdef DEBUG
@@ -405,41 +601,112 @@ _XkbLoadDpy(dpy)
_XkbGetConverters(xkbi->charset,&xkbi->cvt);
UnlockDisplay(dpy);
oldEvents= xkbi->selected_events;
+ if (!(xkbi->xlib_ctrls&XkbLC_IgnoreNewKeyboards)) {
+ XkbSelectEventDetails(dpy,xkbi->desc->device_spec,XkbNewKeyboardNotify,
+ XkbNKN_KeycodesMask|XkbNKN_DeviceIDMask,
+ XkbNKN_KeycodesMask|XkbNKN_DeviceIDMask);
+ }
XkbSelectEventDetails(dpy,xkbi->desc->device_spec,XkbMapNotify,
- XkbAllMapComponentsMask,XkbFullClientInfoMask);
+ XkbAllClientInfoMask,XkbAllClientInfoMask);
LockDisplay(dpy);
xkbi->selected_events= oldEvents;
UnlockDisplay(dpy);
+ return 1;
}
-int
-XkbTranslateKeySym(dpy, sym_return, modifiers, buffer, nbytes)
+void
+#if NeedFunctionPrototypes
+_XkbReloadDpy(Display *dpy)
+#else
+_XkbReloadDpy(dpy)
Display *dpy;
- register KeySym *sym_return;
- unsigned int modifiers;
+#endif
+{
+ XkbInfoPtr xkbi;
+ XkbDescRec *desc;
+ unsigned oldDeviceID;
+
+ if (_XkbUnavailable(dpy))
+ return;
+
+ xkbi = dpy->xkb_info;
+ LockDisplay(dpy);
+ if (xkbi->desc) {
+ oldDeviceID= xkbi->desc->device_spec;
+ XkbFreeKeyboard(xkbi->desc,XkbAllComponentsMask,True);
+ xkbi->desc= NULL;
+ xkbi->flags&= ~(XkbMapPending|XkbXlibNewKeyboard);
+ xkbi->changes.changed= 0;
+ }
+ else oldDeviceID= XkbUseCoreKbd;
+ UnlockDisplay(dpy);
+ desc = XkbGetMap(dpy,XkbAllClientInfoMask,XkbUseCoreKbd);
+ if (!desc)
+ return;
+ LockDisplay(dpy);
+ xkbi->desc = desc;
+ UnlockDisplay(dpy);
+
+ if (desc->device_spec!=oldDeviceID) {
+ /* transfer(?) event masks here */
+#ifdef NOTYET
+ unsigned oldEvents;
+ oldEvents= xkbi->selected_events;
+ XkbSelectEventDetails(dpy,xkbi->desc->device_spec,XkbMapNotify,
+ XkbAllMapComponentsMask,XkbAllClientInfoMask);
+ LockDisplay(dpy);
+ xkbi->selected_events= oldEvents;
+ UnlockDisplay(dpy);
+#endif
+ }
+ return;
+}
+
+int
+#if NeedFunctionPrototypes
+XkbTranslateKeySym( register Display * dpy,
+ register KeySym * sym_rtrn,
+ unsigned int mods,
+ char * buffer,
+ int nbytes,
+ int * extra_rtrn)
+#else
+XkbTranslateKeySym(dpy, sym_rtrn, mods, buffer, nbytes, extra_rtrn)
+ register Display *dpy;
+ register KeySym *sym_rtrn;
+ unsigned int mods;
char *buffer;
int nbytes;
+ int *extra_rtrn;
+#endif
{
+ register XkbInfoPtr xkb;
char tmp[4];
- register XkbInfoPtr xkb;
register struct _XKeytrans *p;
int n;
- if (XKB_UNAVAILABLE(dpy))
- return _XTranslateKeySym(dpy,*sym_return,modifiers,buffer,nbytes);
- CHECK_PENDING_REFRESH(dpy);
+ if (extra_rtrn)
+ *extra_rtrn= 0;
+ if (_XkbUnavailable(dpy))
+ return _XTranslateKeySym(dpy, *sym_rtrn, mods, buffer, nbytes);
+ _XkbCheckPendingRefresh(dpy,dpy->xkb_info);
+
+ xkb= dpy->xkb_info;
if ((buffer==NULL)||(nbytes==0)) {
buffer= tmp;
nbytes= 4;
}
- xkb = dpy->xkb_info;
/* see if symbol rebound, if so, return that string. */
for (p = dpy->key_bindings; p; p = p->next) {
- if (((modifiers & AllMods) == p->state) && (*sym_return == p->key)) {
+ if (((mods & AllMods) == p->state) && (*sym_rtrn == p->key)) {
int tmp = p->len;
- if (tmp > nbytes) tmp = nbytes;
+ if (tmp > nbytes) {
+ if (extra_rtrn)
+ *extra_rtrn= tmp-nbytes;
+ tmp = nbytes;
+ }
memcpy (buffer, p->string, tmp);
return tmp;
}
@@ -448,12 +715,13 @@ XkbTranslateKeySym(dpy, sym_return, modifiers, buffer, nbytes)
if ( nbytes>0 )
buffer[0]= '\0';
- if ( xkb->cvt.KSToUpper && (modifiers&LockMask) ) {
- *sym_return = (*xkb->cvt.KSToUpper)(*sym_return);
+ if ( xkb->cvt.KSToUpper && (mods&LockMask) ) {
+ *sym_rtrn = (*xkb->cvt.KSToUpper)(*sym_rtrn);
}
- n = (*xkb->cvt.KSToMB)(xkb->cvt.KSToMBPriv,*sym_return,buffer,nbytes,NULL);
+ n = (*xkb->cvt.KSToMB)(xkb->cvt.KSToMBPriv,*sym_rtrn,buffer,nbytes,
+ extra_rtrn);
- if ((!xkb->cvt.KSToUpper)&&( modifiers&LockMask )) {
+ if ((!xkb->cvt.KSToUpper)&&( mods&LockMask )) {
register int i;
if (!xkb->cvt.KSToUpper) {
@@ -466,14 +734,14 @@ XkbTranslateKeySym(dpy, sym_return, modifiers, buffer, nbytes)
}
if (change) {
if (n==1)
- *sym_return=(*xkb->cvt.MBToKS)(xkb->cvt.MBToKSPriv,
+ *sym_rtrn=(*xkb->cvt.MBToKS)(xkb->cvt.MBToKSPriv,
buffer,n,0);
- else *sym_return= NoSymbol;
+ else *sym_rtrn= NoSymbol;
}
}
}
- if ( modifiers&ControlMask ) {
+ if ( mods&ControlMask ) {
if ( n==1 ) {
register char c = buffer[0];
@@ -496,57 +764,88 @@ XkbTranslateKeySym(dpy, sym_return, modifiers, buffer, nbytes)
}
int
+#if NeedFunctionPrototypes
+XLookupString ( register XKeyEvent * event,
+ char * buffer,
+ int nbytes,
+ KeySym * keysym,
+ XComposeStatus * status)
+#else
XLookupString (event, buffer, nbytes, keysym, status)
register XKeyEvent *event;
char *buffer; /* buffer */
int nbytes; /* space in buffer for characters */
KeySym *keysym;
XComposeStatus *status;
+#endif
{
KeySym dummy;
int rtrnLen;
unsigned int new_mods;
Display *dpy = event->display;
+ XkbDescPtr xkb;
- if (XKB_UNAVAILABLE(dpy))
+ if (_XkbUnavailable(dpy))
return _XLookupString(event, buffer, nbytes, keysym, status);
- CHECK_PENDING_REFRESH(dpy);
+ _XkbCheckPendingRefresh(dpy,dpy->xkb_info);
if (keysym==NULL)
keysym= &dummy;
-
- if (!XkbTranslateKey(dpy,event->keycode,event->state, &new_mods,keysym))
+ xkb= dpy->xkb_info->desc;
+ if (!XkbTranslateKeyCode(xkb,event->keycode,event->state, &new_mods,keysym))
return 0;
+ new_mods= (event->state&(~new_mods));
-#if defined(__sgi) && defined(USE_OWN_COMPOSE)
+#ifdef USE_OWN_COMPOSE
if ( status ) {
static int been_here= 0;
if ( !been_here ) {
- ComposeInitTables();
+ XimCompInitTables();
been_here = 1;
}
- if ( !ComposeLegalStatus(status) ) {
+ if ( !XimCompLegalStatus(status) ) {
status->compose_ptr = NULL;
status->chars_matched = 0;
}
if ( ((status->chars_matched>0)&&(status->compose_ptr!=NULL)) ||
- IsComposeKey(*keysym,event->keycode,status) ) {
- ComposeRtrn rtrn;
- switch (ComposeProcessSym(status,*keysym,&rtrn)) {
- case COMPOSE_IGNORE:
+ XimCompIsComposeKey(*keysym,event->keycode,status) ) {
+ XimCompRtrn rtrn;
+
+ switch (XimCompProcessSym(status,*keysym,&rtrn)) {
+ case XIM_COMP_IGNORE:
break;
- case COMPOSE_IN_PROGRESS:
+ case XIM_COMP_IN_PROGRESS:
if ( keysym!=NULL )
*keysym = NoSymbol;
+#ifndef NO_COMPOSE_LED
+ if ( dpy->xkb_info->xlib_ctrls&XkbLC_ComposeLED ) {
+ XkbSetNamedIndicator(dpy,dpy->xkb_info->composeLED,
+ True,True,False,NULL);
+ }
+#endif
return 0;
- case COMPOSE_FAIL:
+ case XIM_COMP_FAIL:
{
+ static Atom _ComposeFail= None;
int n = 0, len= 0;
+#ifndef NO_COMPOSE_LED
+ if ( dpy->xkb_info->xlib_ctrls&XkbLC_ComposeLED ) {
+ XkbSetNamedIndicator(dpy,dpy->xkb_info->composeLED,
+ True,False,False,NULL);
+ }
+#endif
+#ifndef NO_BELL_ON_COMPOSE_FAIL
+ if (dpy->xkb_info->xlib_ctrls&XkbLC_BeepOnComposeFail) {
+ if (_ComposeFail==None)
+ _ComposeFail= XInternAtom(dpy,"ComposeFail",0);
+ XkbBell(dpy,event->window,0,_ComposeFail);
+ }
+#endif
for (n=len=0;rtrn.sym[n]!=XK_VoidSymbol;n++) {
if ( nbytes-len > 0 ) {
- len+= _XTranslateKeySym(event->display,&rtrn.sym[n],
- new_mods,
- buffer+len,nbytes-len);
+ len+= XkbTranslateKeySym(dpy,&rtrn.sym[n],new_mods,
+ buffer+len,nbytes-len,
+ NULL);
}
}
if ( keysym!=NULL ) {
@@ -555,26 +854,33 @@ XLookupString (event, buffer, nbytes, keysym, status)
}
return len;
}
- case COMPOSE_SUCCEED:
+ case XIM_COMP_SUCCEED:
{
int len,n = 0;
+#ifndef NO_COMPOSE_LED
+ if ( dpy->xkb_info->xlib_ctrls&XkbLC_ComposeLED ) {
+ XkbSetNamedIndicator(dpy,dpy->xkb_info->composeLED,
+ True,False,False,NULL);
+ }
+#endif
*keysym = rtrn.matchSym;
if ( rtrn.str[0]!='\0' ) {
strncpy(buffer,rtrn.str,nbytes-1);
buffer[nbytes-1]= '\0';
- len = strlen(buffer);
+ len = (int)strlen(buffer);
}
else {
- len = XkbTranslateKeySym(event->display,keysym,
- new_mods,
- buffer,nbytes);
+ len = XkbTranslateKeySym(dpy,keysym,new_mods,
+ buffer,nbytes,
+ NULL);
}
for (n=0;rtrn.sym[n]!=XK_VoidSymbol;n++) {
if ( nbytes-len > 0 ) {
- len+= _XTranslateKeySym(event->display,rtrn.sym[n],
+ len+= XkbTranslateKeySym(dpy,&rtrn.sym[n],
event->state,
- buffer+len,nbytes-len);
+ buffer+len,nbytes-len,
+ NULL);
}
}
return len;
@@ -584,27 +890,60 @@ XLookupString (event, buffer, nbytes, keysym, status)
}
#endif
- rtrnLen = XkbTranslateKeySym(dpy,keysym,new_mods,buffer,nbytes);
+ /* We *should* use the new_mods (which does not contain any modifiers */
+ /* that were used to compute the symbol here, but pre-XKB XLookupString */
+ /* did not and we have to remain compatible. Sigh. */
+ if ((dpy->xkb_info->flags&XkbLC_ConsumeLookupMods)==0)
+ new_mods= event->state;
+
+ rtrnLen= XkbLookupKeyBinding(dpy,*keysym,new_mods,buffer,nbytes,NULL);
+ if (rtrnLen>0)
+ return rtrnLen;
+
+ rtrnLen = XkbTranslateKeySym(dpy,keysym,new_mods,buffer,nbytes,NULL);
+ if ((event->state&ControlMask)&&(nbytes>0)&&
+ ((rtrnLen==0)||((rtrnLen==1)&&(buffer[0]>=' ')))&&
+ (XkbGroupForCoreState(event->state)!=XkbGroup1Index)&&
+ (dpy->xkb_info->flags&XkbLC_ControlFallback)) {
+ XKeyEvent tmp_ev;
+ tmp_ev= *event;
+ tmp_ev.state= XkbBuildCoreState(event->state,XkbGroup1Index);
+ return XLookupString (&tmp_ev, buffer, nbytes, keysym, status);
+ }
return rtrnLen;
}
int
-XkbLookupKeyBinding(dpy, sym_return, modifiers, buffer, nbytes)
+#if NeedFunctionPrototypes
+XkbLookupKeyBinding( Display * dpy,
+ register KeySym sym,
+ unsigned int mods,
+ char * buffer,
+ int nbytes,
+ int * extra_rtrn)
+#else
+XkbLookupKeyBinding(dpy, sym, mods, buffer, nbytes, extra_rtrn)
Display *dpy;
- register KeySym *sym_return;
- unsigned int modifiers;
+ register KeySym sym;
+ unsigned int mods;
char *buffer;
int nbytes;
+ int * extra_rtrn;
+#endif
{
- char tmp[4];
register struct _XKeytrans *p;
- int n;
+ if (extra_rtrn)
+ *extra_rtrn= 0;
for (p = dpy->key_bindings; p; p = p->next) {
- if (((modifiers & AllMods) == p->state) && (*sym_return == p->key)) {
+ if (((mods & AllMods) == p->state) && (sym == p->key)) {
int tmp = p->len;
- if (tmp > nbytes) tmp = nbytes;
+ if (tmp > nbytes) {
+ if (extra_rtrn)
+ *extra_rtrn= (tmp-nbytes);
+ tmp = nbytes;
+ }
memcpy (buffer, p->string, tmp);
if (tmp < nbytes) buffer[tmp]= '\0';
return tmp;
@@ -614,8 +953,12 @@ XkbLookupKeyBinding(dpy, sym_return, modifiers, buffer, nbytes)
}
char
+#if NeedFunctionPrototypes
+XkbToControl( char c )
+#else
XkbToControl( c )
char c;
+#endif
{
if ((c >= '@' && c < '\177') || c == ' ') c &= 0x1F;
else if (c == '2') c = '\000';
diff --git a/lib/X11/XKBCompat.c b/lib/X11/XKBCompat.c
index d02b4aa60..4a1b81650 100644
--- a/lib/X11/XKBCompat.c
+++ b/lib/X11/XKBCompat.c
@@ -1,4 +1,4 @@
-/* $XConsortium: XKBCompat.c,v 1.2 94/04/08 15:10:49 erik Exp $ */
+/* $XConsortium: XKBCompat.c /main/8 1996/03/01 14:29:32 kaleb $ */
/************************************************************
Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
@@ -28,32 +28,43 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <stdio.h>
#define NEED_REPLIES
#define NEED_EVENTS
+#define NEED_MAP_READERS
#include "Xlibint.h"
#include <X11/extensions/XKBproto.h>
#include "XKBlibint.h"
-static Status
-_XkbReadGetCompatMapReply(dpy,rep,xkb)
+Status
+#if NeedFunctionPrototypes
+_XkbReadGetCompatMapReply( Display * dpy,
+ xkbGetCompatMapReply * rep,
+ XkbDescPtr xkb,
+ int * nread_rtrn)
+#else
+_XkbReadGetCompatMapReply(dpy,rep,xkb,nread_rtrn)
Display * dpy;
xkbGetCompatMapReply * rep;
XkbDescPtr xkb;
+ int * nread_rtrn;
+#endif
{
register int i;
XkbReadBufferRec buf;
-int nMods,nVMods;
- if (!_XkbInitReadBuffer(dpy,&buf,rep->length*4))
- return False;
+ if (!_XkbInitReadBuffer(dpy,&buf,(int)rep->length*4))
+ return BadAlloc;
+ if (nread_rtrn)
+ *nread_rtrn= (int)rep->length*4;
+
+ i= rep->firstSI+rep->nSI;
if ((!xkb->compat)&&
- (!XkbAllocCompatMap(xkb,XkbAllCompatMask,rep->firstSI+rep->nSI-1)))
- return False;
+ (XkbAllocCompatMap(xkb,XkbAllCompatMask,i)!=Success))
+ return BadAlloc;
if (rep->nSI!=0) {
XkbSymInterpretRec *syms;
xkbSymInterpretWireDesc *wire;
- int lastSI= rep->firstSI+rep->nSI-1;
wire= (xkbSymInterpretWireDesc *)_XkbGetReadBufferPtr(&buf,
rep->nSI*SIZEOF(xkbSymInterpretWireDesc));
if (wire==NULL)
@@ -70,78 +81,57 @@ int nMods,nVMods;
}
xkb->compat->num_si+= rep->nSI;
}
- nMods= nVMods= 0;
-
- if (rep->mods) {
- register int bit;
- xkbModCompatWireDesc *wire;
-
- for (i=0,bit=1;i<XkbNumModifiers;i++,bit<<=1) {
- if (rep->mods&bit)
- nMods++;
- }
- wire= (xkbModCompatWireDesc *)_XkbGetReadBufferPtr(&buf,
- sz_xkbModCompatWireDesc*nMods);
- if (wire==NULL)
- goto BAILOUT;
- for (i=0,bit=1;i<XkbNumModifiers;i++,bit<<=1) {
- if (rep->mods&bit) {
- xkb->compat->real_mod_compat[i].mods= wire->mods;
- xkb->compat->real_mod_compat[i].groups= wire->groups;
- wire++;
- }
- }
- }
- if (rep->virtualMods) {
- register int bit;
- xkbModCompatWireDesc *wire;
- for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
- if (rep->virtualMods&bit)
- nVMods++;
+ if (rep->groups&XkbAllGroupsMask) {
+ register unsigned bit,nGroups;
+ xkbModsWireDesc * wire;
+ for (i=0,nGroups=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
+ if (rep->groups&bit)
+ nGroups++;
}
- wire= (xkbModCompatWireDesc *)_XkbGetReadBufferPtr(&buf,
- sz_xkbModCompatWireDesc*nVMods);
+ wire= (xkbModsWireDesc *)_XkbGetReadBufferPtr(&buf,
+ nGroups*SIZEOF(xkbModsWireDesc));
if (wire==NULL)
goto BAILOUT;
- for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
- if (rep->virtualMods&bit) {
- xkb->compat->vmod_compat[i].mods= wire->mods;
- xkb->compat->vmod_compat[i].groups= wire->groups;
- wire++;
- }
+ for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
+ if ((rep->groups&bit)==0)
+ continue;
+ xkb->compat->groups[i].mask= wire->mask;
+ xkb->compat->groups[i].real_mods= wire->realMods;
+ xkb->compat->groups[i].vmods= wire->virtualMods;
+ wire++;
}
}
- i= ((nMods+nVMods)*sz_xkbModCompatWireDesc);
- i= (((i+3)/4)*4)-i;
- if (i>0)
- _XkbSkipReadBufferData(&buf,i);
-
i= _XkbFreeReadBuffer(&buf);
if (i)
fprintf(stderr,"CompatMapReply! Bad length (%d extra bytes)\n",i);
if (i || buf.error)
- return False;
- return True;
+ return BadLength;
+ return Success;
BAILOUT:
_XkbFreeReadBuffer(&buf);
- return False;
+ return BadLength;
}
Status
+#if NeedFunctionPrototypes
+XkbGetCompatMap(Display *dpy,unsigned which,XkbDescPtr xkb)
+#else
XkbGetCompatMap(dpy,which,xkb)
- Display *dpy;
- unsigned which;
- XkbDescRec *xkb;
+ Display * dpy;
+ unsigned which;
+ XkbDescPtr xkb;
+#endif
{
register xkbGetCompatMapReq *req;
xkbGetCompatMapReply rep;
- Status ok;
+ Status status;
XkbInfoPtr xkbi;
- if ((dpy->flags & XlibDisplayNoXkb) ||
- (!dpy->xkb_info && !XkbUseExtension(dpy)))
- return False;
+ if ( (!dpy) || (!xkb) || (dpy->flags & XlibDisplayNoXkb) ||
+ ((xkb->dpy!=NULL)&&(xkb->dpy!=dpy)) ||
+ (!dpy->xkb_info && (!XkbUseExtension(dpy,NULL,NULL))))
+ return BadAccess;
LockDisplay(dpy);
xkbi = dpy->xkb_info;
GetReq(kbGetCompatMap, req);
@@ -153,53 +143,57 @@ XkbGetCompatMap(dpy,which,xkb)
else req->getAllSI= False;
req->firstSI= req->nSI= 0;
- if (which&XkbModCompatMask)
- req->mods= ~0;
- else req->mods= 0;
-
- if (which&XkbVirtualModCompatMask)
- req->virtualMods= ~0;
- else req->virtualMods= 0;
+ if (which&XkbGroupCompatMask)
+ req->groups= XkbAllGroupsMask;
+ else req->groups= 0;
if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
- return False;
+ return BadLength;
}
+ if (xkb->dpy==NULL)
+ xkb->dpy= dpy;
if (xkb->device_spec==XkbUseCoreKbd)
xkb->device_spec= rep.deviceID;
- ok = _XkbReadGetCompatMapReply(dpy,&rep,xkb);
+ status = _XkbReadGetCompatMapReply(dpy,&rep,xkb,NULL);
UnlockDisplay(dpy);
SyncHandle();
- return ok;
+ return status;
}
-static Status
+static Bool
+#if NeedFunctionPrototypes
+_XkbWriteSetCompatMap(Display *dpy,xkbSetCompatMapReq *req,XkbDescPtr xkb)
+#else
_XkbWriteSetCompatMap(dpy,req,xkb)
Display * dpy;
xkbSetCompatMapReq *req;
XkbDescPtr xkb;
+#endif
{
-CARD8 mods = req->mods;
-CARD16 vmods = req->virtualMods;
-CARD16 firstSI = req->firstSI;
-CARD16 nSI = req->nSI;
-int size,nMods,nVMods;
-register int i,bit;
-char *buf;
+CARD16 firstSI;
+CARD16 nSI;
+int size;
+register int i,nGroups;
+register unsigned bit;
+unsigned groups;
+char * buf;
- for (i=0,bit=1;i<XkbNumModifiers;i++,bit<<=1) {
- if (mods&bit) nMods++;
- if (vmods&bit) nVMods++;
- }
- for (;i<XkbNumVirtualMods;i++,bit<<=1) {
- if (vmods&bit) nVMods++;
+ firstSI = req->firstSI;
+ nSI = req->nSI;
+ size= nSI*SIZEOF(xkbSymInterpretWireDesc);
+ nGroups= 0;
+ groups= req->groups;
+ if (groups&XkbAllGroupsMask) {
+ for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
+ if (groups&bit)
+ nGroups++;
+ }
+ size+= SIZEOF(xkbModsWireDesc)*nGroups;
}
-
- size= nSI*sz_xkbSymInterpretWireDesc;
- size+= (((nMods*sz_xkbModCompatWireDesc)+3)/4)*4;
- req->length+= (size+3)/4;
+ req->length+= size/4;
BufAlloc(char *,buf,size);
if (!buf)
return False;
@@ -207,52 +201,50 @@ char *buf;
if (nSI) {
XkbSymInterpretPtr sym= &xkb->compat->sym_interpret[firstSI];
xkbSymInterpretWireDesc *wire= (xkbSymInterpretWireDesc *)buf;
- for (i=0;i<nSI;i++) {
- wire->sym= sym->sym;
+ for (i=0;i<nSI;i++,wire++,sym++) {
+ wire->sym= (CARD32)sym->sym;
wire->mods= sym->mods;
wire->match= sym->match;
wire->flags= sym->flags;
wire->virtualMod= sym->virtual_mod;
memcpy(&wire->act,&sym->act,sz_xkbActionWireDesc);
}
- buf+= nSI*sz_xkbSymInterpretWireDesc;
+ buf+= nSI*SIZEOF(xkbSymInterpretWireDesc);
}
- if (mods) {
- xkbModCompatWireDesc *out= (xkbModCompatWireDesc *)buf;
- for (i=0,bit=1;i<XkbNumModifiers;i++,bit<<=1) {
- if (mods&bit) {
- out->mods= xkb->compat->real_mod_compat[i].mods;
- out->groups= xkb->compat->real_mod_compat[i].groups;
- out++;
- }
- }
- }
- if (vmods) {
- xkbModCompatWireDesc *out= (xkbModCompatWireDesc *)buf;
- for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
- if (vmods&bit) {
- out->mods= xkb->compat->vmod_compat[i].mods;
- out->groups= xkb->compat->vmod_compat[i].groups;
+ if (groups&XkbAllGroupsMask) {
+ xkbModsWireDesc * out;
+
+ out= (xkbModsWireDesc *)buf;
+ for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
+ if ((groups&bit)!=0) {
+ out->mask= xkb->compat->groups[i].mask;
+ out->realMods= xkb->compat->groups[i].real_mods;
+ out->virtualMods= xkb->compat->groups[i].vmods;
out++;
}
}
+ buf+= nGroups*SIZEOF(xkbModsWireDesc);
}
return True;
}
-Status
+Bool
+#if NeedFunctionPrototypes
+XkbSetCompatMap(Display *dpy,unsigned which,XkbDescPtr xkb,Bool updateActions)
+#else
XkbSetCompatMap(dpy,which,xkb,updateActions)
Display * dpy;
unsigned which;
XkbDescPtr xkb;
Bool updateActions;
+#endif
{
register xkbSetCompatMapReq *req;
Status ok;
XkbInfoPtr xkbi;
- if ((dpy->flags & XlibDisplayNoXkb) ||
- (!dpy->xkb_info && !XkbUseExtension(dpy)))
+ if ((dpy->flags & XlibDisplayNoXkb) || (dpy!=xkb->dpy) ||
+ (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
return False;
if ((!xkb->compat) ||
((which&XkbSymInterpMask)&&(!xkb->compat->sym_interpret)))
@@ -274,108 +266,12 @@ XkbSetCompatMap(dpy,which,xkb,updateActions)
req->firstSI= 0;
req->nSI= 0;
}
- if (which&XkbModCompatMask)
- req->mods= ~0;
- else req->mods= 0;
- if (which&XkbVirtualModCompatMask)
- req->virtualMods= ~0;
- else req->virtualMods= 0;
+ if (which&XkbGroupCompatMask)
+ req->groups= XkbAllGroupsMask;
+ else req->groups= 0;
ok= _XkbWriteSetCompatMap(dpy,req,xkb);
UnlockDisplay(dpy);
SyncHandle();
return ok;
}
-/***====================================================================***/
-
-Status
-XkbAllocCompatMap(xkb,which,nInterpret)
- XkbDescPtr xkb;
- unsigned which;
- unsigned nInterpret;
-{
-register int i;
-XkbCompatPtr compat;
-
- if (!xkb)
- return False;
- if (xkb->compat) {
- if (xkb->compat->size_si>=nInterpret)
- return True;
- compat= xkb->compat;
- compat->size_si= nInterpret;
- i= nInterpret*sizeof(XkbSymInterpretRec);
- if (compat->sym_interpret==NULL) {
- compat->num_si= 0;
- compat->sym_interpret= (XkbSymInterpretPtr)
- Xcalloc(nInterpret,sizeof(XkbSymInterpretRec));
- }
- else {
- compat->sym_interpret= (XkbSymInterpretPtr)
- Xrealloc(compat->sym_interpret,i);
- if (compat->sym_interpret!=NULL)
- bzero(&compat->sym_interpret[compat->num_si],
- (nInterpret-compat->size_si)*sizeof(XkbSymInterpretRec));
- }
- if (compat->sym_interpret==NULL) {
- compat->size_si= compat->num_si= 0;
- return False;
- }
- return True;
- }
- compat= (XkbCompatPtr)Xmalloc(sizeof(XkbCompatRec));
- if (compat==NULL)
- return False;
- if (nInterpret>0) {
- i= nInterpret*sizeof(XkbSymInterpretRec);
- compat->sym_interpret= (XkbSymInterpretPtr)Xmalloc(i);
- if (!compat->sym_interpret) {
- Xfree(compat);
- return False;
- }
- bzero(compat->sym_interpret,i);
- }
- compat->size_si= nInterpret;
- compat->num_si= 0;
- for (i=0;i<XkbNumModifiers;i++) {
- compat->real_mod_compat[i].mods= (1<<i);
- compat->real_mod_compat[i].groups= 0;
- compat->mod_compat[i]= &compat->real_mod_compat[i];
- }
- bzero(compat->vmod_compat,sizeof(compat->vmod_compat));
- xkb->compat= compat;
- return True;
-}
-
-
-Status
-XkbFreeCompatMap(xkb,all,which)
- XkbDescPtr xkb;
- Bool all;
- unsigned which;
-{
- if ((xkb==NULL)||(xkb->compat==NULL))
- return False;
- if (which&XkbModCompatMask) {
- register int i;
- for (i=0;i<XkbNumModifiers;i++) {
- xkb->compat->real_mod_compat[i].mods= (1<<i);
- xkb->compat->real_mod_compat[i].groups= 0;
- xkb->compat->mod_compat[i]= &xkb->compat->real_mod_compat[i];
- }
- }
- if (which&XkbVirtualModCompatMask) {
- bzero(xkb->compat->vmod_compat,sizeof(xkb->compat->vmod_compat));
- }
- if (which&XkbSymInterpMask) {
- if ((xkb->compat->sym_interpret)&&(xkb->compat->size_si>0))
- Xfree(xkb->compat->sym_interpret);
- xkb->compat->size_si= xkb->compat->num_si= 0;
- xkb->compat->sym_interpret= NULL;
- }
- if (all) {
- Xfree(xkb->compat);
- xkb->compat= NULL;
- }
- return True;
-}
diff --git a/lib/X11/XKBCvt.c b/lib/X11/XKBCvt.c
index 2a741dd3c..cd48a6bdf 100644
--- a/lib/X11/XKBCvt.c
+++ b/lib/X11/XKBCvt.c
@@ -1,5 +1,5 @@
-/* $XConsortium: XKBCvt.c /main/21 1996/02/02 14:09:26 kaleb $ */
-/* $XFree86: xc/lib/X11/XKBCvt.c,v 3.5 1996/01/16 15:01:06 dawes Exp $ */
+/* $XConsortium: XKBCvt.c /main/22 1996/03/01 14:29:37 kaleb $ */
+/* $XFree86: xc/lib/X11/XKBCvt.c,v 3.6 1996/02/04 08:54:25 dawes Exp $ */
/*
Copyright (c) 1988, 1989 X Consortium
@@ -125,6 +125,24 @@ static unsigned char Const cyrillic[128] =
0xbf, 0xcf, 0xc0, 0xc1, 0xc2, 0xc3, 0xb6, 0xb2, /* 15 */
0xcc, 0xcb, 0xb7, 0xc8, 0xcd, 0xc9, 0xc7, 0xca};
+/* maps Cyrillic keysyms to KOI0-8 */
+static unsigned char Const koi8[128] =
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0xa3, 0x00, 0x00, 0x00, 0x00, /* 10 */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0xb3, 0x00, 0x00, 0x00, 0x00, /* 11 */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, /* 12 */
+ 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+ 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, /* 13 */
+ 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+ 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, /* 14 */
+ 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+ 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, /* 15 */
+ 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff};
/* maps Greek keysyms to 8859-7 */
static unsigned char Const greek[128] =
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -435,6 +453,41 @@ __XkbDefaultToUpper(sym)
return upper;
}
+int _XkbKSToKoi8 (priv, keysym, buffer, nbytes, status)
+ XPointer priv;
+ KeySym keysym;
+ char *buffer;
+ int nbytes;
+ Status *status;
+{
+ if ((keysym&0xffffff00)==0xff00) {
+ return _XkbHandleSpecialSym(keysym, buffer, nbytes, status);
+ } else {
+ if (nbytes>0) {
+ buffer[0] = koi8[keysym & 0x7f];
+ if (nbytes>1)
+ buffer[1]= '\0';
+ return 1;
+ }
+ }
+ return 0;
+}
+static KeySym
+_XkbKoi8ToKS(priv,buffer,nbytes,status)
+ XPointer priv;
+ char *buffer;
+ int nbytes;
+ Status *status;
+{
+ if (nbytes!=1)
+ return NoSymbol;
+ if (((buffer[0]&0x80)==0)&&(buffer[0]>=32))
+ return buffer[0];
+ else if ((buffer[0]&0x7f)>=32) {
+ return 0xd00|buffer[0];
+ }
+ return NoSymbol;
+}
/***====================================================================***/
@@ -490,6 +543,9 @@ static XkbConverters cvt_Thai = {
_XkbKSToThai, NULL, _XkbThaiToKS, NULL, NULL
};
+static XkbConverters cvt_Koi8 = {
+ _XkbKSToKoi8, NULL, _XkbKoi8ToKS, NULL, NULL
+};
static int
#if NeedFunctionPrototypes
Strcmp(char *str1, char *str2)
@@ -546,6 +602,8 @@ _XkbGetConverters(charset, cvt_rtrn)
*cvt_rtrn = cvt_kana;
else if (Strcmp(charset, "tis620.2533-1")==0)
*cvt_rtrn = cvt_Thai;
+ else if (Strcmp(charset, "koi8")==0)
+ *cvt_rtrn = cvt_Koi8;
/* other codesets go here */
else *cvt_rtrn = cvt_latin1;
return 1;
@@ -678,4 +736,3 @@ char *tmp;
}
#endif
-
diff --git a/lib/X11/XKBMAlloc.c b/lib/X11/XKBMAlloc.c
index 66582d8fe..39fe45cab 100644
--- a/lib/X11/XKBMAlloc.c
+++ b/lib/X11/XKBMAlloc.c
@@ -1,5 +1,5 @@
-/* $XConsortium: XKBMAlloc.c /main/6 1996/02/02 14:09:43 kaleb $ */
-/* $XFree86: xc/lib/X11/XKBMAlloc.c,v 3.1 1996/01/16 15:01:07 dawes Exp $ */
+/* $XConsortium: XKBMAlloc.c /main/7 1996/03/01 14:29:44 kaleb $ */
+/* $XFree86: xc/lib/X11/XKBMAlloc.c,v 3.2 1996/02/04 08:54:26 dawes Exp $ */
/************************************************************
Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
@@ -645,6 +645,224 @@ KeySym *newSyms;
return &xkb->map->syms[xkb->map->key_sym_map[key].offset];
}
+static unsigned
+#if NeedFunctionPrototypes
+_ExtendRange( unsigned int old_flags,
+ unsigned int flag,
+ KeyCode newKC,
+ KeyCode * old_min,
+ unsigned char * old_num)
+#else
+_ExtendRange(old_flags,flag,newKC,old_min,old_num)
+ unsigned int old_flags;
+ unsigned int flag;
+ KeyCode newKC;
+ KeyCode * old_min;
+ unsigned char * old_num;
+#endif
+{
+ if ((old_flags&flag)==0) {
+ old_flags|= flag;
+ *old_min= newKC;
+ *old_num= 1;
+ }
+ else {
+ int last= (*old_min)+(*old_num)-1;
+ if (newKC<*old_min) {
+ *old_min= newKC;
+ *old_num= (last-newKC)+1;
+ }
+ else if (newKC>last) {
+ *old_num= (newKC-(*old_min))+1;
+ }
+ }
+ return old_flags;
+}
+
+Status
+#if NeedFunctionPrototypes
+XkbChangeKeycodeRange( XkbDescPtr xkb,
+ int minKC,
+ int maxKC,
+ XkbChangesPtr changes)
+#else
+XkbChangeKeycodeRange(xkb,minKC,maxKC,changes)
+ XkbDescPtr xkb;
+ int minKC;
+ int maxKC;
+ XkbChangesPtr changes;
+#endif
+{
+int tmp;
+
+ if ((!xkb)||(minKC<XkbMinLegalKeyCode)||(maxKC>XkbMaxLegalKeyCode))
+ return BadValue;
+ if (minKC>maxKC)
+ return BadMatch;
+ if (minKC<xkb->min_key_code) {
+ if (changes)
+ changes->map.min_key_code= minKC;
+ tmp= xkb->min_key_code-minKC;
+ if (xkb->map) {
+ if (xkb->map->key_sym_map) {
+ bzero((char *)&xkb->map->key_sym_map[minKC],
+ tmp*sizeof(XkbSymMapRec));
+ if (changes) {
+ changes->map.changed= _ExtendRange(changes->map.changed,
+ XkbKeySymsMask,minKC,
+ &changes->map.first_key_sym,
+ &changes->map.num_key_syms);
+ }
+ }
+ if (xkb->map->modmap) {
+ bzero((char *)&xkb->map->modmap[minKC],tmp);
+ if (changes) {
+ changes->map.changed= _ExtendRange(changes->map.changed,
+ XkbModifierMapMask,minKC,
+ &changes->map.first_modmap_key,
+ &changes->map.num_modmap_keys);
+ }
+ }
+ }
+ if (xkb->server) {
+ if (xkb->server->behaviors) {
+ bzero((char *)&xkb->server->behaviors[minKC],
+ tmp*sizeof(XkbBehavior));
+ if (changes) {
+ changes->map.changed= _ExtendRange(changes->map.changed,
+ XkbKeyBehaviorsMask,minKC,
+ &changes->map.first_key_behavior,
+ &changes->map.num_key_behaviors);
+ }
+ }
+ if (xkb->server->key_acts) {
+ bzero((char *)&xkb->server->key_acts[minKC],
+ tmp*sizeof(unsigned short));
+ if (changes) {
+ changes->map.changed= _ExtendRange(changes->map.changed,
+ XkbKeyActionsMask,minKC,
+ &changes->map.first_key_act,
+ &changes->map.num_key_acts);
+ }
+ }
+ if (xkb->server->vmodmap) {
+ bzero((char *)&xkb->server->vmodmap[minKC],
+ tmp*sizeof(unsigned short));
+ if (changes) {
+ changes->map.changed= _ExtendRange(changes->map.changed,
+ XkbVirtualModMapMask,minKC,
+ &changes->map.first_modmap_key,
+ &changes->map.num_vmodmap_keys);
+ }
+ }
+ }
+ if ((xkb->names)&&(xkb->names->keys)) {
+ bzero((char *)&xkb->names->keys[minKC],tmp*sizeof(XkbKeyNameRec));
+ if (changes) {
+ changes->names.changed= _ExtendRange(changes->names.changed,
+ XkbKeyNamesMask,minKC,
+ &changes->names.first_key,
+ &changes->names.num_keys);
+ }
+ }
+ xkb->min_key_code= minKC;
+ }
+ if (maxKC>xkb->max_key_code) {
+ if (changes)
+ changes->map.max_key_code= maxKC;
+ tmp= maxKC-xkb->max_key_code;
+ if (xkb->map) {
+ if (xkb->map->key_sym_map) {
+ xkb->map->key_sym_map= _XkbTypedRealloc(xkb->map->key_sym_map,
+ (maxKC+1),XkbSymMapRec);
+ if (!xkb->map->key_sym_map)
+ return BadAlloc;
+ bzero((char *)&xkb->map->key_sym_map[xkb->max_key_code],
+ tmp*sizeof(XkbSymMapRec));
+ if (changes) {
+ changes->map.changed= _ExtendRange(changes->map.changed,
+ XkbKeySymsMask,maxKC,
+ &changes->map.first_key_sym,
+ &changes->map.num_key_syms);
+ }
+ }
+ if (xkb->map->modmap) {
+ xkb->map->modmap= _XkbTypedRealloc(xkb->map->modmap,
+ (maxKC+1),unsigned char);
+ if (!xkb->map->modmap)
+ return BadAlloc;
+ bzero((char *)&xkb->map->modmap[xkb->max_key_code],tmp);
+ if (changes) {
+ changes->map.changed= _ExtendRange(changes->map.changed,
+ XkbModifierMapMask,maxKC,
+ &changes->map.first_modmap_key,
+ &changes->map.num_modmap_keys);
+ }
+ }
+ }
+ if (xkb->server) {
+ if (xkb->server->behaviors) {
+ xkb->server->behaviors=_XkbTypedRealloc(xkb->server->behaviors,
+ (maxKC+1),XkbBehavior);
+ if (!xkb->server->behaviors)
+ return BadAlloc;
+ bzero((char *)&xkb->server->behaviors[xkb->max_key_code],
+ tmp*sizeof(XkbBehavior));
+ if (changes) {
+ changes->map.changed= _ExtendRange(changes->map.changed,
+ XkbKeyBehaviorsMask,maxKC,
+ &changes->map.first_key_behavior,
+ &changes->map.num_key_behaviors);
+ }
+ }
+ if (xkb->server->key_acts) {
+ xkb->server->key_acts= _XkbTypedRealloc(xkb->server->key_acts,
+ (maxKC+1),unsigned short);
+ if (!xkb->server->key_acts)
+ return BadAlloc;
+ bzero((char *)&xkb->server->key_acts[xkb->max_key_code],
+ tmp*sizeof(unsigned short));
+ if (changes) {
+ changes->map.changed= _ExtendRange(changes->map.changed,
+ XkbKeyActionsMask,maxKC,
+ &changes->map.first_key_act,
+ &changes->map.num_key_acts);
+ }
+ }
+ if (xkb->server->vmodmap) {
+ xkb->server->vmodmap= _XkbTypedRealloc(xkb->server->vmodmap,
+ (maxKC+1),unsigned short);
+ if (!xkb->server->vmodmap)
+ return BadAlloc;
+ bzero((char *)&xkb->server->vmodmap[xkb->max_key_code],
+ tmp*sizeof(unsigned short));
+ if (changes) {
+ changes->map.changed= _ExtendRange(changes->map.changed,
+ XkbVirtualModMapMask,maxKC,
+ &changes->map.first_modmap_key,
+ &changes->map.num_vmodmap_keys);
+ }
+ }
+ }
+ if ((xkb->names)&&(xkb->names->keys)) {
+ xkb->names->keys= _XkbTypedRealloc(xkb->names->keys,
+ (maxKC+1),XkbKeyNameRec);
+ if (!xkb->names->keys)
+ return BadAlloc;
+ bzero((char *)&xkb->names->keys[xkb->max_key_code],
+ tmp*sizeof(XkbKeyNameRec));
+ if (changes) {
+ changes->names.changed= _ExtendRange(changes->names.changed,
+ XkbKeyNamesMask,maxKC,
+ &changes->names.first_key,
+ &changes->names.num_keys);
+ }
+ }
+ xkb->max_key_code= maxKC;
+ }
+ return Success;
+}
+
XkbAction *
#if NeedFunctionPrototypes
XkbResizeKeyActions(XkbDescPtr xkb,int key,int needed)
diff --git a/lib/X11/XKBMisc.c b/lib/X11/XKBMisc.c
index da384f5f7..76956354a 100644
--- a/lib/X11/XKBMisc.c
+++ b/lib/X11/XKBMisc.c
@@ -1,4 +1,4 @@
-/* $XConsortium: XKBMisc.c /main/2 1996/02/03 06:04:25 kaleb $ */
+/* $XConsortium: XKBMisc.c /main/3 1996/03/01 14:29:50 kaleb $ */
/************************************************************
Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
@@ -517,31 +517,31 @@ unsigned changed,changedVMods,tmp;
}
else {
XkbAction *pActs;
+ unsigned int new_vmodmask;
changed|= XkbKeyActionsMask;
pActs= XkbResizeKeyActions(xkb,key,nSyms);
if (!pActs)
return False;
+ new_vmodmask= 0;
for (n=0;n<nSyms;n++) {
if (interps[n]) {
unsigned effMods;
pActs[n]= *((XkbAction *)&interps[n]->act);
- if ((n==0)||((interps[n]->match&XkbSI_LevelOneOnly)==0))
+ if ((n==0)||((interps[n]->match&XkbSI_LevelOneOnly)==0)) {
effMods= mods;
+ if (interps[n]->virtual_mod!=XkbNoModifier)
+ new_vmodmask|= (1<<interps[n]->virtual_mod);
+ }
else effMods= 0;
_XkbSetActionKeyMods(xkb,&pActs[n],effMods);
}
else pActs[n].type= XkbSA_NoAction;
}
- if ((explicit&XkbExplicitVModMapMask)==0) {
- unsigned new_vmodmask;
- if (interps[0]&&(interps[0]->virtual_mod!=XkbNoModifier))
- new_vmodmask= (1<<interps[0]->virtual_mod);
- else new_vmodmask= 0;
- if (xkb->server->vmodmap[key]!=new_vmodmask) {
- changed|= XkbVirtualModMapMask;
- xkb->server->vmodmap[key]= new_vmodmask;
- }
+ if (((explicit&XkbExplicitVModMapMask)==0)&&
+ (xkb->server->vmodmap[key]!=new_vmodmask)) {
+ changed|= XkbVirtualModMapMask;
+ xkb->server->vmodmap[key]= new_vmodmask;
}
if (interps[0]) {
if ((interps[0]->flags&XkbSI_LockingKey)&&
diff --git a/lib/X11/XKBSetGeom.c b/lib/X11/XKBSetGeom.c
index 0327536f1..2dc6b05f2 100644
--- a/lib/X11/XKBSetGeom.c
+++ b/lib/X11/XKBSetGeom.c
@@ -1,4 +1,4 @@
-/* $XConsortium: XKBSetGeom.c /main/2 1996/02/02 14:38:34 kaleb $ */
+/* $XConsortium: XKBSetGeom.c /main/4 1996/03/01 14:29:56 kaleb $ */
/************************************************************
Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
diff --git a/lib/X11/XKBSetMap.c b/lib/X11/XKBSetMap.c
index 7f1667b16..9ef479bcb 100644
--- a/lib/X11/XKBSetMap.c
+++ b/lib/X11/XKBSetMap.c
@@ -1,4 +1,4 @@
-/* $XConsortium: XKBSetMap.c,v 1.3 94/04/02 14:34:00 erik Exp $ */
+/* $XConsortium: XKBSetMap.c /main/8 1996/03/01 14:30:01 kaleb $ */
/************************************************************
Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
@@ -33,62 +33,76 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "XKBlibint.h"
static int
-_XkbSizeKeyTypes(xkb,firstType,nTypes)
- XkbDescRec *xkb;
- unsigned firstType;
- unsigned nTypes;
+#if NeedFunctionPrototypes
+_XkbSizeKeyTypes(XkbDescPtr xkb,xkbSetMapReq *req)
+#else
+_XkbSizeKeyTypes(xkb,req)
+ XkbDescPtr xkb;
+ xkbSetMapReq * req;
+#endif
{
- XkbKeyTypeRec *map;
- int i,n,len;
+ XkbKeyTypePtr map;
+ int i,len;
+ if (((req->present&XkbKeyTypesMask)==0)||(req->nTypes==0)) {
+ req->present&= ~XkbKeyTypesMask;
+ req->firstType= req->nTypes= 0;
+ return 0;
+ }
len= 0;
- map= &xkb->map->types[firstType];
- for (i=0;i<nTypes;i++,map++){
+ map= &xkb->map->types[req->firstType];
+ for (i=0;i<req->nTypes;i++,map++){
len+= SIZEOF(xkbKeyTypeWireDesc);
len+= map->map_count*SIZEOF(xkbKTSetMapEntryWireDesc);
if (map->preserve)
- len+= map->map_count*SIZEOF(xkbKTPreserveWireDesc);
+ len+= map->map_count*SIZEOF(xkbModsWireDesc);
}
return len;
}
static void
-_XkbWriteKeyTypes(dpy,xkb,firstType,nTypes)
- Display *dpy;
- XkbDescRec *xkb;
- unsigned firstType;
- unsigned nTypes;
+#if NeedFunctionPrototypes
+_XkbWriteKeyTypes(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+#else
+_XkbWriteKeyTypes(dpy,xkb,req)
+ Display * dpy;
+ XkbDescPtr xkb;
+ xkbSetMapReq * req;
+#endif
{
- char *buf,*start;
- XkbKeyTypeRec *type;
+ char * buf;
+ XkbKeyTypePtr type;
int i,n,sz;
- xkbKeyTypeWireDesc *desc;
+ xkbKeyTypeWireDesc *desc;
- type= &xkb->map->types[firstType];
- for (i=0;i<nTypes;i++,type++) {
+ if ((req->present&XkbKeyTypesMask)==0)
+ return;
+ type= &xkb->map->types[req->firstType];
+ for (i=0;i<req->nTypes;i++,type++) {
sz= SIZEOF(xkbKeyTypeWireDesc);
sz+= type->map_count*SIZEOF(xkbKTSetMapEntryWireDesc);
if (type->preserve)
- sz+= type->map_count*SIZEOF(xkbKTPreserveWireDesc);
+ sz+= type->map_count*SIZEOF(xkbModsWireDesc);
BufAlloc(xkbKeyTypeWireDesc *,desc,sz);
- desc->mask = type->mask;
- desc->realMods = type->real_mods;
- desc->virtualMods = type->vmods;
- desc->groupWidth = type->group_width;
+ desc->mask = type->mods.mask;
+ desc->realMods = type->mods.real_mods;
+ desc->virtualMods = type->mods.vmods;
+ desc->numLevels = type->num_levels;
desc->nMapEntries = type->map_count;
- start= buf= (char *)&desc[1];
+ desc->preserve = (type->preserve!=NULL);
+ buf= (char *)&desc[1];
if (desc->nMapEntries>0) {
xkbKTSetMapEntryWireDesc *wire;
wire= (xkbKTSetMapEntryWireDesc *)buf;
for (n=0;n<type->map_count;n++,wire++) {
wire->level= type->map[n].level;
- wire->realMods= type->map[n].real_mods;
- wire->virtualMods= type->map[n].vmods;
+ wire->realMods= type->map[n].mods.real_mods;
+ wire->virtualMods= type->map[n].mods.vmods;
}
buf= (char *)wire;
if (type->preserve) {
- xkbKTPreserveWireDesc *pwire;
- pwire= (xkbKTPreserveWireDesc *)buf;
+ xkbModsWireDesc *pwire;
+ pwire= (xkbModsWireDesc *)buf;
for (n=0;n<type->map_count;n++,pwire++) {
pwire->realMods= type->preserve[n].real_mods;
pwire->virtualMods= type->preserve[n].vmods;
@@ -100,103 +114,129 @@ _XkbWriteKeyTypes(dpy,xkb,firstType,nTypes)
}
static int
-_XkbSizeKeySyms(xkb,firstKey,nKeys,nSymsRtrn)
- XkbDescRec *xkb;
- unsigned firstKey;
- unsigned nKeys;
- CARD16 *nSymsRtrn;
+#if NeedFunctionPrototypes
+_XkbSizeKeySyms(XkbDescPtr xkb,xkbSetMapReq *req)
+#else
+_XkbSizeKeySyms(xkb,req)
+ XkbDescPtr xkb;
+ xkbSetMapReq * req;
+#endif
{
- XkbSymMapRec *symMap;
- XkbKeyTypeRec *type;
int i,len;
unsigned nSyms;
- len= nKeys*sizeof(XkbSymMapRec);
- symMap = &xkb->map->key_sym_map[firstKey];
- for (i=nSyms=0;i<nKeys;i++,symMap++) {
- type = &xkb->map->types[symMap->kt_index];
- nSyms+= XkbNumGroups(symMap->group_info)*type->group_width;
+ if (((req->present&XkbKeySymsMask)==0)||(req->nKeySyms==0)) {
+ req->present&= ~XkbKeySymsMask;
+ req->firstKeySym= req->nKeySyms= 0;
+ req->totalSyms= 0;
+ return 0;
}
- len+= nSyms*sizeof(KeySym);
- *nSymsRtrn = nSyms;
+ len= (int)(req->nKeySyms*sizeof(XkbSymMapRec));
+ for (i=nSyms=0;i<req->nKeySyms;i++) {
+ nSyms+= XkbKeyNumSyms(xkb,i+req->firstKeySym);
+ }
+ len+= nSyms*sizeof(CARD32);
+ req->totalSyms= nSyms;
return len;
}
static void
-_XkbWriteKeySyms(dpy,xkb,firstKeySym,nKeySyms,totalSyms)
- Display *dpy;
- XkbDescRec *xkb;
- unsigned firstKeySym;
- unsigned nKeySyms;
- unsigned totalSyms;
+#if NeedFunctionPrototypes
+_XkbWriteKeySyms(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+#else
+_XkbWriteKeySyms(dpy,xkb,req)
+ Display * dpy;
+ XkbDescPtr xkb;
+ xkbSetMapReq * req;
+#endif
{
-register KeySym *pSym,*outSym;
-XkbSymMapRec *symMap;
-XkbKeyTypeRec *keyType;
+register KeySym * pSym;
+CARD32 * outSym;
+XkbSymMapPtr symMap;
xkbSymMapWireDesc *desc;
register int i;
- i= (nKeySyms*SIZEOF(xkbSymMapWireDesc))+(totalSyms*sizeof(KeySym));
- BufAlloc(xkbSymMapWireDesc *,desc,i);
- symMap = &xkb->map->key_sym_map[firstKeySym];
- for (i=0;i<nKeySyms;i++,symMap++) {
- keyType = &xkb->map->types[symMap->kt_index];
- desc->ktIndex = symMap->kt_index;
+ if ((req->present&XkbKeySymsMask)==0)
+ return;
+ symMap = &xkb->map->key_sym_map[req->firstKeySym];
+ for (i=0;i<req->nKeySyms;i++,symMap++) {
+ BufAlloc(xkbSymMapWireDesc *,desc,
+ SIZEOF(xkbSymMapWireDesc)+
+ (XkbKeyNumSyms(xkb,i+req->firstKeySym)*sizeof(CARD32)));
+ desc->ktIndex[0] = symMap->kt_index[0];
+ desc->ktIndex[1] = symMap->kt_index[1];
+ desc->ktIndex[2] = symMap->kt_index[2];
+ desc->ktIndex[3] = symMap->kt_index[3];
desc->groupInfo = symMap->group_info;
- desc->nSyms = XkbNumGroups(symMap->group_info)*keyType->group_width;
- outSym = (KeySym *)&desc[1];
- pSym = &xkb->map->syms[symMap->offset];
- memcpy(outSym,pSym,desc->nSyms*sizeof(KeySym));
- desc = (xkbSymMapWireDesc *)&outSym[desc->nSyms];
+ desc->width = symMap->width;
+ desc->nSyms = XkbKeyNumSyms(xkb,i+req->firstKeySym);
+ outSym = (CARD32 *)&desc[1];
+ if (desc->nSyms>0) {
+ pSym = XkbKeySymsPtr(xkb,i+req->firstKeySym);
+ _XkbWriteCopyKeySyms(pSym,outSym,desc->nSyms);
+ }
}
return;
}
static int
-_XkbSizeKeyActions(xkb,firstKey,nKeys,nActsRtrn)
- XkbDescRec *xkb;
- unsigned firstKey;
- unsigned nKeys;
- CARD16 *nActsRtrn;
+#if NeedFunctionPrototypes
+_XkbSizeKeyActions(XkbDescPtr xkb,xkbSetMapReq *req)
+#else
+_XkbSizeKeyActions(xkb,req)
+ XkbDescPtr xkb;
+ xkbSetMapReq * req;
+#endif
{
int i,len,nActs;
- unsigned nSyms;
- for (nActs=i=0;i<nKeys;i++) {
- if (xkb->server->key_acts[i+firstKey]!=0)
- nActs+= XkbKeyNumActions(xkb,i+firstKey);
+ if (((req->present&XkbKeyActionsMask)==0)||(req->nKeyActs==0)) {
+ req->present&= ~XkbKeyActionsMask;
+ req->firstKeyAct= req->nKeyActs= 0;
+ req->totalActs= 0;
+ return 0;
}
- len= (((nKeys+3)/4)*4)+(nActs*sizeof(XkbAction));
- *nActsRtrn = nActs;
+ for (nActs=i=0;i<req->nKeyActs;i++) {
+ if (xkb->server->key_acts[i+req->firstKeyAct]!=0)
+ nActs+= XkbKeyNumActions(xkb,i+req->firstKeyAct);
+ }
+ len= XkbPaddedSize(req->nKeyActs)+(nActs*SIZEOF(xkbActionWireDesc));
+ req->totalActs= nActs;
return len;
}
static void
-_XkbWriteKeyActions(dpy,xkb,firstKey,nKeys,totalActs)
- Display *dpy;
- XkbDescRec *xkb;
- unsigned firstKey;
- unsigned nKeys;
- unsigned totalActs;
+#if NeedFunctionPrototypes
+_XkbWriteKeyActions(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+#else
+_XkbWriteKeyActions(dpy,xkb,req)
+ Display * dpy;
+ XkbDescPtr xkb;
+ xkbSetMapReq * req;
+#endif
{
register int i;
int n;
CARD8 *numDesc;
XkbAction *actDesc;
- n = (((nKeys+3)/4)*4)+totalActs*sizeof(XkbAction);
+ if ((req->present&XkbKeyActionsMask)==0)
+ return;
+ n = XkbPaddedSize(req->nKeyActs);
+ n+= (req->totalActs*SIZEOF(xkbActionWireDesc));
+
BufAlloc(CARD8 *,numDesc,n);
- for (i=0;i<nKeys;i++) {
- if (xkb->server->key_acts[i+firstKey]==0)
+ for (i=0;i<req->nKeyActs;i++) {
+ if (xkb->server->key_acts[i+req->firstKeyAct]==0)
numDesc[i] = 0;
- else numDesc[i] = XkbKeyNumActions(xkb,(i+firstKey));
+ else numDesc[i] = XkbKeyNumActions(xkb,(i+req->firstKeyAct));
}
- actDesc = (XkbAction *)&numDesc[(((nKeys)+3)/4)*4];
- for (i=0;i<nKeys;i++) {
- if (xkb->server->key_acts[i+firstKey]!=0) {
- n = XkbKeyNumActions(xkb,(i+firstKey));
- memcpy(actDesc,XkbKeyActionsPtr(xkb,(i+firstKey)),
- n*sizeof(XkbAction));
+ actDesc = (XkbAction *)&numDesc[XkbPaddedSize(req->nKeyActs)];
+ for (i=0;i<req->nKeyActs;i++) {
+ if (xkb->server->key_acts[i+req->firstKeyAct]!=0) {
+ n = XkbKeyNumActions(xkb,(i+req->firstKeyAct));
+ memcpy(actDesc,XkbKeyActionsPtr(xkb,(i+req->firstKeyAct)),
+ n*SIZEOF(xkbActionWireDesc));
actDesc+= n;
}
}
@@ -204,26 +244,24 @@ _XkbWriteKeyActions(dpy,xkb,firstKey,nKeys,totalActs)
}
static int
-_XkbSizeKeyBehaviors(xkb,req,pChanges)
+#if NeedFunctionPrototypes
+_XkbSizeKeyBehaviors(XkbDescPtr xkb,xkbSetMapReq *req)
+#else
+_XkbSizeKeyBehaviors(xkb,req)
XkbDescPtr xkb;
xkbSetMapReq * req;
- XkbMapChangesRec * pChanges;
+#endif
{
register int i,first,last,nFound;
- if ((req->present&XkbKeyBehaviorsMask)==0) {
+ if (((req->present&XkbKeyBehaviorsMask)==0)||(req->nKeyBehaviors<1)) {
+ req->present&= ~XkbKeyBehaviorsMask;
+ req->firstKeyBehavior= req->nKeyBehaviors= 0;
req->totalKeyBehaviors= 0;
return 0;
}
- else if (pChanges) {
- first= pChanges->first_key_behavior;
- last= first+pChanges->num_key_behaviors-1;
- }
- else {
- first= xkb->min_key_code;
- last= xkb->max_key_code;
- }
-
+ first= req->firstKeyBehavior;
+ last= first+req->nKeyBehaviors-1;
for (i=first,nFound=0;i<=last;i++) {
if (xkb->server->behaviors[i].type!=XkbKB_Default)
nFound++;
@@ -233,120 +271,134 @@ register int i,first,last,nFound;
}
static void
-_XkbWriteKeyBehaviors(dpy,xkb,req,pChanges)
+#if NeedFunctionPrototypes
+_XkbWriteKeyBehaviors(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+#else
+_XkbWriteKeyBehaviors(dpy,xkb,req)
Display * dpy;
XkbDescPtr xkb;
xkbSetMapReq * req;
- XkbMapChangesRec * pChanges;
+#endif
{
-register int i,first,last;
-xkbBehaviorWireDesc *wire;
+register int i,first,last;
+xkbBehaviorWireDesc * wire;
+char * buf;
if ((req->present&XkbKeyBehaviorsMask)==0)
return;
- if (pChanges) {
- first= pChanges->first_key_behavior;
- last= first+pChanges->num_key_behaviors-1;
- }
- else {
- first= xkb->min_key_code;
- last= xkb->max_key_code;
- }
+ first= req->firstKeyBehavior;
+ last= first+req->nKeyBehaviors-1;
+
i= req->totalKeyBehaviors*SIZEOF(xkbBehaviorWireDesc);
- BufAlloc(xkbBehaviorWireDesc *,wire,i);
+ BufAlloc(char *,buf,i);
+ wire= (xkbBehaviorWireDesc *)buf;
for (i=first;i<=last;i++) {
if (xkb->server->behaviors[i].type!=XkbKB_Default) {
wire->key= i;
wire->type= xkb->server->behaviors[i].type;
wire->data= xkb->server->behaviors[i].data;
- wire++;
+ buf+= SIZEOF(xkbBehaviorWireDesc);
+ wire= (xkbBehaviorWireDesc *)buf;
}
}
return;
}
-static int
-_XkbSizeVirtualMods(xkb,which)
- XkbDescPtr xkb;
- unsigned which;
+static unsigned
+#if NeedFunctionPrototypes
+_XkbSizeVirtualMods(xkbSetMapReq *req)
+#else
+_XkbSizeVirtualMods(req)
+ xkbSetMapReq * req;
+#endif
{
register int i,bit,nMods;
+ if (((req->present&XkbVirtualModsMask)==0)||(req->virtualMods==0)) {
+ req->present&= ~XkbVirtualModsMask;
+ req->virtualMods= 0;
+ return 0;
+ }
for (i=nMods=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
- if (which&bit)
+ if (req->virtualMods&bit)
nMods++;
}
- return ((nMods+(unsigned)3)/4)*4;
+ return XkbPaddedSize(nMods);
}
static void
-_XkbWriteVirtualMods(dpy,xkb,which,size)
+#if NeedFunctionPrototypes
+_XkbWriteVirtualMods( Display * dpy,
+ XkbDescPtr xkb,
+ xkbSetMapReq * req,
+ unsigned size)
+#else
+_XkbWriteVirtualMods(dpy,xkb,req,size)
Display * dpy;
XkbDescPtr xkb;
- unsigned which;
+ xkbSetMapReq * req;
unsigned size;
+#endif
{
register int i,bit;
CARD8 *vmods;
+ if ((req->present&XkbVirtualModsMask==0)||(size<1))
+ return;
BufAlloc(CARD8 *,vmods,size);
for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
- if (which&bit)
+ if (req->virtualMods&bit)
*vmods++= xkb->server->vmods[i];
}
return;
}
static int
-_XkbSizeKeyExplicit(xkb,req,pChanges)
+#if NeedFunctionPrototypes
+_XkbSizeKeyExplicit(XkbDescPtr xkb,xkbSetMapReq *req)
+#else
+_XkbSizeKeyExplicit(xkb,req)
XkbDescPtr xkb;
xkbSetMapReq * req;
- XkbMapChangesPtr pChanges;
+#endif
{
register int i,first,last,nFound;
- if ((req->present&XkbExplicitComponentsMask)==0) {
+ if (((req->present&XkbExplicitComponentsMask)==0)||(req->nKeyExplicit==0)) {
+ req->present&= ~XkbExplicitComponentsMask;
+ req->firstKeyExplicit= req->nKeyExplicit= 0;
req->totalKeyExplicit= 0;
return 0;
}
- else if (pChanges) {
- first= pChanges->first_key_explicit;
- last= first+pChanges->num_key_explicit-1;
- }
- else {
- first= xkb->min_key_code;
- last= xkb->max_key_code;
- }
+ first= req->firstKeyExplicit;
+ last= first+req->nKeyExplicit-1;
for (i=first,nFound=0;i<=last;i++) {
if (xkb->server->explicit[i]!=0)
nFound++;
}
req->totalKeyExplicit= nFound;
- return (((nFound*2)+3)/4)*4;
+ return XkbPaddedSize((nFound*2));
}
static void
-_XkbWriteKeyExplicit(dpy,xkb,req,pChanges)
+#if NeedFunctionPrototypes
+_XkbWriteKeyExplicit(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+#else
+_XkbWriteKeyExplicit(dpy,xkb,req)
Display * dpy;
XkbDescPtr xkb;
xkbSetMapReq * req;
- XkbMapChangesPtr pChanges;
+#endif
{
register int i,first,last;
CARD8 * wire;
if ((req->present&XkbExplicitComponentsMask)==0)
return;
- else if (pChanges) {
- first= pChanges->first_key_explicit;
- last= first+pChanges->num_key_explicit-1;
- }
- else {
- first= xkb->min_key_code;
- last= xkb->max_key_code;
- }
- i= (((req->totalKeyExplicit*2)+3)/4)*4;
+ first= req->firstKeyExplicit;
+ last= first+req->nKeyExplicit;
+ i= XkbPaddedSize((req->totalKeyExplicit*2));
BufAlloc(CARD8 *,wire,i);
for (i=first;i<=last;i++) {
if (xkb->server->explicit[i]!=0) {
@@ -358,69 +410,197 @@ CARD8 * wire;
return;
}
+static int
+#if NeedFunctionPrototypes
+_XkbSizeModifierMap(XkbDescPtr xkb,xkbSetMapReq *req)
+#else
+_XkbSizeModifierMap(xkb,req)
+ XkbDescPtr xkb;
+ xkbSetMapReq * req;
+#endif
+{
+register int i,first,last,nFound;
+
+ if (((req->present&XkbModifierMapMask)==0)||(req->nModMapKeys==0)) {
+ req->present&= ~XkbModifierMapMask;
+ req->firstModMapKey= req->nModMapKeys= 0;
+ req->totalModMapKeys= 0;
+ return 0;
+ }
+ first= req->firstModMapKey;
+ last= first+req->nModMapKeys-1;
+
+ for (i=first,nFound=0;i<=last;i++) {
+ if (xkb->map->modmap[i]!=0)
+ nFound++;
+ }
+ req->totalModMapKeys= nFound;
+ return XkbPaddedSize((nFound*2));
+}
+
+static void
+#if NeedFunctionPrototypes
+_XkbWriteModifierMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+#else
+_XkbWriteModifierMap(dpy,xkb,req)
+ Display * dpy;
+ XkbDescPtr xkb;
+ xkbSetMapReq * req;
+#endif
+{
+register int i,first,last;
+CARD8 * wire;
+
+ if ((req->present&XkbModifierMapMask)==0)
+ return;
+ first= req->firstModMapKey;
+ last= first+req->nModMapKeys-1;
+ if (req->totalModMapKeys>0) {
+ i= XkbPaddedSize((req->totalModMapKeys*2));
+ BufAlloc(CARD8 *,wire,i);
+ for (i=first;i<=last;i++) {
+ if (xkb->map->modmap[i]!=0) {
+ wire[0]= i;
+ wire[1]= xkb->map->modmap[i];
+ wire+= 2;
+ }
+ }
+ }
+ return;
+}
+
+static int
+#if NeedFunctionPrototypes
+_XkbSizeVirtualModMap(XkbDescPtr xkb,xkbSetMapReq *req)
+#else
+_XkbSizeVirtualModMap(xkb,req)
+ XkbDescPtr xkb;
+ xkbSetMapReq * req;
+#endif
+{
+register int i,first,last,nFound;
+
+ if (((req->present&XkbVirtualModMapMask)==0)||(req->nVModMapKeys==0)) {
+ req->present&= ~XkbVirtualModMapMask;
+ req->firstVModMapKey= req->nVModMapKeys= 0;
+ req->totalVModMapKeys= 0;
+ return 0;
+ }
+ first= req->firstVModMapKey;
+ last= first+req->nVModMapKeys-1;
+
+ for (i=first,nFound=0;i<=last;i++) {
+ if (xkb->server->vmodmap[i]!=0)
+ nFound++;
+ }
+ req->totalVModMapKeys= nFound;
+ return nFound*SIZEOF(xkbVModMapWireDesc);
+}
+
static void
-SendSetMap(dpy,xkb,req,pChanges)
+#if NeedFunctionPrototypes
+_XkbWriteVirtualModMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+#else
+_XkbWriteVirtualModMap(dpy,xkb,req)
+ Display * dpy;
+ XkbDescPtr xkb;
+ xkbSetMapReq * req;
+#endif
+{
+register int i,first,last;
+xkbVModMapWireDesc * wire;
+
+ if ((req->present&XkbVirtualModMapMask)==0)
+ return;
+ first= req->firstVModMapKey;
+ last= first+req->nVModMapKeys-1;
+ if (req->totalVModMapKeys>0) {
+ i= req->totalVModMapKeys*SIZEOF(xkbVModMapWireDesc);
+ BufAlloc(xkbVModMapWireDesc *,wire,i);
+ for (i=first;i<=last;i++) {
+ if (xkb->server->vmodmap[i]!=0) {
+ wire->key= i;
+ wire->vmods= xkb->server->vmodmap[i];
+ wire++;
+ }
+ }
+ }
+ return;
+}
+
+static void
+#if NeedFunctionPrototypes
+SendSetMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+#else
+SendSetMap(dpy,xkb,req)
Display * dpy;
XkbDescPtr xkb;
xkbSetMapReq * req;
- XkbMapChangesRec * pChanges;
+#endif
{
xkbSetMapReq tmp;
-int szMods;
-CARD16 totalSyms,totalActs;
-
- req->length+= _XkbSizeKeyTypes(xkb,req->firstType,req->nTypes)/4;
- req->length+= _XkbSizeKeySyms(xkb,req->firstKeySym,req->nKeySyms,
- &totalSyms)/4;
- req->length+= _XkbSizeKeyActions(xkb,req->firstKeyAction,req->nKeyActions,
- &totalActs)/4;
- req->length+= _XkbSizeKeyBehaviors(xkb,req,pChanges)/4;
- szMods= _XkbSizeVirtualMods(xkb,req->virtualMods);
+unsigned szMods;
+
+ req->length+= _XkbSizeKeyTypes(xkb,req)/4;
+ req->length+= _XkbSizeKeySyms(xkb,req)/4;
+ req->length+= _XkbSizeKeyActions(xkb,req)/4;
+ req->length+= _XkbSizeKeyBehaviors(xkb,req)/4;
+ szMods= _XkbSizeVirtualMods(req);
req->length+= szMods/4;
- req->length+= _XkbSizeKeyExplicit(xkb,req,pChanges)/4;
- req->totalSyms= totalSyms;
- req->totalActions= totalActs;
+ req->length+= _XkbSizeKeyExplicit(xkb,req)/4;
+ req->length+= _XkbSizeModifierMap(xkb,req)/4;
+ req->length+= _XkbSizeVirtualModMap(xkb,req)/4;
tmp= *req;
if ( tmp.nTypes>0 )
- _XkbWriteKeyTypes(dpy,xkb,tmp.firstType,tmp.nTypes);
+ _XkbWriteKeyTypes(dpy,xkb,&tmp);
if ( tmp.nKeySyms>0 )
- _XkbWriteKeySyms(dpy,xkb,tmp.firstKeySym,tmp.nKeySyms,tmp.totalSyms);
- if ( tmp.nKeyActions )
- _XkbWriteKeyActions(dpy,xkb,tmp.firstKeyAction,tmp.nKeyActions,
- tmp.totalActions);
+ _XkbWriteKeySyms(dpy,xkb,&tmp);
+ if ( tmp.nKeyActs )
+ _XkbWriteKeyActions(dpy,xkb,&tmp);
if ( tmp.totalKeyBehaviors>0 )
- _XkbWriteKeyBehaviors(dpy,xkb,&tmp,pChanges);
+ _XkbWriteKeyBehaviors(dpy,xkb,&tmp);
if ( tmp.virtualMods )
- _XkbWriteVirtualMods(dpy,xkb,tmp.virtualMods,szMods);
+ _XkbWriteVirtualMods(dpy,xkb,&tmp,szMods);
if ( tmp.totalKeyExplicit>0)
- _XkbWriteKeyExplicit(dpy,xkb,&tmp,pChanges);
+ _XkbWriteKeyExplicit(dpy,xkb,&tmp);
+ if ( tmp.totalModMapKeys>0)
+ _XkbWriteModifierMap(dpy,xkb,&tmp);
+ if ( tmp.totalVModMapKeys>0)
+ _XkbWriteVirtualModMap(dpy,xkb,&tmp);
return;
}
-Status
+Bool
+#if NeedFunctionPrototypes
+XkbSetMap(Display *dpy,unsigned which,XkbDescPtr xkb)
+#else
XkbSetMap(dpy,which,xkb)
- Display *dpy;
- unsigned which;
- XkbDescRec *xkb;
+ Display * dpy;
+ unsigned which;
+ XkbDescPtr xkb;
+#endif
{
- register xkbSetMapReq *req;
- XkbInfoPtr xkbi;
+register xkbSetMapReq * req;
+XkbInfoPtr xkbi;
+XkbServerMapPtr srv;
+XkbClientMapPtr map;
if ((dpy->flags & XlibDisplayNoXkb) ||
- (!dpy->xkb_info && !XkbUseExtension(dpy)))
+ (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))||
+ (!xkb))
return False;
-
- if (((which&XkbKeyTypesMask)&&(!xkb->map->types))||
- ((which&XkbKeySymsMask)&&
- ((!xkb->map->syms)||(!xkb->map->key_sym_map)))||
- ((which&XkbKeyActionsMask)&&
- ((!xkb->server)||(!xkb->server->key_acts)))||
- ((which&XkbKeyBehaviorsMask)&&
- ((!xkb->server)||(!xkb->server->behaviors)))||
- ((which&XkbVirtualModsMask)&&(!xkb->server))||
- ((which&XkbExplicitComponentsMask)&&
- ((!xkb->server)||(!xkb->server->explicit))))
+ map= xkb->map;
+ srv= xkb->server;
+
+ if (((which&XkbKeyTypesMask)&&((!map)||(!map->types)))||
+ ((which&XkbKeySymsMask)&&((!map)||(!map->syms)||(!map->key_sym_map)))||
+ ((which&XkbKeyActionsMask)&&((!srv)||(!srv->key_acts)))||
+ ((which&XkbKeyBehaviorsMask)&&((!srv)||(!srv->behaviors)))||
+ ((which&XkbVirtualModsMask)&&(!srv))||
+ ((which&XkbExplicitComponentsMask)&&((!srv)||(!srv->explicit)))||
+ ((which&XkbModifierMapMask)&&((!map)||(!map->modmap)))||
+ ((which&XkbVirtualModMapMask)&&((!srv)||(!srv->vmodmap))))
return False;
LockDisplay(dpy);
@@ -430,50 +610,76 @@ XkbSetMap(dpy,which,xkb)
req->xkbReqType = X_kbSetMap;
req->deviceSpec = xkb->device_spec;
req->present = which;
- req->resize = which&XkbResizableInfoMask;
+ req->flags = XkbSetMapAllFlags;
+ req->minKeyCode= xkb->min_key_code;
+ req->maxKeyCode= xkb->max_key_code;
req->firstType = 0;
- if (which&XkbKeyTypesMask) req->nTypes = xkb->map->num_types;
+ if (which&XkbKeyTypesMask) req->nTypes = map->num_types;
else req->nTypes = 0;
- req->firstKeySym = 0;
if (which&XkbKeySymsMask) {
req->firstKeySym = xkb->min_key_code;
- req->nKeySyms = xkb->max_key_code-xkb->min_key_code+1;
+ req->nKeySyms = XkbNumKeys(xkb);
}
if (which&XkbKeyActionsMask) {
- req->firstKeyAction = xkb->min_key_code;
- req->nKeyActions = xkb->max_key_code-xkb->min_key_code+1;
+ req->firstKeyAct = xkb->min_key_code;
+ req->nKeyActs = XkbNumKeys(xkb);
+ }
+ if (which&XkbKeyBehaviorsMask) {
+ req->firstKeyBehavior = xkb->min_key_code;
+ req->nKeyBehaviors = XkbNumKeys(xkb);
}
if (which&XkbVirtualModsMask)
req->virtualMods= ~0;
- SendSetMap(dpy,xkb,req,NULL);
+ if (which&XkbExplicitComponentsMask) {
+ req->firstKeyExplicit= xkb->min_key_code;
+ req->nKeyExplicit = XkbNumKeys(xkb);
+ }
+ if (which&XkbModifierMapMask) {
+ req->firstModMapKey= xkb->min_key_code;
+ req->nModMapKeys = XkbNumKeys(xkb);
+ }
+ if (which&XkbVirtualModMapMask) {
+ req->firstVModMapKey= xkb->min_key_code;
+ req->nVModMapKeys = XkbNumKeys(xkb);
+ }
+ SendSetMap(dpy,xkb,req);
UnlockDisplay(dpy);
SyncHandle();
return True;
}
-Status
+Bool
+#if NeedFunctionPrototypes
+XkbChangeMap(Display *dpy,XkbDescPtr xkb,XkbMapChangesPtr changes)
+#else
XkbChangeMap(dpy,xkb,changes)
- Display *dpy;
- XkbDescRec *xkb;
- XkbMapChangesRec *changes;
+ Display * dpy;
+ XkbDescPtr xkb;
+ XkbMapChangesPtr changes;
+#endif
{
- register xkbSetMapReq *req;
- XkbInfoPtr xkbi;
+register xkbSetMapReq * req;
+XkbInfoPtr xkbi;
+XkbServerMapPtr srv;
+XkbClientMapPtr map;
if ((dpy->flags & XlibDisplayNoXkb) ||
- (!dpy->xkb_info && !XkbUseExtension(dpy)))
+ (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))||
+ (!xkb)||(!changes))
return False;
-
- if (((changes->changed&XkbKeyTypesMask)&&(!xkb->map->types))||
- ((changes->changed&XkbKeySymsMask)&&((!xkb->map->syms)||
- (!xkb->map->key_sym_map)))||
- ((changes->changed&XkbKeyActionsMask)&&
- ((!xkb->server)||(!xkb->server->key_acts)))||
- ((changes->changed&XkbKeyBehaviorsMask)&&
- ((!xkb->server)||(!xkb->server->behaviors)))||
- ((changes->changed&XkbVirtualModsMask)&&(!xkb->server))||
+ srv= xkb->server;
+ map= xkb->map;
+
+ if (((changes->changed&XkbKeyTypesMask)&&((!map)||(!map->types)))||
+ ((changes->changed&XkbKeySymsMask)&&((!map)||(!map->syms)||
+ (!map->key_sym_map)))||
+ ((changes->changed&XkbKeyActionsMask)&&((!srv)||(!srv->key_acts)))||
+ ((changes->changed&XkbKeyBehaviorsMask)&&((!srv)||(!srv->behaviors)))||
+ ((changes->changed&XkbVirtualModsMask)&&(!srv))||
((changes->changed&XkbExplicitComponentsMask)&&
- ((!xkb->server)||(!xkb->server->explicit))))
+ ((!srv)||(!srv->explicit)))||
+ ((changes->changed&XkbModifierMapMask)&&((!map)||(!map->modmap)))||
+ ((changes->changed&XkbVirtualModMapMask)&&((!srv)||(!srv->vmodmap))))
return False;
LockDisplay(dpy);
@@ -483,15 +689,25 @@ XkbChangeMap(dpy,xkb,changes)
req->xkbReqType = X_kbSetMap;
req->deviceSpec = xkb->device_spec;
req->present = changes->changed;
- req->resize = 0;
+ req->flags = XkbSetMapRecomputeActions;
+ req->minKeyCode= xkb->min_key_code;
+ req->maxKeyCode= xkb->max_key_code;
req->firstType = changes->first_type;
req->nTypes = changes->num_types;
req->firstKeySym = changes->first_key_sym;
req->nKeySyms = changes->num_key_syms;
- req->firstKeyAction = changes->first_key_act;
- req->nKeyActions = changes->num_key_acts;
+ req->firstKeyAct = changes->first_key_act;
+ req->nKeyActs = changes->num_key_acts;
+ req->firstKeyBehavior = changes->first_key_behavior;
+ req->nKeyBehaviors = changes->num_key_behaviors;
req->virtualMods = changes->vmods;
- SendSetMap(dpy,xkb,req,changes);
+ req->firstKeyExplicit = changes->first_key_explicit;
+ req->nKeyExplicit = changes->num_key_explicit;
+ req->firstModMapKey = changes->first_modmap_key;
+ req->nModMapKeys = changes->num_modmap_keys;
+ req->firstVModMapKey = changes->first_vmodmap_key;
+ req->nVModMapKeys = changes->num_vmodmap_keys;
+ SendSetMap(dpy,xkb,req);
UnlockDisplay(dpy);
SyncHandle();
return True;
diff --git a/lib/X11/XKBUse.c b/lib/X11/XKBUse.c
index 9e878a115..e53bd36d0 100644
--- a/lib/X11/XKBUse.c
+++ b/lib/X11/XKBUse.c
@@ -1,4 +1,4 @@
-/* $XConsortium: XKBUse.c,v 1.5 94/04/08 02:57:29 erik Exp $ */
+/* $XConsortium: XKBUse.c /main/12 1996/03/01 14:30:08 kaleb $ */
/************************************************************
Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
@@ -26,6 +26,7 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
********************************************************/
#include <stdio.h>
+#include <ctype.h>
#define NEED_REPLIES
#define NEED_EVENTS
#include "Xlibint.h"
@@ -39,10 +40,14 @@ extern char *getenv();
static Bool _XkbIgnoreExtension = False;
void
+#if NeedFunctionPrototypes
+XkbNoteMapChanges(XkbMapChangesPtr old,XkbMapNotifyEvent *new,unsigned wanted)
+#else
XkbNoteMapChanges(old,new,wanted)
- XkbMapChangesRec *old;
- XkbMapNotifyEvent *new;
- unsigned int wanted;
+ XkbMapChangesPtr old;
+ XkbMapNotifyEvent * new;
+ unsigned int wanted;
+#endif
{
int first,oldLast,newLast;
wanted&= new->changed;
@@ -140,19 +145,60 @@ XkbNoteMapChanges(old,new,wanted)
old->num_key_explicit = new->num_key_explicit;
}
}
+ if (wanted&XkbModifierMapMask) {
+ if (old->changed&XkbModifierMapMask) {
+ first = old->first_modmap_key;
+ oldLast = old->first_modmap_key+old->num_modmap_keys-1;
+ newLast = new->first_modmap_key+new->num_modmap_keys-1;
+
+ if (new->first_modmap_key<first)
+ first = new->first_modmap_key;
+ if (oldLast>newLast)
+ newLast= oldLast;
+ old->first_modmap_key = first;
+ old->num_modmap_keys = newLast-first+1;
+ }
+ else {
+ old->first_modmap_key = new->first_modmap_key;
+ old->num_modmap_keys = new->num_modmap_keys;
+ }
+ }
+ if (wanted&XkbVirtualModMapMask) {
+ if (old->changed&XkbVirtualModMapMask) {
+ first = old->first_vmodmap_key;
+ oldLast = old->first_vmodmap_key+old->num_vmodmap_keys-1;
+ newLast = new->first_vmodmap_key+new->num_vmodmap_keys-1;
+
+ if (new->first_vmodmap_key<first)
+ first = new->first_vmodmap_key;
+ if (oldLast>newLast)
+ newLast= oldLast;
+ old->first_vmodmap_key = first;
+ old->num_vmodmap_keys = newLast-first+1;
+ }
+ else {
+ old->first_vmodmap_key = new->first_vmodmap_key;
+ old->num_vmodmap_keys = new->num_vmodmap_keys;
+ }
+ }
old->changed|= wanted;
return;
}
void
-XkbNoteCoreMapChanges(old,new,wanted)
- XkbMapChangesRec *old;
- XMappingEvent *new;
- unsigned int wanted;
+#if NeedFunctionPrototypes
+_XkbNoteCoreMapChanges( XkbMapChangesPtr old,
+ XMappingEvent * new,
+ unsigned int wanted)
+#else
+_XkbNoteCoreMapChanges(old,new,wanted)
+ XkbMapChangesPtr old;
+ XMappingEvent * new;
+ unsigned int wanted;
+#endif
{
int first,oldLast,newLast;
-
if ((new->request==MappingKeyboard)&&(wanted&XkbKeySymsMask)) {
if (old->changed&XkbKeySymsMask) {
first = old->first_key_sym;
@@ -176,22 +222,26 @@ XkbNoteCoreMapChanges(old,new,wanted)
}
static Bool
+#if NeedFunctionPrototypes
+wire_to_event(Display *dpy,XEvent *re,xEvent *event)
+#else
wire_to_event(dpy,re,event)
Display *dpy;
XEvent *re;
xEvent *event;
+#endif
{
xkbEvent *xkbevent= (xkbEvent *)event;
XkbInfoPtr xkbi;
if ((dpy->flags & XlibDisplayNoXkb) ||
- (!dpy->xkb_info && !XkbUseExtension(dpy)))
+ (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
return False;
xkbi = dpy->xkb_info;
if (((event->u.u.type&0x7f)-xkbi->codes->first_event)!=XkbEventCode)
return False;
- switch (xkbevent->u.any.xkbType&0x7f) {
+ switch (xkbevent->u.any.xkbType) {
case XkbStateNotify:
{
xkbStateNotify *sn = (xkbStateNotify *)event;
@@ -219,6 +269,11 @@ wire_to_event(dpy,re,event)
sev->latched_mods = sn->latchedMods;
sev->locked_mods = sn->lockedMods;
sev->compat_state = sn->compatState;
+ sev->grab_mods = sn->grabMods;
+ sev->compat_grab_mods = sn->compatGrabMods;
+ sev->lookup_mods = sn->lookupMods;
+ sev->compat_lookup_mods = sn->compatLookupMods;
+ sev->ptr_buttons = sn->ptrBtnState;
return True;
}
}
@@ -226,7 +281,8 @@ wire_to_event(dpy,re,event)
case XkbMapNotify:
{
xkbMapNotify *mn = (xkbMapNotify *)event;
- if (xkbi->selected_events&XkbMapNotifyMask) {
+ if ((xkbi->selected_events&XkbMapNotifyMask)&&
+ (xkbi->selected_map_details&mn->changed)) {
XkbMapNotifyEvent *mev;
mev =(XkbMapNotifyEvent *)re;
mev->type = XkbEventCode+xkbi->codes->first_event;
@@ -238,17 +294,23 @@ wire_to_event(dpy,re,event)
mev->time = mn->time;
mev->device = mn->deviceID;
mev->changed = mn->changed;
+ mev->min_key_code = mn->minKeyCode;
+ mev->max_key_code = mn->maxKeyCode;
mev->first_type = mn->firstType;
mev->num_types = mn->nTypes;
mev->first_key_sym = mn->firstKeySym;
mev->num_key_syms = mn->nKeySyms;
- mev->first_key_act = mn->firstKeyAction;
- mev->num_key_acts = mn->nKeyActions;
+ mev->first_key_act = mn->firstKeyAct;
+ mev->num_key_acts = mn->nKeyActs;
mev->first_key_behavior = mn->firstKeyBehavior;
mev->num_key_behaviors = mn->nKeyBehaviors;
mev->vmods = mn->virtualMods;
mev->first_key_explicit = mn->firstKeyExplicit;
mev->num_key_explicit = mn->nKeyExplicit;
+ mev->first_modmap_key = mn->firstModMapKey;
+ mev->num_modmap_keys = mn->nModMapKeys;
+ mev->first_vmodmap_key = mn->firstVModMapKey;
+ mev->num_vmodmap_keys = mn->nVModMapKeys;
XkbNoteMapChanges(&xkbi->changes,mev,XKB_XLIB_MAP_MASK);
if (xkbi->changes.changed)
xkbi->flags|= XkbMapPending;
@@ -265,7 +327,7 @@ wire_to_event(dpy,re,event)
ev->first_keycode = mn->firstKeySym;
ev->request = MappingKeyboard;
ev->count = mn->nKeySyms;
- XkbNoteCoreMapChanges(&xkbi->changes,ev,XKB_XLIB_MAP_MASK);
+ _XkbNoteCoreMapChanges(&xkbi->changes,ev,XKB_XLIB_MAP_MASK);
if (xkbi->changes.changed)
xkbi->flags|= XkbMapPending;
return True;
@@ -290,6 +352,7 @@ wire_to_event(dpy,re,event)
cev->enabled_ctrls = cn->enabledControls;
cev->enabled_ctrl_changes = cn->enabledControlChanges;
cev->keycode = cn->keycode;
+ cev->num_groups = cn->numGroups;
cev->event_type = cn->eventType;
cev->req_major = cn->requestMajor;
cev->req_minor = cn->requestMinor;
@@ -311,9 +374,8 @@ wire_to_event(dpy,re,event)
iev->display = dpy;
iev->time = in->time;
iev->device = in->deviceID;
- iev->state_changed = in->stateChanged;
+ iev->changed = in->changed;
iev->state= in->state;
- iev->map_changed = in->mapChanged;
return True;
}
}
@@ -332,9 +394,8 @@ wire_to_event(dpy,re,event)
iev->display = dpy;
iev->time = in->time;
iev->device = in->deviceID;
- iev->state_changed = in->stateChanged;
+ iev->changed = in->changed;
iev->state= in->state;
- iev->state_changed = in->mapChanged;
return True;
}
}
@@ -354,33 +415,35 @@ wire_to_event(dpy,re,event)
bev->time = bn->time;
bev->device = bn->deviceID;
bev->percent = bn->percent;
- bev->pitch = bn->percent;
+ bev->pitch = bn->pitch;
bev->duration = bn->duration;
bev->bell_class = bn->bellClass;
bev->bell_id = bn->bellID;
bev->name = bn->name;
bev->window = bn->window;
+ bev->event_only = bn->eventOnly;
return True;
}
}
break;
- case XkbSlowKeyNotify:
+ case XkbAccessXNotify:
{
- if (xkbi->selected_events&XkbSlowKeyNotifyMask) {
- xkbSlowKeyNotify *skn =(xkbSlowKeyNotify *)event;
- XkbSlowKeyNotifyEvent *skev;
- skev =(XkbSlowKeyNotifyEvent *)re;
- skev->type = XkbEventCode+xkbi->codes->first_event;
- skev->xkb_type = XkbSlowKeyNotify;
- skev->serial = _XSetLastRequestRead(dpy,
+ if (xkbi->selected_events&XkbAccessXNotifyMask) {
+ xkbAccessXNotify *axn =(xkbAccessXNotify *)event;
+ XkbAccessXNotifyEvent *axev;
+ axev =(XkbAccessXNotifyEvent *)re;
+ axev->type = XkbEventCode+xkbi->codes->first_event;
+ axev->xkb_type = XkbAccessXNotify;
+ axev->serial = _XSetLastRequestRead(dpy,
(xGenericReply *)event);
- skev->send_event = ((event->u.u.type&0x80)!=0);
- skev->display = dpy;
- skev->time = skn->time;
- skev->device = skn->deviceID;
- skev->slow_key_state = skn->slowKeyState;
- skev->keycode = skn->keycode;
- skev->delay = skn->delay;
+ axev->send_event = ((event->u.u.type&0x80)!=0);
+ axev->display = dpy;
+ axev->time = axn->time;
+ axev->device = axn->deviceID;
+ axev->detail = axn->detail;
+ axev->keycode = axn->keycode;
+ axev->sk_delay = axn->slowKeysDelay;
+ axev->debounce_delay = axn->debounceDelay;
return True;
}
}
@@ -404,12 +467,13 @@ wire_to_event(dpy,re,event)
nev->num_types = nn->nTypes;
nev->first_lvl = nn->firstLevelName;
nev->num_lvls = nn->nLevelNames;
- nev->first_radio_group = nn->firstRadioGroup;
+ nev->num_aliases = nn->nAliases;
nev->num_radio_groups = nn->nRadioGroups;
- nev->num_char_sets = nn->nCharSets;
- nev->changed_mods = nn->changedMods;
nev->changed_vmods = nn->changedVirtualMods;
+ nev->changed_groups = nn->changedGroupNames;
nev->changed_indicators = nn->changedIndicators;
+ nev->first_key = nn->firstKey;
+ nev->num_keys = nn->nKeys;
return True;
}
}
@@ -428,8 +492,7 @@ wire_to_event(dpy,re,event)
cmev->display = dpy;
cmev->time = cmn->time;
cmev->device = cmn->deviceID;
- cmev->changed_mods = cmn->changedMods;
- cmev->changed_vmods = cmn->changedVirtualMods;
+ cmev->changed_groups = cmn->changedGroups;
cmev->first_si = cmn->firstSI;
cmev->num_si = cmn->nSI;
cmev->num_total_si = cmn->nTotalSI;
@@ -437,33 +500,12 @@ wire_to_event(dpy,re,event)
}
}
break;
- case XkbAlternateSymsNotify:
- {
- if (xkbi->selected_events&XkbAlternateSymsNotifyMask) {
- xkbAlternateSymsNotify *asn=(xkbAlternateSymsNotify *)event;
- XkbAlternateSymsNotifyEvent *asev;
- asev =(XkbAlternateSymsNotifyEvent *)re;
- asev->type = XkbEventCode+xkbi->codes->first_event;
- asev->xkb_type = XkbAlternateSymsNotify;
- asev->serial = _XSetLastRequestRead(dpy,
- (xGenericReply *)event);
- asev->send_event = ((event->u.u.type&0x80)!=0);
- asev->display = dpy;
- asev->time = asn->time;
- asev->device = asn->deviceID;
- asev->alt_syms_id = asn->altSymsID;
- asev->first_key = asn->firstKey;
- asev->num_keys = asn->nKeys;
- return True;
- }
- }
- break;
case XkbActionMessage:
{
if (xkbi->selected_events&XkbActionMessageMask) {
xkbActionMessage *am= (xkbActionMessage *)event;
XkbActionMessageEvent *amev;
- amev= (XkbActionMessageEvent *)am;
+ amev= (XkbActionMessageEvent *)re;
amev->type = XkbEventCode+xkbi->codes->first_event;
amev->xkb_type = XkbActionMessage;
amev->serial = _XSetLastRequestRead(dpy,
@@ -475,75 +517,185 @@ wire_to_event(dpy,re,event)
amev->keycode = am->keycode;
amev->press = am->press;
amev->key_event_follows = am->keyEventFollows;
+ amev->group = am->group;
+ amev->mods = am->mods;
memcpy(amev->message,am->message,XkbActionMessageLength);
+ amev->message[XkbActionMessageLength]= '\0';
+ return True;
+ }
+ }
+ break;
+ case XkbExtensionDeviceNotify:
+ {
+ if (xkbi->selected_events&XkbExtensionDeviceNotifyMask) {
+ xkbExtensionDeviceNotify *ed=
+ (xkbExtensionDeviceNotify *)event;
+ XkbExtensionDeviceNotifyEvent *edev;
+ edev= (XkbExtensionDeviceNotifyEvent *)re;
+ edev->type= XkbEventCode+xkbi->codes->first_event;
+ edev->xkb_type= XkbExtensionDeviceNotify;
+ edev->serial= _XSetLastRequestRead(dpy,
+ (xGenericReply *)event);
+ edev->send_event= ((event->u.u.type&0x80)!=0);
+ edev->display= dpy;
+ edev->time= ed->time;
+ edev->device= ed->deviceID;
+ edev->led_class= ed->ledClass;
+ edev->led_id= ed->ledID;
+ edev->reason= ed->reason;
+ edev->supported= ed->supported;
+ edev->leds_defined= ed->ledsDefined;
+ edev->led_state= ed->ledState;
+ edev->first_btn= ed->firstBtn;
+ edev->num_btns= ed->nBtns;
+ edev->unsupported= ed->unsupported;
+ return True;
+ }
+ }
+ break;
+ case XkbNewKeyboardNotify:
+ {
+ xkbNewKeyboardNotify *nkn = (xkbNewKeyboardNotify *)event;
+ if ((xkbi->selected_events&XkbNewKeyboardNotifyMask)&&
+ (xkbi->selected_nkn_details&nkn->changed)) {
+ XkbNewKeyboardNotifyEvent *nkev;
+ nkev =(XkbNewKeyboardNotifyEvent *)re;
+ nkev->type = XkbEventCode+xkbi->codes->first_event;
+ nkev->xkb_type = XkbNewKeyboardNotify;
+ nkev->serial = _XSetLastRequestRead(dpy,
+ (xGenericReply *)event);
+ nkev->send_event = ((event->u.u.type&0x80)!=0);
+ nkev->display = dpy;
+ nkev->time = nkn->time;
+ nkev->device = nkn->deviceID;
+ nkev->old_device = nkn->oldDeviceID;
+ nkev->min_key_code = nkn->minKeyCode;
+ nkev->max_key_code = nkn->maxKeyCode;
+ nkev->old_min_key_code = nkn->oldMinKeyCode;
+ nkev->old_max_key_code = nkn->oldMaxKeyCode;
+ nkev->req_major = nkn->requestMajor;
+ nkev->req_minor = nkn->requestMinor;
+ nkev->changed = nkn->changed;
+ if ((xkbi->desc)&&(nkev->send_event==0)&&
+ ((xkbi->desc->device_spec==nkev->old_device)||
+ (nkev->device!=nkev->old_device))) {
+ xkbi->flags= XkbMapPending|XkbXlibNewKeyboard;
+ }
+ return True;
+ }
+ else if(nkn->changed&(XkbNKN_KeycodesMask|XkbNKN_DeviceIDMask)){
+ register XMappingEvent *ev = (XMappingEvent *)re;
+ ev->type = MappingNotify;
+ ev->serial = _XSetLastRequestRead(dpy,
+ (xGenericReply *)event);
+ ev->send_event = ((event->u.u.type&0x80)!=0);
+ ev->display = dpy;
+ ev->window = 0;
+ ev->first_keycode = dpy->min_keycode;
+ ev->request = MappingKeyboard;
+ ev->count = (dpy->max_keycode-dpy->min_keycode)+1;
+ if ((xkbi->desc)&&(ev->send_event==0)&&
+ ((xkbi->desc->device_spec==nkn->oldDeviceID)||
+ (nkn->deviceID!=nkn->oldDeviceID))) {
+ xkbi->flags|= XkbMapPending|XkbXlibNewKeyboard;
+ }
+ return True;
}
}
break;
default:
+#ifdef DEBUG
fprintf(stderr,"Got unknown Xkb event (%d, base=%d)\n",re->type,
xkbi->codes->first_event);
+#endif
break;
}
return False;
}
Bool
+#if NeedFunctionPrototypes
+XkbIgnoreExtension(Bool ignore)
+#else
XkbIgnoreExtension(ignore)
Bool ignore;
+#endif
{
+ if (getenv("XKB_FORCE")!=NULL) {
+#ifdef DEBUG
+ fprintf(stderr,"Forcing use of XKB (overriding an IgnoreExtensions)\n");
+#endif
+ return False;
+ }
+#ifdef DEBUG
+ else if (getenv("XKB_DEBUG")!=NULL) {
+ fprintf(stderr,"Explicitly %signoring XKB\n",ignore?"":"not ");
+ }
+#endif
_XkbIgnoreExtension = ignore;
return True;
}
static void
+#if NeedFunctionPrototypes
+_XkbFreeInfo(Display *dpy)
+#else
_XkbFreeInfo(dpy)
Display *dpy;
+#endif
{
XkbInfoPtr xkbi = dpy->xkb_info;
if (xkbi) {
if (xkbi->desc)
- Xfree(xkbi->desc);
- if (xkbi->modmap)
- Xfree(xkbi->modmap);
+ XkbFreeKeyboard(xkbi->desc,XkbAllComponentsMask,True);
Xfree(xkbi);
}
}
Bool
-XkbUseExtension(dpy)
- Display *dpy;
+#if NeedFunctionPrototypes
+XkbUseExtension(Display *dpy,int *major_rtrn,int *minor_rtrn)
+#else
+XkbUseExtension(dpy,major_rtrn,minor_rtrn)
+ Display * dpy;
+ int * major_rtrn;
+ int * minor_rtrn;
+#endif
{
xkbUseExtensionReply rep;
register xkbUseExtensionReq *req;
XExtCodes *codes;
- int ev_base;
+ int ev_base,forceIgnore;
XkbInfoPtr xkbi;
-#ifdef DEBUG
+ char * str;
static int debugMsg;
-#endif
static int been_here= 0;
- if ( dpy->xkb_info )
+ if ( dpy->xkb_info ) {
+ if (major_rtrn) *major_rtrn= dpy->xkb_info->srv_major;
+ if (minor_rtrn) *minor_rtrn= dpy->xkb_info->srv_minor;
return True;
+ }
if (!been_here) {
-#ifdef DEBUG
debugMsg= (getenv("XKB_DEBUG")!=NULL);
-#endif
been_here= 1;
}
- if ((dpy->flags&XlibDisplayNoXkb) || dpy->keysyms ||
- _XkbIgnoreExtension || getenv("XKB_DISABLE")) {
+
+ if (major_rtrn) *major_rtrn= 0;
+ if (minor_rtrn) *minor_rtrn= 0;
+
+ forceIgnore= (dpy->flags&XlibDisplayNoXkb)||dpy->keysyms;
+ forceIgnore= forceIgnore&(major_rtrn==NULL)&&(minor_rtrn==NULL);
+ if ( forceIgnore || _XkbIgnoreExtension || getenv("XKB_DISABLE")) {
LockDisplay(dpy);
dpy->flags |= XlibDisplayNoXkb;
UnlockDisplay(dpy);
-#ifdef DEBUG
if (debugMsg)
fprintf(stderr,"XKB extension disabled or missing\n");
-#endif
return False;
}
- xkbi = (XkbInfoPtr)Xcalloc(1, sizeof(XkbInfoRec));
+ xkbi = _XkbTypedCalloc(1, XkbInfoRec);
if ( !xkbi )
return False;
@@ -552,10 +704,8 @@ XkbUseExtension(dpy)
dpy->flags |= XlibDisplayNoXkb;
UnlockDisplay(dpy);
Xfree(xkbi);
-#ifdef DEBUG
if (debugMsg)
fprintf(stderr,"XKB extension not present\n");
-#endif
return False;
}
xkbi->codes = codes;
@@ -566,34 +716,120 @@ XkbUseExtension(dpy)
req->xkbReqType = X_kbUseExtension;
req->wantedMajor = XkbMajorVersion;
req->wantedMinor = XkbMinorVersion;
- if (!_XReply(dpy, (xReply *)&rep, 0, xFalse) || !rep.supported) {
-#ifdef DEBUG
+ if (!_XReply(dpy, (xReply *)&rep, 0, xFalse) || !rep.supported ) {
+ Bool fail;
+ fail= True;
if (debugMsg)
fprintf(stderr,
"XKB version mismatch (want %d.%02d, got %d.%02d)\n",
XkbMajorVersion,XkbMinorVersion,
rep.serverMajor, rep.serverMinor);
-#endif
- /* could theoretically try for an older version here */
- dpy->flags |= XlibDisplayNoXkb;
- UnlockDisplay(dpy);
- SyncHandle();
- Xfree(xkbi);
- return False;
+
+ /* pre-release 0.65 is very close to 1.00 */
+ if ((rep.serverMajor==0)&&(rep.serverMinor==65)) {
+ if (debugMsg)
+ fprintf(stderr,"Trying to fall back to version 0.65...");
+ GetReq(kbUseExtension, req);
+ req->reqType = xkbi->codes->major_opcode;
+ req->xkbReqType = X_kbUseExtension;
+ req->wantedMajor = 0;
+ req->wantedMinor = 65;
+ if ( _XReply(dpy, (xReply *)&rep, 0, xFalse) && rep.supported ) {
+ if (debugMsg)
+ fprintf(stderr,"succeeded\n");
+ fail= False;
+ }
+ else if (debugMsg) fprintf(stderr,"failed\n");
+ }
+ if (fail) {
+ dpy->flags |= XlibDisplayNoXkb;
+ UnlockDisplay(dpy);
+ SyncHandle();
+ Xfree(xkbi);
+ if (major_rtrn) *major_rtrn= rep.serverMajor;
+ if (minor_rtrn) *minor_rtrn= rep.serverMinor;
+ return False;
+ }
}
+#ifdef DEBUG
+ else if ( forceIgnore ) {
+ fprintf(stderr,"Internal Error! XkbUseExtension succeeded with forceIgnore set\n");
+ }
+#endif
+ UnlockDisplay(dpy);
xkbi->srv_major= rep.serverMajor;
xkbi->srv_minor= rep.serverMinor;
-#ifdef DEBUG
+ if (major_rtrn) *major_rtrn= rep.serverMajor;
+ if (minor_rtrn) *minor_rtrn= rep.serverMinor;
if (debugMsg)
fprintf(stderr,"XKB (version %d.%02d/%d.%02d) OK!\n",
XkbMajorVersion,XkbMinorVersion,
rep.serverMajor,rep.serverMinor);
-#endif
dpy->xkb_info = xkbi;
dpy->free_funcs->xkb = _XkbFreeInfo;
ev_base = codes->first_event;
- UnlockDisplay(dpy);
+ xkbi->xlib_ctrls|= (XkbLC_BeepOnComposeFail|XkbLC_ComposeLED);
+ if ((str=getenv("_XKB_OPTIONS_ENABLE"))!=NULL) {
+ if ((str=getenv("_XKB_LATIN1_LOOKUP"))!=NULL) {
+ if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))
+ xkbi->xlib_ctrls&= ~XkbLC_ForceLatin1Lookup;
+ else xkbi->xlib_ctrls|= XkbLC_ForceLatin1Lookup;
+ }
+ if ((str=getenv("_XKB_CONSUME_LOOKUP_MODS"))!=NULL) {
+ if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))
+ xkbi->xlib_ctrls&= ~XkbLC_ConsumeLookupMods;
+ else xkbi->xlib_ctrls|= XkbLC_ConsumeLookupMods;
+ }
+ if ((str=getenv("_XKB_CONSUME_SHIFT_AND_LOCK"))!=NULL) {
+ if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))
+ xkbi->xlib_ctrls&= ~XkbLC_AlwaysConsumeShiftAndLock;
+ else xkbi->xlib_ctrls|= XkbLC_AlwaysConsumeShiftAndLock;
+ }
+ if ((str=getenv("_XKB_IGNORE_NEW_KEYBOARDS"))!=NULL) {
+ if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))
+ xkbi->xlib_ctrls&= ~XkbLC_IgnoreNewKeyboards;
+ else xkbi->xlib_ctrls|= XkbLC_IgnoreNewKeyboards;
+ }
+ if ((str=getenv("_XKB_CONTROL_FALLBACK"))!=NULL) {
+ if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))
+ xkbi->xlib_ctrls&= ~XkbLC_ControlFallback;
+ else xkbi->xlib_ctrls|= XkbLC_ControlFallback;
+ }
+ if ((str=getenv("_XKB_COMP_LED"))!=NULL) {
+ if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))
+ xkbi->xlib_ctrls&= ~XkbLC_ComposeLED;
+ else {
+ xkbi->xlib_ctrls|= XkbLC_ComposeLED;
+ if (strlen(str)>0)
+ xkbi->composeLED= XInternAtom(dpy,str,False);
+ }
+ }
+ if ((str=getenv("_XKB_COMP_FAIL_BEEP"))!=NULL) {
+ if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))
+ xkbi->xlib_ctrls&= ~XkbLC_BeepOnComposeFail;
+ else xkbi->xlib_ctrls|= XkbLC_BeepOnComposeFail;
+ }
+ }
+ if ((xkbi->composeLED==None)&&((xkbi->xlib_ctrls&XkbLC_ComposeLED)!=0))
+ xkbi->composeLED= XInternAtom(dpy,"Compose",False);
+#ifdef DEBUG
+ if (debugMsg) {
+ register unsigned c= xkbi->xlib_ctrls;
+ fprintf(stderr,"XKB compose: beep on failure is %s, LED is %s\n",
+ ((c&XkbLC_BeepOnComposeFail)?"on":"off"),
+ ((c&XkbLC_ComposeLED)?"on":"off"));
+ fprintf(stderr,"XKB XLookupString: %slatin-1, %s lookup modifiers\n",
+ ((c&XkbLC_ForceLatin1Lookup)?"allow non-":"force "),
+ ((c&XkbLC_ConsumeLookupMods)?"consume":"re-use"));
+ fprintf(stderr,
+ "XKB XLookupString: %sconsume shift and lock, %scontrol fallback\n",
+ ((c&XkbLC_AlwaysConsumeShiftAndLock)?"always ":"don't "),
+ ((c&XkbLC_ControlFallback)?"":"no "));
+
+ }
+#endif
XESetWireToEvent(dpy,ev_base+XkbEventCode,wire_to_event);
SyncHandle();
return True;
}
+
diff --git a/lib/X11/XKBlib.h b/lib/X11/XKBlib.h
index f6ede0af7..ac354d1e2 100644
--- a/lib/X11/XKBlib.h
+++ b/lib/X11/XKBlib.h
@@ -1,4 +1,4 @@
-/* $XConsortium: XKBlib.h,v 1.8 94/04/08 15:11:49 erik Exp $ */
+/* $XConsortium: XKBlib.h /main/17 1996/03/01 14:30:14 kaleb $ */
/************************************************************
Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
@@ -31,203 +31,265 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <X11/extensions/XKBstr.h>
typedef struct _XkbAnyEvent {
- int type; /* XkbAnyEvent */
- unsigned long serial; /* # of last request processed by server */
- Bool send_event; /* true if this came from a SendEvent request */
- Display *display; /* Display the event was read from */
- Time time; /* milliseconds */
- int xkb_type; /* XkbStateNotify ... XkbCompatMapNotify */
- unsigned int device; /* device ID */
+ int type; /* XkbAnyEvent */
+ unsigned long serial; /* # of last req processed by server */
+ Bool send_event; /* is this from a SendEvent request? */
+ Display * display; /* Display the event was read from */
+ Time time; /* milliseconds */
+ int xkb_type; /* XKB event minor code */
+ unsigned int device; /* device ID */
} XkbAnyEvent;
-typedef struct _XkbStateNotifyEvent {
- int type; /* XkbAnyEvent */
- unsigned long serial; /* # of last request processed by server */
- Bool send_event; /* true if this came from a SendEvent request */
- Display *display; /* Display the event was read from */
- Time time; /* milliseconds */
- int xkb_type; /* XkbStateNotify */
- unsigned int device; /* device ID */
- unsigned int keycode; /* keycode that caused the change */
- unsigned int event_type;/* KeyPress or KeyRelease */
- unsigned int req_major;/* Major opcode of request */
- unsigned int req_minor;/* Minor opcode of request */
- unsigned int changed; /* mask of changed state components */
- unsigned int group; /* keyboard group */
- unsigned int base_group;/* base keyboard group */
- unsigned int latched_group;/* latched keyboard group */
- unsigned int locked_group; /* locked keyboard group */
- unsigned int mods; /* modifier state */
- unsigned int base_mods; /* base modifier state */
- unsigned int latched_mods; /* latched modifiers */
- unsigned int locked_mods; /* locked modifiers */
- unsigned int compat_state; /* compatibility state */
-} XkbStateNotifyEvent;
+typedef struct _XkbNewKeyboardNotify {
+ int type; /* XkbAnyEvent */
+ unsigned long serial; /* of last req processed by server */
+ Bool send_event; /* is this from a SendEvent request? */
+ Display * display; /* Display the event was read from */
+ Time time; /* milliseconds */
+ int xkb_type; /* XkbNewKeyboardNotify */
+ int device; /* device ID */
+ int old_device; /* device ID of previous keyboard */
+ int min_key_code; /* minimum key code */
+ int max_key_code; /* maximum key code */
+ int old_min_key_code;/* min key code of previous kbd */
+ int old_max_key_code;/* max key code of previous kbd */
+ unsigned int changed; /* changed aspects of the keyboard */
+ char req_major; /* major and minor opcode of req */
+ char req_minor; /* that caused change, if applicable */
+} XkbNewKeyboardNotifyEvent;
typedef struct _XkbMapNotifyEvent {
- int type; /* XkbAnyEvent */
- unsigned long serial; /* of last request processed by server */
- Bool send_event; /* true if this came from a SendEvent request */
- Display *display; /* Display the event was read from */
- Time time; /* milliseconds */
- int xkb_type; /* XkbMapNotify */
- unsigned int device; /* device ID */
- unsigned int changed; /* fields which have been changed */
- unsigned int resized; /* fields which have been resized */
- unsigned int first_type; /* first changed key type */
- unsigned int num_types; /* number of changed key types */
- unsigned int first_key_sym; /* first changed key sym */
- unsigned int num_key_syms; /* number of changed key syms */
- unsigned int first_key_act; /* first changed key act */
- unsigned int num_key_acts; /* number of changed key acts */
- unsigned int first_key_behavior;/* first changed key behavior */
- unsigned int num_key_behaviors; /* number of changed key behaviors */
- unsigned int vmods; /* mask of changed virtual mods */
- unsigned int first_key_explicit;/* range of keys with changed... */
- unsigned int num_key_explicit; /* ...explicit component settings */
+ int type; /* XkbAnyEvent */
+ unsigned long serial; /* of last req processed by server */
+ Bool send_event; /* is this from a SendEvent request */
+ Display * display; /* Display the event was read from */
+ Time time; /* milliseconds */
+ int xkb_type; /* XkbMapNotify */
+ int device; /* device ID */
+ unsigned int changed; /* fields which have been changed */
+ unsigned int flags; /* reserved */
+ int first_type; /* first changed key type */
+ int num_types; /* number of changed key types */
+ KeyCode min_key_code;
+ KeyCode max_key_code;
+ KeyCode first_key_sym;
+ KeyCode first_key_act;
+ KeyCode first_key_behavior;
+ KeyCode first_key_explicit;
+ KeyCode first_modmap_key;
+ KeyCode first_vmodmap_key;
+ int num_key_syms;
+ int num_key_acts;
+ int num_key_behaviors;
+ int num_key_explicit;
+ int num_modmap_keys;
+ int num_vmodmap_keys;
+ unsigned int vmods; /* mask of changed virtual mods */
} XkbMapNotifyEvent;
+typedef struct _XkbStateNotifyEvent {
+ int type; /* XkbAnyEvent */
+ unsigned long serial; /* # of last req processed by server */
+ Bool send_event; /* is this from a SendEvent request? */
+ Display * display; /* Display the event was read from */
+ Time time; /* milliseconds */
+ int xkb_type; /* XkbStateNotify */
+ int device; /* device ID */
+ unsigned int changed; /* mask of changed state components */
+ int group; /* keyboard group */
+ int base_group; /* base keyboard group */
+ int latched_group; /* latched keyboard group */
+ int locked_group; /* locked keyboard group */
+ unsigned int mods; /* modifier state */
+ unsigned int base_mods; /* base modifier state */
+ unsigned int latched_mods; /* latched modifiers */
+ unsigned int locked_mods; /* locked modifiers */
+ int compat_state; /* compatibility state */
+ unsigned char grab_mods; /* mods used for grabs */
+ unsigned char compat_grab_mods;/* grab mods for non-XKB clients */
+ unsigned char lookup_mods; /* mods sent to clients */
+ unsigned char compat_lookup_mods; /* mods sent to non-XKB clients */
+ int ptr_buttons; /* pointer button state */
+ KeyCode keycode; /* keycode that caused the change */
+ char event_type; /* KeyPress or KeyRelease */
+ char req_major; /* Major opcode of request */
+ char req_minor; /* Minor opcode of request */
+} XkbStateNotifyEvent;
+
typedef struct _XkbControlsNotify {
- int type; /* XkbAnyEvent */
- unsigned long serial; /* of last request processed by server */
- Bool send_event; /* true if this came from a SendEvent request */
- Display *display; /* Display the event was read from */
- Time time; /* milliseconds */
- int xkb_type; /* XkbControlsNotify */
- unsigned int device; /* device ID */
- unsigned long int changed_ctrls;
- unsigned long int enabled_ctrls;
- unsigned long int enabled_ctrl_changes;
- unsigned int keycode;
- unsigned int event_type;
- unsigned int req_major;
- unsigned int req_minor;
+ int type; /* XkbAnyEvent */
+ unsigned long serial; /* of last req processed by server */
+ Bool send_event; /* is this from a SendEvent request? */
+ Display * display; /* Display the event was read from */
+ Time time; /* milliseconds */
+ int xkb_type; /* XkbControlsNotify */
+ int device; /* device ID */
+ unsigned int changed_ctrls; /* controls with changed sub-values */
+ unsigned int enabled_ctrls; /* controls currently enabled */
+ unsigned int enabled_ctrl_changes;/* controls just {en,dis}abled */
+ int num_groups; /* total groups on keyboard */
+ KeyCode keycode; /* key that caused change or 0 */
+ char event_type; /* type of event that caused change */
+ char req_major; /* if keycode==0, major and minor */
+ char req_minor; /* opcode of req that caused change */
} XkbControlsNotifyEvent;
typedef struct _XkbIndicatorNotify {
- int type; /* XkbAnyEvent */
- unsigned long serial; /* of last request processed by server */
- Bool send_event; /* true if this came from a SendEvent request */
- Display *display; /* Display the event was read from */
- Time time; /* milliseconds */
- int xkb_type; /* XkbIndicatorNotify */
- unsigned int device; /* device ID */
- unsigned int state_changed;/* indicators that have changed state */
- unsigned int state; /* current state of all indicators */
- unsigned int map_changed;/* indicators whose maps have changed */
+ int type; /* XkbAnyEvent */
+ unsigned long serial; /* of last req processed by server */
+ Bool send_event; /* is this from a SendEvent request? */
+ Display * display; /* Display the event was read from */
+ Time time; /* milliseconds */
+ int xkb_type; /* XkbIndicatorNotify */
+ int device; /* device ID */
+ unsigned int changed; /* indicators with new state or map */
+ unsigned int state; /* current state of all indicators */
} XkbIndicatorNotifyEvent;
-typedef struct _XkbBellNotify {
- int type; /* XkbAnyEvent */
- unsigned long serial; /* of last request processed by server */
- Bool send_event; /* true if this came from a SendEvent request */
- Display *display; /* Display the event was read from */
- Time time; /* milliseconds */
- int xkb_type; /* XkbBellNotify */
- unsigned int device; /* device ID */
- unsigned int percent; /* requested volume as a percent of maximum */
- unsigned int pitch; /* requested pitch in Hz */
- unsigned int duration; /* requested duration in milliseconds */
- unsigned int bell_class;/* (input extension) class of feedback */
- unsigned int bell_id; /* (input extension) ID of feedback */
- Atom name; /* "name" of requested bell */
- Window window; /* window associated with event (if any) */
-} XkbBellNotifyEvent;
-
-typedef struct _XkbSlowKeyNotify {
- int type; /* XkbAnyEvent */
- unsigned long serial; /* of last request processed by server */
- Bool send_event; /* true if this came from a SendEvent request */
- Display *display; /* Display the event was read from */
- Time time; /* milliseconds */
- int xkb_type; /* XkbSlowKeyNotify */
- unsigned int device; /* device ID */
- unsigned int slow_key_state;/* press, release, accept, reject */
- unsigned int keycode; /* key of event */
- unsigned int delay; /* current delay in milliseconds */
-} XkbSlowKeyNotifyEvent;
-
typedef struct _XkbNamesNotify {
- int type; /* XkbAnyEvent */
- unsigned long serial; /* of last request processed by server */
- Bool send_event; /* true if this came from a SendEvent request */
- Display *display; /* Display the event was read from */
- Time time; /* milliseconds */
- int xkb_type; /* XkbNamesNotify */
- unsigned int device; /* device ID */
- unsigned int changed; /* names that have changed */
- unsigned int first_type; /* first key type with new name */
- unsigned int num_types; /* number of key types with new names */
- unsigned int first_lvl; /* first key type new new level names */
- unsigned int num_lvls; /* # of key types w/new level names */
- unsigned int first_radio_group; /* first radio group with new name */
- unsigned int num_radio_groups; /* # of radio groups with new names */
- unsigned int num_char_sets; /* total number of charsets */
- unsigned int changed_mods; /* modifiers with new names */
- unsigned int changed_vmods;/* virtual modifiers with new names */
- unsigned int changed_indicators;/* indicators with new names */
+ int type; /* XkbAnyEvent */
+ unsigned long serial; /* of last req processed by server */
+ Bool send_event; /* is this from a SendEvent request? */
+ Display * display; /* Display the event was read from */
+ Time time; /* milliseconds */
+ int xkb_type; /* XkbNamesNotify */
+ int device; /* device ID */
+ unsigned int changed; /* names that have changed */
+ int first_type; /* first key type with new name */
+ int num_types; /* number of key types with new names */
+ int first_lvl; /* first key type new new level names */
+ int num_lvls; /* # of key types w/new level names */
+ int num_aliases; /* total number of key aliases*/
+ int num_radio_groups;/* total number of radio groups */
+ unsigned int changed_vmods; /* virtual modifiers with new names */
+ unsigned int changed_groups; /* groups with new names */
+ unsigned int changed_indicators;/* indicators with new names */
+ int first_key; /* first key with new name */
+ int num_keys; /* number of keys with new names */
} XkbNamesNotifyEvent;
typedef struct _XkbCompatMapNotify {
- int type; /* XkbAnyEvent */
- unsigned long serial; /* of last request processed by server */
- Bool send_event; /* true if this came from a SendEvent request */
- Display *display; /* Display the event was read from */
- Time time; /* milliseconds */
- int xkb_type; /* XkbCompatMapNotify */
- unsigned int device; /* device ID */
- unsigned int changed_mods; /* modifiers with new compat maps */
- unsigned int changed_vmods;/* virtual mods w/new compat maps */
- unsigned int first_si; /* first new symbol interp */
- unsigned int num_si; /* number of new symbol interps */
- unsigned int num_total_si; /* total # of symbol interps */
+ int type; /* XkbAnyEvent */
+ unsigned long serial; /* of last req processed by server */
+ Bool send_event; /* is this from a SendEvent request? */
+ Display * display; /* Display the event was read from */
+ Time time; /* milliseconds */
+ int xkb_type; /* XkbCompatMapNotify */
+ int device; /* device ID */
+ unsigned int changed_groups; /* groups with new compat maps */
+ int first_si; /* first new symbol interp */
+ int num_si; /* number of new symbol interps */
+ int num_total_si; /* total # of symbol interps */
} XkbCompatMapNotifyEvent;
-typedef struct _XkbAlternateSymsNotify {
- int type; /* XkbAnyEvent */
- unsigned long serial; /* of last request processed by server */
- Bool send_event; /* true if this came from a SendEvent request */
- Display *display; /* Display the event was read from */
- Time time; /* milliseconds */
- int xkb_type; /* XkbAlternateSymsNotify */
- unsigned int device; /* device ID */
- unsigned int alt_syms_id;/* identifier of changed alt symbol set */
- unsigned int first_key; /* first key with new alternate syms */
- unsigned int num_keys; /* number of keys with alternate syms */
-} XkbAlternateSymsNotifyEvent;
+typedef struct _XkbBellNotify {
+ int type; /* XkbAnyEvent */
+ unsigned long serial; /* of last req processed by server */
+ Bool send_event; /* is this from a SendEvent request? */
+ Display * display; /* Display the event was read from */
+ Time time; /* milliseconds */
+ int xkb_type; /* XkbBellNotify */
+ int device; /* device ID */
+ int percent; /* requested volume as a % of maximum */
+ int pitch; /* requested pitch in Hz */
+ int duration; /* requested duration in useconds */
+ int bell_class; /* (input extension) feedback class */
+ int bell_id; /* (input extension) ID of feedback */
+ Atom name; /* "name" of requested bell */
+ Window window; /* window associated with event */
+ Bool event_only; /* "event only" requested */
+} XkbBellNotifyEvent;
typedef struct _XkbActionMessage {
- int type; /* XkbAnyEvent */
- unsigned long serial; /* of last request processed by server */
- Bool send_event; /* true if this came from a SendEvent request */
- Display *display; /* Display the event was read from */
- Time time; /* milliseconds */
- int xkb_type; /* XkbActionMessage */
- unsigned int device; /* device ID */
- unsigned int keycode; /* key that generated the event */
- Bool press; /* true if act caused by key press */
- Bool key_event_follows; /* true if key event is also generated */
- char message[XkbActionMessageLength]; /* message generated by key */
+ int type; /* XkbAnyEvent */
+ unsigned long serial; /* of last req processed by server */
+ Bool send_event; /* is this from a SendEvent request? */
+ Display * display; /* Display the event was read from */
+ Time time; /* milliseconds */
+ int xkb_type; /* XkbActionMessage */
+ int device; /* device ID */
+ KeyCode keycode; /* key that generated the event */
+ Bool press; /* true if act caused by key press */
+ Bool key_event_follows;/* true if key event also generated */
+ int group; /* effective group */
+ unsigned int mods; /* effective mods */
+ char message[XkbActionMessageLength+1];
+ /* message -- leave space for NUL */
} XkbActionMessageEvent;
+typedef struct _XkbAccessXNotify {
+ int type; /* XkbAnyEvent */
+ unsigned long serial; /* of last req processed by server */
+ Bool send_event; /* is this from a SendEvent request? */
+ Display * display; /* Display the event was read from */
+ Time time; /* milliseconds */
+ int xkb_type; /* XkbAccessXNotify */
+ int device; /* device ID */
+ int detail; /* XkbAXN_* */
+ int keycode; /* key of event */
+ int sk_delay; /* current slow keys delay */
+ int debounce_delay; /* current debounce delay */
+} XkbAccessXNotifyEvent;
+
+typedef struct _XkbExtensionDeviceNotify {
+ int type; /* XkbAnyEvent */
+ unsigned long serial; /* of last req processed by server */
+ Bool send_event; /* is this from a SendEvent request? */
+ Display * display; /* Display the event was read from */
+ Time time; /* milliseconds */
+ int xkb_type; /* XkbExtensionDeviceNotify */
+ int device; /* device ID */
+ unsigned int reason; /* reason for the event */
+ unsigned int supported; /* mask of supported features */
+ unsigned int unsupported; /* mask of unsupported features */
+ /* that some app tried to use */
+ int first_btn; /* first button that changed */
+ int num_btns; /* range of buttons changed */
+ unsigned int leds_defined; /* indicators with names or maps */
+ unsigned int led_state; /* current state of the indicators */
+ int led_class; /* feedback class for led changes */
+ int led_id; /* feedback id for led changes */
+} XkbExtensionDeviceNotifyEvent;
+
typedef union _XkbEvent {
- int type;
- XkbAnyEvent any;
- XkbStateNotifyEvent state;
- XkbMapNotifyEvent map;
- XkbControlsNotifyEvent ctrls;
- XkbIndicatorNotifyEvent indicators;
- XkbBellNotifyEvent bell;
- XkbSlowKeyNotifyEvent slow_key;
- XkbNamesNotifyEvent names;
- XkbCompatMapNotifyEvent compat;
- XkbAlternateSymsNotifyEvent alt_syms;
- XkbActionMessageEvent message;
- XEvent core;
+ int type;
+ XkbAnyEvent any;
+ XkbNewKeyboardNotifyEvent new_kbd;
+ XkbMapNotifyEvent map;
+ XkbStateNotifyEvent state;
+ XkbControlsNotifyEvent ctrls;
+ XkbIndicatorNotifyEvent indicators;
+ XkbNamesNotifyEvent names;
+ XkbCompatMapNotifyEvent compat;
+ XkbBellNotifyEvent bell;
+ XkbActionMessageEvent message;
+ XkbAccessXNotifyEvent accessx;
+ XkbExtensionDeviceNotifyEvent device;
+ XEvent core;
} XkbEvent;
typedef struct _XkbKbdDpyState XkbKbdDpyStateRec,*XkbKbdDpyStatePtr;
+ /* XkbOpenDisplay error codes */
+#define XkbOD_Success 0
+#define XkbOD_BadLibraryVersion 1
+#define XkbOD_ConnectionRefused 2
+#define XkbOD_NonXkbServer 3
+#define XkbOD_BadServerVersion 4
+
+ /* Values for XlibFlags */
+#define XkbLC_ForceLatin1Lookup (1<<0)
+#define XkbLC_ConsumeLookupMods (1<<1)
+#define XkbLC_AlwaysConsumeShiftAndLock (1<<2)
+#define XkbLC_IgnoreNewKeyboards (1<<3)
+#define XkbLC_ControlFallback (1<<4)
+#define XkbLC_ConsumeKeysOnComposeFail (1<<29)
+#define XkbLC_ComposeLED (1<<30)
+#define XkbLC_BeepOnComposeFail (1<<31)
+
+#define XkbLC_AllComposeControls (0xc0000000)
+#define XkbLC_AllControls (0xc000001f)
+
_XFUNCPROTOBEGIN
extern Bool XkbIgnoreExtension(
@@ -236,9 +298,20 @@ extern Bool XkbIgnoreExtension(
#endif
);
+extern Display *XkbOpenDisplay(
+#if NeedFunctionPrototypes
+ char * /* name */,
+ int * /* ev_rtrn */,
+ int * /* err_rtrn */,
+ int * /* major_rtrn */,
+ int * /* minor_rtrn */,
+ int * /* reason */
+#endif
+);
+
extern Bool XkbQueryExtension(
#if NeedFunctionPrototypes
- Display * /* display */,
+ Display * /* dpy */,
int * /* opcodeReturn */,
int * /* eventBaseReturn */,
int * /* errorBaseReturn */,
@@ -249,38 +322,147 @@ extern Bool XkbQueryExtension(
extern Bool XkbUseExtension(
#if NeedFunctionPrototypes
- Display * /* display */
+ Display * /* dpy */,
+ int * /* major_rtrn */,
+ int * /* minor_rtrn */
#endif
);
-extern Status XkbLibraryVersion(
+extern Bool XkbLibraryVersion(
#if NeedFunctionPrototypes
int * /* libMajorRtrn */,
int * /* libMinorRtrn */
#endif
);
-extern Status XkbSetAutoRepeatRate(
+extern unsigned int XkbSetXlibControls(
+#if NeedFunctionPrototypes
+ Display* /* dpy */,
+ unsigned int /* affect */,
+ unsigned int /* values */
+#endif
+);
+
+extern unsigned int XkbGetXlibControls(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* deviceSpec */,
- unsigned /* delay */,
- unsigned /* interval */
+ Display* /* dpy */
+#endif
+);
+
+typedef Atom (*XkbInternAtomFunc)(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ _Xconst char * /* name */,
+ Bool /* only_if_exists */
+#endif
+);
+
+typedef char * (*XkbGetAtomNameFunc)(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ Atom /* atom */
+#endif
+);
+
+extern void XkbSetAtomFuncs(
+#if NeedFunctionPrototypes
+ XkbInternAtomFunc /* getAtom */,
+ XkbGetAtomNameFunc /* getName */
+#endif
+);
+
+extern KeySym XkbKeycodeToKeysym(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+#if NeedWidePrototypes
+ unsigned int /* kc */,
+#else
+ KeyCode /* kc */,
+#endif
+ int /* group */,
+ int /* level */
+#endif
+);
+
+extern unsigned int XkbKeysymToModifiers(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ KeySym /* ks */
+#endif
+);
+
+extern Bool XkbLookupKeySym(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ KeyCode /* keycode */,
+ unsigned int /* modifiers */,
+ unsigned int * /* modifiers_return */,
+ KeySym * /* keysym_return */
+#endif
+);
+
+extern int XkbLookupKeyBinding(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ KeySym /* sym_rtrn */,
+ unsigned int /* mods */,
+ char * /* buffer */,
+ int /* nbytes */,
+ int * /* extra_rtrn */
+#endif
+);
+
+extern Bool XkbTranslateKeyCode(
+#if NeedFunctionPrototypes
+ XkbDescPtr /* xkb */,
+ KeyCode /* keycode */,
+ unsigned int /* modifiers */,
+ unsigned int * /* modifiers_return */,
+ KeySym * /* keysym_return */
+#endif
+);
+
+extern int XkbTranslateKeySym(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ register KeySym * /* sym_return */,
+ unsigned int /* modifiers */,
+ char * /* buffer */,
+ int /* nbytes */,
+ int * /* extra_rtrn */
+#endif
+);
+
+extern Bool XkbSetAutoRepeatRate(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ unsigned int /* deviceSpec */,
+ unsigned int /* delay */,
+ unsigned int /* interval */
#endif
);
extern Bool XkbGetAutoRepeatRate(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* deviceSpec */,
- unsigned * /* delayRtrn */,
- unsigned * /* intervalRtrn */
+ Display * /* dpy */,
+ unsigned int /* deviceSpec */,
+ unsigned int * /* delayRtrn */,
+ unsigned int * /* intervalRtrn */
+#endif
+);
+
+extern Bool XkbChangeEnabledControls(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ unsigned int /* deviceSpec */,
+ unsigned int /* affect */,
+ unsigned int /* values */
#endif
);
extern Bool XkbDeviceBell(
#if NeedFunctionPrototypes
- Display * /* display */,
+ Display * /* dpy */,
Window /* win */,
int /* deviceSpec */,
int /* bellClass */,
@@ -292,7 +474,7 @@ extern Bool XkbDeviceBell(
extern Bool XkbForceDeviceBell(
#if NeedFunctionPrototypes
- Display * /* display */,
+ Display * /* dpy */,
int /* deviceSpec */,
int /* bellClass */,
int /* bellID */,
@@ -300,9 +482,21 @@ extern Bool XkbForceDeviceBell(
#endif
);
+extern Bool XkbDeviceBellEvent(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ Window /* win */,
+ int /* deviceSpec */,
+ int /* bellClass */,
+ int /* bellID */,
+ int /* percent */,
+ Atom /* name */
+#endif
+);
+
extern Bool XkbBell(
#if NeedFunctionPrototypes
- Display * /* display */,
+ Display * /* dpy */,
Window /* win */,
int /* percent */,
Atom /* name */
@@ -311,100 +505,214 @@ extern Bool XkbBell(
extern Bool XkbForceBell(
#if NeedFunctionPrototypes
- Display * /* display */,
+ Display * /* dpy */,
int /* percent */
#endif
);
+extern Bool XkbBellEvent(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ Window /* win */,
+ int /* percent */,
+ Atom /* name */
+#endif
+);
+
extern Bool XkbSelectEvents(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* deviceID */,
- unsigned long /* affect */,
- unsigned long /* values */
+ Display * /* dpy */,
+ unsigned int /* deviceID */,
+ unsigned int /* affect */,
+ unsigned int /* values */
#endif
);
extern Bool XkbSelectEventDetails(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* deviceID */,
- unsigned /* eventType */,
+ Display * /* dpy */,
+ unsigned int /* deviceID */,
+ unsigned int /* eventType */,
unsigned long /* affect */,
unsigned long /* details */
#endif
);
+extern void XkbNoteMapChanges(
+#if NeedFunctionPrototypes
+ XkbMapChangesPtr /* old */,
+ XkbMapNotifyEvent * /* new */,
+ unsigned int /* wanted */
+#endif
+);
+
+extern void XkbNoteNameChanges(
+#if NeedFunctionPrototypes
+ XkbNameChangesPtr /* old */,
+ XkbNamesNotifyEvent * /* new */,
+ unsigned int /* wanted */
+#endif
+);
+
extern Status XkbGetIndicatorState(
#if NeedFunctionPrototypes
- Display * /* dpy */,
- unsigned int /* deviceSpec */,
- unsigned int * /* pStateRtrn */
+ Display * /* dpy */,
+ unsigned int /* deviceSpec */,
+ unsigned int * /* pStateRtrn */
+#endif
+);
+
+extern Status XkbGetDeviceIndicatorState(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ unsigned int /* deviceSpec */,
+ unsigned int /* ledClass */,
+ unsigned int /* ledID */,
+ unsigned int * /* pStateRtrn */
#endif
);
extern Status XkbGetIndicatorMap(
#if NeedFunctionPrototypes
- Display * /* display */,
+ Display * /* dpy */,
unsigned long /* which */,
XkbDescPtr /* desc */
#endif
);
-extern Status XkbSetIndicatorMap(
+extern Bool XkbSetIndicatorMap(
#if NeedFunctionPrototypes
- Display * /* display */,
+ Display * /* dpy */,
unsigned long /* which */,
XkbDescPtr /* desc */
#endif
);
-extern Status XkbLockModifiers(
+#define XkbNoteIndicatorMapChanges(o,n,w) \
+ ((o)->map_changes|=((n)->map_changes&(w)))
+#define XkbNoteIndicatorStateChanges(o,n,w)\
+ ((o)->state_changes|=((n)->state_changes&(w)))
+#define XkbGetIndicatorMapChanges(d,x,c) \
+ (XkbGetIndicatorMap((d),(c)->map_changes,x)
+#define XkbChangeIndicatorMaps(d,x,c) \
+ (XkbSetIndicatorMap((d),(c)->map_changes,x))
+
+extern Bool XkbGetNamedIndicator(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* deviceSpec */,
- unsigned /* affect */,
- unsigned /* values */
+ Display * /* dpy */,
+ Atom /* name */,
+ int * /* pNdxRtrn */,
+ Bool * /* pStateRtrn */,
+ XkbIndicatorMapPtr /* pMapRtrn */,
+ Bool * /* pRealRtrn */
#endif
);
-extern Status XkbLatchModifiers(
+extern Bool XkbGetNamedDeviceIndicator(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* deviceSpec */,
- unsigned /* affect */,
- unsigned /* values */
+ Display * /* dpy */,
+ unsigned int /* deviceSpec */,
+ unsigned int /* ledClass */,
+ unsigned int /* ledID */,
+ Atom /* name */,
+ int * /* pNdxRtrn */,
+ Bool * /* pStateRtrn */,
+ XkbIndicatorMapPtr /* pMapRtrn */,
+ Bool * /* pRealRtrn */
#endif
);
-extern Status XkbSetServerInternalMods(
+extern Bool XkbSetNamedIndicator(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* deviceSpec */,
- unsigned /* affect */,
- unsigned /* values */
+ Display * /* dpy */,
+ Atom /* name */,
+ Bool /* changeState */,
+ Bool /* state */,
+ Bool /* createNewMap */,
+ XkbIndicatorMapPtr /* pMap */
#endif
);
-extern Status XkbSetIgnoreLockMods(
+extern Bool XkbSetNamedDeviceIndicator(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* deviceSpec */,
- unsigned /* affect */,
- unsigned /* values */
+ Display * /* dpy */,
+ unsigned int /* deviceSpec */,
+ unsigned int /* ledClass */,
+ unsigned int /* ledID */,
+ Atom /* name */,
+ Bool /* changeState */,
+ Bool /* state */,
+ Bool /* createNewMap */,
+ XkbIndicatorMapPtr /* pMap */
#endif
);
+extern Bool XkbLockModifiers(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ unsigned int /* deviceSpec */,
+ unsigned int /* affect */,
+ unsigned int /* values */
+#endif
+);
-extern Status XkbVirtualModsToReal(
+extern Bool XkbLatchModifiers(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ unsigned int /* deviceSpec */,
+ unsigned int /* affect */,
+ unsigned int /* values */
+#endif
+);
+
+extern Bool XkbLockGroup(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ unsigned int /* deviceSpec */,
+ unsigned int /* group */
+#endif
+);
+
+extern Bool XkbLatchGroup(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ unsigned int /* deviceSpec */,
+ unsigned int /* group */
+#endif
+);
+
+extern Bool XkbSetServerInternalMods(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ unsigned int /* deviceSpec */,
+ unsigned int /* affectReal */,
+ unsigned int /* realValues */,
+ unsigned int /* affectVirtual */,
+ unsigned int /* virtualValues */
+#endif
+);
+
+extern Bool XkbSetIgnoreLockMods(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ unsigned int /* deviceSpec */,
+ unsigned int /* affectReal */,
+ unsigned int /* realValues */,
+ unsigned int /* affectVirtual */,
+ unsigned int /* virtualValues */
+#endif
+);
+
+
+extern Bool XkbVirtualModsToReal(
#if NeedFunctionPrototypes
XkbDescPtr /* xkb */,
- unsigned /* virtual_mask */,
- unsigned * /* mask_rtrn */
+ unsigned int /* virtual_mask */,
+ unsigned int * /* mask_rtrn */
#endif
);
-extern Status XkbComputeEffectiveMap(
+extern Bool XkbComputeEffectiveMap(
#if NeedFunctionPrototypes
XkbDescPtr /* xkb */,
XkbKeyTypePtr /* type */,
@@ -415,220 +723,382 @@ extern Status XkbComputeEffectiveMap(
extern Status XkbInitCanonicalKeyTypes(
#if NeedFunctionPrototypes
XkbDescPtr /* xkb */,
- unsigned /* which */,
+ unsigned int /* which */,
int /* keypadVMod */
#endif
);
+extern XkbDescPtr XkbAllocKeyboard(
+#if NeedFunctionPrototypes
+ void
+#endif
+);
+
+extern void XkbFreeKeyboard(
+#if NeedFunctionPrototypes
+ XkbDescPtr /* xkb */,
+ unsigned int /* which */,
+ Bool /* freeDesc */
+#endif
+);
+
extern Status XkbAllocClientMap(
#if NeedFunctionPrototypes
XkbDescPtr /* xkb */,
- unsigned /* which */,
- unsigned /* nTypes */
+ unsigned int /* which */,
+ unsigned int /* nTypes */
#endif
);
extern Status XkbAllocServerMap(
#if NeedFunctionPrototypes
XkbDescPtr /* xkb */,
- unsigned /* which */,
- unsigned /* nActions */
+ unsigned int /* which */,
+ unsigned int /* nActions */
+#endif
+);
+
+extern void XkbFreeClientMap(
+#if NeedFunctionPrototypes
+ XkbDescPtr /* xkb */,
+ unsigned int /* what */,
+ Bool /* freeMap */
+#endif
+);
+
+extern void XkbFreeServerMap(
+#if NeedFunctionPrototypes
+ XkbDescPtr /* xkb */,
+ unsigned int /* what */,
+ Bool /* freeMap */
+#endif
+);
+
+extern XkbKeyTypePtr XkbAddKeyType(
+#if NeedFunctionPrototypes
+ XkbDescPtr /* xkb */,
+ Atom /* name */,
+ int /* map_count */,
+ Bool /* want_preserve */,
+ int /* num_lvls */
+#endif
+);
+
+extern Status XkbAllocIndicatorMaps(
+#if NeedFunctionPrototypes
+ XkbDescPtr /* xkb */
+#endif
+);
+
+extern void XkbFreeIndicatorMaps(
+#if NeedFunctionPrototypes
+ XkbDescPtr /* xkb */
#endif
);
extern XkbDescPtr XkbGetMap(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* which */,
- unsigned /* deviceSpec */
+ Display * /* dpy */,
+ unsigned int /* which */,
+ unsigned int /* deviceSpec */
#endif
);
extern Status XkbGetUpdatedMap(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* which */,
+ Display * /* dpy */,
+ unsigned int /* which */,
XkbDescPtr /* desc */
#endif
);
extern Status XkbGetMapChanges(
#if NeedFunctionPrototypes
- Display * /* display */,
- XkbDescPtr /* desc */,
- XkbChangesPtr /* changes */
+ Display * /* dpy */,
+ XkbDescPtr /* xkb */,
+ XkbMapChangesPtr /* changes */
#endif
);
-extern Status XkbGetActions(
+
+extern Status XkbRefreshKeyboardMapping(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* firstAction */,
- unsigned /* nActions */,
- XkbDescPtr /* desc */
+ XkbMapNotifyEvent * /* event */
#endif
);
-extern Status XkbGetRadioGroups(
+extern Status XkbGetKeyTypes(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* firstRadioGroup */,
- unsigned /* nRadioGroups */,
- XkbDescPtr /* desc */
+ Display * /* dpy */,
+ unsigned int /* first */,
+ unsigned int /* num */,
+ XkbDescPtr /* xkb */
#endif
);
extern Status XkbGetKeySyms(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* firstKey */,
- unsigned /* nKeys */,
- XkbDescPtr /* desc */
+ Display * /* dpy */,
+ unsigned int /* first */,
+ unsigned int /* num */,
+ XkbDescPtr /* xkb */
#endif
);
extern Status XkbGetKeyActions(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* firstKey */,
- unsigned /* nKeys */,
- XkbDescPtr /* desc */
+ Display * /* dpy */,
+ unsigned int /* first */,
+ unsigned int /* num */,
+ XkbDescPtr /* xkb */
#endif
);
extern Status XkbGetKeyBehaviors(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* firstKey */,
- unsigned /* nKeys */,
+ Display * /* dpy */,
+ unsigned int /* firstKey */,
+ unsigned int /* nKeys */,
XkbDescPtr /* desc */
#endif
);
extern Status XkbGetVirtualMods(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* which */,
+ Display * /* dpy */,
+ unsigned int /* which */,
XkbDescPtr /* desc */
#endif
);
extern Status XkbGetKeyExplicitComponents(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* firstKey */,
- unsigned /* nKeys */,
+ Display * /* dpy */,
+ unsigned int /* firstKey */,
+ unsigned int /* nKeys */,
+ XkbDescPtr /* desc */
+#endif
+);
+
+extern Status XkbGetKeyModifierMap(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ unsigned int /* firstKey */,
+ unsigned int /* nKeys */,
XkbDescPtr /* desc */
#endif
);
+extern Status XkbAllocControls(
+#if NeedFunctionPrototypes
+ XkbDescPtr /* xkb */,
+ unsigned int /* which*/
+#endif
+);
+
+extern void XkbFreeControls(
+#if NeedFunctionPrototypes
+ XkbDescPtr /* xkb */,
+ unsigned int /* which */,
+ Bool /* freeMap */
+#endif
+);
+
extern Status XkbGetControls(
#if NeedFunctionPrototypes
- Display * /* display */,
+ Display * /* dpy */,
unsigned long /* which */,
XkbDescPtr /* desc */
#endif
);
-extern Status XkbSetControls(
+extern Bool XkbSetControls(
#if NeedFunctionPrototypes
- Display * /* display */,
+ Display * /* dpy */,
unsigned long /* which */,
XkbDescPtr /* desc */
#endif
);
+extern void XkbNoteControlsChanges(
+#if NeedFunctionPrototypes
+ XkbControlsChangesPtr /* old */,
+ XkbControlsNotifyEvent * /* new */,
+ unsigned int /* wanted */
+#endif
+);
+
+#define XkbGetControlsChanges(d,x,c) XkbGetControls(d,(c)->changed_ctrls,x)
+#define XkbChangeControls(d,x,c) XkbSetControls(d,(c)->changed_ctrls,x)
+
extern Status XkbAllocCompatMap(
#if NeedFunctionPrototypes
XkbDescPtr /* xkb */,
- unsigned /* which */,
- unsigned /* nInterpret */
+ unsigned int /* which */,
+ unsigned int /* nInterpret */
#endif
);
-extern Status XkbFreeCompatMap(
+extern void XkbFreeCompatMap(
#if NeedFunctionPrototypes
XkbDescPtr /* xkb */,
- Bool /* all */,
- unsigned /* which */
+ unsigned int /* which */,
+ Bool /* freeMap */
#endif
);
extern Status XkbGetCompatMap(
#if NeedFunctionPrototypes
Display * /* dpy */,
- unsigned /* which */,
+ unsigned int /* which */,
XkbDescPtr /* xkb */
#endif
);
-extern Status XkbSetCompatMap(
+extern Bool XkbSetCompatMap(
#if NeedFunctionPrototypes
Display * /* dpy */,
- unsigned /* which */,
+ unsigned int /* which */,
XkbDescPtr /* xkb */,
Bool /* updateActions */
#endif
);
-extern Status XkbAllocNames(
+extern XkbSymInterpretPtr XkbAddSymInterpret(
#if NeedFunctionPrototypes
XkbDescPtr /* xkb */,
- unsigned /* which */
+ XkbSymInterpretPtr /* si */,
+ Bool /* updateMap */,
+ XkbChangesPtr /* changes */
#endif
);
-extern Status XkbFreeNames(
+extern Status XkbAllocNames(
#if NeedFunctionPrototypes
XkbDescPtr /* xkb */,
- Bool /* all */,
- unsigned /* which */
+ unsigned int /* which */,
+ int /* nTotalRG */,
+ int /* nTotalAliases */
#endif
);
extern Status XkbGetNames(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* which */,
+ Display * /* dpy */,
+ unsigned int /* which */,
XkbDescPtr /* desc */
#endif
);
-extern Status XkbSetNames(
+extern Bool XkbSetNames(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* which */,
- unsigned /* firstColMap */,
- unsigned /* nColMaps */,
+ Display * /* dpy */,
+ unsigned int /* which */,
+ unsigned int /* firstType */,
+ unsigned int /* nTypes */,
XkbDescPtr /* desc */
#endif
);
+extern Bool XkbChangeNames(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ XkbDescPtr /* xkb */,
+ XkbNameChangesPtr /* changes */
+#endif
+);
+
+extern void XkbFreeNames(
+#if NeedFunctionPrototypes
+ XkbDescPtr /* xkb */,
+ unsigned int /* which */,
+ Bool /* freeMap */
+#endif
+);
+
+
extern Status XkbGetState(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* deviceSpec */,
+ Display * /* dpy */,
+ unsigned int /* deviceSpec */,
XkbStatePtr /* rtrnState */
#endif
);
-extern Status XkbSetMap(
+extern Bool XkbSetMap(
#if NeedFunctionPrototypes
- Display * /* display */,
- unsigned /* which */,
+ Display * /* dpy */,
+ unsigned int /* which */,
XkbDescPtr /* desc */
#endif
);
-extern Status XkbChangeMap(
+extern Bool XkbChangeMap(
#if NeedFunctionPrototypes
- Display* /* display */,
+ Display* /* dpy */,
XkbDescPtr /* desc */,
- XkbMapChangesRec * /* changes */
+ XkbMapChangesPtr /* changes */
#endif
);
-extern KeySym *XkbEnlargeKeySyms(
+extern Bool XkbSetDetectableAutoRepeat(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ Bool /* detectable */,
+ Bool * /* supported */
+#endif
+);
+
+extern Bool XkbGetDetectableAutoRepeat(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ Bool * /* supported */
+#endif
+);
+
+extern Bool XkbSetAutoResetControls(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ unsigned int /* changes */,
+ unsigned int * /* auto_ctrls */,
+ unsigned int * /* auto_values */
+#endif
+);
+
+extern Bool XkbGetAutoResetControls(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ unsigned int * /* auto_ctrls */,
+ unsigned int * /* auto_ctrl_values */
+#endif
+);
+
+extern Status XkbCopyKeyType(
+#if NeedFunctionPrototypes
+ XkbKeyTypePtr /* from */,
+ XkbKeyTypePtr /* into */
+#endif
+);
+
+extern Status XkbCopyKeyTypes(
+#if NeedFunctionPrototypes
+ XkbKeyTypePtr /* from */,
+ XkbKeyTypePtr /* into */,
+ int /* num_types */
+#endif
+);
+
+extern Status XkbResizeKeyType(
+#if NeedFunctionPrototypes
+ XkbDescPtr /* xkb */,
+ int /* type_ndx */,
+ int /* map_count */,
+ Bool /* want_preserve */,
+ int /* new_num_lvls */
+#endif
+);
+
+extern KeySym *XkbResizeKeySyms(
#if NeedFunctionPrototypes
XkbDescPtr /* desc */,
int /* forKey */,
@@ -636,7 +1106,7 @@ extern KeySym *XkbEnlargeKeySyms(
#endif
);
-extern XkbAction *XkbEnlargeKeyActions(
+extern XkbAction *XkbResizeKeyActions(
#if NeedFunctionPrototypes
XkbDescPtr /* desc */,
int /* forKey */,
@@ -644,55 +1114,219 @@ extern XkbAction *XkbEnlargeKeyActions(
#endif
);
-extern Status XkbChangeTypeOfKey(
+extern Status XkbChangeTypesOfKey(
#if NeedFunctionPrototypes
XkbDescPtr /* xkb */,
- unsigned /* key */,
- unsigned /* newType */,
- XkbMapChangesRec * /* pChanges */
+ int /* key */,
+ int /* num_groups */,
+ unsigned int /* groups */,
+ int * /* newTypes */,
+ XkbMapChangesPtr /* pChanges */
#endif
);
-extern Status XkbChangeSymsForKey(
+/***====================================================================***/
+
+extern XkbComponentListPtr XkbListComponents(
#if NeedFunctionPrototypes
- XkbDescPtr /* xkb */,
- unsigned /* key */,
- unsigned /* count */,
- KeySym * /* syms */,
- XkbMapChangesRec * /* pChanges */
+ Display * /* dpy */,
+ unsigned int /* deviceSpec */,
+ XkbComponentNamesPtr /* ptrns */,
+ int * /* max_inout */
+#endif
+);
+
+extern void XkbFreeComponentList(
+#if NeedFunctionPrototypes
+ XkbComponentListPtr /* list */
+#endif
+);
+
+extern XkbDescPtr XkbGetKeyboard(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ unsigned int /* which */,
+ unsigned int /* deviceSpec */
+#endif
+);
+
+extern XkbDescPtr XkbGetKeyboardByName(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ unsigned int /* deviceSpec */,
+ XkbComponentNamesPtr /* names */,
+ unsigned int /* want */,
+ unsigned int /* need */,
+ Bool /* load */
+#endif
+);
+
+/***====================================================================***/
+
+extern int XkbKeyTypesForCoreSymbols( /* returns # of groups */
+#if NeedFunctionPrototypes
+ XkbDescPtr /* xkb */, /* keyboard device */
+ int /* map_width */, /* width of core KeySym array */
+ KeySym * /* core_syms */, /* always mapWidth symbols */
+ unsigned int /* protected */, /* explicit key types */
+ int * /* types_inout */, /* always four type indices */
+ KeySym * /* xkb_syms_rtrn */ /* must have enough space */
+#endif
+);
+
+extern Bool XkbApplyCompatMapToKey( /* False only on error */
+#if NeedFunctionPrototypes
+ XkbDescPtr /* xkb */, /* keymap to be edited */
+ KeyCode /* key */, /* key to be updated */
+ XkbChangesPtr /* changes */ /* resulting changes to map */
+#endif
+);
+
+extern Bool XkbUpdateMapFromCore( /* False only on error */
+#if NeedFunctionPrototypes
+ XkbDescPtr /* xkb */, /* XKB keyboard to be edited */
+ KeyCode /* first_key */, /* first changed key */
+ int /* num_keys */, /* number of changed keys */
+ int /* map_width */, /* width of core keymap */
+ KeySym * /* core_keysyms */, /* symbols from core keymap */
+ XkbChangesPtr /* changes */ /* resulting changes */
+#endif
+);
+
+/***====================================================================***/
+
+extern XkbDeviceLedInfoPtr XkbAddDeviceLedInfo(
+#if NeedFunctionPrototypes
+ XkbDeviceInfoPtr /* devi */,
+ unsigned int /* ledClass */,
+ unsigned int /* ledId */
+#endif
+);
+
+extern Status XkbResizeDeviceButtonActions(
+#if NeedFunctionPrototypes
+ XkbDeviceInfoPtr /* devi */,
+ unsigned int /* newTotal */
#endif
);
-#ifdef NOTYET
+extern XkbDeviceInfoPtr XkbAllocDeviceInfo(
+#if NeedFunctionPrototypes
+ unsigned int /* deviceSpec */,
+ unsigned int /* nButtons */,
+ unsigned int /* szLeds */
+#endif
+);
-extern XkbKbdGeometryRec *XkbGetKbdGeometry(
+extern void XkbFreeDeviceInfo(
#if NeedFunctionPrototypes
- Display *dpy, char *name
+ XkbDeviceInfoPtr /* devi */,
+ unsigned int /* which */,
+ Bool /* freeDevI */
#endif
);
-extern XkbKbdDpyStateRec *XkbKbdZoom(
+extern void XkbNoteDeviceChanges(
#if NeedFunctionPrototypes
- XkbKbdGeometryRec*,int w,int h
+ XkbDeviceChangesPtr /* old */,
+ XkbExtensionDeviceNotifyEvent * /* new */,
+ unsigned int /* wanted */
#endif
);
-extern XkbKbdKeyRec *XkbKbdNextKey(
+
+extern XkbDeviceInfoPtr XkbGetDeviceInfo(
#if NeedFunctionPrototypes
- XkbKbdDpyStatePtr pState,
- int *left,int *top,
- int *right,int *bottom
+ Display * /* dpy */,
+ unsigned int /* which */,
+ unsigned int /* deviceSpec */,
+ unsigned int /* ledClass */,
+ unsigned int /* ledID */
#endif
);
+
+extern Status XkbGetDeviceInfoChanges(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ XkbDeviceInfoPtr /* devi */,
+ XkbDeviceChangesPtr /* changes */
#endif
+);
+
+extern Status XkbGetDeviceButtonActions(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ XkbDeviceInfoPtr /* devi */,
+ Bool /* all */,
+ unsigned int /* first */,
+ unsigned int /* nBtns */
+#endif
+);
+
+extern Status XkbGetDeviceLedInfo(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ XkbDeviceInfoPtr /* devi */,
+ unsigned int /* ledClass (class, XIDflt, XIAll) */,
+ unsigned int /* ledId (id, XIDflt, XIAll) */,
+ unsigned int /* which (XkbXI_Indicator{Names,Map}Mask */
+#endif
+);
+
+extern Bool XkbSetDeviceInfo(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ unsigned int /* which */,
+ XkbDeviceInfoPtr /* devi */
+#endif
+);
+
+extern Bool XkbChangeDeviceInfo(
+#if NeedFunctionPrototypes
+ Display* /* dpy */,
+ XkbDeviceInfoPtr /* desc */,
+ XkbDeviceChangesPtr /* changes */
+#endif
+);
+
+extern Bool XkbSetDeviceLedInfo(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ XkbDeviceInfoPtr /* devi */,
+ unsigned int /* ledClass */,
+ unsigned int /* ledID */,
+ unsigned int /* which */
+#endif
+);
+
+extern Bool XkbSetDeviceButtonActions(
+#if NeedFunctionPrototypes
+ Display * /* dpy */,
+ XkbDeviceInfoPtr /* devi */,
+ unsigned int /* first */,
+ unsigned int /* nBtns */
+#endif
+);
+
+/***====================================================================***/
+
+extern char XkbToControl(
+#if NeedFunctionPrototypes
+ char /* c */
+#endif
+);
+
+/***====================================================================***/
-extern Status XkbSetDebuggingFlags(
+extern Bool XkbSetDebuggingFlags(
#if NeedFunctionPrototypes
Display * /* dpy */,
unsigned int /* mask */,
unsigned int /* flags */,
char * /* msg */,
- unsigned int * /* rtrnFlags */,
- Bool * /* disableLocks */
+ unsigned int /* ctrls_mask */,
+ unsigned int /* ctrls */,
+ unsigned int * /* rtrn_flags */,
+ unsigned int * /* rtrn_ctrls */
#endif
);
diff --git a/lib/xkbfile/XKBfile.h b/lib/xkbfile/XKBfile.h
index 72d45d1cd..e0748f906 100644
--- a/lib/xkbfile/XKBfile.h
+++ b/lib/xkbfile/XKBfile.h
@@ -1,7 +1,7 @@
#ifndef _XKBFILE_H_
#define _XKBFILE_H_ 1
-/* $XConsortium: XKBfile.h /main/2 1995/12/07 21:18:19 kaleb $ */
+/* $XConsortium: XKBfile.h /main/5 1996/03/01 14:30:21 kaleb $ */
/************************************************************
Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
@@ -191,6 +191,13 @@ extern char * XkbAccessXDetailText(
#endif
);
+extern char * XkbNKNDetailMaskText(
+#if NeedFunctionPrototypes
+ unsigned /* detail */,
+ unsigned /* format */
+#endif
+);
+
extern char * XkbControlsMaskText(
#if NeedFunctionPrototypes
unsigned /* ctrls */,
@@ -256,7 +263,8 @@ extern unsigned _XkbKSCheckCase(
extern int XkbFindKeycodeByName(
#if NeedFunctionPrototypes
XkbDescPtr /* xkb */,
- char * /* name */
+ char * /* name */,
+ Bool /* use_aliases */
#endif
);
@@ -366,6 +374,13 @@ extern Bool XkbDetermineFileType(
#endif
);
+extern Bool XkbNameMatchesPattern(
+#if NeedFunctionPrototypes
+ char * /* name */,
+ char * /* pattern */
+#endif
+);
+
/***====================================================================***/
extern Bool XkbWriteXKBKeycodes(
generated by cgit v1.2.3 (git 2.39.1) at 2025-08-19 22:23:44 +0000