From 3562e78743202e43aec8727005182a2558117eca Mon Sep 17 00:00:00 2001 From: marha Date: Sun, 28 Jun 2009 22:07:26 +0000 Subject: Checked in the following released items: xkeyboard-config-1.4.tar.gz ttf-bitstream-vera-1.10.tar.gz font-alias-1.0.1.tar.gz font-sun-misc-1.0.0.tar.gz font-sun-misc-1.0.0.tar.gz font-sony-misc-1.0.0.tar.gz font-schumacher-misc-1.0.0.tar.gz font-mutt-misc-1.0.0.tar.gz font-misc-misc-1.0.0.tar.gz font-misc-meltho-1.0.0.tar.gz font-micro-misc-1.0.0.tar.gz font-jis-misc-1.0.0.tar.gz font-isas-misc-1.0.0.tar.gz font-dec-misc-1.0.0.tar.gz font-daewoo-misc-1.0.0.tar.gz font-cursor-misc-1.0.0.tar.gz font-arabic-misc-1.0.0.tar.gz font-winitzki-cyrillic-1.0.0.tar.gz font-misc-cyrillic-1.0.0.tar.gz font-cronyx-cyrillic-1.0.0.tar.gz font-screen-cyrillic-1.0.1.tar.gz font-xfree86-type1-1.0.1.tar.gz font-adobe-utopia-type1-1.0.1.tar.gz font-ibm-type1-1.0.0.tar.gz font-bitstream-type1-1.0.0.tar.gz font-bitstream-speedo-1.0.0.tar.gz font-bh-ttf-1.0.0.tar.gz font-bh-type1-1.0.0.tar.gz font-bitstream-100dpi-1.0.0.tar.gz font-bh-lucidatypewriter-100dpi-1.0.0.tar.gz font-bh-100dpi-1.0.0.tar.gz font-adobe-utopia-100dpi-1.0.1.tar.gz font-adobe-100dpi-1.0.0.tar.gz font-util-1.0.1.tar.gz font-bitstream-75dpi-1.0.0.tar.gz font-bh-lucidatypewriter-75dpi-1.0.0.tar.gz font-adobe-utopia-75dpi-1.0.1.tar.gz font-bh-75dpi-1.0.0.tar.gz bdftopcf-1.0.1.tar.gz font-adobe-75dpi-1.0.0.tar.gz mkfontscale-1.0.6.tar.gz openssl-0.9.8k.tar.gz bigreqsproto-1.0.2.tar.gz xtrans-1.2.2.tar.gz resourceproto-1.0.2.tar.gz inputproto-1.4.4.tar.gz compositeproto-0.4.tar.gz damageproto-1.1.0.tar.gz zlib-1.2.3.tar.gz xkbcomp-1.0.5.tar.gz freetype-2.3.9.tar.gz pthreads-w32-2-8-0-release.tar.gz pixman-0.12.0.tar.gz kbproto-1.0.3.tar.gz evieext-1.0.2.tar.gz fixesproto-4.0.tar.gz recordproto-1.13.2.tar.gz randrproto-1.2.2.tar.gz scrnsaverproto-1.1.0.tar.gz renderproto-0.9.3.tar.gz xcmiscproto-1.1.2.tar.gz fontsproto-2.0.2.tar.gz xextproto-7.0.3.tar.gz xproto-7.0.14.tar.gz libXdmcp-1.0.2.tar.gz libxkbfile-1.0.5.tar.gz libfontenc-1.0.4.tar.gz libXfont-1.3.4.tar.gz libX11-1.1.5.tar.gz libXau-1.0.4.tar.gz libxcb-1.1.tar.gz xorg-server-1.5.3.tar.gz --- libX11/src/xkb/XKBNames.c | 891 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 891 insertions(+) create mode 100644 libX11/src/xkb/XKBNames.c (limited to 'libX11/src/xkb/XKBNames.c') diff --git a/libX11/src/xkb/XKBNames.c b/libX11/src/xkb/XKBNames.c new file mode 100644 index 000000000..a8eeb2adf --- /dev/null +++ b/libX11/src/xkb/XKBNames.c @@ -0,0 +1,891 @@ +/* $Xorg: XKBNames.c,v 1.3 2000/08/17 19:45:02 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/XKBNames.c,v 1.5 2003/04/13 19:22:18 dawes Exp $ */ + +#define NEED_REPLIES +#define NEED_EVENTS +#define NEED_MAP_READERS +#ifdef HAVE_CONFIG_H +#include +#endif +#include "Xlibint.h" +#include +#include "XKBlibint.h" + + +static Status +_XkbReadAtoms( XkbReadBufferPtr buf, + Atom * atoms, + int maxAtoms, + CARD32 present) +{ +register int i,bit; + + for (i=0,bit=1;(idevice_spec == XkbUseCoreKbd ) + xkb->device_spec = rep->deviceID; + + if ((xkb->names==NULL)&& + (XkbAllocNames(xkb,rep->which, + rep->nRadioGroups,rep->nKeyAliases)!=Success)) { + return BadAlloc; + } + names= xkb->names; + if (rep->length==0) + return Success; + + if (!_XkbInitReadBuffer(dpy,&buf,(int)rep->length*4)) + return BadAlloc; + if (nread_rtrn) + *nread_rtrn= (int)rep->length*4; + + if ((rep->which&XkbKeycodesNameMask)&& + (!_XkbReadBufferCopy32(&buf,(long *)&names->keycodes,1))) + goto BAILOUT; + if ((rep->which&XkbGeometryNameMask)&& + (!_XkbReadBufferCopy32(&buf,(long *)&names->geometry,1))) + goto BAILOUT; + if ((rep->which&XkbSymbolsNameMask)&& + (!_XkbReadBufferCopy32(&buf,(long *)&names->symbols,1))) + goto BAILOUT; + if ((rep->which&XkbPhysSymbolsNameMask)&& + (!_XkbReadBufferCopy32(&buf,(long *)&names->phys_symbols,1))) + goto BAILOUT; + if ((rep->which&XkbTypesNameMask)&& + (!_XkbReadBufferCopy32(&buf,(long *)&names->types,1))) + goto BAILOUT; + if ((rep->which&XkbCompatNameMask)&& + (!_XkbReadBufferCopy32(&buf,(long *)&names->compat,1))) + goto BAILOUT; + + if ( rep->which & XkbKeyTypeNamesMask ) { + XkbClientMapPtr map= xkb->map; + XkbKeyTypePtr type; + + len= rep->nTypes*4; + if (map!=NULL) { + type= map->types; + for (i=0;(inum_types)&&(inTypes);i++,type++) { + if (!_XkbReadBufferCopy32(&buf,(long *)&type->name,1)) + goto BAILOUT; + len-= 4; + } + } + if ((len>0)&&(!_XkbSkipReadBufferData(&buf,len))) + goto BAILOUT; + } + if ( rep->which&XkbKTLevelNamesMask ) { + CARD8 *nLevels; + XkbClientMapPtr map= xkb->map; + XkbKeyTypePtr type; + + nLevels=(CARD8*)_XkbGetReadBufferPtr(&buf,XkbPaddedSize(rep->nTypes)); + if (nLevels==NULL) + goto BAILOUT; + if (map!=NULL) { + type= map->types; + for (i=0;i<(int)rep->nTypes;i++,type++) { + if (i>=map->num_types) { + if (!_XkbSkipReadBufferData(&buf,nLevels[i]*4)) + goto BAILOUT; + continue; + } + if ((nLevels[i]>0)&&(nLevels[i]!=type->num_levels)) { + goto BAILOUT; + } + if (type->level_names!=NULL) + Xfree(type->level_names); + if (nLevels[i]==0) { + type->level_names= NULL; + continue; + } + type->level_names= _XkbTypedCalloc(nLevels[i],Atom); + if (type->level_names!=NULL) { + if (!_XkbReadBufferCopy32(&buf,(long *)type->level_names, + nLevels[i])) + goto BAILOUT; + } + else { + _XkbSkipReadBufferData(&buf,nLevels[i]*4); + } + } + } + else { + for (i=0;i<(int)rep->nTypes;i++) { + _XkbSkipReadBufferData(&buf,nLevels[i]*4); + } + } + } + if (rep->which & XkbIndicatorNamesMask) { + if (_XkbReadAtoms(&buf,names->indicators,XkbNumIndicators, + rep->indicators)!=Success) + goto BAILOUT; + } + if ( rep->which&XkbVirtualModNamesMask ) { + if (_XkbReadAtoms(&buf,names->vmods,XkbNumVirtualMods, + (CARD32)rep->virtualMods)!=Success) + goto BAILOUT; + } + if ( rep->which&XkbGroupNamesMask ) { + if (_XkbReadAtoms(&buf,names->groups,XkbNumKbdGroups, + (CARD32)rep->groupNames)!=Success) + goto BAILOUT; + } + if ( rep->which&XkbKeyNamesMask ) { + if (names->keys==NULL) { + int nKeys; + if (xkb->max_key_code==0) { + xkb->min_key_code= rep->minKeyCode; + xkb->max_key_code= rep->maxKeyCode; + } + nKeys= xkb->max_key_code+1; + names->keys= _XkbTypedCalloc(nKeys,XkbKeyNameRec); + } + if (names->keys!=NULL) { + if (!_XkbCopyFromReadBuffer(&buf, + (char *)&names->keys[rep->firstKey], + rep->nKeys*XkbKeyNameLength)) + goto BAILOUT; + } + else _XkbSkipReadBufferData(&buf,rep->nKeys*XkbKeyNameLength); + } + if ( rep->which&XkbKeyAliasesMask && (rep->nKeyAliases>0) ) { + if (XkbAllocNames(xkb,XkbKeyAliasesMask,0,rep->nKeyAliases)!=Success) + goto BAILOUT; + if (!_XkbCopyFromReadBuffer(&buf,(char *)names->key_aliases, + rep->nKeyAliases*XkbKeyNameLength*2)) + goto BAILOUT; + } + if ( rep->which&XkbRGNamesMask ) { + if (rep->nRadioGroups>0) { + Atom *rgNames; + + if (names->radio_groups==NULL) + names->radio_groups = _XkbTypedCalloc(rep->nRadioGroups,Atom); + else if (names->num_rgnRadioGroups) { + names->radio_groups = _XkbTypedRealloc(names->radio_groups, + rep->nRadioGroups, + Atom); + } + rgNames= names->radio_groups; + if (!rgNames) { + goto BAILOUT; + } + if (!_XkbReadBufferCopy32(&buf,(long *)rgNames,rep->nRadioGroups)) + goto BAILOUT; + names->num_rg= rep->nRadioGroups; + } + else if (names->num_rg>0) { + names->num_rg= 0; + Xfree(names->radio_groups); + } + } + len= _XkbFreeReadBuffer(&buf); + if (len!=0) return BadLength; + else return Success; +BAILOUT: + _XkbFreeReadBuffer(&buf); + return BadLength; +} + +Status +XkbGetNames(Display *dpy,unsigned which,XkbDescPtr xkb) +{ + register xkbGetNamesReq *req; + xkbGetNamesReply rep; + Status status; + XkbInfoPtr xkbi; + + if ((dpy->flags & XlibDisplayNoXkb) || + (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))) + return BadAccess; + LockDisplay(dpy); + xkbi = dpy->xkb_info; + if (!xkb->names) { + xkb->names = _XkbTypedCalloc(1,XkbNamesRec); + if (!xkb->names) { + UnlockDisplay(dpy); + SyncHandle(); + return BadAlloc; + } + } + GetReq(kbGetNames, req); + req->reqType = xkbi->codes->major_opcode; + req->xkbReqType = X_kbGetNames; + req->deviceSpec = xkb->device_spec; + req->which = which; + if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { + UnlockDisplay(dpy); + SyncHandle(); + return BadImplementation; + } + + status = _XkbReadGetNamesReply(dpy,&rep,xkb,NULL); + UnlockDisplay(dpy); + SyncHandle(); + return status; +} + +/***====================================================================***/ + +static int +_XkbCountBits(int nBitsMax,unsigned long mask) +{ +register unsigned long y, nBits; + + y = (mask >> 1) &033333333333; + y = mask - y - ((y >>1) & 033333333333); + nBits = ((unsigned int) (((y + (y >> 3)) & 030707070707) % 077)); + + /* nBitsMax really means max+1 */ + return (nBits < nBitsMax) ? nBits : (nBitsMax - 1); +} + +static CARD32 +_XkbCountAtoms(Atom *atoms,int maxAtoms,int *count) +{ +register unsigned int i,bit,nAtoms; +register CARD32 atomsPresent; + + for (i=nAtoms=atomsPresent=0,bit=1;iflags & XlibDisplayNoXkb) || + (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))) + return False; + if ((!xkb)||(!xkb->names)) + return False; + firstLvlType= firstType; + nLvlTypes= nTypes; + if (nTypes<1) + which&= ~(XkbKTLevelNamesMask|XkbKeyTypeNamesMask); + else if (firstType<=XkbLastRequiredType) { + int adjust; + adjust= XkbLastRequiredType-firstType+1; + firstType+= adjust; + nTypes-= adjust; + if (nTypes<1) + which&= ~XkbKeyTypeNamesMask; + } + names= xkb->names; + if (which&(XkbKTLevelNamesMask|XkbKeyTypeNamesMask)) { + register int i; + XkbKeyTypePtr type; + if((xkb->map==NULL)||(xkb->map->types==NULL)||(nTypes==0)|| + (firstType+nTypes>xkb->map->num_types)|| + (firstLvlType+nLvlTypes>xkb->map->num_types)) + return False; + if (which&XkbKTLevelNamesMask) { + type= &xkb->map->types[firstLvlType]; + for (i=nLvlNames=0;ilevel_names!=NULL) + nLvlNames+= type->num_levels; + } + } + } + + nVMods= nLEDs= nRG= nKA= nAtoms= nGroups= 0; + LockDisplay(dpy); + xkbi = dpy->xkb_info; + GetReq(kbSetNames, req); + req->reqType = xkbi->codes->major_opcode; + req->xkbReqType = X_kbSetNames; + req->deviceSpec = xkb->device_spec; + req->firstType = firstType; + req->nTypes = nTypes; + req->firstKey = xkb->min_key_code; + req->nKeys = xkb->max_key_code-xkb->min_key_code+1; + + if (which&XkbKeycodesNameMask) + nAtoms++; + if (which&XkbGeometryNameMask) + nAtoms++; + if (which&XkbSymbolsNameMask) + nAtoms++; + if (which&XkbPhysSymbolsNameMask) + nAtoms++; + if (which&XkbTypesNameMask) + nAtoms++; + if (which&XkbCompatNameMask) + nAtoms++; + if (which&XkbKeyTypeNamesMask) + nAtoms+= nTypes; + if (which&XkbKTLevelNamesMask) { + req->firstKTLevel= firstLvlType; + req->nKTLevels= nLvlTypes; + req->length+= XkbPaddedSize(nLvlTypes)/4; /* room for group widths */ + nAtoms+= nLvlNames; + } + else req->firstKTLevel= req->nKTLevels= 0; + + if (which&XkbIndicatorNamesMask) { + req->indicators= leds= + _XkbCountAtoms(names->indicators,XkbNumIndicators,&nLEDs); + if (nLEDs>0) + nAtoms+= nLEDs; + else which&= ~XkbIndicatorNamesMask; + } + else req->indicators= leds= 0; + + if (which&XkbVirtualModNamesMask) { + vmods= req->virtualMods= (CARD16) + _XkbCountAtoms(names->vmods,XkbNumVirtualMods,&nVMods); + if (nVMods>0) + nAtoms+= nVMods; + else which&= ~XkbVirtualModNamesMask; + } + else vmods= req->virtualMods= 0; + + if (which&XkbGroupNamesMask) { + groups= req->groupNames= (CARD8) + _XkbCountAtoms(names->groups,XkbNumKbdGroups,&nGroups); + if (nGroups>0) + nAtoms+= nGroups; + else which&= ~XkbGroupNamesMask; + } + else groups= req->groupNames= 0; + + if ((which&XkbKeyNamesMask)&&(names->keys!=NULL)) { + firstKey= req->firstKey; + nKeys= req->nKeys; + nAtoms+= nKeys; /* technically not atoms, but 4 bytes wide */ + } + else which&= ~XkbKeyNamesMask; + + if (which&XkbKeyAliasesMask) { + nKA= ((names->key_aliases!=NULL)?names->num_key_aliases:0); + if (nKA>0) { + req->nKeyAliases= nKA; + nAtoms+= nKA*2; /* not atoms, but 8 bytes on the wire */ + } + else { + which&= ~XkbKeyAliasesMask; + req->nKeyAliases = 0; + } + } + else req->nKeyAliases= 0; + + if (which&XkbRGNamesMask) { + nRG= names->num_rg; + if (nRG>0) + nAtoms+= nRG; + else which&= ~XkbRGNamesMask; + } + + req->which= which; + req->nRadioGroups= nRG; + req->length+= (nAtoms*4)/4; + + if (which&XkbKeycodesNameMask) + Data32(dpy,(long *)&names->keycodes,4); + if (which&XkbGeometryNameMask) + Data32(dpy,(long *)&names->geometry,4); + if (which&XkbSymbolsNameMask) + Data32(dpy,(long *)&names->symbols,4); + if (which&XkbPhysSymbolsNameMask) + Data32(dpy,(long *)&names->phys_symbols,4); + if (which&XkbTypesNameMask) + Data32(dpy,(long *)&names->types,4); + if (which&XkbCompatNameMask) + Data32(dpy,(long *)&names->compat,4); + if (which&XkbKeyTypeNamesMask) { + register int i; + register XkbKeyTypePtr type; + type= &xkb->map->types[firstType]; + for (i=0;iname,4); + } + } + if (which&XkbKTLevelNamesMask) { + XkbKeyTypePtr type; + int i; + char *tmp; + + BufAlloc(char *,tmp,XkbPaddedSize(nLvlTypes)); + type = &xkb->map->types[firstLvlType]; + for (i=0;inum_levels; + } + type = &xkb->map->types[firstLvlType]; + for (i=0;ilevel_names!=NULL) + Data32(dpy,(long *)type->level_names,type->num_levels*4); + } + } + if (which&XkbIndicatorNamesMask) + _XkbCopyAtoms(dpy,names->indicators,leds,XkbNumIndicators); + if (which&XkbVirtualModNamesMask) + _XkbCopyAtoms(dpy,names->vmods,vmods,XkbNumVirtualMods); + if (which&XkbGroupNamesMask) + _XkbCopyAtoms(dpy,names->groups,groups,XkbNumKbdGroups); + if (which&XkbKeyNamesMask) { +#ifdef WORD64 + char *tmp; + register int i; + BufAlloc(char *,tmp,nKeys*XkbKeyNameLength); + for (i=0;ikeys[firstKey+i].name[0]; + tmp[1]= names->keys[firstKey+i].name[1]; + tmp[2]= names->keys[firstKey+i].name[2]; + tmp[3]= names->keys[firstKey+i].name[3]; + } +#else + Data(dpy,(char *)&names->keys[firstKey],nKeys*XkbKeyNameLength); +#endif + } + if (which&XkbKeyAliasesMask) { +#ifdef WORD64 + char *tmp; + register int i; + BufAlloc(char *,tmp,nKA*XkbKeyNameLength*2); + for (i=0;ikey_aliases[i].real[0]; + tmp[1]= names->key_aliases[i].real[1]; + tmp[2]= names->key_aliases[i].real[2]; + tmp[3]= names->key_aliases[i].real[3]; + tmp[4]= names->key_aliases[i].alias[0]; + tmp[5]= names->key_aliases[i].alias[1]; + tmp[6]= names->key_aliases[i].alias[2]; + tmp[7]= names->key_aliases[i].alias[3]; + } +#else + Data(dpy,(char *)names->key_aliases,nKA*XkbKeyNameLength*2); +#endif + } + if (which&XkbRGNamesMask) { + Data32(dpy,(long *)names->radio_groups,nRG*4); + } + UnlockDisplay(dpy); + SyncHandle(); + return True; +} + +Bool +XkbChangeNames(Display *dpy,XkbDescPtr xkb,XkbNameChangesPtr changes) +{ + register xkbSetNamesReq *req; + int nLvlNames = 0; + XkbInfoPtr xkbi; + XkbNamesPtr names; + unsigned which,firstType,nTypes; + unsigned firstLvlType,nLvlTypes; + int nVMods,nLEDs,nRG,nKA,nGroups; + int nKeys=0,firstKey=0,nAtoms; + CARD32 leds=0,vmods=0,groups=0; + + if ((dpy->flags & XlibDisplayNoXkb) || + (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))) + return False; + if ((!xkb)||(!xkb->names)||(!changes)) + return False; + which= changes->changed; + firstType= changes->first_type; + nTypes= changes->num_types; + firstLvlType= changes->first_lvl;; + nLvlTypes= changes->num_lvls; + if (which&XkbKeyTypeNamesMask) { + if (nTypes<1) + which&= ~XkbKeyTypeNamesMask; + else if (firstType<=XkbLastRequiredType) { + int adjust; + adjust= XkbLastRequiredType-firstType+1; + firstType+= adjust; + nTypes-= adjust; + if (nTypes<1) + which&= ~XkbKeyTypeNamesMask; + } + } + else firstType= nTypes= 0; + + if (which&XkbKTLevelNamesMask) { + if (nLvlTypes<1) + which&= ~XkbKTLevelNamesMask; + } + else firstLvlType= nLvlTypes= 0; + + names= xkb->names; + if (which&(XkbKTLevelNamesMask|XkbKeyTypeNamesMask)) { + register int i; + XkbKeyTypePtr type; + if((xkb->map==NULL)||(xkb->map->types==NULL)||(nTypes==0)|| + (firstType+nTypes>xkb->map->num_types)|| + (firstLvlType+nLvlTypes>xkb->map->num_types)) + return False; + if (which&XkbKTLevelNamesMask) { + type= &xkb->map->types[firstLvlType]; + for (i=nLvlNames=0;ilevel_names!=NULL) + nLvlNames+= type->num_levels; + } + } + } + + if (changes->num_keys<1) + which&= ~XkbKeyNamesMask; + if ((which&XkbKeyNamesMask)==0) + changes->first_key= changes->num_keys= 0; + else if ((changes->first_keymin_key_code)|| + (changes->first_key+changes->num_keys>xkb->max_key_code)) { + return False; + } + + if ((which&XkbVirtualModNamesMask)==0) + changes->changed_vmods= 0; + else if (changes->changed_vmods==0) + which&= ~XkbVirtualModNamesMask; + + if ((which&XkbIndicatorNamesMask)==0) + changes->changed_indicators= 0; + else if (changes->changed_indicators==0) + which&= ~XkbIndicatorNamesMask; + + if ((which&XkbGroupNamesMask)==0) + changes->changed_groups= 0; + else if (changes->changed_groups==0) + which&= ~XkbGroupNamesMask; + + nVMods= nLEDs= nRG= nKA= nAtoms= nGroups= 0; + LockDisplay(dpy); + xkbi = dpy->xkb_info; + GetReq(kbSetNames, req); + req->reqType = xkbi->codes->major_opcode; + req->xkbReqType = X_kbSetNames; + req->deviceSpec = xkb->device_spec; + req->firstType = firstType; + req->nTypes = nTypes; + req->firstKey = changes->first_key; + req->nKeys = changes->num_keys; + + if (which&XkbKeycodesNameMask) + nAtoms++; + if (which&XkbGeometryNameMask) + nAtoms++; + if (which&XkbSymbolsNameMask) + nAtoms++; + if (which&XkbPhysSymbolsNameMask) + nAtoms++; + if (which&XkbTypesNameMask) + nAtoms++; + if (which&XkbCompatNameMask) + nAtoms++; + if (which&XkbKeyTypeNamesMask) + nAtoms+= nTypes; + if (which&XkbKTLevelNamesMask) { + req->firstKTLevel= firstLvlType; + req->nKTLevels= nLvlTypes; + req->length+= XkbPaddedSize(nLvlTypes)/4; /* room for group widths */ + nAtoms+= nLvlNames; + } + else req->firstKTLevel= req->nKTLevels= 0; + + if (which&XkbIndicatorNamesMask) { + leds= req->indicators= (CARD32)changes->changed_indicators; + nLEDs= _XkbCountBits(XkbNumIndicators,changes->changed_indicators); + if (nLEDs>0) + nAtoms+= nLEDs; + else which&= ~XkbIndicatorNamesMask; + } + else req->indicators= 0; + + if (which&XkbVirtualModNamesMask) { + vmods= req->virtualMods= changes->changed_vmods; + nVMods= _XkbCountBits(XkbNumVirtualMods, + (unsigned long)changes->changed_vmods); + if (nVMods>0) + nAtoms+= nVMods; + else which&= ~XkbVirtualModNamesMask; + } + else req->virtualMods= 0; + + if (which&XkbGroupNamesMask) { + groups= req->groupNames= changes->changed_groups; + nGroups= _XkbCountBits(XkbNumKbdGroups, + (unsigned long)changes->changed_groups); + if (nGroups>0) + nAtoms+= nGroups; + else which&= ~XkbGroupNamesMask; + } + else req->groupNames= 0; + + if ((which&XkbKeyNamesMask)&&(names->keys!=NULL)) { + firstKey= req->firstKey; + nKeys= req->nKeys; + nAtoms+= nKeys; /* technically not atoms, but 4 bytes wide */ + } + else which&= ~XkbKeyNamesMask; + + if (which&XkbKeyAliasesMask) { + nKA= ((names->key_aliases!=NULL)?names->num_key_aliases:0); + if (nKA>0) + nAtoms+= nKA*2; /* not atoms, but 8 bytes on the wire */ + else which&= ~XkbKeyAliasesMask; + } + + if (which&XkbRGNamesMask) { + nRG= names->num_rg; + if (nRG>0) + nAtoms+= nRG; + else which&= ~XkbRGNamesMask; + } + + req->which= which; + req->nRadioGroups= nRG; + req->length+= (nAtoms*4)/4; + + if (which&XkbKeycodesNameMask) + Data32(dpy,(long *)&names->keycodes,4); + if (which&XkbGeometryNameMask) + Data32(dpy,(long *)&names->geometry,4); + if (which&XkbSymbolsNameMask) + Data32(dpy,(long *)&names->symbols,4); + if (which&XkbPhysSymbolsNameMask) + Data32(dpy,(long *)&names->phys_symbols,4); + if (which&XkbTypesNameMask) + Data32(dpy,(long *)&names->types,4); + if (which&XkbCompatNameMask) + Data32(dpy,(long *)&names->compat,4); + if (which&XkbKeyTypeNamesMask) { + register int i; + register XkbKeyTypePtr type; + type= &xkb->map->types[firstType]; + for (i=0;iname,4); + } + } + if (which&XkbKTLevelNamesMask) { + XkbKeyTypePtr type; + int i; + char *tmp; + + BufAlloc(char *,tmp,XkbPaddedSize(nLvlTypes)); + type = &xkb->map->types[firstLvlType]; + for (i=0;inum_levels; + } + type = &xkb->map->types[firstLvlType]; + for (i=0;ilevel_names!=NULL) + Data32(dpy,(long *)type->level_names,type->num_levels*4); + } + } + if (which&XkbIndicatorNamesMask) + _XkbCopyAtoms(dpy,names->indicators,leds,XkbNumIndicators); + if (which&XkbVirtualModNamesMask) + _XkbCopyAtoms(dpy,names->vmods,vmods,XkbNumVirtualMods); + if (which&XkbGroupNamesMask) + _XkbCopyAtoms(dpy,names->groups,groups,XkbNumKbdGroups); + if (which&XkbKeyNamesMask) { +#ifdef WORD64 + char *tmp; + register int i; + BufAlloc(char *,tmp,nKeys*4); + for (i=0;ikeys[firstKey+i].name[0]; + tmp[1]= names->keys[firstKey+i].name[1]; + tmp[2]= names->keys[firstKey+i].name[2]; + tmp[3]= names->keys[firstKey+i].name[3]; + } +#else + Data(dpy,(char *)&names->keys[firstKey],nKeys*XkbKeyNameLength); +#endif + } + if (which&XkbKeyAliasesMask) { +#ifdef WORD64 + char *tmp; + register int i; + BufAlloc(char *,tmp,nKA*XkbKeyNameLength*2); + for (i=0;ikey_aliases[i].real[0]; + tmp[1]= names->key_aliases[i].real[1]; + tmp[2]= names->key_aliases[i].real[2]; + tmp[3]= names->key_aliases[i].real[3]; + tmp[4]= names->key_aliases[i].alias[0]; + tmp[5]= names->key_aliases[i].alias[1]; + tmp[6]= names->key_aliases[i].alias[2]; + tmp[7]= names->key_aliases[i].alias[3]; + } +#else + Data(dpy,(char *)names->key_aliases,nKA*XkbKeyNameLength*2); +#endif + } + if (which&XkbRGNamesMask) { + Data32(dpy,(long *)names->radio_groups,nRG*4); + } + UnlockDisplay(dpy); + SyncHandle(); + return True; +} + +void +XkbNoteNameChanges( XkbNameChangesPtr old, + XkbNamesNotifyEvent * new, + unsigned int wanted) +{ +int first,last,old_last,new_last; + + wanted&= new->changed; + if ((old==NULL)||(new==NULL)||(wanted==0)) + return; + if (wanted&XkbKeyTypeNamesMask) { + if (old->changed&XkbKeyTypeNamesMask) { + new_last= (new->first_type+new->num_types-1); + old_last= (old->first_type+old->num_types-1); + + if (new->first_typefirst_type) + first= new->first_type; + else first= old->first_type; + + if (old_last>new_last) + last= old_last; + else last= new_last; + + old->first_type= first; + old->num_types= (last-first)+1; + } + else { + old->first_type= new->first_type; + old->num_types= new->num_types; + } + } + if (wanted&XkbKTLevelNamesMask) { + if (old->changed&XkbKTLevelNamesMask) { + new_last= (new->first_lvl+new->num_lvls-1); + old_last= (old->first_lvl+old->num_lvls-1); + + if (new->first_lvlfirst_lvl) + first= new->first_lvl; + else first= old->first_lvl; + + if (old_last>new_last) + last= old_last; + else last= new_last; + + old->first_lvl= first; + old->num_lvls= (last-first)+1; + } + else { + old->first_lvl= new->first_lvl; + old->num_lvls= new->num_lvls; + } + } + if (wanted&XkbIndicatorNamesMask) { + if (old->changed&XkbIndicatorNamesMask) + old->changed_indicators|= new->changed_indicators; + else old->changed_indicators= new->changed_indicators; + } + if (wanted&XkbKeyNamesMask) { + if (old->changed&XkbKeyNamesMask) { + new_last= (new->first_key+new->num_keys-1); + old_last= (old->first_key+old->num_keys-1); + + first= old->first_key; + + if (new->first_keyfirst_key) + first= new->first_key; + if (old_last>new_last) + new_last= old_last; + + old->first_key= first; + old->num_keys= (new_last-first)+1; + } + else { + old->first_key= new->first_key; + old->num_keys= new->num_keys; + } + } + if (wanted&XkbVirtualModNamesMask) { + if (old->changed&XkbVirtualModNamesMask) + old->changed_vmods|= new->changed_vmods; + else old->changed_vmods= new->changed_vmods; + } + if (wanted&XkbGroupNamesMask) { + if (old->changed&XkbGroupNamesMask) + old->changed_groups|= new->changed_groups; + else old->changed_groups= new->changed_groups; + } + if (wanted&XkbRGNamesMask) + old->num_rg= new->num_radio_groups; + if (wanted&XkbKeyAliasesMask) + old->num_aliases= new->num_aliases; + old->changed|= wanted; + return; +} -- cgit v1.2.3