aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/lib/X11/XKBSetMap.c
diff options
context:
space:
mode:
Diffstat (limited to 'nx-X11/lib/X11/XKBSetMap.c')
-rw-r--r--nx-X11/lib/X11/XKBSetMap.c595
1 files changed, 595 insertions, 0 deletions
diff --git a/nx-X11/lib/X11/XKBSetMap.c b/nx-X11/lib/X11/XKBSetMap.c
new file mode 100644
index 000000000..4a3b15c70
--- /dev/null
+++ b/nx-X11/lib/X11/XKBSetMap.c
@@ -0,0 +1,595 @@
+/* $Xorg: XKBSetMap.c,v 1.4 2000/08/17 19:45:03 cpqbld Exp $ */
+/************************************************************
+Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
+
+Permission to use, copy, modify, and distribute this
+software and its documentation for any purpose and without
+fee is hereby granted, provided that the above copyright
+notice appear in all copies and that both that copyright
+notice and this permission notice appear in supporting
+documentation, and that the name of Silicon Graphics not be
+used in advertising or publicity pertaining to distribution
+of the software without specific prior written permission.
+Silicon Graphics makes no representation about the suitability
+of this software for any purpose. It is provided "as is"
+without any express or implied warranty.
+
+SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
+THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+********************************************************/
+/* $XFree86: xc/lib/X11/XKBSetMap.c,v 3.2 2001/01/17 19:41:49 dawes Exp $ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <stdio.h>
+#define NEED_REPLIES
+#define NEED_EVENTS
+#include "Xlibint.h"
+#include <X11/extensions/XKBproto.h>
+#include "XKBlibint.h"
+
+static int
+_XkbSizeKeyTypes(XkbDescPtr xkb,xkbSetMapReq *req)
+{
+ 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[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(xkbModsWireDesc);
+ }
+ return len;
+}
+
+static void
+_XkbWriteKeyTypes(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+ char * buf;
+ XkbKeyTypePtr type;
+ int i,n,sz;
+ xkbKeyTypeWireDesc *desc;
+
+ 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(xkbModsWireDesc);
+ BufAlloc(xkbKeyTypeWireDesc *,desc,sz);
+ 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;
+ 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].mods.real_mods;
+ wire->virtualMods= type->map[n].mods.vmods;
+ }
+ buf= (char *)wire;
+ if (type->preserve) {
+ 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;
+ }
+ }
+ }
+ }
+ return;
+}
+
+static int
+_XkbSizeKeySyms(XkbDescPtr xkb,xkbSetMapReq *req)
+{
+ int i,len;
+ unsigned nSyms;
+
+ if (((req->present&XkbKeySymsMask)==0)||(req->nKeySyms==0)) {
+ req->present&= ~XkbKeySymsMask;
+ req->firstKeySym= req->nKeySyms= 0;
+ req->totalSyms= 0;
+ return 0;
+ }
+ 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(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register KeySym * pSym;
+CARD32 * outSym;
+XkbSymMapPtr symMap;
+xkbSymMapWireDesc *desc;
+register int i;
+
+ 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->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(XkbDescPtr xkb,xkbSetMapReq *req)
+{
+ int i,len,nActs;
+
+ if (((req->present&XkbKeyActionsMask)==0)||(req->nKeyActs==0)) {
+ req->present&= ~XkbKeyActionsMask;
+ req->firstKeyAct= req->nKeyActs= 0;
+ req->totalActs= 0;
+ return 0;
+ }
+ 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(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+ register int i;
+ int n;
+ CARD8 *numDesc;
+ XkbAction *actDesc;
+
+ if ((req->present&XkbKeyActionsMask)==0)
+ return;
+ n = XkbPaddedSize(req->nKeyActs);
+ n+= (req->totalActs*SIZEOF(xkbActionWireDesc));
+
+ BufAlloc(CARD8 *,numDesc,n);
+ 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+req->firstKeyAct));
+ }
+ 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;
+ }
+ }
+ return;
+}
+
+static int
+_XkbSizeKeyBehaviors(XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register int i,first,last,nFound;
+
+ if (((req->present&XkbKeyBehaviorsMask)==0)||(req->nKeyBehaviors<1)) {
+ req->present&= ~XkbKeyBehaviorsMask;
+ req->firstKeyBehavior= req->nKeyBehaviors= 0;
+ req->totalKeyBehaviors= 0;
+ return 0;
+ }
+ 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++;
+ }
+ req->totalKeyBehaviors= nFound;
+ return (nFound*SIZEOF(xkbBehaviorWireDesc));
+}
+
+static void
+_XkbWriteKeyBehaviors(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register int i,first,last;
+xkbBehaviorWireDesc * wire;
+char * buf;
+
+ if ((req->present&XkbKeyBehaviorsMask)==0)
+ return;
+ first= req->firstKeyBehavior;
+ last= first+req->nKeyBehaviors-1;
+
+ i= req->totalKeyBehaviors*SIZEOF(xkbBehaviorWireDesc);
+ 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;
+ buf+= SIZEOF(xkbBehaviorWireDesc);
+ wire= (xkbBehaviorWireDesc *)buf;
+ }
+ }
+ return;
+}
+
+static unsigned
+_XkbSizeVirtualMods(xkbSetMapReq *req)
+{
+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 (req->virtualMods&bit)
+ nMods++;
+ }
+ return XkbPaddedSize(nMods);
+}
+
+static void
+_XkbWriteVirtualMods( Display * dpy,
+ XkbDescPtr xkb,
+ xkbSetMapReq * req,
+ unsigned size)
+{
+ register int i,bit;
+ CARD8 *vmods;
+
+ /* This was req->present&XkbVirtualModsMask==0, and '==' beats '&' */
+ if (((req->present & XkbVirtualModsMask) == 0) || (size < 1))
+ return;
+ BufAlloc(CARD8 *,vmods,size);
+ for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
+ if (req->virtualMods&bit)
+ *vmods++= xkb->server->vmods[i];
+ }
+ return;
+}
+
+static int
+_XkbSizeKeyExplicit(XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register int i,first,last,nFound;
+
+ if (((req->present&XkbExplicitComponentsMask)==0)||(req->nKeyExplicit==0)) {
+ req->present&= ~XkbExplicitComponentsMask;
+ req->firstKeyExplicit= req->nKeyExplicit= 0;
+ req->totalKeyExplicit= 0;
+ return 0;
+ }
+ 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 XkbPaddedSize((nFound*2));
+}
+
+static void
+_XkbWriteKeyExplicit(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register int i,first,last;
+CARD8 * wire;
+
+ if ((req->present&XkbExplicitComponentsMask)==0)
+ return;
+ 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) {
+ wire[0]= i;
+ wire[1]= xkb->server->explicit[i];
+ wire+= 2;
+ }
+ }
+ return;
+}
+
+static int
+_XkbSizeModifierMap(XkbDescPtr xkb,xkbSetMapReq *req)
+{
+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
+_XkbWriteModifierMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+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
+_XkbSizeVirtualModMap(XkbDescPtr xkb,xkbSetMapReq *req)
+{
+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
+_XkbWriteVirtualModMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+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
+SendSetMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+xkbSetMapReq tmp;
+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)/4;
+ req->length+= _XkbSizeModifierMap(xkb,req)/4;
+ req->length+= _XkbSizeVirtualModMap(xkb,req)/4;
+
+ tmp= *req;
+ if ( tmp.nTypes>0 )
+ _XkbWriteKeyTypes(dpy,xkb,&tmp);
+ if ( tmp.nKeySyms>0 )
+ _XkbWriteKeySyms(dpy,xkb,&tmp);
+ if ( tmp.nKeyActs )
+ _XkbWriteKeyActions(dpy,xkb,&tmp);
+ if ( tmp.totalKeyBehaviors>0 )
+ _XkbWriteKeyBehaviors(dpy,xkb,&tmp);
+ if ( tmp.virtualMods )
+ _XkbWriteVirtualMods(dpy,xkb,&tmp,szMods);
+ if ( tmp.totalKeyExplicit>0)
+ _XkbWriteKeyExplicit(dpy,xkb,&tmp);
+ if ( tmp.totalModMapKeys>0)
+ _XkbWriteModifierMap(dpy,xkb,&tmp);
+ if ( tmp.totalVModMapKeys>0)
+ _XkbWriteVirtualModMap(dpy,xkb,&tmp);
+ return;
+}
+
+Bool
+XkbSetMap(Display *dpy,unsigned which,XkbDescPtr xkb)
+{
+register xkbSetMapReq * req;
+XkbInfoPtr xkbi;
+XkbServerMapPtr srv;
+XkbClientMapPtr map;
+
+ if ((dpy->flags & XlibDisplayNoXkb) ||
+ (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))||
+ (!xkb))
+ return False;
+ 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);
+ xkbi = dpy->xkb_info;
+ GetReq(kbSetMap, req);
+ req->reqType = xkbi->codes->major_opcode;
+ req->xkbReqType = X_kbSetMap;
+ req->deviceSpec = xkb->device_spec;
+ req->present = which;
+ req->flags = XkbSetMapAllFlags;
+ req->minKeyCode= xkb->min_key_code;
+ req->maxKeyCode= xkb->max_key_code;
+ req->firstType = 0;
+ if (which&XkbKeyTypesMask) req->nTypes = map->num_types;
+ else req->nTypes = 0;
+ if (which&XkbKeySymsMask) {
+ req->firstKeySym = xkb->min_key_code;
+ req->nKeySyms = XkbNumKeys(xkb);
+ }
+ if (which&XkbKeyActionsMask) {
+ 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;
+ 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;
+}
+
+Bool
+XkbChangeMap(Display *dpy,XkbDescPtr xkb,XkbMapChangesPtr changes)
+{
+register xkbSetMapReq * req;
+XkbInfoPtr xkbi;
+XkbServerMapPtr srv;
+XkbClientMapPtr map;
+
+ if ((dpy->flags & XlibDisplayNoXkb) ||
+ (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))||
+ (!xkb)||(!changes))
+ return False;
+ 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)&&
+ ((!srv)||(!srv->explicit)))||
+ ((changes->changed&XkbModifierMapMask)&&((!map)||(!map->modmap)))||
+ ((changes->changed&XkbVirtualModMapMask)&&((!srv)||(!srv->vmodmap))))
+ return False;
+
+ LockDisplay(dpy);
+ xkbi = dpy->xkb_info;
+ GetReq(kbSetMap, req);
+ req->reqType = xkbi->codes->major_opcode;
+ req->xkbReqType = X_kbSetMap;
+ req->deviceSpec = xkb->device_spec;
+ req->present = changes->changed;
+ 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->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;
+ 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;
+}
+