home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
OS/2 Shareware BBS: 10 Tools
/
10-Tools.zip
/
evbl0627.zip
/
everblue_20010627.zip
/
x11
/
XKBSetMap.c
< prev
next >
Wrap
C/C++ Source or Header
|
1999-11-02
|
21KB
|
742 lines
/* $XConsortium: XKBSetMap.c /main/8 1996/03/01 14:30:01 kaleb $ */
/************************************************************
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.
********************************************************/
#include <stdio.h>
#define NEED_REPLIES
#define NEED_EVENTS
#include "Xlib_private.h"
#include <X11/extensions/XKBproto.h>
#include "XKBlibint.h"
#if 0
static int
#if NeedFunctionPrototypes
_XkbSizeKeyTypes(XkbDescPtr xkb,xkbSetMapReq *req)
#else
_XkbSizeKeyTypes(xkb,req)
XkbDescPtr xkb;
xkbSetMapReq * req;
#endif
{
DBUG_ENTER("_XkbSizeKeyTypes")
XkbKeyTypePtr map;
int i,len;
if (((req->present&XkbKeyTypesMask)==0)||(req->nTypes==0)) {
req->present&= ~XkbKeyTypesMask;
req->firstType= req->nTypes= 0;
DBUG_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);
}
DBUG_RETURN(len);
}
static void
#if NeedFunctionPrototypes
_XkbWriteKeyTypes(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
#else
_XkbWriteKeyTypes(dpy,xkb,req)
Display * dpy;
XkbDescPtr xkb;
xkbSetMapReq * req;
#endif
{
DBUG_ENTER("_XkbWriteKeyTypes")
char * buf;
XkbKeyTypePtr type;
int i,n,sz;
xkbKeyTypeWireDesc *desc;
if ((req->present&XkbKeyTypesMask)==0)
DBUG_VOID_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;
}
}
}
}
DBUG_VOID_RETURN;
}
static int
#if NeedFunctionPrototypes
_XkbSizeKeySyms(XkbDescPtr xkb,xkbSetMapReq *req)
#else
_XkbSizeKeySyms(xkb,req)
XkbDescPtr xkb;
xkbSetMapReq * req;
#endif
{
DBUG_ENTER("_XkbSizeKeySyms")
int i,len;
unsigned nSyms;
if (((req->present&XkbKeySymsMask)==0)||(req->nKeySyms==0)) {
req->present&= ~XkbKeySymsMask;
req->firstKeySym= req->nKeySyms= 0;
req->totalSyms= 0;
DBUG_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;
DBUG_RETURN(len);
}
static void
#if NeedFunctionPrototypes
_XkbWriteKeySyms(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
#else
_XkbWriteKeySyms(dpy,xkb,req)
Display * dpy;
XkbDescPtr xkb;
xkbSetMapReq * req;
#endif
{
DBUG_ENTER("_XkbWriteKeySyms")
register KeySym * pSym;
CARD32 * outSym;
XkbSymMapPtr symMap;
xkbSymMapWireDesc *desc;
register int i;
if ((req->present&XkbKeySymsMask)==0)
DBUG_VOID_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);
}
}
DBUG_VOID_RETURN;
}
static int
#if NeedFunctionPrototypes
_XkbSizeKeyActions(XkbDescPtr xkb,xkbSetMapReq *req)
#else
_XkbSizeKeyActions(xkb,req)
XkbDescPtr xkb;
xkbSetMapReq * req;
#endif
{
DBUG_ENTER("_XkbSizeKeyActions")
int i,len,nActs;
if (((req->present&XkbKeyActionsMask)==0)||(req->nKeyActs==0)) {
req->present&= ~XkbKeyActionsMask;
req->firstKeyAct= req->nKeyActs= 0;
req->totalActs= 0;
DBUG_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;
DBUG_RETURN(len);
}
static void
#if NeedFunctionPrototypes
_XkbWriteKeyActions(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
#else
_XkbWriteKeyActions(dpy,xkb,req)
Display * dpy;
XkbDescPtr xkb;
xkbSetMapReq * req;
#endif
{
DBUG_ENTER("_XkbWriteKeyActions")
register int i;
int n;
CARD8 *numDesc;
XkbAction *actDesc;
if ((req->present&XkbKeyActionsMask)==0)
DBUG_VOID_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;
}
}
DBUG_VOID_RETURN;
}
static int
#if NeedFunctionPrototypes
_XkbSizeKeyBehaviors(XkbDescPtr xkb,xkbSetMapReq *req)
#else
_XkbSizeKeyBehaviors(xkb,req)
XkbDescPtr xkb;
xkbSetMapReq * req;
#endif
{
DBUG_ENTER("_XkbSizeKeyBehaviors")
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;
DBUG_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;
DBUG_RETURN(nFound*SIZEOF(xkbBehaviorWireDesc));
}
static void
#if NeedFunctionPrototypes
_XkbWriteKeyBehaviors(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
#else
_XkbWriteKeyBehaviors(dpy,xkb,req)
Display * dpy;
XkbDescPtr xkb;
xkbSetMapReq * req;
#endif
{
DBUG_ENTER("_XkbWriteKeyBehaviors")
register int i,first,last;
xkbBehaviorWireDesc * wire;
char * buf;
if ((req->present&XkbKeyBehaviorsMask)==0)
DBUG_VOID_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;
}
}
DBUG_VOID_RETURN;
}
static unsigned
#if NeedFunctionPrototypes
_XkbSizeVirtualMods(xkbSetMapReq *req)
#else
_XkbSizeVirtualMods(req)
xkbSetMapReq * req;
#endif
{
DBUG_ENTER("_XkbSizeVirtualMods")
register int i,bit,nMods;
unsigned result;
if (((req->present&XkbVirtualModsMask)==0)||(req->virtualMods==0)) {
req->present&= ~XkbVirtualModsMask;
req->virtualMods= 0;
DBUG_RETURN(0);
}
for (i=nMods=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
if (req->virtualMods&bit)
nMods++;
}
result = XkbPaddedSize(nMods);
DBUG_RETURN(result);
}
static void
#if NeedFunctionPrototypes
_XkbWriteVirtualMods( Display * dpy,
XkbDescPtr xkb,
xkbSetMapReq * req,
unsigned size)
#else
_XkbWriteVirtualMods(dpy,xkb,req,size)
Display * dpy;
XkbDescPtr xkb;
xkbSetMapReq * req;
unsigned size;
#endif
{
DBUG_ENTER("_XkbWriteVirtualMods")
register int i,bit;
CARD8 *vmods;
if ((req->present&XkbVirtualModsMask==0)||(size<1))
DBUG_VOID_RETURN;
BufAlloc(CARD8 *,vmods,size);
for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
if (req->virtualMods&bit)
*vmods++= xkb->server->vmods[i];
}
DBUG_VOID_RETURN;
}
static int
#if NeedFunctionPrototypes
_XkbSizeKeyExplicit(XkbDescPtr xkb,xkbSetMapReq *req)
#else
_XkbSizeKeyExplicit(xkb,req)
XkbDescPtr xkb;
xkbSetMapReq * req;
#endif
{
DBUG_ENTER("_XkbSizeKeyExplicit")
register int i,first,last,nFound;
int result;
if (((req->present&XkbExplicitComponentsMask)==0)||(req->nKeyExplicit==0)) {
req->present&= ~XkbExplicitComponentsMask;
req->firstKeyExplicit= req->nKeyExplicit= 0;
req->totalKeyExplicit= 0;
DBUG_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;
result = XkbPaddedSize((nFound*2));
DBUG_RETURN(result);
}
static void
#if NeedFunctionPrototypes
_XkbWriteKeyExplicit(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
#else
_XkbWriteKeyExplicit(dpy,xkb,req)
Display * dpy;
XkbDescPtr xkb;
xkbSetMapReq * req;
#endif
{
DBUG_ENTER("_XkbWriteKeyExplicit")
register int i,first,last;
CARD8 * wire;
if ((req->present&XkbExplicitComponentsMask)==0)
DBUG_VOID_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;
}
}
DBUG_VOID_RETURN;
}
static int
#if NeedFunctionPrototypes
_XkbSizeModifierMap(XkbDescPtr xkb,xkbSetMapReq *req)
#else
_XkbSizeModifierMap(xkb,req)
XkbDescPtr xkb;
xkbSetMapReq * req;
#endif
{
DBUG_ENTER("_XkbSizeModifierMap")
register int i,first,last,nFound;
int result;
if (((req->present&XkbModifierMapMask)==0)||(req->nModMapKeys==0)) {
req->present&= ~XkbModifierMapMask;
req->firstModMapKey= req->nModMapKeys= 0;
req->totalModMapKeys= 0;
DBUG_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;
result = XkbPaddedSize((nFound*2));
DBUG_RETURN(result);
}
static void
#if NeedFunctionPrototypes
_XkbWriteModifierMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
#else
_XkbWriteModifierMap(dpy,xkb,req)
Display * dpy;
XkbDescPtr xkb;
xkbSetMapReq * req;
#endif
{
DBUG_ENTER("_XkbWriteModifierMap")
register int i,first,last;
CARD8 * wire;
if ((req->present&XkbModifierMapMask)==0)
DBUG_VOID_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;
}
}
}
DBUG_VOID_RETURN;
}
static int
#if NeedFunctionPrototypes
_XkbSizeVirtualModMap(XkbDescPtr xkb,xkbSetMapReq *req)
#else
_XkbSizeVirtualModMap(xkb,req)
XkbDescPtr xkb;
xkbSetMapReq * req;
#endif
{
DBUG_ENTER("_XkbSizeVirtualModMap")
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;
DBUG_RETURN(nFound*SIZEOF(xkbVModMapWireDesc));
}
static void
#if NeedFunctionPrototypes
_XkbWriteVirtualModMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
#else
_XkbWriteVirtualModMap(dpy,xkb,req)
Display * dpy;
XkbDescPtr xkb;
xkbSetMapReq * req;
#endif
{
DBUG_ENTER("_XkbWriteVirtualModMap")
register int i,first,last;
xkbVModMapWireDesc * wire;
if ((req->present&XkbVirtualModMapMask)==0)
DBUG_VOID_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++;
}
}
}
DBUG_VOID_RETURN;
}
static void
#if NeedFunctionPrototypes
SendSetMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
#else
SendSetMap(dpy,xkb,req)
Display * dpy;
XkbDescPtr xkb;
xkbSetMapReq * req;
#endif
{
DBUG_ENTER("SendSetMap")
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);
DBUG_VOID_RETURN;
}
Bool
#if NeedFunctionPrototypes
XkbSetMap(Display *dpy,unsigned which,XkbDescPtr xkb)
#else
XkbSetMap(dpy,which,xkb)
Display * dpy;
unsigned which;
XkbDescPtr xkb;
#endif
{
DBUG_ENTER("XkbSetMap")
register xkbSetMapReq * req;
XkbInfoPtr xkbi;
XkbServerMapPtr srv;
XkbClientMapPtr map;
if ((dpy->flags & XlibDisplayNoXkb) ||
(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))||
(!xkb))
DBUG_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))))
DBUG_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();
DBUG_RETURN(True);
}
Bool
#if NeedFunctionPrototypes
XkbChangeMap(Display *dpy,XkbDescPtr xkb,XkbMapChangesPtr changes)
#else
XkbChangeMap(dpy,xkb,changes)
Display * dpy;
XkbDescPtr xkb;
XkbMapChangesPtr changes;
#endif
{
DBUG_ENTER("XkbChangeMap")
register xkbSetMapReq * req;
XkbInfoPtr xkbi;
XkbServerMapPtr srv;
XkbClientMapPtr map;
if ((dpy->flags & XlibDisplayNoXkb) ||
(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))||
(!xkb)||(!changes))
DBUG_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))))
DBUG_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();
DBUG_RETURN(True);
}
#endif