summaryrefslogtreecommitdiff
path: root/xkb
diff options
context:
space:
mode:
Diffstat (limited to 'xkb')
-rw-r--r--xkb/XKBAlloc.c412
-rw-r--r--xkb/XKBGAlloc.c1044
-rw-r--r--xkb/XKBMAlloc.c1481
-rw-r--r--xkb/XKBMisc.c1354
-rw-r--r--xkb/ddxBeep.c455
-rw-r--r--xkb/ddxCtrls.c32
-rw-r--r--xkb/ddxKillSrv.c2
-rw-r--r--xkb/ddxLEDs.c40
-rw-r--r--xkb/ddxList.c350
-rw-r--r--xkb/ddxLoad.c384
-rw-r--r--xkb/ddxPrivate.c2
-rw-r--r--xkb/ddxVT.c2
-rw-r--r--xkb/maprules.c1340
-rw-r--r--xkb/xkb.c9037
-rw-r--r--xkb/xkbAccessX.c872
-rw-r--r--xkb/xkbActions.c2063
-rw-r--r--xkb/xkbDflts.h780
-rw-r--r--xkb/xkbEvents.c1199
-rw-r--r--xkb/xkbInit.c588
-rw-r--r--xkb/xkbLEDs.c1497
-rw-r--r--xkb/xkbPrKeyEv.c151
-rw-r--r--xkb/xkbSwap.c188
-rw-r--r--xkb/xkbUtils.c1292
-rw-r--r--xkb/xkbfmisc.c624
-rw-r--r--xkb/xkbgeom.h829
-rw-r--r--xkb/xkbout.c1551
-rw-r--r--xkb/xkbtext.c1883
-rw-r--r--xkb/xkmread.c1831
28 files changed, 15882 insertions, 15401 deletions
diff --git a/xkb/XKBAlloc.c b/xkb/XKBAlloc.c
index b70ac1705..20e0459af 100644
--- a/xkb/XKBAlloc.c
+++ b/xkb/XKBAlloc.c
@@ -40,75 +40,76 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
/***===================================================================***/
-/*ARGSUSED*/
-Status
-XkbAllocCompatMap(XkbDescPtr xkb,unsigned which,unsigned nSI)
+ /*ARGSUSED*/ Status
+XkbAllocCompatMap(XkbDescPtr xkb, unsigned which, unsigned nSI)
{
-XkbCompatMapPtr compat;
-XkbSymInterpretRec *prev_interpret;
+ XkbCompatMapPtr compat;
+ XkbSymInterpretRec *prev_interpret;
if (!xkb)
- return BadMatch;
+ return BadMatch;
if (xkb->compat) {
- if (xkb->compat->size_si>=nSI)
- return Success;
- compat= xkb->compat;
- compat->size_si= nSI;
- if (compat->sym_interpret==NULL)
- compat->num_si= 0;
- prev_interpret = compat->sym_interpret;
- compat->sym_interpret= realloc(compat->sym_interpret,
- nSI * sizeof(XkbSymInterpretRec));
- if (compat->sym_interpret==NULL) {
- free(prev_interpret);
- compat->size_si= compat->num_si= 0;
- return BadAlloc;
- }
- if (compat->num_si!=0) {
- memset(&compat->sym_interpret[compat->num_si], 0,
- (compat->size_si - compat->num_si) * sizeof(XkbSymInterpretRec));
- }
- return Success;
+ if (xkb->compat->size_si >= nSI)
+ return Success;
+ compat = xkb->compat;
+ compat->size_si = nSI;
+ if (compat->sym_interpret == NULL)
+ compat->num_si = 0;
+ prev_interpret = compat->sym_interpret;
+ compat->sym_interpret = realloc(compat->sym_interpret,
+ nSI * sizeof(XkbSymInterpretRec));
+ if (compat->sym_interpret == NULL) {
+ free(prev_interpret);
+ compat->size_si = compat->num_si = 0;
+ return BadAlloc;
+ }
+ if (compat->num_si != 0) {
+ memset(&compat->sym_interpret[compat->num_si], 0,
+ (compat->size_si -
+ compat->num_si) * sizeof(XkbSymInterpretRec));
+ }
+ return Success;
}
- compat= calloc(1, sizeof(XkbCompatMapRec));
- if (compat==NULL)
- return BadAlloc;
- if (nSI>0) {
- compat->sym_interpret= calloc(nSI, sizeof(XkbSymInterpretRec));
- if (!compat->sym_interpret) {
- free(compat);
- return BadAlloc;
- }
+ compat = calloc(1, sizeof(XkbCompatMapRec));
+ if (compat == NULL)
+ return BadAlloc;
+ if (nSI > 0) {
+ compat->sym_interpret = calloc(nSI, sizeof(XkbSymInterpretRec));
+ if (!compat->sym_interpret) {
+ free(compat);
+ return BadAlloc;
+ }
}
- compat->size_si= nSI;
- compat->num_si= 0;
- memset((char *)&compat->groups[0], 0, XkbNumKbdGroups*sizeof(XkbModsRec));
- xkb->compat= compat;
+ compat->size_si = nSI;
+ compat->num_si = 0;
+ memset((char *) &compat->groups[0], 0,
+ XkbNumKbdGroups * sizeof(XkbModsRec));
+ xkb->compat = compat;
return Success;
}
-
void
-XkbFreeCompatMap(XkbDescPtr xkb,unsigned which,Bool freeMap)
+XkbFreeCompatMap(XkbDescPtr xkb, unsigned which, Bool freeMap)
{
-register XkbCompatMapPtr compat;
+ register XkbCompatMapPtr compat;
- if ((xkb==NULL)||(xkb->compat==NULL))
- return;
- compat= xkb->compat;
+ if ((xkb == NULL) || (xkb->compat == NULL))
+ return;
+ compat = xkb->compat;
if (freeMap)
- which= XkbAllCompatMask;
- if (which&XkbGroupCompatMask)
- memset((char *)&compat->groups[0], 0, XkbNumKbdGroups*sizeof(XkbModsRec));
- if (which&XkbSymInterpMask) {
- if ((compat->sym_interpret)&&(compat->size_si>0))
- free(compat->sym_interpret);
- compat->size_si= compat->num_si= 0;
- compat->sym_interpret= NULL;
+ which = XkbAllCompatMask;
+ if (which & XkbGroupCompatMask)
+ memset((char *) &compat->groups[0], 0,
+ XkbNumKbdGroups * sizeof(XkbModsRec));
+ if (which & XkbSymInterpMask) {
+ if ((compat->sym_interpret) && (compat->size_si > 0))
+ free(compat->sym_interpret);
+ compat->size_si = compat->num_si = 0;
+ compat->sym_interpret = NULL;
}
if (freeMap) {
- free(compat);
- xkb->compat= NULL;
+ free(compat);
+ xkb->compat = NULL;
}
return;
}
@@ -116,153 +117,158 @@ register XkbCompatMapPtr compat;
/***===================================================================***/
Status
-XkbAllocNames(XkbDescPtr xkb,unsigned which,int nTotalRG,int nTotalAliases)
+XkbAllocNames(XkbDescPtr xkb, unsigned which, int nTotalRG, int nTotalAliases)
{
-XkbNamesPtr names;
-
- if (xkb==NULL)
- return BadMatch;
- if (xkb->names==NULL) {
- xkb->names = calloc(1, sizeof(XkbNamesRec));
- if (xkb->names==NULL)
- return BadAlloc;
+ XkbNamesPtr names;
+
+ if (xkb == NULL)
+ return BadMatch;
+ if (xkb->names == NULL) {
+ xkb->names = calloc(1, sizeof(XkbNamesRec));
+ if (xkb->names == NULL)
+ return BadAlloc;
}
- names= xkb->names;
- if ((which&XkbKTLevelNamesMask)&&(xkb->map!=NULL)&&(xkb->map->types!=NULL)){
- register int i;
- XkbKeyTypePtr type;
-
- type= xkb->map->types;
- for (i=0;i<xkb->map->num_types;i++,type++) {
- if (type->level_names==NULL) {
- type->level_names= calloc(type->num_levels, sizeof(Atom));
- if (type->level_names==NULL)
- return BadAlloc;
- }
- }
+ names = xkb->names;
+ if ((which & XkbKTLevelNamesMask) && (xkb->map != NULL) &&
+ (xkb->map->types != NULL)) {
+ register int i;
+ XkbKeyTypePtr type;
+
+ type = xkb->map->types;
+ for (i = 0; i < xkb->map->num_types; i++, type++) {
+ if (type->level_names == NULL) {
+ type->level_names = calloc(type->num_levels, sizeof(Atom));
+ if (type->level_names == NULL)
+ return BadAlloc;
+ }
+ }
}
- if ((which&XkbKeyNamesMask)&&(names->keys==NULL)) {
- if ((!XkbIsLegalKeycode(xkb->min_key_code))||
- (!XkbIsLegalKeycode(xkb->max_key_code))||
- (xkb->max_key_code<xkb->min_key_code))
- return BadValue;
- names->keys= calloc((xkb->max_key_code+1), sizeof(XkbKeyNameRec));
- if (names->keys==NULL)
- return BadAlloc;
+ if ((which & XkbKeyNamesMask) && (names->keys == NULL)) {
+ if ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
+ (!XkbIsLegalKeycode(xkb->max_key_code)) ||
+ (xkb->max_key_code < xkb->min_key_code))
+ return BadValue;
+ names->keys = calloc((xkb->max_key_code + 1), sizeof(XkbKeyNameRec));
+ if (names->keys == NULL)
+ return BadAlloc;
}
- if ((which&XkbKeyAliasesMask)&&(nTotalAliases>0)) {
- if (names->key_aliases==NULL) {
- names->key_aliases= calloc(nTotalAliases, sizeof(XkbKeyAliasRec));
- }
- else if (nTotalAliases>names->num_key_aliases) {
- XkbKeyAliasRec *prev_aliases = names->key_aliases;
-
- names->key_aliases= realloc(names->key_aliases,
- nTotalAliases * sizeof(XkbKeyAliasRec));
- if (names->key_aliases!=NULL) {
- memset(&names->key_aliases[names->num_key_aliases], 0,
- (nTotalAliases - names->num_key_aliases) * sizeof(XkbKeyAliasRec));
- } else {
- free(prev_aliases);
- }
- }
- if (names->key_aliases==NULL) {
- names->num_key_aliases= 0;
- return BadAlloc;
- }
- names->num_key_aliases= nTotalAliases;
+ if ((which & XkbKeyAliasesMask) && (nTotalAliases > 0)) {
+ if (names->key_aliases == NULL) {
+ names->key_aliases = calloc(nTotalAliases, sizeof(XkbKeyAliasRec));
+ }
+ else if (nTotalAliases > names->num_key_aliases) {
+ XkbKeyAliasRec *prev_aliases = names->key_aliases;
+
+ names->key_aliases = realloc(names->key_aliases,
+ nTotalAliases *
+ sizeof(XkbKeyAliasRec));
+ if (names->key_aliases != NULL) {
+ memset(&names->key_aliases[names->num_key_aliases], 0,
+ (nTotalAliases -
+ names->num_key_aliases) * sizeof(XkbKeyAliasRec));
+ }
+ else {
+ free(prev_aliases);
+ }
+ }
+ if (names->key_aliases == NULL) {
+ names->num_key_aliases = 0;
+ return BadAlloc;
+ }
+ names->num_key_aliases = nTotalAliases;
}
- if ((which&XkbRGNamesMask)&&(nTotalRG>0)) {
- if (names->radio_groups==NULL) {
- names->radio_groups= calloc(nTotalRG, sizeof(Atom));
- }
- else if (nTotalRG>names->num_rg) {
- Atom *prev_radio_groups = names->radio_groups;
-
- names->radio_groups= realloc(names->radio_groups,
- nTotalRG * sizeof(Atom));
- if (names->radio_groups!=NULL) {
- memset(&names->radio_groups[names->num_rg], 0,
- (nTotalRG - names->num_rg) * sizeof(Atom));
- } else {
- free(prev_radio_groups);
- }
- }
- if (names->radio_groups==NULL)
- return BadAlloc;
- names->num_rg= nTotalRG;
+ if ((which & XkbRGNamesMask) && (nTotalRG > 0)) {
+ if (names->radio_groups == NULL) {
+ names->radio_groups = calloc(nTotalRG, sizeof(Atom));
+ }
+ else if (nTotalRG > names->num_rg) {
+ Atom *prev_radio_groups = names->radio_groups;
+
+ names->radio_groups = realloc(names->radio_groups,
+ nTotalRG * sizeof(Atom));
+ if (names->radio_groups != NULL) {
+ memset(&names->radio_groups[names->num_rg], 0,
+ (nTotalRG - names->num_rg) * sizeof(Atom));
+ }
+ else {
+ free(prev_radio_groups);
+ }
+ }
+ if (names->radio_groups == NULL)
+ return BadAlloc;
+ names->num_rg = nTotalRG;
}
return Success;
}
void
-XkbFreeNames(XkbDescPtr xkb,unsigned which,Bool freeMap)
+XkbFreeNames(XkbDescPtr xkb, unsigned which, Bool freeMap)
{
-XkbNamesPtr names;
+ XkbNamesPtr names;
- if ((xkb==NULL)||(xkb->names==NULL))
- return;
- names= xkb->names;
+ if ((xkb == NULL) || (xkb->names == NULL))
+ return;
+ names = xkb->names;
if (freeMap)
- which= XkbAllNamesMask;
- if (which&XkbKTLevelNamesMask) {
- XkbClientMapPtr map= xkb->map;
- if ((map!=NULL)&&(map->types!=NULL)) {
- register int i;
- register XkbKeyTypePtr type;
- type= map->types;
- for (i=0;i<map->num_types;i++,type++) {
- free(type->level_names);
- type->level_names = NULL;
- }
- }
+ which = XkbAllNamesMask;
+ if (which & XkbKTLevelNamesMask) {
+ XkbClientMapPtr map = xkb->map;
+
+ if ((map != NULL) && (map->types != NULL)) {
+ register int i;
+ register XkbKeyTypePtr type;
+
+ type = map->types;
+ for (i = 0; i < map->num_types; i++, type++) {
+ free(type->level_names);
+ type->level_names = NULL;
+ }
+ }
}
- if ((which&XkbKeyNamesMask)&&(names->keys!=NULL)) {
- free(names->keys);
- names->keys= NULL;
- names->num_keys= 0;
+ if ((which & XkbKeyNamesMask) && (names->keys != NULL)) {
+ free(names->keys);
+ names->keys = NULL;
+ names->num_keys = 0;
}
- if ((which&XkbKeyAliasesMask)&&(names->key_aliases)){
- free(names->key_aliases);
- names->key_aliases=NULL;
- names->num_key_aliases=0;
+ if ((which & XkbKeyAliasesMask) && (names->key_aliases)) {
+ free(names->key_aliases);
+ names->key_aliases = NULL;
+ names->num_key_aliases = 0;
}
- if ((which&XkbRGNamesMask)&&(names->radio_groups)) {
- free(names->radio_groups);
- names->radio_groups= NULL;
- names->num_rg= 0;
+ if ((which & XkbRGNamesMask) && (names->radio_groups)) {
+ free(names->radio_groups);
+ names->radio_groups = NULL;
+ names->num_rg = 0;
}
if (freeMap) {
- free(names);
- xkb->names= NULL;
+ free(names);
+ xkb->names = NULL;
}
return;
}
/***===================================================================***/
-/*ARGSUSED*/
-Status
-XkbAllocControls(XkbDescPtr xkb,unsigned which)
+ /*ARGSUSED*/ Status
+XkbAllocControls(XkbDescPtr xkb, unsigned which)
{
- if (xkb==NULL)
- return BadMatch;
+ if (xkb == NULL)
+ return BadMatch;
- if (xkb->ctrls==NULL) {
- xkb->ctrls= calloc(1, sizeof(XkbControlsRec));
- if (!xkb->ctrls)
- return BadAlloc;
+ if (xkb->ctrls == NULL) {
+ xkb->ctrls = calloc(1, sizeof(XkbControlsRec));
+ if (!xkb->ctrls)
+ return BadAlloc;
}
return Success;
}
-/*ARGSUSED*/
-static void
-XkbFreeControls(XkbDescPtr xkb,unsigned which,Bool freeMap)
+ /*ARGSUSED*/ static void
+XkbFreeControls(XkbDescPtr xkb, unsigned which, Bool freeMap)
{
- if (freeMap && (xkb!=NULL) && (xkb->ctrls!=NULL)) {
- free(xkb->ctrls);
- xkb->ctrls= NULL;
+ if (freeMap && (xkb != NULL) && (xkb->ctrls != NULL)) {
+ free(xkb->ctrls);
+ xkb->ctrls = NULL;
}
return;
}
@@ -272,12 +278,12 @@ XkbFreeControls(XkbDescPtr xkb,unsigned which,Bool freeMap)
Status
XkbAllocIndicatorMaps(XkbDescPtr xkb)
{
- if (xkb==NULL)
- return BadMatch;
- if (xkb->indicators==NULL) {
- xkb->indicators= calloc(1, sizeof(XkbIndicatorRec));
- if (!xkb->indicators)
- return BadAlloc;
+ if (xkb == NULL)
+ return BadMatch;
+ if (xkb->indicators == NULL) {
+ xkb->indicators = calloc(1, sizeof(XkbIndicatorRec));
+ if (!xkb->indicators)
+ return BadAlloc;
}
return Success;
}
@@ -285,63 +291,61 @@ XkbAllocIndicatorMaps(XkbDescPtr xkb)
static void
XkbFreeIndicatorMaps(XkbDescPtr xkb)
{
- if ((xkb!=NULL)&&(xkb->indicators!=NULL)) {
- free(xkb->indicators);
- xkb->indicators= NULL;
+ if ((xkb != NULL) && (xkb->indicators != NULL)) {
+ free(xkb->indicators);
+ xkb->indicators = NULL;
}
return;
}
/***====================================================================***/
-XkbDescRec *
+XkbDescRec *
XkbAllocKeyboard(void)
{
-XkbDescRec *xkb;
+ XkbDescRec *xkb;
xkb = calloc(1, sizeof(XkbDescRec));
if (xkb)
- xkb->device_spec= XkbUseCoreKbd;
+ xkb->device_spec = XkbUseCoreKbd;
return xkb;
}
void
-XkbFreeKeyboard(XkbDescPtr xkb,unsigned which,Bool freeAll)
+XkbFreeKeyboard(XkbDescPtr xkb, unsigned which, Bool freeAll)
{
- if (xkb==NULL)
- return;
+ if (xkb == NULL)
+ return;
if (freeAll)
- which= XkbAllComponentsMask;
- if (which&XkbClientMapMask)
- XkbFreeClientMap(xkb,XkbAllClientInfoMask,TRUE);
- if (which&XkbServerMapMask)
- XkbFreeServerMap(xkb,XkbAllServerInfoMask,TRUE);
- if (which&XkbCompatMapMask)
- XkbFreeCompatMap(xkb,XkbAllCompatMask,TRUE);
- if (which&XkbIndicatorMapMask)
- XkbFreeIndicatorMaps(xkb);
- if (which&XkbNamesMask)
- XkbFreeNames(xkb,XkbAllNamesMask,TRUE);
- if ((which&XkbGeometryMask) && (xkb->geom!=NULL)) {
- XkbFreeGeometry(xkb->geom,XkbGeomAllMask,TRUE);
+ which = XkbAllComponentsMask;
+ if (which & XkbClientMapMask)
+ XkbFreeClientMap(xkb, XkbAllClientInfoMask, TRUE);
+ if (which & XkbServerMapMask)
+ XkbFreeServerMap(xkb, XkbAllServerInfoMask, TRUE);
+ if (which & XkbCompatMapMask)
+ XkbFreeCompatMap(xkb, XkbAllCompatMask, TRUE);
+ if (which & XkbIndicatorMapMask)
+ XkbFreeIndicatorMaps(xkb);
+ if (which & XkbNamesMask)
+ XkbFreeNames(xkb, XkbAllNamesMask, TRUE);
+ if ((which & XkbGeometryMask) && (xkb->geom != NULL)) {
+ XkbFreeGeometry(xkb->geom, XkbGeomAllMask, TRUE);
/* PERHAPS BONGHITS etc */
xkb->geom = NULL;
}
- if (which&XkbControlsMask)
- XkbFreeControls(xkb,XkbAllControlsMask,TRUE);
+ if (which & XkbControlsMask)
+ XkbFreeControls(xkb, XkbAllControlsMask, TRUE);
if (freeAll)
- free(xkb);
+ free(xkb);
return;
}
-
/***====================================================================***/
void
XkbFreeComponentNames(XkbComponentNamesPtr names, Bool freeNames)
{
- if (names)
- {
+ if (names) {
free(names->keycodes);
free(names->types);
free(names->compat);
diff --git a/xkb/XKBGAlloc.c b/xkb/XKBGAlloc.c
index dd2b04696..f7e017682 100644
--- a/xkb/XKBGAlloc.c
+++ b/xkb/XKBGAlloc.c
@@ -28,7 +28,6 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <dix-config.h>
#endif
-
#include <stdio.h>
#include <X11/X.h>
#include <X11/Xproto.h>
@@ -39,89 +38,88 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
/***====================================================================***/
-static void
-_XkbFreeGeomLeafElems( Bool freeAll,
- int first,
- int count,
- unsigned short * num_inout,
- unsigned short * sz_inout,
- char ** elems,
- unsigned int elem_sz)
+static void
+_XkbFreeGeomLeafElems(Bool freeAll,
+ int first,
+ int count,
+ unsigned short *num_inout,
+ unsigned short *sz_inout,
+ char **elems, unsigned int elem_sz)
{
- if ((freeAll)||(*elems==NULL)) {
- *num_inout= *sz_inout= 0;
- free(*elems);
- *elems = NULL;
- return;
+ if ((freeAll) || (*elems == NULL)) {
+ *num_inout = *sz_inout = 0;
+ free(*elems);
+ *elems = NULL;
+ return;
}
- if ((first>=(*num_inout))||(first<0)||(count<1))
- return;
+ if ((first >= (*num_inout)) || (first < 0) || (count < 1))
+ return;
- if (first+count>=(*num_inout)) {
- /* truncating the array is easy */
- (*num_inout)= first;
+ if (first + count >= (*num_inout)) {
+ /* truncating the array is easy */
+ (*num_inout) = first;
}
else {
- char * ptr;
- int extra;
- ptr= *elems;
- extra= ((*num_inout)-(first+count))*elem_sz;
- if (extra>0)
- memmove(&ptr[first*elem_sz],&ptr[(first+count)*elem_sz],extra);
- (*num_inout)-= count;
+ char *ptr;
+ int extra;
+
+ ptr = *elems;
+ extra = ((*num_inout) - (first + count)) * elem_sz;
+ if (extra > 0)
+ memmove(&ptr[first * elem_sz], &ptr[(first + count) * elem_sz],
+ extra);
+ (*num_inout) -= count;
}
return;
}
-typedef void (*ContentsClearFunc)(
- char * /* priv */
-);
+typedef void (*ContentsClearFunc) (char * /* priv */
+ );
-static void
-_XkbFreeGeomNonLeafElems( Bool freeAll,
- int first,
- int count,
- unsigned short * num_inout,
- unsigned short * sz_inout,
- char ** elems,
- unsigned int elem_sz,
- ContentsClearFunc freeFunc)
+static void
+_XkbFreeGeomNonLeafElems(Bool freeAll,
+ int first,
+ int count,
+ unsigned short *num_inout,
+ unsigned short *sz_inout,
+ char **elems,
+ unsigned int elem_sz, ContentsClearFunc freeFunc)
{
-register int i;
-register char *ptr;
+ register int i;
+ register char *ptr;
if (freeAll) {
- first= 0;
- count= (*num_inout);
+ first = 0;
+ count = (*num_inout);
}
- else if ((first>=(*num_inout))||(first<0)||(count<1))
- return;
- else if (first+count>(*num_inout))
- count= (*num_inout)-first;
- if (*elems==NULL)
- return;
+ else if ((first >= (*num_inout)) || (first < 0) || (count < 1))
+ return;
+ else if (first + count > (*num_inout))
+ count = (*num_inout) - first;
+ if (*elems == NULL)
+ return;
if (freeFunc) {
- ptr= *elems;
- ptr+= first*elem_sz;
- for (i=0;i<count;i++) {
- (*freeFunc)(ptr);
- ptr+= elem_sz;
- }
+ ptr = *elems;
+ ptr += first * elem_sz;
+ for (i = 0; i < count; i++) {
+ (*freeFunc) (ptr);
+ ptr += elem_sz;
+ }
}
if (freeAll) {
- (*num_inout)= (*sz_inout)= 0;
- free(*elems);
- *elems = NULL;
+ (*num_inout) = (*sz_inout) = 0;
+ free(*elems);
+ *elems = NULL;
}
- else if (first+count>=(*num_inout))
- *num_inout= first;
+ else if (first + count >= (*num_inout))
+ *num_inout = first;
else {
- i= ((*num_inout)-(first+count))*elem_sz;
- ptr= *elems;
- memmove(&ptr[first*elem_sz],&ptr[(first+count)*elem_sz],i);
- (*num_inout)-= count;
+ i = ((*num_inout) - (first + count)) * elem_sz;
+ ptr = *elems;
+ memmove(&ptr[first * elem_sz], &ptr[(first + count) * elem_sz], i);
+ (*num_inout) -= count;
}
return;
}
@@ -131,7 +129,7 @@ register char *ptr;
static void
_XkbClearProperty(char *prop_in)
{
-XkbPropertyPtr prop= (XkbPropertyPtr)prop_in;
+ XkbPropertyPtr prop = (XkbPropertyPtr) prop_in;
free(prop->name);
prop->name = NULL;
@@ -141,30 +139,23 @@ XkbPropertyPtr prop= (XkbPropertyPtr)prop_in;
}
void
-XkbFreeGeomProperties( XkbGeometryPtr geom,
- int first,
- int count,
- Bool freeAll)
-{
- _XkbFreeGeomNonLeafElems(freeAll,first,count,
- &geom->num_properties,&geom->sz_properties,
- (char **)&geom->properties,
- sizeof(XkbPropertyRec),_XkbClearProperty);
+XkbFreeGeomProperties(XkbGeometryPtr geom, int first, int count, Bool freeAll)
+{
+ _XkbFreeGeomNonLeafElems(freeAll, first, count,
+ &geom->num_properties, &geom->sz_properties,
+ (char **) &geom->properties,
+ sizeof(XkbPropertyRec), _XkbClearProperty);
return;
}
/***====================================================================***/
void
-XkbFreeGeomKeyAliases( XkbGeometryPtr geom,
- int first,
- int count,
- Bool freeAll)
-{
- _XkbFreeGeomLeafElems(freeAll,first,count,
- &geom->num_key_aliases,&geom->sz_key_aliases,
- (char **)&geom->key_aliases,
- sizeof(XkbKeyAliasRec));
+XkbFreeGeomKeyAliases(XkbGeometryPtr geom, int first, int count, Bool freeAll)
+{
+ _XkbFreeGeomLeafElems(freeAll, first, count,
+ &geom->num_key_aliases, &geom->sz_key_aliases,
+ (char **) &geom->key_aliases, sizeof(XkbKeyAliasRec));
return;
}
@@ -173,31 +164,30 @@ XkbFreeGeomKeyAliases( XkbGeometryPtr geom,
static void
_XkbClearColor(char *color_in)
{
-XkbColorPtr color= (XkbColorPtr)color_in;
+ XkbColorPtr color = (XkbColorPtr) color_in;
free(color->spec);
return;
}
void
-XkbFreeGeomColors(XkbGeometryPtr geom,int first,int count,Bool freeAll)
+XkbFreeGeomColors(XkbGeometryPtr geom, int first, int count, Bool freeAll)
{
- _XkbFreeGeomNonLeafElems(freeAll,first,count,
- &geom->num_colors,&geom->sz_colors,
- (char **)&geom->colors,
- sizeof(XkbColorRec),_XkbClearColor);
+ _XkbFreeGeomNonLeafElems(freeAll, first, count,
+ &geom->num_colors, &geom->sz_colors,
+ (char **) &geom->colors,
+ sizeof(XkbColorRec), _XkbClearColor);
return;
}
/***====================================================================***/
void
-XkbFreeGeomPoints(XkbOutlinePtr outline,int first,int count,Bool freeAll)
+XkbFreeGeomPoints(XkbOutlinePtr outline, int first, int count, Bool freeAll)
{
- _XkbFreeGeomLeafElems(freeAll,first,count,
- &outline->num_points,&outline->sz_points,
- (char **)&outline->points,
- sizeof(XkbPointRec));
+ _XkbFreeGeomLeafElems(freeAll, first, count,
+ &outline->num_points, &outline->sz_points,
+ (char **) &outline->points, sizeof(XkbPointRec));
return;
}
@@ -206,21 +196,21 @@ XkbFreeGeomPoints(XkbOutlinePtr outline,int first,int count,Bool freeAll)
static void
_XkbClearOutline(char *outline_in)
{
-XkbOutlinePtr outline= (XkbOutlinePtr)outline_in;
+ XkbOutlinePtr outline = (XkbOutlinePtr) outline_in;
- if (outline->points!=NULL)
- XkbFreeGeomPoints(outline,0,outline->num_points,TRUE);
+ if (outline->points != NULL)
+ XkbFreeGeomPoints(outline, 0, outline->num_points, TRUE);
return;
}
void
-XkbFreeGeomOutlines(XkbShapePtr shape,int first,int count,Bool freeAll)
+XkbFreeGeomOutlines(XkbShapePtr shape, int first, int count, Bool freeAll)
{
- _XkbFreeGeomNonLeafElems(freeAll,first,count,
- &shape->num_outlines,&shape->sz_outlines,
- (char **)&shape->outlines,
- sizeof(XkbOutlineRec),_XkbClearOutline);
-
+ _XkbFreeGeomNonLeafElems(freeAll, first, count,
+ &shape->num_outlines, &shape->sz_outlines,
+ (char **) &shape->outlines,
+ sizeof(XkbOutlineRec), _XkbClearOutline);
+
return;
}
@@ -229,32 +219,31 @@ XkbFreeGeomOutlines(XkbShapePtr shape,int first,int count,Bool freeAll)
static void
_XkbClearShape(char *shape_in)
{
-XkbShapePtr shape= (XkbShapePtr)shape_in;
+ XkbShapePtr shape = (XkbShapePtr) shape_in;
if (shape->outlines)
- XkbFreeGeomOutlines(shape,0,shape->num_outlines,TRUE);
+ XkbFreeGeomOutlines(shape, 0, shape->num_outlines, TRUE);
return;
}
void
-XkbFreeGeomShapes(XkbGeometryPtr geom,int first,int count,Bool freeAll)
+XkbFreeGeomShapes(XkbGeometryPtr geom, int first, int count, Bool freeAll)
{
- _XkbFreeGeomNonLeafElems(freeAll,first,count,
- &geom->num_shapes,&geom->sz_shapes,
- (char **)&geom->shapes,
- sizeof(XkbShapeRec),_XkbClearShape);
+ _XkbFreeGeomNonLeafElems(freeAll, first, count,
+ &geom->num_shapes, &geom->sz_shapes,
+ (char **) &geom->shapes,
+ sizeof(XkbShapeRec), _XkbClearShape);
return;
}
/***====================================================================***/
-void
-XkbFreeGeomOverlayKeys(XkbOverlayRowPtr row,int first,int count,Bool freeAll)
+void
+XkbFreeGeomOverlayKeys(XkbOverlayRowPtr row, int first, int count, Bool freeAll)
{
- _XkbFreeGeomLeafElems(freeAll,first,count,
- &row->num_keys,&row->sz_keys,
- (char **)&row->keys,
- sizeof(XkbOverlayKeyRec));
+ _XkbFreeGeomLeafElems(freeAll, first, count,
+ &row->num_keys, &row->sz_keys,
+ (char **) &row->keys, sizeof(XkbOverlayKeyRec));
return;
}
@@ -263,20 +252,21 @@ XkbFreeGeomOverlayKeys(XkbOverlayRowPtr row,int first,int count,Bool freeAll)
static void
_XkbClearOverlayRow(char *row_in)
{
-XkbOverlayRowPtr row= (XkbOverlayRowPtr)row_in;
+ XkbOverlayRowPtr row = (XkbOverlayRowPtr) row_in;
- if (row->keys!=NULL)
- XkbFreeGeomOverlayKeys(row,0,row->num_keys,TRUE);
+ if (row->keys != NULL)
+ XkbFreeGeomOverlayKeys(row, 0, row->num_keys, TRUE);
return;
}
void
-XkbFreeGeomOverlayRows(XkbOverlayPtr overlay,int first,int count,Bool freeAll)
+XkbFreeGeomOverlayRows(XkbOverlayPtr overlay, int first, int count,
+ Bool freeAll)
{
- _XkbFreeGeomNonLeafElems(freeAll,first,count,
- &overlay->num_rows,&overlay->sz_rows,
- (char **)&overlay->rows,
- sizeof(XkbOverlayRowRec),_XkbClearOverlayRow);
+ _XkbFreeGeomNonLeafElems(freeAll, first, count,
+ &overlay->num_rows, &overlay->sz_rows,
+ (char **) &overlay->rows,
+ sizeof(XkbOverlayRowRec), _XkbClearOverlayRow);
return;
}
@@ -285,32 +275,31 @@ XkbFreeGeomOverlayRows(XkbOverlayPtr overlay,int first,int count,Bool freeAll)
static void
_XkbClearOverlay(char *overlay_in)
{
-XkbOverlayPtr overlay= (XkbOverlayPtr)overlay_in;
+ XkbOverlayPtr overlay = (XkbOverlayPtr) overlay_in;
- if (overlay->rows!=NULL)
- XkbFreeGeomOverlayRows(overlay,0,overlay->num_rows,TRUE);
+ if (overlay->rows != NULL)
+ XkbFreeGeomOverlayRows(overlay, 0, overlay->num_rows, TRUE);
return;
}
void
-XkbFreeGeomOverlays(XkbSectionPtr section,int first,int count,Bool freeAll)
+XkbFreeGeomOverlays(XkbSectionPtr section, int first, int count, Bool freeAll)
{
- _XkbFreeGeomNonLeafElems(freeAll,first,count,
- &section->num_overlays,&section->sz_overlays,
- (char **)&section->overlays,
- sizeof(XkbOverlayRec),_XkbClearOverlay);
+ _XkbFreeGeomNonLeafElems(freeAll, first, count,
+ &section->num_overlays, &section->sz_overlays,
+ (char **) &section->overlays,
+ sizeof(XkbOverlayRec), _XkbClearOverlay);
return;
}
/***====================================================================***/
void
-XkbFreeGeomKeys(XkbRowPtr row,int first,int count,Bool freeAll)
+XkbFreeGeomKeys(XkbRowPtr row, int first, int count, Bool freeAll)
{
- _XkbFreeGeomLeafElems(freeAll,first,count,
- &row->num_keys,&row->sz_keys,
- (char **)&row->keys,
- sizeof(XkbKeyRec));
+ _XkbFreeGeomLeafElems(freeAll, first, count,
+ &row->num_keys, &row->sz_keys,
+ (char **) &row->keys, sizeof(XkbKeyRec));
return;
}
@@ -319,20 +308,20 @@ XkbFreeGeomKeys(XkbRowPtr row,int first,int count,Bool freeAll)
static void
_XkbClearRow(char *row_in)
{
-XkbRowPtr row= (XkbRowPtr)row_in;
+ XkbRowPtr row = (XkbRowPtr) row_in;
- if (row->keys!=NULL)
- XkbFreeGeomKeys(row,0,row->num_keys,TRUE);
+ if (row->keys != NULL)
+ XkbFreeGeomKeys(row, 0, row->num_keys, TRUE);
return;
}
void
-XkbFreeGeomRows(XkbSectionPtr section,int first,int count,Bool freeAll)
+XkbFreeGeomRows(XkbSectionPtr section, int first, int count, Bool freeAll)
{
- _XkbFreeGeomNonLeafElems(freeAll,first,count,
- &section->num_rows,&section->sz_rows,
- (char **)&section->rows,
- sizeof(XkbRowRec),_XkbClearRow);
+ _XkbFreeGeomNonLeafElems(freeAll, first, count,
+ &section->num_rows, &section->sz_rows,
+ (char **) &section->rows,
+ sizeof(XkbRowRec), _XkbClearRow);
}
/***====================================================================***/
@@ -340,24 +329,24 @@ XkbFreeGeomRows(XkbSectionPtr section,int first,int count,Bool freeAll)
static void
_XkbClearSection(char *section_in)
{
-XkbSectionPtr section= (XkbSectionPtr)section_in;
+ XkbSectionPtr section = (XkbSectionPtr) section_in;
- if (section->rows!=NULL)
- XkbFreeGeomRows(section,0,section->num_rows,TRUE);
- if (section->doodads!=NULL) {
- XkbFreeGeomDoodads(section->doodads,section->num_doodads,TRUE);
- section->doodads= NULL;
+ if (section->rows != NULL)
+ XkbFreeGeomRows(section, 0, section->num_rows, TRUE);
+ if (section->doodads != NULL) {
+ XkbFreeGeomDoodads(section->doodads, section->num_doodads, TRUE);
+ section->doodads = NULL;
}
return;
}
void
-XkbFreeGeomSections(XkbGeometryPtr geom,int first,int count,Bool freeAll)
+XkbFreeGeomSections(XkbGeometryPtr geom, int first, int count, Bool freeAll)
{
- _XkbFreeGeomNonLeafElems(freeAll,first,count,
- &geom->num_sections,&geom->sz_sections,
- (char **)&geom->sections,
- sizeof(XkbSectionRec),_XkbClearSection);
+ _XkbFreeGeomNonLeafElems(freeAll, first, count,
+ &geom->num_sections, &geom->sz_sections,
+ (char **) &geom->sections,
+ sizeof(XkbSectionRec), _XkbClearSection);
return;
}
@@ -366,69 +355,69 @@ XkbFreeGeomSections(XkbGeometryPtr geom,int first,int count,Bool freeAll)
static void
_XkbClearDoodad(char *doodad_in)
{
-XkbDoodadPtr doodad= (XkbDoodadPtr)doodad_in;
+ XkbDoodadPtr doodad = (XkbDoodadPtr) doodad_in;
switch (doodad->any.type) {
- case XkbTextDoodad:
- {
- free(doodad->text.text);
- doodad->text.text = NULL;
- free(doodad->text.font);
- doodad->text.font = NULL;
- }
- break;
- case XkbLogoDoodad:
- {
- free(doodad->logo.logo_name);
- doodad->logo.logo_name = NULL;
- }
- break;
+ case XkbTextDoodad:
+ {
+ free(doodad->text.text);
+ doodad->text.text = NULL;
+ free(doodad->text.font);
+ doodad->text.font = NULL;
+ }
+ break;
+ case XkbLogoDoodad:
+ {
+ free(doodad->logo.logo_name);
+ doodad->logo.logo_name = NULL;
+ }
+ break;
}
return;
}
void
-XkbFreeGeomDoodads(XkbDoodadPtr doodads,int nDoodads,Bool freeAll)
+XkbFreeGeomDoodads(XkbDoodadPtr doodads, int nDoodads, Bool freeAll)
{
-register int i;
-register XkbDoodadPtr doodad;
+ register int i;
+ register XkbDoodadPtr doodad;
if (doodads) {
- for (i=0,doodad= doodads;i<nDoodads;i++,doodad++) {
- _XkbClearDoodad((char *)doodad);
- }
- if (freeAll)
- free(doodads);
+ for (i = 0, doodad = doodads; i < nDoodads; i++, doodad++) {
+ _XkbClearDoodad((char *) doodad);
+ }
+ if (freeAll)
+ free(doodads);
}
return;
}
void
-XkbFreeGeometry(XkbGeometryPtr geom,unsigned which,Bool freeMap)
+XkbFreeGeometry(XkbGeometryPtr geom, unsigned which, Bool freeMap)
{
- if (geom==NULL)
- return;
+ if (geom == NULL)
+ return;
if (freeMap)
- which= XkbGeomAllMask;
- if ((which&XkbGeomPropertiesMask)&&(geom->properties!=NULL))
- XkbFreeGeomProperties(geom,0,geom->num_properties,TRUE);
- if ((which&XkbGeomColorsMask)&&(geom->colors!=NULL))
- XkbFreeGeomColors(geom,0,geom->num_colors,TRUE);
- if ((which&XkbGeomShapesMask)&&(geom->shapes!=NULL))
- XkbFreeGeomShapes(geom,0,geom->num_shapes,TRUE);
- if ((which&XkbGeomSectionsMask)&&(geom->sections!=NULL))
- XkbFreeGeomSections(geom,0,geom->num_sections,TRUE);
- if ((which&XkbGeomDoodadsMask)&&(geom->doodads!= NULL)) {
- XkbFreeGeomDoodads(geom->doodads,geom->num_doodads,TRUE);
- geom->doodads= NULL;
- geom->num_doodads= geom->sz_doodads= 0;
- }
- if ((which&XkbGeomKeyAliasesMask)&&(geom->key_aliases!=NULL))
- XkbFreeGeomKeyAliases(geom,0,geom->num_key_aliases,TRUE);
+ which = XkbGeomAllMask;
+ if ((which & XkbGeomPropertiesMask) && (geom->properties != NULL))
+ XkbFreeGeomProperties(geom, 0, geom->num_properties, TRUE);
+ if ((which & XkbGeomColorsMask) && (geom->colors != NULL))
+ XkbFreeGeomColors(geom, 0, geom->num_colors, TRUE);
+ if ((which & XkbGeomShapesMask) && (geom->shapes != NULL))
+ XkbFreeGeomShapes(geom, 0, geom->num_shapes, TRUE);
+ if ((which & XkbGeomSectionsMask) && (geom->sections != NULL))
+ XkbFreeGeomSections(geom, 0, geom->num_sections, TRUE);
+ if ((which & XkbGeomDoodadsMask) && (geom->doodads != NULL)) {
+ XkbFreeGeomDoodads(geom->doodads, geom->num_doodads, TRUE);
+ geom->doodads = NULL;
+ geom->num_doodads = geom->sz_doodads = 0;
+ }
+ if ((which & XkbGeomKeyAliasesMask) && (geom->key_aliases != NULL))
+ XkbFreeGeomKeyAliases(geom, 0, geom->num_key_aliases, TRUE);
if (freeMap) {
- free(geom->label_font);
- geom->label_font = NULL;
- free(geom);
+ free(geom->label_font);
+ geom->label_font = NULL;
+ free(geom);
}
return;
}
@@ -456,6 +445,7 @@ XkbGeomRealloc(void **buffer, int szItems, int nrItems,
{
void *items;
int clearBegin;
+
/* Check validity of arguments. */
if (!buffer)
return FALSE;
@@ -467,8 +457,7 @@ XkbGeomRealloc(void **buffer, int szItems, int nrItems,
if (!(items = realloc(items, nrItems * itemSize)))
return FALSE;
/* Clear specified items to zero. */
- switch (clearance)
- {
+ switch (clearance) {
case XKB_GEOM_CLEAR_EXCESS:
clearBegin = szItems;
break;
@@ -481,34 +470,32 @@ XkbGeomRealloc(void **buffer, int szItems, int nrItems,
break;
}
if (items && (clearBegin < nrItems))
- memset((char *)items + (clearBegin * itemSize), 0, (nrItems - clearBegin) * itemSize);
+ memset((char *) items + (clearBegin * itemSize), 0,
+ (nrItems - clearBegin) * itemSize);
*buffer = items;
return TRUE;
}
static Status
-_XkbGeomAlloc( void ** old,
- unsigned short * num,
- unsigned short * total,
- int num_new,
- size_t sz_elem)
+_XkbGeomAlloc(void **old,
+ unsigned short *num,
+ unsigned short *total, int num_new, size_t sz_elem)
{
- if (num_new<1)
- return Success;
- if ((*old)==NULL)
- *num= *total= 0;
+ if (num_new < 1)
+ return Success;
+ if ((*old) == NULL)
+ *num = *total = 0;
- if ((*num)+num_new<=(*total))
- return Success;
+ if ((*num) + num_new <= (*total))
+ return Success;
- *total= (*num)+num_new;
+ *total = (*num) + num_new;
- if (!XkbGeomRealloc(old, *num, *total, sz_elem, XKB_GEOM_CLEAR_EXCESS))
- {
- free(*old);
- (*old)= NULL;
- *total= *num= 0;
- return BadAlloc;
+ if (!XkbGeomRealloc(old, *num, *total, sz_elem, XKB_GEOM_CLEAR_EXCESS)) {
+ free(*old);
+ (*old) = NULL;
+ *total = *num = 0;
+ return BadAlloc;
}
return Success;
@@ -554,265 +541,267 @@ _XkbGeomAlloc( void ** old,
#define _XkbAllocOverlayKeys(r,n) _XkbGeomAlloc((void *)&(r)->keys,\
&(r)->num_keys,&(r)->sz_keys,\
(n),sizeof(XkbOverlayKeyRec))
-
+
Status
-XkbAllocGeomProps(XkbGeometryPtr geom,int nProps)
+XkbAllocGeomProps(XkbGeometryPtr geom, int nProps)
{
- return _XkbAllocProps(geom,nProps);
+ return _XkbAllocProps(geom, nProps);
}
Status
-XkbAllocGeomColors(XkbGeometryPtr geom,int nColors)
+XkbAllocGeomColors(XkbGeometryPtr geom, int nColors)
{
- return _XkbAllocColors(geom,nColors);
+ return _XkbAllocColors(geom, nColors);
}
Status
-XkbAllocGeomKeyAliases(XkbGeometryPtr geom,int nKeyAliases)
+XkbAllocGeomKeyAliases(XkbGeometryPtr geom, int nKeyAliases)
{
- return _XkbAllocKeyAliases(geom,nKeyAliases);
+ return _XkbAllocKeyAliases(geom, nKeyAliases);
}
Status
-XkbAllocGeomShapes(XkbGeometryPtr geom,int nShapes)
+XkbAllocGeomShapes(XkbGeometryPtr geom, int nShapes)
{
- return _XkbAllocShapes(geom,nShapes);
+ return _XkbAllocShapes(geom, nShapes);
}
Status
-XkbAllocGeomSections(XkbGeometryPtr geom,int nSections)
+XkbAllocGeomSections(XkbGeometryPtr geom, int nSections)
{
- return _XkbAllocSections(geom,nSections);
+ return _XkbAllocSections(geom, nSections);
}
Status
-XkbAllocGeomOverlays(XkbSectionPtr section,int nOverlays)
+XkbAllocGeomOverlays(XkbSectionPtr section, int nOverlays)
{
- return _XkbAllocOverlays(section,nOverlays);
+ return _XkbAllocOverlays(section, nOverlays);
}
Status
-XkbAllocGeomOverlayRows(XkbOverlayPtr overlay,int nRows)
+XkbAllocGeomOverlayRows(XkbOverlayPtr overlay, int nRows)
{
- return _XkbAllocOverlayRows(overlay,nRows);
+ return _XkbAllocOverlayRows(overlay, nRows);
}
Status
-XkbAllocGeomOverlayKeys(XkbOverlayRowPtr row,int nKeys)
+XkbAllocGeomOverlayKeys(XkbOverlayRowPtr row, int nKeys)
{
- return _XkbAllocOverlayKeys(row,nKeys);
+ return _XkbAllocOverlayKeys(row, nKeys);
}
Status
-XkbAllocGeomDoodads(XkbGeometryPtr geom,int nDoodads)
+XkbAllocGeomDoodads(XkbGeometryPtr geom, int nDoodads)
{
- return _XkbAllocDoodads(geom,nDoodads);
+ return _XkbAllocDoodads(geom, nDoodads);
}
Status
-XkbAllocGeomSectionDoodads(XkbSectionPtr section,int nDoodads)
+XkbAllocGeomSectionDoodads(XkbSectionPtr section, int nDoodads)
{
- return _XkbAllocDoodads(section,nDoodads);
+ return _XkbAllocDoodads(section, nDoodads);
}
Status
-XkbAllocGeomOutlines(XkbShapePtr shape,int nOL)
+XkbAllocGeomOutlines(XkbShapePtr shape, int nOL)
{
- return _XkbAllocOutlines(shape,nOL);
+ return _XkbAllocOutlines(shape, nOL);
}
Status
-XkbAllocGeomRows(XkbSectionPtr section,int nRows)
+XkbAllocGeomRows(XkbSectionPtr section, int nRows)
{
- return _XkbAllocRows(section,nRows);
+ return _XkbAllocRows(section, nRows);
}
Status
-XkbAllocGeomPoints(XkbOutlinePtr ol,int nPts)
+XkbAllocGeomPoints(XkbOutlinePtr ol, int nPts)
{
- return _XkbAllocPoints(ol,nPts);
+ return _XkbAllocPoints(ol, nPts);
}
Status
-XkbAllocGeomKeys(XkbRowPtr row,int nKeys)
+XkbAllocGeomKeys(XkbRowPtr row, int nKeys)
{
- return _XkbAllocKeys(row,nKeys);
+ return _XkbAllocKeys(row, nKeys);
}
Status
-XkbAllocGeometry(XkbDescPtr xkb,XkbGeometrySizesPtr sizes)
+XkbAllocGeometry(XkbDescPtr xkb, XkbGeometrySizesPtr sizes)
{
-XkbGeometryPtr geom;
-Status rtrn;
+ XkbGeometryPtr geom;
+ Status rtrn;
- if (xkb->geom==NULL) {
- xkb->geom= calloc(1, sizeof(XkbGeometryRec));
- if (!xkb->geom)
- return BadAlloc;
+ if (xkb->geom == NULL) {
+ xkb->geom = calloc(1, sizeof(XkbGeometryRec));
+ if (!xkb->geom)
+ return BadAlloc;
}
- geom= xkb->geom;
- if ((sizes->which&XkbGeomPropertiesMask)&&
- ((rtrn=_XkbAllocProps(geom,sizes->num_properties))!=Success)) {
- goto BAIL;
+ geom = xkb->geom;
+ if ((sizes->which & XkbGeomPropertiesMask) &&
+ ((rtrn = _XkbAllocProps(geom, sizes->num_properties)) != Success)) {
+ goto BAIL;
}
- if ((sizes->which&XkbGeomColorsMask)&&
- ((rtrn=_XkbAllocColors(geom,sizes->num_colors))!=Success)) {
- goto BAIL;
+ if ((sizes->which & XkbGeomColorsMask) &&
+ ((rtrn = _XkbAllocColors(geom, sizes->num_colors)) != Success)) {
+ goto BAIL;
}
- if ((sizes->which&XkbGeomShapesMask)&&
- ((rtrn=_XkbAllocShapes(geom,sizes->num_shapes))!=Success)) {
- goto BAIL;
+ if ((sizes->which & XkbGeomShapesMask) &&
+ ((rtrn = _XkbAllocShapes(geom, sizes->num_shapes)) != Success)) {
+ goto BAIL;
}
- if ((sizes->which&XkbGeomSectionsMask)&&
- ((rtrn=_XkbAllocSections(geom,sizes->num_sections))!=Success)) {
- goto BAIL;
+ if ((sizes->which & XkbGeomSectionsMask) &&
+ ((rtrn = _XkbAllocSections(geom, sizes->num_sections)) != Success)) {
+ goto BAIL;
}
- if ((sizes->which&XkbGeomDoodadsMask)&&
- ((rtrn=_XkbAllocDoodads(geom,sizes->num_doodads))!=Success)) {
- goto BAIL;
+ if ((sizes->which & XkbGeomDoodadsMask) &&
+ ((rtrn = _XkbAllocDoodads(geom, sizes->num_doodads)) != Success)) {
+ goto BAIL;
}
- if ((sizes->which&XkbGeomKeyAliasesMask)&&
- ((rtrn=_XkbAllocKeyAliases(geom,sizes->num_key_aliases))!=Success)) {
- goto BAIL;
+ if ((sizes->which & XkbGeomKeyAliasesMask) &&
+ ((rtrn =
+ _XkbAllocKeyAliases(geom, sizes->num_key_aliases)) != Success)) {
+ goto BAIL;
}
return Success;
-BAIL:
- XkbFreeGeometry(geom,XkbGeomAllMask,TRUE);
- xkb->geom= NULL;
+ BAIL:
+ XkbFreeGeometry(geom, XkbGeomAllMask, TRUE);
+ xkb->geom = NULL;
return rtrn;
}
/***====================================================================***/
XkbPropertyPtr
-XkbAddGeomProperty(XkbGeometryPtr geom,char *name,char *value)
-{
-register int i;
-register XkbPropertyPtr prop;
-
- if ((!geom)||(!name)||(!value))
- return NULL;
- for (i=0,prop=geom->properties;i<geom->num_properties;i++,prop++) {
- if ((prop->name)&&(strcmp(name,prop->name)==0)) {
- free(prop->value);
- prop->value= strdup(value);
- return prop;
- }
- }
- if ((geom->num_properties>=geom->sz_properties)&&
- (_XkbAllocProps(geom,1)!=Success)) {
- return NULL;
- }
- prop= &geom->properties[geom->num_properties];
- prop->name= strdup(name);
+XkbAddGeomProperty(XkbGeometryPtr geom, char *name, char *value)
+{
+ register int i;
+ register XkbPropertyPtr prop;
+
+ if ((!geom) || (!name) || (!value))
+ return NULL;
+ for (i = 0, prop = geom->properties; i < geom->num_properties; i++, prop++) {
+ if ((prop->name) && (strcmp(name, prop->name) == 0)) {
+ free(prop->value);
+ prop->value = strdup(value);
+ return prop;
+ }
+ }
+ if ((geom->num_properties >= geom->sz_properties) &&
+ (_XkbAllocProps(geom, 1) != Success)) {
+ return NULL;
+ }
+ prop = &geom->properties[geom->num_properties];
+ prop->name = strdup(name);
if (!prop->name)
- return NULL;
- prop->value= strdup(value);
+ return NULL;
+ prop->value = strdup(value);
if (!prop->value) {
- free(prop->name);
- prop->name= NULL;
- return NULL;
+ free(prop->name);
+ prop->name = NULL;
+ return NULL;
}
geom->num_properties++;
return prop;
}
XkbKeyAliasPtr
-XkbAddGeomKeyAlias(XkbGeometryPtr geom,char *aliasStr,char *realStr)
-{
-register int i;
-register XkbKeyAliasPtr alias;
-
- if ((!geom)||(!aliasStr)||(!realStr)||(!aliasStr[0])||(!realStr[0]))
- return NULL;
- for (i=0,alias=geom->key_aliases;i<geom->num_key_aliases;i++,alias++) {
- if (strncmp(alias->alias,aliasStr,XkbKeyNameLength)==0) {
- memset(alias->real, 0, XkbKeyNameLength);
- strncpy(alias->real,realStr,XkbKeyNameLength);
- return alias;
- }
- }
- if ((geom->num_key_aliases>=geom->sz_key_aliases)&&
- (_XkbAllocKeyAliases(geom,1)!=Success)) {
- return NULL;
- }
- alias= &geom->key_aliases[geom->num_key_aliases];
+XkbAddGeomKeyAlias(XkbGeometryPtr geom, char *aliasStr, char *realStr)
+{
+ register int i;
+ register XkbKeyAliasPtr alias;
+
+ if ((!geom) || (!aliasStr) || (!realStr) || (!aliasStr[0]) || (!realStr[0]))
+ return NULL;
+ for (i = 0, alias = geom->key_aliases; i < geom->num_key_aliases;
+ i++, alias++) {
+ if (strncmp(alias->alias, aliasStr, XkbKeyNameLength) == 0) {
+ memset(alias->real, 0, XkbKeyNameLength);
+ strncpy(alias->real, realStr, XkbKeyNameLength);
+ return alias;
+ }
+ }
+ if ((geom->num_key_aliases >= geom->sz_key_aliases) &&
+ (_XkbAllocKeyAliases(geom, 1) != Success)) {
+ return NULL;
+ }
+ alias = &geom->key_aliases[geom->num_key_aliases];
memset(alias, 0, sizeof(XkbKeyAliasRec));
- strncpy(alias->alias,aliasStr,XkbKeyNameLength);
- strncpy(alias->real,realStr,XkbKeyNameLength);
+ strncpy(alias->alias, aliasStr, XkbKeyNameLength);
+ strncpy(alias->real, realStr, XkbKeyNameLength);
geom->num_key_aliases++;
return alias;
}
XkbColorPtr
-XkbAddGeomColor(XkbGeometryPtr geom,char *spec,unsigned int pixel)
-{
-register int i;
-register XkbColorPtr color;
-
- if ((!geom)||(!spec))
- return NULL;
- for (i=0,color=geom->colors;i<geom->num_colors;i++,color++) {
- if ((color->spec)&&(strcmp(color->spec,spec)==0)) {
- color->pixel= pixel;
- return color;
- }
- }
- if ((geom->num_colors>=geom->sz_colors)&&
- (_XkbAllocColors(geom,1)!=Success)) {
- return NULL;
- }
- color= &geom->colors[geom->num_colors];
- color->pixel= pixel;
- color->spec= strdup(spec);
+XkbAddGeomColor(XkbGeometryPtr geom, char *spec, unsigned int pixel)
+{
+ register int i;
+ register XkbColorPtr color;
+
+ if ((!geom) || (!spec))
+ return NULL;
+ for (i = 0, color = geom->colors; i < geom->num_colors; i++, color++) {
+ if ((color->spec) && (strcmp(color->spec, spec) == 0)) {
+ color->pixel = pixel;
+ return color;
+ }
+ }
+ if ((geom->num_colors >= geom->sz_colors) &&
+ (_XkbAllocColors(geom, 1) != Success)) {
+ return NULL;
+ }
+ color = &geom->colors[geom->num_colors];
+ color->pixel = pixel;
+ color->spec = strdup(spec);
if (!color->spec)
- return NULL;
+ return NULL;
geom->num_colors++;
return color;
}
XkbOutlinePtr
-XkbAddGeomOutline(XkbShapePtr shape,int sz_points)
+XkbAddGeomOutline(XkbShapePtr shape, int sz_points)
{
-XkbOutlinePtr outline;
+ XkbOutlinePtr outline;
- if ((!shape)||(sz_points<0))
- return NULL;
- if ((shape->num_outlines>=shape->sz_outlines)&&
- (_XkbAllocOutlines(shape,1)!=Success)) {
- return NULL;
+ if ((!shape) || (sz_points < 0))
+ return NULL;
+ if ((shape->num_outlines >= shape->sz_outlines) &&
+ (_XkbAllocOutlines(shape, 1) != Success)) {
+ return NULL;
}
- outline= &shape->outlines[shape->num_outlines];
+ outline = &shape->outlines[shape->num_outlines];
memset(outline, 0, sizeof(XkbOutlineRec));
- if ((sz_points>0)&&(_XkbAllocPoints(outline,sz_points)!=Success))
- return NULL;
+ if ((sz_points > 0) && (_XkbAllocPoints(outline, sz_points) != Success))
+ return NULL;
shape->num_outlines++;
return outline;
}
XkbShapePtr
-XkbAddGeomShape(XkbGeometryPtr geom,Atom name,int sz_outlines)
-{
-XkbShapePtr shape;
-register int i;
-
- if ((!geom)||(!name)||(sz_outlines<0))
- return NULL;
- if (geom->num_shapes>0) {
- for (shape=geom->shapes,i=0;i<geom->num_shapes;i++,shape++) {
- if (name==shape->name)
- return shape;
- }
- }
- if ((geom->num_shapes>=geom->sz_shapes)&&
- (_XkbAllocShapes(geom,1)!=Success))
- return NULL;
- shape= &geom->shapes[geom->num_shapes];
+XkbAddGeomShape(XkbGeometryPtr geom, Atom name, int sz_outlines)
+{
+ XkbShapePtr shape;
+ register int i;
+
+ if ((!geom) || (!name) || (sz_outlines < 0))
+ return NULL;
+ if (geom->num_shapes > 0) {
+ for (shape = geom->shapes, i = 0; i < geom->num_shapes; i++, shape++) {
+ if (name == shape->name)
+ return shape;
+ }
+ }
+ if ((geom->num_shapes >= geom->sz_shapes) &&
+ (_XkbAllocShapes(geom, 1) != Success))
+ return NULL;
+ shape = &geom->shapes[geom->num_shapes];
memset(shape, 0, sizeof(XkbShapeRec));
- if ((sz_outlines>0)&&(_XkbAllocOutlines(shape,sz_outlines)!=Success))
- return NULL;
- shape->name= name;
- shape->primary= shape->approx= NULL;
+ if ((sz_outlines > 0) && (_XkbAllocOutlines(shape, sz_outlines) != Success))
+ return NULL;
+ shape->name = name;
+ shape->primary = shape->approx = NULL;
geom->num_shapes++;
return shape;
}
@@ -820,203 +809,204 @@ register int i;
XkbKeyPtr
XkbAddGeomKey(XkbRowPtr row)
{
-XkbKeyPtr key;
+ XkbKeyPtr key;
+
if (!row)
- return NULL;
- if ((row->num_keys>=row->sz_keys)&&(_XkbAllocKeys(row,1)!=Success))
- return NULL;
- key= &row->keys[row->num_keys++];
+ return NULL;
+ if ((row->num_keys >= row->sz_keys) && (_XkbAllocKeys(row, 1) != Success))
+ return NULL;
+ key = &row->keys[row->num_keys++];
memset(key, 0, sizeof(XkbKeyRec));
return key;
}
XkbRowPtr
-XkbAddGeomRow(XkbSectionPtr section,int sz_keys)
+XkbAddGeomRow(XkbSectionPtr section, int sz_keys)
{
-XkbRowPtr row;
+ XkbRowPtr row;
- if ((!section)||(sz_keys<0))
- return NULL;
- if ((section->num_rows>=section->sz_rows)&&
- (_XkbAllocRows(section,1)!=Success))
- return NULL;
- row= &section->rows[section->num_rows];
+ if ((!section) || (sz_keys < 0))
+ return NULL;
+ if ((section->num_rows >= section->sz_rows) &&
+ (_XkbAllocRows(section, 1) != Success))
+ return NULL;
+ row = &section->rows[section->num_rows];
memset(row, 0, sizeof(XkbRowRec));
- if ((sz_keys>0)&&(_XkbAllocKeys(row,sz_keys)!=Success))
- return NULL;
+ if ((sz_keys > 0) && (_XkbAllocKeys(row, sz_keys) != Success))
+ return NULL;
section->num_rows++;
return row;
}
XkbSectionPtr
-XkbAddGeomSection( XkbGeometryPtr geom,
- Atom name,
- int sz_rows,
- int sz_doodads,
- int sz_over)
-{
-register int i;
-XkbSectionPtr section;
-
- if ((!geom)||(name==None)||(sz_rows<0))
- return NULL;
- for (i=0,section=geom->sections;i<geom->num_sections;i++,section++) {
- if (section->name!=name)
- continue;
- if (((sz_rows>0)&&(_XkbAllocRows(section,sz_rows)!=Success))||
- ((sz_doodads>0)&&(_XkbAllocDoodads(section,sz_doodads)!=Success))||
- ((sz_over>0)&&(_XkbAllocOverlays(section,sz_over)!=Success)))
- return NULL;
- return section;
- }
- if ((geom->num_sections>=geom->sz_sections)&&
- (_XkbAllocSections(geom,1)!=Success))
- return NULL;
- section= &geom->sections[geom->num_sections];
- if ((sz_rows>0)&&(_XkbAllocRows(section,sz_rows)!=Success))
- return NULL;
- if ((sz_doodads>0)&&(_XkbAllocDoodads(section,sz_doodads)!=Success)) {
- if (section->rows) {
- free(section->rows);
- section->rows= NULL;
- section->sz_rows= section->num_rows= 0;
- }
- return NULL;
- }
- section->name= name;
+XkbAddGeomSection(XkbGeometryPtr geom,
+ Atom name, int sz_rows, int sz_doodads, int sz_over)
+{
+ register int i;
+ XkbSectionPtr section;
+
+ if ((!geom) || (name == None) || (sz_rows < 0))
+ return NULL;
+ for (i = 0, section = geom->sections; i < geom->num_sections;
+ i++, section++) {
+ if (section->name != name)
+ continue;
+ if (((sz_rows > 0) && (_XkbAllocRows(section, sz_rows) != Success)) ||
+ ((sz_doodads > 0) &&
+ (_XkbAllocDoodads(section, sz_doodads) != Success)) ||
+ ((sz_over > 0) && (_XkbAllocOverlays(section, sz_over) != Success)))
+ return NULL;
+ return section;
+ }
+ if ((geom->num_sections >= geom->sz_sections) &&
+ (_XkbAllocSections(geom, 1) != Success))
+ return NULL;
+ section = &geom->sections[geom->num_sections];
+ if ((sz_rows > 0) && (_XkbAllocRows(section, sz_rows) != Success))
+ return NULL;
+ if ((sz_doodads > 0) && (_XkbAllocDoodads(section, sz_doodads) != Success)) {
+ if (section->rows) {
+ free(section->rows);
+ section->rows = NULL;
+ section->sz_rows = section->num_rows = 0;
+ }
+ return NULL;
+ }
+ section->name = name;
geom->num_sections++;
return section;
}
XkbDoodadPtr
-XkbAddGeomDoodad(XkbGeometryPtr geom,XkbSectionPtr section,Atom name)
+XkbAddGeomDoodad(XkbGeometryPtr geom, XkbSectionPtr section, Atom name)
{
-XkbDoodadPtr old,doodad;
-register int i,nDoodads;
+ XkbDoodadPtr old, doodad;
+ register int i, nDoodads;
- if ((!geom)||(name==None))
- return NULL;
- if ((section!=NULL)&&(section->num_doodads>0)) {
- old= section->doodads;
- nDoodads= section->num_doodads;
+ if ((!geom) || (name == None))
+ return NULL;
+ if ((section != NULL) && (section->num_doodads > 0)) {
+ old = section->doodads;
+ nDoodads = section->num_doodads;
}
else {
- old= geom->doodads;
- nDoodads= geom->num_doodads;
+ old = geom->doodads;
+ nDoodads = geom->num_doodads;
}
- for (i=0,doodad=old;i<nDoodads;i++,doodad++) {
- if (doodad->any.name==name)
- return doodad;
+ for (i = 0, doodad = old; i < nDoodads; i++, doodad++) {
+ if (doodad->any.name == name)
+ return doodad;
}
if (section) {
- if ((section->num_doodads>=geom->sz_doodads)&&
- (_XkbAllocDoodads(section,1)!=Success)) {
- return NULL;
- }
- doodad= &section->doodads[section->num_doodads++];
+ if ((section->num_doodads >= geom->sz_doodads) &&
+ (_XkbAllocDoodads(section, 1) != Success)) {
+ return NULL;
+ }
+ doodad = &section->doodads[section->num_doodads++];
}
else {
- if ((geom->num_doodads>=geom->sz_doodads)&&
- (_XkbAllocDoodads(geom,1)!=Success))
- return NULL;
- doodad= &geom->doodads[geom->num_doodads++];
+ if ((geom->num_doodads >= geom->sz_doodads) &&
+ (_XkbAllocDoodads(geom, 1) != Success))
+ return NULL;
+ doodad = &geom->doodads[geom->num_doodads++];
}
memset(doodad, 0, sizeof(XkbDoodadRec));
- doodad->any.name= name;
+ doodad->any.name = name;
return doodad;
}
XkbOverlayKeyPtr
-XkbAddGeomOverlayKey( XkbOverlayPtr overlay,
- XkbOverlayRowPtr row,
- char * over,
- char * under)
-{
-register int i;
-XkbOverlayKeyPtr key;
-XkbSectionPtr section;
-XkbRowPtr row_under;
-Bool found;
-
- if ((!overlay)||(!row)||(!over)||(!under))
- return NULL;
- section= overlay->section_under;
- if (row->row_under>=section->num_rows)
- return NULL;
- row_under= &section->rows[row->row_under];
- for (i=0,found=FALSE;i<row_under->num_keys;i++) {
- if (strncmp(under,row_under->keys[i].name.name,XkbKeyNameLength)==0) {
- found= TRUE;
- break;
- }
+XkbAddGeomOverlayKey(XkbOverlayPtr overlay,
+ XkbOverlayRowPtr row, char *over, char *under)
+{
+ register int i;
+ XkbOverlayKeyPtr key;
+ XkbSectionPtr section;
+ XkbRowPtr row_under;
+ Bool found;
+
+ if ((!overlay) || (!row) || (!over) || (!under))
+ return NULL;
+ section = overlay->section_under;
+ if (row->row_under >= section->num_rows)
+ return NULL;
+ row_under = &section->rows[row->row_under];
+ for (i = 0, found = FALSE; i < row_under->num_keys; i++) {
+ if (strncmp(under, row_under->keys[i].name.name, XkbKeyNameLength) == 0) {
+ found = TRUE;
+ break;
+ }
}
if (!found)
- return NULL;
- if ((row->num_keys>=row->sz_keys)&&(_XkbAllocOverlayKeys(row,1)!=Success))
- return NULL;
- key= &row->keys[row->num_keys];
- strncpy(key->under.name,under,XkbKeyNameLength);
- strncpy(key->over.name,over,XkbKeyNameLength);
+ return NULL;
+ if ((row->num_keys >= row->sz_keys) &&
+ (_XkbAllocOverlayKeys(row, 1) != Success))
+ return NULL;
+ key = &row->keys[row->num_keys];
+ strncpy(key->under.name, under, XkbKeyNameLength);
+ strncpy(key->over.name, over, XkbKeyNameLength);
row->num_keys++;
return key;
}
XkbOverlayRowPtr
-XkbAddGeomOverlayRow(XkbOverlayPtr overlay,int row_under,int sz_keys)
-{
-register int i;
-XkbOverlayRowPtr row;
-
- if ((!overlay)||(sz_keys<0))
- return NULL;
- if (row_under>=overlay->section_under->num_rows)
- return NULL;
- for (i=0;i<overlay->num_rows;i++) {
- if (overlay->rows[i].row_under==row_under) {
- row= &overlay->rows[i];
- if ((row->sz_keys<sz_keys)&&
- (_XkbAllocOverlayKeys(row,sz_keys)!=Success)) {
- return NULL;
- }
- return &overlay->rows[i];
- }
- }
- if ((overlay->num_rows>=overlay->sz_rows)&&
- (_XkbAllocOverlayRows(overlay,1)!=Success))
- return NULL;
- row= &overlay->rows[overlay->num_rows];
+XkbAddGeomOverlayRow(XkbOverlayPtr overlay, int row_under, int sz_keys)
+{
+ register int i;
+ XkbOverlayRowPtr row;
+
+ if ((!overlay) || (sz_keys < 0))
+ return NULL;
+ if (row_under >= overlay->section_under->num_rows)
+ return NULL;
+ for (i = 0; i < overlay->num_rows; i++) {
+ if (overlay->rows[i].row_under == row_under) {
+ row = &overlay->rows[i];
+ if ((row->sz_keys < sz_keys) &&
+ (_XkbAllocOverlayKeys(row, sz_keys) != Success)) {
+ return NULL;
+ }
+ return &overlay->rows[i];
+ }
+ }
+ if ((overlay->num_rows >= overlay->sz_rows) &&
+ (_XkbAllocOverlayRows(overlay, 1) != Success))
+ return NULL;
+ row = &overlay->rows[overlay->num_rows];
memset(row, 0, sizeof(XkbOverlayRowRec));
- if ((sz_keys>0)&&(_XkbAllocOverlayKeys(row,sz_keys)!=Success))
- return NULL;
- row->row_under= row_under;
+ if ((sz_keys > 0) && (_XkbAllocOverlayKeys(row, sz_keys) != Success))
+ return NULL;
+ row->row_under = row_under;
overlay->num_rows++;
return row;
}
XkbOverlayPtr
-XkbAddGeomOverlay(XkbSectionPtr section,Atom name,int sz_rows)
-{
-register int i;
-XkbOverlayPtr overlay;
-
- if ((!section)||(name==None)||(sz_rows==0))
- return NULL;
-
- for (i=0,overlay=section->overlays;i<section->num_overlays;i++,overlay++) {
- if (overlay->name==name) {
- if ((sz_rows>0)&&(_XkbAllocOverlayRows(overlay,sz_rows)!=Success))
- return NULL;
- return overlay;
- }
- }
- if ((section->num_overlays>=section->sz_overlays)&&
- (_XkbAllocOverlays(section,1)!=Success))
- return NULL;
- overlay= &section->overlays[section->num_overlays];
- if ((sz_rows>0)&&(_XkbAllocOverlayRows(overlay,sz_rows)!=Success))
- return NULL;
- overlay->name= name;
- overlay->section_under= section;
+XkbAddGeomOverlay(XkbSectionPtr section, Atom name, int sz_rows)
+{
+ register int i;
+ XkbOverlayPtr overlay;
+
+ if ((!section) || (name == None) || (sz_rows == 0))
+ return NULL;
+
+ for (i = 0, overlay = section->overlays; i < section->num_overlays;
+ i++, overlay++) {
+ if (overlay->name == name) {
+ if ((sz_rows > 0) &&
+ (_XkbAllocOverlayRows(overlay, sz_rows) != Success))
+ return NULL;
+ return overlay;
+ }
+ }
+ if ((section->num_overlays >= section->sz_overlays) &&
+ (_XkbAllocOverlays(section, 1) != Success))
+ return NULL;
+ overlay = &section->overlays[section->num_overlays];
+ if ((sz_rows > 0) && (_XkbAllocOverlayRows(overlay, sz_rows) != Success))
+ return NULL;
+ overlay->name = name;
+ overlay->section_under = section;
section->num_overlays++;
return overlay;
}
diff --git a/xkb/XKBMAlloc.c b/xkb/XKBMAlloc.c
index 2681ba3c3..645e90544 100644
--- a/xkb/XKBMAlloc.c
+++ b/xkb/XKBMAlloc.c
@@ -42,174 +42,181 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
/***====================================================================***/
Status
-XkbAllocClientMap(XkbDescPtr xkb,unsigned which,unsigned nTotalTypes)
+XkbAllocClientMap(XkbDescPtr xkb, unsigned which, unsigned nTotalTypes)
{
-register int i;
-XkbClientMapPtr map;
-
- if ((xkb==NULL)||((nTotalTypes>0)&&(nTotalTypes<XkbNumRequiredTypes)))
- return BadValue;
- if ((which&XkbKeySymsMask)&&
- ((!XkbIsLegalKeycode(xkb->min_key_code))||
- (!XkbIsLegalKeycode(xkb->max_key_code))||
- (xkb->max_key_code<xkb->min_key_code))) {
+ register int i;
+ XkbClientMapPtr map;
+
+ if ((xkb == NULL) ||
+ ((nTotalTypes > 0) && (nTotalTypes < XkbNumRequiredTypes)))
+ return BadValue;
+ if ((which & XkbKeySymsMask) &&
+ ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
+ (!XkbIsLegalKeycode(xkb->max_key_code)) ||
+ (xkb->max_key_code < xkb->min_key_code))) {
DebugF("bad keycode (%d,%d) in XkbAllocClientMap\n",
- xkb->min_key_code,xkb->max_key_code);
- return BadValue;
- }
-
- if (xkb->map==NULL) {
- map= calloc(1, sizeof(XkbClientMapRec));
- if (map==NULL)
- return BadAlloc;
- xkb->map= map;
- }
- else map= xkb->map;
-
- if ((which&XkbKeyTypesMask)&&(nTotalTypes>0)) {
- if (map->types==NULL) {
- map->types= calloc(nTotalTypes, sizeof(XkbKeyTypeRec));
- if (map->types==NULL)
- return BadAlloc;
- map->num_types= 0;
- map->size_types= nTotalTypes;
- }
- else if (map->size_types<nTotalTypes) {
- XkbKeyTypeRec *prev_types = map->types;
-
- map->types= realloc(map->types,nTotalTypes * sizeof(XkbKeyTypeRec));
- if (map->types==NULL) {
- free(prev_types);
- map->num_types= map->size_types= 0;
- return BadAlloc;
- }
- map->size_types= nTotalTypes;
- memset(&map->types[map->num_types], 0,
- ((map->size_types-map->num_types)*sizeof(XkbKeyTypeRec)));
- }
- }
- if (which&XkbKeySymsMask) {
- int nKeys= XkbNumKeys(xkb);
- if (map->syms==NULL) {
- map->size_syms= (nKeys*15)/10;
- map->syms= calloc(map->size_syms, sizeof(KeySym));
- if (!map->syms) {
- map->size_syms= 0;
- return BadAlloc;
- }
- map->num_syms= 1;
- map->syms[0]= NoSymbol;
- }
- if (map->key_sym_map==NULL) {
- i= xkb->max_key_code+1;
- map->key_sym_map= calloc(i, sizeof(XkbSymMapRec));
- if (map->key_sym_map==NULL)
- return BadAlloc;
- }
- }
- if (which&XkbModifierMapMask) {
- if ((!XkbIsLegalKeycode(xkb->min_key_code))||
- (!XkbIsLegalKeycode(xkb->max_key_code))||
- (xkb->max_key_code<xkb->min_key_code))
- return BadMatch;
- if (map->modmap==NULL) {
- i= xkb->max_key_code+1;
- map->modmap= calloc(i, sizeof(unsigned char));
- if (map->modmap==NULL)
- return BadAlloc;
- }
+ xkb->min_key_code, xkb->max_key_code);
+ return BadValue;
+ }
+
+ if (xkb->map == NULL) {
+ map = calloc(1, sizeof(XkbClientMapRec));
+ if (map == NULL)
+ return BadAlloc;
+ xkb->map = map;
+ }
+ else
+ map = xkb->map;
+
+ if ((which & XkbKeyTypesMask) && (nTotalTypes > 0)) {
+ if (map->types == NULL) {
+ map->types = calloc(nTotalTypes, sizeof(XkbKeyTypeRec));
+ if (map->types == NULL)
+ return BadAlloc;
+ map->num_types = 0;
+ map->size_types = nTotalTypes;
+ }
+ else if (map->size_types < nTotalTypes) {
+ XkbKeyTypeRec *prev_types = map->types;
+
+ map->types =
+ realloc(map->types, nTotalTypes * sizeof(XkbKeyTypeRec));
+ if (map->types == NULL) {
+ free(prev_types);
+ map->num_types = map->size_types = 0;
+ return BadAlloc;
+ }
+ map->size_types = nTotalTypes;
+ memset(&map->types[map->num_types], 0,
+ ((map->size_types -
+ map->num_types) * sizeof(XkbKeyTypeRec)));
+ }
+ }
+ if (which & XkbKeySymsMask) {
+ int nKeys = XkbNumKeys(xkb);
+
+ if (map->syms == NULL) {
+ map->size_syms = (nKeys * 15) / 10;
+ map->syms = calloc(map->size_syms, sizeof(KeySym));
+ if (!map->syms) {
+ map->size_syms = 0;
+ return BadAlloc;
+ }
+ map->num_syms = 1;
+ map->syms[0] = NoSymbol;
+ }
+ if (map->key_sym_map == NULL) {
+ i = xkb->max_key_code + 1;
+ map->key_sym_map = calloc(i, sizeof(XkbSymMapRec));
+ if (map->key_sym_map == NULL)
+ return BadAlloc;
+ }
+ }
+ if (which & XkbModifierMapMask) {
+ if ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
+ (!XkbIsLegalKeycode(xkb->max_key_code)) ||
+ (xkb->max_key_code < xkb->min_key_code))
+ return BadMatch;
+ if (map->modmap == NULL) {
+ i = xkb->max_key_code + 1;
+ map->modmap = calloc(i, sizeof(unsigned char));
+ if (map->modmap == NULL)
+ return BadAlloc;
+ }
}
return Success;
}
Status
-XkbAllocServerMap(XkbDescPtr xkb,unsigned which,unsigned nNewActions)
+XkbAllocServerMap(XkbDescPtr xkb, unsigned which, unsigned nNewActions)
{
-register int i;
-XkbServerMapPtr map;
-
- if (xkb==NULL)
- return BadMatch;
- if (xkb->server==NULL) {
- map= calloc(1, sizeof(XkbServerMapRec));
- if (map==NULL)
- return BadAlloc;
- for (i=0;i<XkbNumVirtualMods;i++) {
- map->vmods[i]= XkbNoModifierMask;
- }
- xkb->server= map;
- }
- else map= xkb->server;
- if (which&XkbExplicitComponentsMask) {
- if ((!XkbIsLegalKeycode(xkb->min_key_code))||
- (!XkbIsLegalKeycode(xkb->max_key_code))||
- (xkb->max_key_code<xkb->min_key_code))
- return BadMatch;
- if (map->explicit==NULL) {
- i= xkb->max_key_code+1;
- map->explicit= calloc(i, sizeof(unsigned char));
- if (map->explicit==NULL)
- return BadAlloc;
- }
- }
- if (which&XkbKeyActionsMask) {
- if ((!XkbIsLegalKeycode(xkb->min_key_code))||
- (!XkbIsLegalKeycode(xkb->max_key_code))||
- (xkb->max_key_code<xkb->min_key_code))
- return BadMatch;
- if (nNewActions<1)
- nNewActions= 1;
- if (map->acts==NULL) {
- map->acts= calloc((nNewActions+1), sizeof(XkbAction));
- if (map->acts==NULL)
- return BadAlloc;
- map->num_acts= 1;
- map->size_acts= nNewActions+1;
- }
- else if ((map->size_acts-map->num_acts)<nNewActions) {
- unsigned need;
- XkbAction *prev_acts = map->acts;
- need= map->num_acts+nNewActions;
- map->acts= realloc(map->acts,need * sizeof(XkbAction));
- if (map->acts==NULL) {
- free(prev_acts);
- map->num_acts= map->size_acts= 0;
- return BadAlloc;
- }
- map->size_acts= need;
- memset(&map->acts[map->num_acts], 0,
- ((map->size_acts-map->num_acts)*sizeof(XkbAction)));
- }
- if (map->key_acts==NULL) {
- i= xkb->max_key_code+1;
- map->key_acts= calloc(i, sizeof(unsigned short));
- if (map->key_acts==NULL)
- return BadAlloc;
- }
- }
- if (which&XkbKeyBehaviorsMask) {
- if ((!XkbIsLegalKeycode(xkb->min_key_code))||
- (!XkbIsLegalKeycode(xkb->max_key_code))||
- (xkb->max_key_code<xkb->min_key_code))
- return BadMatch;
- if (map->behaviors==NULL) {
- i= xkb->max_key_code+1;
- map->behaviors= calloc(i, sizeof(XkbBehavior));
- if (map->behaviors==NULL)
- return BadAlloc;
- }
- }
- if (which&XkbVirtualModMapMask) {
- if ((!XkbIsLegalKeycode(xkb->min_key_code))||
- (!XkbIsLegalKeycode(xkb->max_key_code))||
- (xkb->max_key_code<xkb->min_key_code))
- return BadMatch;
- if (map->vmodmap==NULL) {
- i= xkb->max_key_code+1;
- map->vmodmap= calloc(i, sizeof(unsigned short));
- if (map->vmodmap==NULL)
- return BadAlloc;
- }
+ register int i;
+ XkbServerMapPtr map;
+
+ if (xkb == NULL)
+ return BadMatch;
+ if (xkb->server == NULL) {
+ map = calloc(1, sizeof(XkbServerMapRec));
+ if (map == NULL)
+ return BadAlloc;
+ for (i = 0; i < XkbNumVirtualMods; i++) {
+ map->vmods[i] = XkbNoModifierMask;
+ }
+ xkb->server = map;
+ }
+ else
+ map = xkb->server;
+ if (which & XkbExplicitComponentsMask) {
+ if ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
+ (!XkbIsLegalKeycode(xkb->max_key_code)) ||
+ (xkb->max_key_code < xkb->min_key_code))
+ return BadMatch;
+ if (map->explicit == NULL) {
+ i = xkb->max_key_code + 1;
+ map->explicit = calloc(i, sizeof(unsigned char));
+ if (map->explicit == NULL)
+ return BadAlloc;
+ }
+ }
+ if (which & XkbKeyActionsMask) {
+ if ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
+ (!XkbIsLegalKeycode(xkb->max_key_code)) ||
+ (xkb->max_key_code < xkb->min_key_code))
+ return BadMatch;
+ if (nNewActions < 1)
+ nNewActions = 1;
+ if (map->acts == NULL) {
+ map->acts = calloc((nNewActions + 1), sizeof(XkbAction));
+ if (map->acts == NULL)
+ return BadAlloc;
+ map->num_acts = 1;
+ map->size_acts = nNewActions + 1;
+ }
+ else if ((map->size_acts - map->num_acts) < nNewActions) {
+ unsigned need;
+ XkbAction *prev_acts = map->acts;
+
+ need = map->num_acts + nNewActions;
+ map->acts = realloc(map->acts, need * sizeof(XkbAction));
+ if (map->acts == NULL) {
+ free(prev_acts);
+ map->num_acts = map->size_acts = 0;
+ return BadAlloc;
+ }
+ map->size_acts = need;
+ memset(&map->acts[map->num_acts], 0,
+ ((map->size_acts - map->num_acts) * sizeof(XkbAction)));
+ }
+ if (map->key_acts == NULL) {
+ i = xkb->max_key_code + 1;
+ map->key_acts = calloc(i, sizeof(unsigned short));
+ if (map->key_acts == NULL)
+ return BadAlloc;
+ }
+ }
+ if (which & XkbKeyBehaviorsMask) {
+ if ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
+ (!XkbIsLegalKeycode(xkb->max_key_code)) ||
+ (xkb->max_key_code < xkb->min_key_code))
+ return BadMatch;
+ if (map->behaviors == NULL) {
+ i = xkb->max_key_code + 1;
+ map->behaviors = calloc(i, sizeof(XkbBehavior));
+ if (map->behaviors == NULL)
+ return BadAlloc;
+ }
+ }
+ if (which & XkbVirtualModMapMask) {
+ if ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
+ (!XkbIsLegalKeycode(xkb->max_key_code)) ||
+ (xkb->max_key_code < xkb->min_key_code))
+ return BadMatch;
+ if (map->vmodmap == NULL) {
+ i = xkb->max_key_code + 1;
+ map->vmodmap = calloc(i, sizeof(unsigned short));
+ if (map->vmodmap == NULL)
+ return BadAlloc;
+ }
}
return Success;
}
@@ -217,124 +224,124 @@ XkbServerMapPtr map;
/***====================================================================***/
static Status
-XkbCopyKeyType(XkbKeyTypePtr from,XkbKeyTypePtr into)
+XkbCopyKeyType(XkbKeyTypePtr from, XkbKeyTypePtr into)
{
- if ((!from)||(!into))
- return BadMatch;
+ if ((!from) || (!into))
+ return BadMatch;
free(into->map);
into->map = NULL;
free(into->preserve);
into->preserve = NULL;
free(into->level_names);
into->level_names = NULL;
- *into= *from;
- if ((from->map)&&(into->map_count>0)) {
- into->map= calloc(into->map_count, sizeof(XkbKTMapEntryRec));
- if (!into->map)
- return BadAlloc;
- memcpy(into->map,from->map,into->map_count*sizeof(XkbKTMapEntryRec));
- }
- if ((from->preserve)&&(into->map_count>0)) {
- into->preserve= calloc(into->map_count, sizeof(XkbModsRec));
- if (!into->preserve)
- return BadAlloc;
- memcpy(into->preserve,from->preserve,
- into->map_count*sizeof(XkbModsRec));
- }
- if ((from->level_names)&&(into->num_levels>0)) {
- into->level_names= calloc(into->num_levels, sizeof(Atom));
- if (!into->level_names)
- return BadAlloc;
- memcpy(into->level_names,from->level_names,
- into->num_levels*sizeof(Atom));
+ *into = *from;
+ if ((from->map) && (into->map_count > 0)) {
+ into->map = calloc(into->map_count, sizeof(XkbKTMapEntryRec));
+ if (!into->map)
+ return BadAlloc;
+ memcpy(into->map, from->map,
+ into->map_count * sizeof(XkbKTMapEntryRec));
+ }
+ if ((from->preserve) && (into->map_count > 0)) {
+ into->preserve = calloc(into->map_count, sizeof(XkbModsRec));
+ if (!into->preserve)
+ return BadAlloc;
+ memcpy(into->preserve, from->preserve,
+ into->map_count * sizeof(XkbModsRec));
+ }
+ if ((from->level_names) && (into->num_levels > 0)) {
+ into->level_names = calloc(into->num_levels, sizeof(Atom));
+ if (!into->level_names)
+ return BadAlloc;
+ memcpy(into->level_names, from->level_names,
+ into->num_levels * sizeof(Atom));
}
return Success;
}
Status
-XkbCopyKeyTypes(XkbKeyTypePtr from,XkbKeyTypePtr into,int num_types)
+XkbCopyKeyTypes(XkbKeyTypePtr from, XkbKeyTypePtr into, int num_types)
{
-register int i,rtrn;
+ register int i, rtrn;
- if ((!from)||(!into)||(num_types<0))
- return BadMatch;
- for (i=0;i<num_types;i++) {
- if ((rtrn= XkbCopyKeyType(from++,into++))!=Success)
- return rtrn;
+ if ((!from) || (!into) || (num_types < 0))
+ return BadMatch;
+ for (i = 0; i < num_types; i++) {
+ if ((rtrn = XkbCopyKeyType(from++, into++)) != Success)
+ return rtrn;
}
return Success;
}
Status
-XkbResizeKeyType( XkbDescPtr xkb,
- int type_ndx,
- int map_count,
- Bool want_preserve,
- int new_num_lvls)
+XkbResizeKeyType(XkbDescPtr xkb,
+ int type_ndx,
+ int map_count, Bool want_preserve, int new_num_lvls)
{
-XkbKeyTypePtr type;
-KeyCode matchingKeys[XkbMaxKeyCount],nMatchingKeys;
+ XkbKeyTypePtr type;
+ KeyCode matchingKeys[XkbMaxKeyCount], nMatchingKeys;
- if ((type_ndx<0)||(type_ndx>=xkb->map->num_types)||(map_count<0)||
- (new_num_lvls<1))
- return BadValue;
+ if ((type_ndx < 0) || (type_ndx >= xkb->map->num_types) || (map_count < 0)
+ || (new_num_lvls < 1))
+ return BadValue;
switch (type_ndx) {
- case XkbOneLevelIndex:
- if (new_num_lvls!=1)
- return BadMatch;
- break;
- case XkbTwoLevelIndex:
- case XkbAlphabeticIndex:
- case XkbKeypadIndex:
- if (new_num_lvls!=2)
- return BadMatch;
- break;
- }
- type= &xkb->map->types[type_ndx];
- if (map_count==0) {
- free(type->map);
- type->map= NULL;
- free(type->preserve);
- type->preserve= NULL;
- type->map_count= 0;
+ case XkbOneLevelIndex:
+ if (new_num_lvls != 1)
+ return BadMatch;
+ break;
+ case XkbTwoLevelIndex:
+ case XkbAlphabeticIndex:
+ case XkbKeypadIndex:
+ if (new_num_lvls != 2)
+ return BadMatch;
+ break;
+ }
+ type = &xkb->map->types[type_ndx];
+ if (map_count == 0) {
+ free(type->map);
+ type->map = NULL;
+ free(type->preserve);
+ type->preserve = NULL;
+ type->map_count = 0;
}
else {
- XkbKTMapEntryRec *prev_map = type->map;
-
- if ((map_count>type->map_count)||(type->map==NULL))
- type->map = realloc(type->map,map_count * sizeof(XkbKTMapEntryRec));
- if (!type->map) {
- free(prev_map);
- return BadAlloc;
- }
- if (want_preserve) {
- XkbModsRec *prev_preserve = type->preserve;
-
- if ((map_count>type->map_count)||(type->preserve==NULL)) {
- type->preserve = realloc(type->preserve,
- map_count * sizeof(XkbModsRec));
- }
- if (!type->preserve) {
- free(prev_preserve);
- return BadAlloc;
- }
- }
- else {
- free(type->preserve);
- type->preserve = NULL;
- }
- type->map_count= map_count;
- }
-
- if ((new_num_lvls>type->num_levels)||(type->level_names==NULL)) {
- Atom * prev_level_names = type->level_names;
-
- type->level_names = realloc(type->level_names,
- new_num_lvls * sizeof(Atom));
- if (!type->level_names) {
- free(prev_level_names);
- return BadAlloc;
- }
+ XkbKTMapEntryRec *prev_map = type->map;
+
+ if ((map_count > type->map_count) || (type->map == NULL))
+ type->map =
+ realloc(type->map, map_count * sizeof(XkbKTMapEntryRec));
+ if (!type->map) {
+ free(prev_map);
+ return BadAlloc;
+ }
+ if (want_preserve) {
+ XkbModsRec *prev_preserve = type->preserve;
+
+ if ((map_count > type->map_count) || (type->preserve == NULL)) {
+ type->preserve = realloc(type->preserve,
+ map_count * sizeof(XkbModsRec));
+ }
+ if (!type->preserve) {
+ free(prev_preserve);
+ return BadAlloc;
+ }
+ }
+ else {
+ free(type->preserve);
+ type->preserve = NULL;
+ }
+ type->map_count = map_count;
+ }
+
+ if ((new_num_lvls > type->num_levels) || (type->level_names == NULL)) {
+ Atom *prev_level_names = type->level_names;
+
+ type->level_names = realloc(type->level_names,
+ new_num_lvls * sizeof(Atom));
+ if (!type->level_names) {
+ free(prev_level_names);
+ return BadAlloc;
+ }
}
/*
* Here's the theory:
@@ -357,156 +364,167 @@ KeyCode matchingKeys[XkbMaxKeyCount],nMatchingKeys;
* The possibilities marked with '+' require us to examine the key types
* associated with each group for the key.
*/
- memset(matchingKeys, 0, XkbMaxKeyCount*sizeof(KeyCode));
- nMatchingKeys= 0;
- if (new_num_lvls>type->num_levels) {
- int nTotal;
- KeySym * newSyms;
- int width,match,nResize;
- register int i,g,nSyms;
-
- nResize= 0;
- for (nTotal=1,i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
- width= XkbKeyGroupsWidth(xkb,i);
- if (width<type->num_levels)
- continue;
- for (match=0,g=XkbKeyNumGroups(xkb,i)-1;(g>=0)&&(!match);g--) {
- if (XkbKeyKeyTypeIndex(xkb,i,g)==type_ndx) {
- matchingKeys[nMatchingKeys++]= i;
- match= 1;
- }
- }
- if ((!match)||(width>=new_num_lvls))
- nTotal+= XkbKeyNumSyms(xkb,i);
- else {
- nTotal+= XkbKeyNumGroups(xkb,i)*new_num_lvls;
- nResize++;
- }
- }
- if (nResize>0) {
- int nextMatch;
- xkb->map->size_syms= (nTotal*15)/10;
- newSyms = calloc(xkb->map->size_syms, sizeof(KeySym));
- if (newSyms==NULL)
- return BadAlloc;
- nextMatch= 0;
- nSyms= 1;
- for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
- if (matchingKeys[nextMatch]==i) {
- KeySym *pOld;
- nextMatch++;
- width= XkbKeyGroupsWidth(xkb,i);
- pOld= XkbKeySymsPtr(xkb,i);
- for (g=XkbKeyNumGroups(xkb,i)-1;g>=0;g--) {
- memcpy(&newSyms[nSyms+(new_num_lvls*g)],&pOld[width*g],
- width*sizeof(KeySym));
- }
- xkb->map->key_sym_map[i].offset= nSyms;
- nSyms+= XkbKeyNumGroups(xkb,i)*new_num_lvls;
- }
- else {
- memcpy(&newSyms[nSyms],XkbKeySymsPtr(xkb,i),
- XkbKeyNumSyms(xkb,i)*sizeof(KeySym));
- xkb->map->key_sym_map[i].offset= nSyms;
- nSyms+= XkbKeyNumSyms(xkb,i);
- }
- }
- type->num_levels= new_num_lvls;
- free(xkb->map->syms);
- xkb->map->syms= newSyms;
- xkb->map->num_syms= nSyms;
- return Success;
- }
- }
- else if (new_num_lvls<type->num_levels) {
- int width,match;
- register int g,i;
- for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
- width= XkbKeyGroupsWidth(xkb,i);
- if (width<type->num_levels)
- continue;
- for (match=0,g=XkbKeyNumGroups(xkb,i)-1;(g>=0)&&(!match);g--) {
- if (XkbKeyKeyTypeIndex(xkb,i,g)==type_ndx) {
- matchingKeys[nMatchingKeys++]= i;
- match= 1;
- }
- }
- }
- }
- if (nMatchingKeys>0) {
- int key,firstClear;
- register int i,g;
- if (new_num_lvls>type->num_levels)
- firstClear= type->num_levels;
- else firstClear= new_num_lvls;
- for (i=0;i<nMatchingKeys;i++) {
- KeySym * pSyms;
- int width,nClear;
-
- key= matchingKeys[i];
- width= XkbKeyGroupsWidth(xkb,key);
- nClear= width-firstClear;
- pSyms= XkbKeySymsPtr(xkb,key);
- for (g=XkbKeyNumGroups(xkb,key)-1;g>=0;g--) {
- if (XkbKeyKeyTypeIndex(xkb,key,g)==type_ndx) {
- if (nClear>0)
- memset(&pSyms[g*width+firstClear], 0, nClear*sizeof(KeySym));
- }
- }
- }
- }
- type->num_levels= new_num_lvls;
+ memset(matchingKeys, 0, XkbMaxKeyCount * sizeof(KeyCode));
+ nMatchingKeys = 0;
+ if (new_num_lvls > type->num_levels) {
+ int nTotal;
+ KeySym *newSyms;
+ int width, match, nResize;
+ register int i, g, nSyms;
+
+ nResize = 0;
+ for (nTotal = 1, i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+ width = XkbKeyGroupsWidth(xkb, i);
+ if (width < type->num_levels)
+ continue;
+ for (match = 0, g = XkbKeyNumGroups(xkb, i) - 1;
+ (g >= 0) && (!match); g--) {
+ if (XkbKeyKeyTypeIndex(xkb, i, g) == type_ndx) {
+ matchingKeys[nMatchingKeys++] = i;
+ match = 1;
+ }
+ }
+ if ((!match) || (width >= new_num_lvls))
+ nTotal += XkbKeyNumSyms(xkb, i);
+ else {
+ nTotal += XkbKeyNumGroups(xkb, i) * new_num_lvls;
+ nResize++;
+ }
+ }
+ if (nResize > 0) {
+ int nextMatch;
+
+ xkb->map->size_syms = (nTotal * 15) / 10;
+ newSyms = calloc(xkb->map->size_syms, sizeof(KeySym));
+ if (newSyms == NULL)
+ return BadAlloc;
+ nextMatch = 0;
+ nSyms = 1;
+ for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+ if (matchingKeys[nextMatch] == i) {
+ KeySym *pOld;
+
+ nextMatch++;
+ width = XkbKeyGroupsWidth(xkb, i);
+ pOld = XkbKeySymsPtr(xkb, i);
+ for (g = XkbKeyNumGroups(xkb, i) - 1; g >= 0; g--) {
+ memcpy(&newSyms[nSyms + (new_num_lvls * g)],
+ &pOld[width * g], width * sizeof(KeySym));
+ }
+ xkb->map->key_sym_map[i].offset = nSyms;
+ nSyms += XkbKeyNumGroups(xkb, i) * new_num_lvls;
+ }
+ else {
+ memcpy(&newSyms[nSyms], XkbKeySymsPtr(xkb, i),
+ XkbKeyNumSyms(xkb, i) * sizeof(KeySym));
+ xkb->map->key_sym_map[i].offset = nSyms;
+ nSyms += XkbKeyNumSyms(xkb, i);
+ }
+ }
+ type->num_levels = new_num_lvls;
+ free(xkb->map->syms);
+ xkb->map->syms = newSyms;
+ xkb->map->num_syms = nSyms;
+ return Success;
+ }
+ }
+ else if (new_num_lvls < type->num_levels) {
+ int width, match;
+ register int g, i;
+
+ for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+ width = XkbKeyGroupsWidth(xkb, i);
+ if (width < type->num_levels)
+ continue;
+ for (match = 0, g = XkbKeyNumGroups(xkb, i) - 1;
+ (g >= 0) && (!match); g--) {
+ if (XkbKeyKeyTypeIndex(xkb, i, g) == type_ndx) {
+ matchingKeys[nMatchingKeys++] = i;
+ match = 1;
+ }
+ }
+ }
+ }
+ if (nMatchingKeys > 0) {
+ int key, firstClear;
+ register int i, g;
+
+ if (new_num_lvls > type->num_levels)
+ firstClear = type->num_levels;
+ else
+ firstClear = new_num_lvls;
+ for (i = 0; i < nMatchingKeys; i++) {
+ KeySym *pSyms;
+ int width, nClear;
+
+ key = matchingKeys[i];
+ width = XkbKeyGroupsWidth(xkb, key);
+ nClear = width - firstClear;
+ pSyms = XkbKeySymsPtr(xkb, key);
+ for (g = XkbKeyNumGroups(xkb, key) - 1; g >= 0; g--) {
+ if (XkbKeyKeyTypeIndex(xkb, key, g) == type_ndx) {
+ if (nClear > 0)
+ memset(&pSyms[g * width + firstClear], 0,
+ nClear * sizeof(KeySym));
+ }
+ }
+ }
+ }
+ type->num_levels = new_num_lvls;
return Success;
}
KeySym *
-XkbResizeKeySyms(XkbDescPtr xkb,int key,int needed)
+XkbResizeKeySyms(XkbDescPtr xkb, int key, int needed)
{
-register int i,nSyms,nKeySyms;
-unsigned nOldSyms;
-KeySym *newSyms;
-
- if (needed==0) {
- xkb->map->key_sym_map[key].offset= 0;
- return xkb->map->syms;
- }
- nOldSyms= XkbKeyNumSyms(xkb,key);
- if (nOldSyms>=(unsigned)needed) {
- return XkbKeySymsPtr(xkb,key);
- }
- if (xkb->map->size_syms-xkb->map->num_syms>=(unsigned)needed) {
- if (nOldSyms>0) {
- memcpy(&xkb->map->syms[xkb->map->num_syms],XkbKeySymsPtr(xkb,key),
- nOldSyms*sizeof(KeySym));
- }
- if ((needed-nOldSyms)>0) {
- memset(&xkb->map->syms[xkb->map->num_syms+XkbKeyNumSyms(xkb, key)],
- 0, (needed-nOldSyms)*sizeof(KeySym));
- }
- xkb->map->key_sym_map[key].offset = xkb->map->num_syms;
- xkb->map->num_syms+= needed;
- return &xkb->map->syms[xkb->map->key_sym_map[key].offset];
- }
- xkb->map->size_syms+= (needed>32?needed:32);
+ register int i, nSyms, nKeySyms;
+ unsigned nOldSyms;
+ KeySym *newSyms;
+
+ if (needed == 0) {
+ xkb->map->key_sym_map[key].offset = 0;
+ return xkb->map->syms;
+ }
+ nOldSyms = XkbKeyNumSyms(xkb, key);
+ if (nOldSyms >= (unsigned) needed) {
+ return XkbKeySymsPtr(xkb, key);
+ }
+ if (xkb->map->size_syms - xkb->map->num_syms >= (unsigned) needed) {
+ if (nOldSyms > 0) {
+ memcpy(&xkb->map->syms[xkb->map->num_syms], XkbKeySymsPtr(xkb, key),
+ nOldSyms * sizeof(KeySym));
+ }
+ if ((needed - nOldSyms) > 0) {
+ memset(&xkb->map->
+ syms[xkb->map->num_syms + XkbKeyNumSyms(xkb, key)], 0,
+ (needed - nOldSyms) * sizeof(KeySym));
+ }
+ xkb->map->key_sym_map[key].offset = xkb->map->num_syms;
+ xkb->map->num_syms += needed;
+ return &xkb->map->syms[xkb->map->key_sym_map[key].offset];
+ }
+ xkb->map->size_syms += (needed > 32 ? needed : 32);
newSyms = calloc(xkb->map->size_syms, sizeof(KeySym));
- if (newSyms==NULL)
- return NULL;
- newSyms[0]= NoSymbol;
+ if (newSyms == NULL)
+ return NULL;
+ newSyms[0] = NoSymbol;
nSyms = 1;
- for (i=xkb->min_key_code;i<=(int)xkb->max_key_code;i++) {
- int nCopy;
-
- nCopy= nKeySyms= XkbKeyNumSyms(xkb,i);
- if ((nKeySyms==0)&&(i!=key))
- continue;
- if (i==key)
- nKeySyms= needed;
- if (nCopy!=0)
- memcpy(&newSyms[nSyms],XkbKeySymsPtr(xkb,i),nCopy*sizeof(KeySym));
- if (nKeySyms>nCopy)
- memset(&newSyms[nSyms+nCopy], 0, (nKeySyms-nCopy)*sizeof(KeySym));
- xkb->map->key_sym_map[i].offset = nSyms;
- nSyms+= nKeySyms;
+ for (i = xkb->min_key_code; i <= (int) xkb->max_key_code; i++) {
+ int nCopy;
+
+ nCopy = nKeySyms = XkbKeyNumSyms(xkb, i);
+ if ((nKeySyms == 0) && (i != key))
+ continue;
+ if (i == key)
+ nKeySyms = needed;
+ if (nCopy != 0)
+ memcpy(&newSyms[nSyms], XkbKeySymsPtr(xkb, i),
+ nCopy * sizeof(KeySym));
+ if (nKeySyms > nCopy)
+ memset(&newSyms[nSyms + nCopy], 0,
+ (nKeySyms - nCopy) * sizeof(KeySym));
+ xkb->map->key_sym_map[i].offset = nSyms;
+ nSyms += nKeySyms;
}
free(xkb->map->syms);
xkb->map->syms = newSyms;
@@ -515,365 +533,398 @@ KeySym *newSyms;
}
static unsigned
-_ExtendRange( unsigned int old_flags,
- unsigned int flag,
- KeyCode newKC,
- KeyCode * old_min,
- unsigned char * old_num)
+_ExtendRange(unsigned int old_flags,
+ unsigned int flag,
+ KeyCode newKC, KeyCode *old_min, unsigned char *old_num)
{
- if ((old_flags&flag)==0) {
- old_flags|= flag;
- *old_min= newKC;
- *old_num= 1;
+ 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;
- }
+ 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
-XkbChangeKeycodeRange( XkbDescPtr xkb,
- int minKC,
- int maxKC,
- XkbChangesPtr changes)
+XkbChangeKeycodeRange(XkbDescPtr xkb,
+ int minKC, int maxKC, XkbChangesPtr changes)
{
-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) {
- memset((char *)&xkb->map->key_sym_map[minKC], 0,
- 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) {
- memset((char *)&xkb->map->modmap[minKC], 0, 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) {
- memset((char *)&xkb->server->behaviors[minKC], 0,
- 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) {
- memset((char *)&xkb->server->key_acts[minKC], 0,
- 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) {
- memset((char *)&xkb->server->vmodmap[minKC], 0,
- 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)) {
- memset((char *)&xkb->names->keys[minKC], 0, 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) {
- XkbSymMapRec *prev_key_sym_map = xkb->map->key_sym_map;
-
- xkb->map->key_sym_map = realloc(xkb->map->key_sym_map,
- (maxKC+1) * sizeof(XkbSymMapRec));
- if (!xkb->map->key_sym_map) {
- free(prev_key_sym_map);
- return BadAlloc;
- }
- memset((char *)&xkb->map->key_sym_map[xkb->max_key_code], 0,
- 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) {
- unsigned char *prev_modmap = xkb->map->modmap;
-
- xkb->map->modmap = realloc(xkb->map->modmap,
- (maxKC+1) * sizeof(unsigned char));
- if (!xkb->map->modmap) {
- free(prev_modmap);
- return BadAlloc;
- }
- memset((char *)&xkb->map->modmap[xkb->max_key_code], 0, 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) {
- XkbBehavior *prev_behaviors = xkb->server->behaviors;
-
- xkb->server->behaviors = realloc(xkb->server->behaviors,
- (maxKC+1) * sizeof(XkbBehavior));
- if (!xkb->server->behaviors) {
- free(prev_behaviors);
- return BadAlloc;
- }
- memset((char *)&xkb->server->behaviors[xkb->max_key_code], 0,
- 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) {
- unsigned short *prev_key_acts = xkb->server->key_acts;
-
- xkb->server->key_acts= realloc(xkb->server->key_acts,
- (maxKC+1) * sizeof(unsigned short));
- if (!xkb->server->key_acts) {
- free(prev_key_acts);
- return BadAlloc;
- }
- memset((char *)&xkb->server->key_acts[xkb->max_key_code], 0,
- 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) {
- unsigned short *prev_vmodmap = xkb->server->vmodmap;
-
- xkb->server->vmodmap= realloc(xkb->server->vmodmap,
- (maxKC+1) * sizeof(unsigned short));
- if (!xkb->server->vmodmap) {
- free(prev_vmodmap);
- return BadAlloc;
- }
- memset((char *)&xkb->server->vmodmap[xkb->max_key_code], 0,
- 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)) {
- XkbKeyNameRec *prev_keys = xkb->names->keys;
-
- xkb->names->keys = realloc(xkb->names->keys,
- (maxKC+1) * sizeof(XkbKeyNameRec));
- if (!xkb->names->keys) {
- free(prev_keys);
- return BadAlloc;
- }
- memset((char *)&xkb->names->keys[xkb->max_key_code], 0,
- 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;
+ 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) {
+ memset((char *) &xkb->map->key_sym_map[minKC], 0,
+ 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) {
+ memset((char *) &xkb->map->modmap[minKC], 0, 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) {
+ memset((char *) &xkb->server->behaviors[minKC], 0,
+ 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) {
+ memset((char *) &xkb->server->key_acts[minKC], 0,
+ 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) {
+ memset((char *) &xkb->server->vmodmap[minKC], 0,
+ 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)) {
+ memset((char *) &xkb->names->keys[minKC], 0,
+ 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) {
+ XkbSymMapRec *prev_key_sym_map = xkb->map->key_sym_map;
+
+ xkb->map->key_sym_map = realloc(xkb->map->key_sym_map,
+ (maxKC +
+ 1) * sizeof(XkbSymMapRec));
+ if (!xkb->map->key_sym_map) {
+ free(prev_key_sym_map);
+ return BadAlloc;
+ }
+ memset((char *) &xkb->map->key_sym_map[xkb->max_key_code], 0,
+ 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) {
+ unsigned char *prev_modmap = xkb->map->modmap;
+
+ xkb->map->modmap = realloc(xkb->map->modmap,
+ (maxKC + 1) * sizeof(unsigned char));
+ if (!xkb->map->modmap) {
+ free(prev_modmap);
+ return BadAlloc;
+ }
+ memset((char *) &xkb->map->modmap[xkb->max_key_code], 0, 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) {
+ XkbBehavior *prev_behaviors = xkb->server->behaviors;
+
+ xkb->server->behaviors = realloc(xkb->server->behaviors,
+ (maxKC +
+ 1) * sizeof(XkbBehavior));
+ if (!xkb->server->behaviors) {
+ free(prev_behaviors);
+ return BadAlloc;
+ }
+ memset((char *) &xkb->server->behaviors[xkb->max_key_code], 0,
+ 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) {
+ unsigned short *prev_key_acts = xkb->server->key_acts;
+
+ xkb->server->key_acts = realloc(xkb->server->key_acts,
+ (maxKC +
+ 1) * sizeof(unsigned short));
+ if (!xkb->server->key_acts) {
+ free(prev_key_acts);
+ return BadAlloc;
+ }
+ memset((char *) &xkb->server->key_acts[xkb->max_key_code], 0,
+ 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) {
+ unsigned short *prev_vmodmap = xkb->server->vmodmap;
+
+ xkb->server->vmodmap = realloc(xkb->server->vmodmap,
+ (maxKC +
+ 1) * sizeof(unsigned short));
+ if (!xkb->server->vmodmap) {
+ free(prev_vmodmap);
+ return BadAlloc;
+ }
+ memset((char *) &xkb->server->vmodmap[xkb->max_key_code], 0,
+ 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)) {
+ XkbKeyNameRec *prev_keys = xkb->names->keys;
+
+ xkb->names->keys = realloc(xkb->names->keys,
+ (maxKC + 1) * sizeof(XkbKeyNameRec));
+ if (!xkb->names->keys) {
+ free(prev_keys);
+ return BadAlloc;
+ }
+ memset((char *) &xkb->names->keys[xkb->max_key_code], 0,
+ 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 *
-XkbResizeKeyActions(XkbDescPtr xkb,int key,int needed)
+XkbResizeKeyActions(XkbDescPtr xkb, int key, int needed)
{
-register int i,nActs;
-XkbAction *newActs;
-
- if (needed==0) {
- xkb->server->key_acts[key]= 0;
- return NULL;
- }
- if (XkbKeyHasActions(xkb,key)&&(XkbKeyNumSyms(xkb,key)>=(unsigned)needed))
- return XkbKeyActionsPtr(xkb,key);
- if (xkb->server->size_acts-xkb->server->num_acts>=(unsigned)needed) {
- xkb->server->key_acts[key]= xkb->server->num_acts;
- xkb->server->num_acts+= needed;
- return &xkb->server->acts[xkb->server->key_acts[key]];
- }
- xkb->server->size_acts= xkb->server->num_acts+needed+8;
+ register int i, nActs;
+ XkbAction *newActs;
+
+ if (needed == 0) {
+ xkb->server->key_acts[key] = 0;
+ return NULL;
+ }
+ if (XkbKeyHasActions(xkb, key) &&
+ (XkbKeyNumSyms(xkb, key) >= (unsigned) needed))
+ return XkbKeyActionsPtr(xkb, key);
+ if (xkb->server->size_acts - xkb->server->num_acts >= (unsigned) needed) {
+ xkb->server->key_acts[key] = xkb->server->num_acts;
+ xkb->server->num_acts += needed;
+ return &xkb->server->acts[xkb->server->key_acts[key]];
+ }
+ xkb->server->size_acts = xkb->server->num_acts + needed + 8;
newActs = calloc(xkb->server->size_acts, sizeof(XkbAction));
- if (newActs==NULL)
- return NULL;
+ if (newActs == NULL)
+ return NULL;
newActs[0].type = XkbSA_NoAction;
nActs = 1;
- for (i=xkb->min_key_code;i<=(int)xkb->max_key_code;i++) {
- int nKeyActs,nCopy;
-
- if ((xkb->server->key_acts[i]==0)&&(i!=key))
- continue;
-
- nCopy= nKeyActs= XkbKeyNumActions(xkb,i);
- if (i==key) {
- nKeyActs= needed;
- if (needed<nCopy)
- nCopy= needed;
- }
-
- if (nCopy>0)
- memcpy(&newActs[nActs],XkbKeyActionsPtr(xkb,i),
- nCopy*sizeof(XkbAction));
- if (nCopy<nKeyActs)
- memset(&newActs[nActs+nCopy], 0, (nKeyActs-nCopy)*sizeof(XkbAction));
- xkb->server->key_acts[i]= nActs;
- nActs+= nKeyActs;
+ for (i = xkb->min_key_code; i <= (int) xkb->max_key_code; i++) {
+ int nKeyActs, nCopy;
+
+ if ((xkb->server->key_acts[i] == 0) && (i != key))
+ continue;
+
+ nCopy = nKeyActs = XkbKeyNumActions(xkb, i);
+ if (i == key) {
+ nKeyActs = needed;
+ if (needed < nCopy)
+ nCopy = needed;
+ }
+
+ if (nCopy > 0)
+ memcpy(&newActs[nActs], XkbKeyActionsPtr(xkb, i),
+ nCopy * sizeof(XkbAction));
+ if (nCopy < nKeyActs)
+ memset(&newActs[nActs + nCopy], 0,
+ (nKeyActs - nCopy) * sizeof(XkbAction));
+ xkb->server->key_acts[i] = nActs;
+ nActs += nKeyActs;
}
free(xkb->server->acts);
xkb->server->acts = newActs;
- xkb->server->num_acts= nActs;
+ xkb->server->num_acts = nActs;
return &xkb->server->acts[xkb->server->key_acts[key]];
}
void
-XkbFreeClientMap(XkbDescPtr xkb,unsigned what,Bool freeMap)
+XkbFreeClientMap(XkbDescPtr xkb, unsigned what, Bool freeMap)
{
-XkbClientMapPtr map;
+ XkbClientMapPtr map;
- if ((xkb==NULL)||(xkb->map==NULL))
- return;
+ if ((xkb == NULL) || (xkb->map == NULL))
+ return;
if (freeMap)
- what= XkbAllClientInfoMask;
- map= xkb->map;
- if (what&XkbKeyTypesMask) {
- if (map->types!=NULL) {
- if (map->num_types>0) {
- register int i;
- XkbKeyTypePtr type;
- for (i=0,type=map->types;i<map->num_types;i++,type++) {
- free(type->map);
- type->map = NULL;
- free(type->preserve);
- type->preserve = NULL;
- type->map_count= 0;
- free(type->level_names);
- type->level_names = NULL;
- }
- }
- free(map->types);
- map->num_types= map->size_types= 0;
- map->types= NULL;
- }
- }
- if (what&XkbKeySymsMask) {
- free(map->key_sym_map);
- map->key_sym_map = NULL;
- if (map->syms!=NULL) {
- free(map->syms);
- map->size_syms= map->num_syms= 0;
- map->syms= NULL;
- }
- }
- if ((what&XkbModifierMapMask)&&(map->modmap!=NULL)) {
- free(map->modmap);
- map->modmap= NULL;
+ what = XkbAllClientInfoMask;
+ map = xkb->map;
+ if (what & XkbKeyTypesMask) {
+ if (map->types != NULL) {
+ if (map->num_types > 0) {
+ register int i;
+ XkbKeyTypePtr type;
+
+ for (i = 0, type = map->types; i < map->num_types; i++, type++) {
+ free(type->map);
+ type->map = NULL;
+ free(type->preserve);
+ type->preserve = NULL;
+ type->map_count = 0;
+ free(type->level_names);
+ type->level_names = NULL;
+ }
+ }
+ free(map->types);
+ map->num_types = map->size_types = 0;
+ map->types = NULL;
+ }
+ }
+ if (what & XkbKeySymsMask) {
+ free(map->key_sym_map);
+ map->key_sym_map = NULL;
+ if (map->syms != NULL) {
+ free(map->syms);
+ map->size_syms = map->num_syms = 0;
+ map->syms = NULL;
+ }
+ }
+ if ((what & XkbModifierMapMask) && (map->modmap != NULL)) {
+ free(map->modmap);
+ map->modmap = NULL;
}
if (freeMap) {
- free(xkb->map);
- xkb->map= NULL;
+ free(xkb->map);
+ xkb->map = NULL;
}
return;
}
void
-XkbFreeServerMap(XkbDescPtr xkb,unsigned what,Bool freeMap)
+XkbFreeServerMap(XkbDescPtr xkb, unsigned what, Bool freeMap)
{
-XkbServerMapPtr map;
+ XkbServerMapPtr map;
- if ((xkb==NULL)||(xkb->server==NULL))
- return;
+ if ((xkb == NULL) || (xkb->server == NULL))
+ return;
if (freeMap)
- what= XkbAllServerInfoMask;
- map= xkb->server;
- if ((what&XkbExplicitComponentsMask)&&(map->explicit!=NULL)) {
- free(map->explicit);
- map->explicit= NULL;
- }
- if (what&XkbKeyActionsMask) {
- free(map->key_acts);
- map->key_acts = NULL;
- if (map->acts!=NULL) {
- free(map->acts);
- map->num_acts= map->size_acts= 0;
- map->acts= NULL;
- }
- }
- if ((what&XkbKeyBehaviorsMask)&&(map->behaviors!=NULL)) {
- free(map->behaviors);
- map->behaviors= NULL;
- }
- if ((what&XkbVirtualModMapMask)&&(map->vmodmap!=NULL)) {
- free(map->vmodmap);
- map->vmodmap= NULL;
+ what = XkbAllServerInfoMask;
+ map = xkb->server;
+ if ((what & XkbExplicitComponentsMask) && (map->explicit != NULL)) {
+ free(map->explicit);
+ map->explicit = NULL;
+ }
+ if (what & XkbKeyActionsMask) {
+ free(map->key_acts);
+ map->key_acts = NULL;
+ if (map->acts != NULL) {
+ free(map->acts);
+ map->num_acts = map->size_acts = 0;
+ map->acts = NULL;
+ }
+ }
+ if ((what & XkbKeyBehaviorsMask) && (map->behaviors != NULL)) {
+ free(map->behaviors);
+ map->behaviors = NULL;
+ }
+ if ((what & XkbVirtualModMapMask) && (map->vmodmap != NULL)) {
+ free(map->vmodmap);
+ map->vmodmap = NULL;
}
if (freeMap) {
- free(xkb->server);
- xkb->server= NULL;
+ free(xkb->server);
+ xkb->server = NULL;
}
return;
}
diff --git a/xkb/XKBMisc.c b/xkb/XKBMisc.c
index 96688be18..6abd1d11a 100644
--- a/xkb/XKBMisc.c
+++ b/xkb/XKBMisc.c
@@ -45,56 +45,54 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#define XKB_OFFSET(g,l) (((g)*groupsWidth)+(l))
int
-XkbKeyTypesForCoreSymbols( XkbDescPtr xkb,
- int map_width,
- KeySym * core_syms,
- unsigned int protected,
- int * types_inout,
- KeySym * xkb_syms_rtrn)
+XkbKeyTypesForCoreSymbols(XkbDescPtr xkb,
+ int map_width,
+ KeySym * core_syms,
+ unsigned int protected,
+ int *types_inout, KeySym * xkb_syms_rtrn)
{
-register int i;
-unsigned int empty;
-int nSyms[XkbNumKbdGroups];
-int nGroups,tmp,groupsWidth;
-BOOL replicated = FALSE;
+ register int i;
+ unsigned int empty;
+ int nSyms[XkbNumKbdGroups];
+ int nGroups, tmp, groupsWidth;
+ BOOL replicated = FALSE;
/* Section 12.2 of the protocol describes this process in more detail */
/* Step 1: find the # of symbols in the core mapping per group */
- groupsWidth= 2;
- for (i=0;i<XkbNumKbdGroups;i++) {
- if ((protected&(1<<i))&&(types_inout[i]<xkb->map->num_types)) {
- nSyms[i]= xkb->map->types[types_inout[i]].num_levels;
- if (nSyms[i]>groupsWidth)
- groupsWidth= nSyms[i];
- }
- else {
- types_inout[i]= XkbTwoLevelIndex; /* don't really know, yet */
- nSyms[i]= 2;
- }
- }
- if (nSyms[XkbGroup1Index]<2)
- nSyms[XkbGroup1Index]= 2;
- if (nSyms[XkbGroup2Index]<2)
- nSyms[XkbGroup2Index]= 2;
- /* Step 2: Copy the symbols from the core ordering to XKB ordering */
- /* symbols in the core are in the order: */
- /* G1L1 G1L2 G2L1 G2L2 [G1L[3-n]] [G2L[3-n]] [G3L*] [G3L*] */
- xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index,0)]= CORE_SYM(0);
- xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index,1)]= CORE_SYM(1);
- for (i=2;i<nSyms[XkbGroup1Index];i++) {
- xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index,i)]= CORE_SYM(2+i);
- }
- xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index,0)]= CORE_SYM(2);
- xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index,1)]= CORE_SYM(3);
- tmp= 2+(nSyms[XkbGroup1Index]-2); /* offset to extra group2 syms */
- for (i=2;i<nSyms[XkbGroup2Index];i++) {
- xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index,i)]= CORE_SYM(tmp+i);
+ groupsWidth = 2;
+ for (i = 0; i < XkbNumKbdGroups; i++) {
+ if ((protected & (1 << i)) && (types_inout[i] < xkb->map->num_types)) {
+ nSyms[i] = xkb->map->types[types_inout[i]].num_levels;
+ if (nSyms[i] > groupsWidth)
+ groupsWidth = nSyms[i];
+ }
+ else {
+ types_inout[i] = XkbTwoLevelIndex; /* don't really know, yet */
+ nSyms[i] = 2;
+ }
+ }
+ if (nSyms[XkbGroup1Index] < 2)
+ nSyms[XkbGroup1Index] = 2;
+ if (nSyms[XkbGroup2Index] < 2)
+ nSyms[XkbGroup2Index] = 2;
+ /* Step 2: Copy the symbols from the core ordering to XKB ordering */
+ /* symbols in the core are in the order: */
+ /* G1L1 G1L2 G2L1 G2L2 [G1L[3-n]] [G2L[3-n]] [G3L*] [G3L*] */
+ xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index, 0)] = CORE_SYM(0);
+ xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index, 1)] = CORE_SYM(1);
+ for (i = 2; i < nSyms[XkbGroup1Index]; i++) {
+ xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index, i)] = CORE_SYM(2 + i);
+ }
+ xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index, 0)] = CORE_SYM(2);
+ xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index, 1)] = CORE_SYM(3);
+ tmp = 2 + (nSyms[XkbGroup1Index] - 2); /* offset to extra group2 syms */
+ for (i = 2; i < nSyms[XkbGroup2Index]; i++) {
+ xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index, i)] = CORE_SYM(tmp + i);
}
/* Special case: if only the first group is explicit, and the symbols
* replicate across all groups, then we have a Section 12.4 replication */
- if ((protected & ~XkbExplicitKeyType1Mask) == 0)
- {
+ if ((protected & ~XkbExplicitKeyType1Mask) == 0) {
int j, width = nSyms[XkbGroup1Index];
replicated = TRUE;
@@ -105,119 +103,123 @@ BOOL replicated = FALSE;
replicated = FALSE;
/* Check CDECDE in ABABCDECDEABCDE */
- for (i = 2; i < width && replicated; i++)
- {
+ for (i = 2; i < width && replicated; i++) {
if (CORE_SYM(2 + i) != CORE_SYM(i + width))
replicated = FALSE;
}
/* Check ABCDE in ABABCDECDEABCDE */
for (j = 2; replicated &&
- j < XkbNumKbdGroups &&
- map_width >= width * (j + 1); j++)
- {
- for (i = 0; i < width && replicated; i++)
- {
+ j < XkbNumKbdGroups && map_width >= width * (j + 1); j++) {
+ for (i = 0; i < width && replicated; i++) {
if (CORE_SYM(((i < 2) ? i : 2 + i)) != CORE_SYM(i + width * j))
replicated = FALSE;
}
}
}
- if (replicated)
- {
- nSyms[XkbGroup2Index]= 0;
- nSyms[XkbGroup3Index]= 0;
- nSyms[XkbGroup4Index]= 0;
- nGroups= 1;
- } else
- {
- tmp= nSyms[XkbGroup1Index]+nSyms[XkbGroup2Index];
- if ((tmp>=map_width)&&
- ((protected&(XkbExplicitKeyType3Mask|XkbExplicitKeyType4Mask))==0)) {
- nSyms[XkbGroup3Index]= 0;
- nSyms[XkbGroup4Index]= 0;
- nGroups= 2;
- } else
- {
- nGroups= 3;
- for (i=0;i<nSyms[XkbGroup3Index];i++,tmp++) {
- xkb_syms_rtrn[XKB_OFFSET(XkbGroup3Index,i)]= CORE_SYM(tmp);
+ if (replicated) {
+ nSyms[XkbGroup2Index] = 0;
+ nSyms[XkbGroup3Index] = 0;
+ nSyms[XkbGroup4Index] = 0;
+ nGroups = 1;
+ }
+ else {
+ tmp = nSyms[XkbGroup1Index] + nSyms[XkbGroup2Index];
+ if ((tmp >= map_width) &&
+ ((protected & (XkbExplicitKeyType3Mask | XkbExplicitKeyType4Mask))
+ == 0)) {
+ nSyms[XkbGroup3Index] = 0;
+ nSyms[XkbGroup4Index] = 0;
+ nGroups = 2;
+ }
+ else {
+ nGroups = 3;
+ for (i = 0; i < nSyms[XkbGroup3Index]; i++, tmp++) {
+ xkb_syms_rtrn[XKB_OFFSET(XkbGroup3Index, i)] = CORE_SYM(tmp);
}
- if ((tmp<map_width)||(protected&XkbExplicitKeyType4Mask)) {
- nGroups= 4;
- for (i=0;i<nSyms[XkbGroup4Index];i++,tmp++) {
- xkb_syms_rtrn[XKB_OFFSET(XkbGroup4Index,i)]= CORE_SYM(tmp);
+ if ((tmp < map_width) || (protected & XkbExplicitKeyType4Mask)) {
+ nGroups = 4;
+ for (i = 0; i < nSyms[XkbGroup4Index]; i++, tmp++) {
+ xkb_syms_rtrn[XKB_OFFSET(XkbGroup4Index, i)] =
+ CORE_SYM(tmp);
}
}
else {
- nSyms[XkbGroup4Index]= 0;
+ nSyms[XkbGroup4Index] = 0;
}
}
}
/* steps 3&4: alphanumeric expansion, assign canonical types */
- empty= 0;
- for (i=0;i<nGroups;i++) {
- KeySym *syms;
- syms= &xkb_syms_rtrn[XKB_OFFSET(i,0)];
- if ((nSyms[i]>1)&&(syms[1]==NoSymbol)&&(syms[0]!=NoSymbol)) {
- KeySym upper,lower;
- XkbConvertCase(syms[0],&lower,&upper);
- if (upper!=lower) {
- xkb_syms_rtrn[XKB_OFFSET(i,0)]= lower;
- xkb_syms_rtrn[XKB_OFFSET(i,1)]= upper;
- if ((protected&(1<<i))==0)
- types_inout[i]= XkbAlphabeticIndex;
- }
- else if ((protected&(1<<i))==0) {
- types_inout[i]= XkbOneLevelIndex;
- /* nSyms[i]= 1;*/
- }
- }
- if (((protected&(1<<i))==0)&&(types_inout[i]==XkbTwoLevelIndex)) {
- if (XkbKSIsKeypad(syms[0])||XkbKSIsKeypad(syms[1]))
- types_inout[i]= XkbKeypadIndex;
- else {
- KeySym upper,lower;
- XkbConvertCase(syms[0],&lower,&upper);
- if ((syms[0]==lower)&&(syms[1]==upper))
- types_inout[i]= XkbAlphabeticIndex;
- }
- }
- if (syms[0]==NoSymbol) {
- register int n;
- Bool found;
- for (n=1,found=FALSE;(!found)&&(n<nSyms[i]);n++) {
- found= (syms[n]!=NoSymbol);
- }
- if (!found)
- empty|= (1<<i);
- }
+ empty = 0;
+ for (i = 0; i < nGroups; i++) {
+ KeySym *syms;
+
+ syms = &xkb_syms_rtrn[XKB_OFFSET(i, 0)];
+ if ((nSyms[i] > 1) && (syms[1] == NoSymbol) && (syms[0] != NoSymbol)) {
+ KeySym upper, lower;
+
+ XkbConvertCase(syms[0], &lower, &upper);
+ if (upper != lower) {
+ xkb_syms_rtrn[XKB_OFFSET(i, 0)] = lower;
+ xkb_syms_rtrn[XKB_OFFSET(i, 1)] = upper;
+ if ((protected & (1 << i)) == 0)
+ types_inout[i] = XkbAlphabeticIndex;
+ }
+ else if ((protected & (1 << i)) == 0) {
+ types_inout[i] = XkbOneLevelIndex;
+ /* nSyms[i]= 1; */
+ }
+ }
+ if (((protected & (1 << i)) == 0) &&
+ (types_inout[i] == XkbTwoLevelIndex)) {
+ if (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1]))
+ types_inout[i] = XkbKeypadIndex;
+ else {
+ KeySym upper, lower;
+
+ XkbConvertCase(syms[0], &lower, &upper);
+ if ((syms[0] == lower) && (syms[1] == upper))
+ types_inout[i] = XkbAlphabeticIndex;
+ }
+ }
+ if (syms[0] == NoSymbol) {
+ register int n;
+ Bool found;
+
+ for (n = 1, found = FALSE; (!found) && (n < nSyms[i]); n++) {
+ found = (syms[n] != NoSymbol);
+ }
+ if (!found)
+ empty |= (1 << i);
+ }
}
/* step 5: squoosh out empty groups */
if (empty) {
- for (i=nGroups-1;i>=0;i--) {
- if (((empty&(1<<i))==0)||(protected&(1<<i)))
- break;
- nGroups--;
- }
+ for (i = nGroups - 1; i >= 0; i--) {
+ if (((empty & (1 << i)) == 0) || (protected & (1 << i)))
+ break;
+ nGroups--;
+ }
}
- if (nGroups<1)
- return 0;
+ if (nGroups < 1)
+ return 0;
/* step 6: replicate group 1 into group two, if necessary */
- if ((nGroups>1)&&((empty&(XkbGroup1Mask|XkbGroup2Mask))==XkbGroup2Mask)) {
- if ((protected&(XkbExplicitKeyType1Mask|XkbExplicitKeyType2Mask))==0) {
- nSyms[XkbGroup2Index]= nSyms[XkbGroup1Index];
- types_inout[XkbGroup2Index]= types_inout[XkbGroup1Index];
- memcpy((char *)&xkb_syms_rtrn[2],(char *)xkb_syms_rtrn,
- 2*sizeof(KeySym));
- }
- else if (types_inout[XkbGroup1Index]==types_inout[XkbGroup2Index]) {
- memcpy((char *)&xkb_syms_rtrn[nSyms[XkbGroup1Index]],
- (char *)xkb_syms_rtrn,
- nSyms[XkbGroup1Index]*sizeof(KeySym));
- }
+ if ((nGroups > 1) &&
+ ((empty & (XkbGroup1Mask | XkbGroup2Mask)) == XkbGroup2Mask)) {
+ if ((protected & (XkbExplicitKeyType1Mask | XkbExplicitKeyType2Mask)) ==
+ 0) {
+ nSyms[XkbGroup2Index] = nSyms[XkbGroup1Index];
+ types_inout[XkbGroup2Index] = types_inout[XkbGroup1Index];
+ memcpy((char *) &xkb_syms_rtrn[2], (char *) xkb_syms_rtrn,
+ 2 * sizeof(KeySym));
+ }
+ else if (types_inout[XkbGroup1Index] == types_inout[XkbGroup2Index]) {
+ memcpy((char *) &xkb_syms_rtrn[nSyms[XkbGroup1Index]],
+ (char *) xkb_syms_rtrn,
+ nSyms[XkbGroup1Index] * sizeof(KeySym));
+ }
}
/* step 7: check for all groups identical or all width 1
@@ -226,136 +228,145 @@ BOOL replicated = FALSE;
* have canonical types with same symbols, we assume it's info lost from
* the core replication.
*/
- if (nGroups>1) {
- Bool sameType,allOneLevel, canonical = TRUE;
- allOneLevel= (xkb->map->types[types_inout[0]].num_levels==1);
- for (i=1,sameType=TRUE;(allOneLevel||sameType)&&(i<nGroups);i++) {
- sameType=(sameType&&(types_inout[i]==types_inout[XkbGroup1Index]));
- if (allOneLevel)
- allOneLevel= (xkb->map->types[types_inout[i]].num_levels==1);
- if (types_inout[i] > XkbLastRequiredType)
- canonical = FALSE;
- }
- if (((sameType) || canonical)&&
- (!(protected&(XkbExplicitKeyTypesMask&~XkbExplicitKeyType1Mask)))){
- register int s;
- Bool identical;
- for (i=1,identical=TRUE;identical&&(i<nGroups);i++) {
- KeySym *syms;
+ if (nGroups > 1) {
+ Bool sameType, allOneLevel, canonical = TRUE;
+
+ allOneLevel = (xkb->map->types[types_inout[0]].num_levels == 1);
+ for (i = 1, sameType = TRUE; (allOneLevel || sameType) && (i < nGroups);
+ i++) {
+ sameType = (sameType &&
+ (types_inout[i] == types_inout[XkbGroup1Index]));
+ if (allOneLevel)
+ allOneLevel = (xkb->map->types[types_inout[i]].num_levels == 1);
+ if (types_inout[i] > XkbLastRequiredType)
+ canonical = FALSE;
+ }
+ if (((sameType) || canonical) &&
+ (!(protected &
+ (XkbExplicitKeyTypesMask & ~XkbExplicitKeyType1Mask)))) {
+ register int s;
+ Bool identical;
+
+ for (i = 1, identical = TRUE; identical && (i < nGroups); i++) {
+ KeySym *syms;
+
if (nSyms[i] != nSyms[XkbGroup1Index])
identical = FALSE;
- syms= &xkb_syms_rtrn[XKB_OFFSET(i,0)];
- for (s=0;identical&&(s<nSyms[i]);s++) {
- if (syms[s]!=xkb_syms_rtrn[s])
- identical= FALSE;
- }
- }
- if (identical)
- nGroups= 1;
- }
- if (allOneLevel && (nGroups>1)) {
- KeySym *syms;
- syms= &xkb_syms_rtrn[nSyms[XkbGroup1Index]];
- nSyms[XkbGroup1Index]= 1;
- for (i=1;i<nGroups;i++) {
- xkb_syms_rtrn[i]= syms[0];
- syms+= nSyms[i];
- nSyms[i]= 1;
- }
- }
+ syms = &xkb_syms_rtrn[XKB_OFFSET(i, 0)];
+ for (s = 0; identical && (s < nSyms[i]); s++) {
+ if (syms[s] != xkb_syms_rtrn[s])
+ identical = FALSE;
+ }
+ }
+ if (identical)
+ nGroups = 1;
+ }
+ if (allOneLevel && (nGroups > 1)) {
+ KeySym *syms;
+
+ syms = &xkb_syms_rtrn[nSyms[XkbGroup1Index]];
+ nSyms[XkbGroup1Index] = 1;
+ for (i = 1; i < nGroups; i++) {
+ xkb_syms_rtrn[i] = syms[0];
+ syms += nSyms[i];
+ nSyms[i] = 1;
+ }
+ }
}
return nGroups;
}
static XkbSymInterpretPtr
-_XkbFindMatchingInterp( XkbDescPtr xkb,
- KeySym sym,
- unsigned int real_mods,
- unsigned int level)
+_XkbFindMatchingInterp(XkbDescPtr xkb,
+ KeySym sym, unsigned int real_mods, unsigned int level)
{
-register unsigned i;
-XkbSymInterpretPtr interp,rtrn;
-CARD8 mods;
-
- rtrn= NULL;
- interp= xkb->compat->sym_interpret;
- for (i=0;i<xkb->compat->num_si;i++,interp++) {
- if ((interp->sym==NoSymbol)||(sym==interp->sym)) {
- int match;
- if ((level==0)||((interp->match&XkbSI_LevelOneOnly)==0))
- mods= real_mods;
- else mods= 0;
- switch (interp->match&XkbSI_OpMask) {
- case XkbSI_NoneOf:
- match= ((interp->mods&mods)==0);
- break;
- case XkbSI_AnyOfOrNone:
- match= ((mods==0)||((interp->mods&mods)!=0));
- break;
- case XkbSI_AnyOf:
- match= ((interp->mods&mods)!=0);
- break;
- case XkbSI_AllOf:
- match= ((interp->mods&mods)==interp->mods);
- break;
- case XkbSI_Exactly:
- match= (interp->mods==mods);
- break;
- default:
- match= 0;
- break;
- }
- if (match) {
- if (interp->sym!=NoSymbol) {
- return interp;
- }
- else if (rtrn==NULL) {
- rtrn= interp;
- }
- }
- }
+ register unsigned i;
+ XkbSymInterpretPtr interp, rtrn;
+ CARD8 mods;
+
+ rtrn = NULL;
+ interp = xkb->compat->sym_interpret;
+ for (i = 0; i < xkb->compat->num_si; i++, interp++) {
+ if ((interp->sym == NoSymbol) || (sym == interp->sym)) {
+ int match;
+
+ if ((level == 0) || ((interp->match & XkbSI_LevelOneOnly) == 0))
+ mods = real_mods;
+ else
+ mods = 0;
+ switch (interp->match & XkbSI_OpMask) {
+ case XkbSI_NoneOf:
+ match = ((interp->mods & mods) == 0);
+ break;
+ case XkbSI_AnyOfOrNone:
+ match = ((mods == 0) || ((interp->mods & mods) != 0));
+ break;
+ case XkbSI_AnyOf:
+ match = ((interp->mods & mods) != 0);
+ break;
+ case XkbSI_AllOf:
+ match = ((interp->mods & mods) == interp->mods);
+ break;
+ case XkbSI_Exactly:
+ match = (interp->mods == mods);
+ break;
+ default:
+ match = 0;
+ break;
+ }
+ if (match) {
+ if (interp->sym != NoSymbol) {
+ return interp;
+ }
+ else if (rtrn == NULL) {
+ rtrn = interp;
+ }
+ }
+ }
}
return rtrn;
}
static void
-_XkbAddKeyChange(KeyCode *pFirst,unsigned char *pNum,KeyCode newKey)
+_XkbAddKeyChange(KeyCode *pFirst, unsigned char *pNum, KeyCode newKey)
{
-KeyCode last;
+ KeyCode last;
- last= (*pFirst)+(*pNum);
- if (newKey<*pFirst) {
- *pFirst= newKey;
- *pNum= (last-newKey)+1;
+ last = (*pFirst) + (*pNum);
+ if (newKey < *pFirst) {
+ *pFirst = newKey;
+ *pNum = (last - newKey) + 1;
}
- else if (newKey>last) {
- *pNum= (last-*pFirst)+1;
+ else if (newKey > last) {
+ *pNum = (last - *pFirst) + 1;
}
return;
}
static void
-_XkbSetActionKeyMods(XkbDescPtr xkb,XkbAction *act,unsigned mods)
+_XkbSetActionKeyMods(XkbDescPtr xkb, XkbAction *act, unsigned mods)
{
-unsigned tmp;
+ unsigned tmp;
switch (act->type) {
- case XkbSA_SetMods: case XkbSA_LatchMods: case XkbSA_LockMods:
- if (act->mods.flags&XkbSA_UseModMapMods)
- act->mods.real_mods= act->mods.mask= mods;
- if ((tmp= XkbModActionVMods(&act->mods))!=0) {
- XkbVirtualModsToReal(xkb,tmp,&tmp);
- act->mods.mask|= tmp;
- }
- break;
- case XkbSA_ISOLock:
- if (act->iso.flags&XkbSA_UseModMapMods)
- act->iso.real_mods= act->iso.mask= mods;
- if ((tmp= XkbModActionVMods(&act->iso))!=0) {
- XkbVirtualModsToReal(xkb,tmp,&tmp);
- act->iso.mask|= tmp;
- }
- break;
+ case XkbSA_SetMods:
+ case XkbSA_LatchMods:
+ case XkbSA_LockMods:
+ if (act->mods.flags & XkbSA_UseModMapMods)
+ act->mods.real_mods = act->mods.mask = mods;
+ if ((tmp = XkbModActionVMods(&act->mods)) != 0) {
+ XkbVirtualModsToReal(xkb, tmp, &tmp);
+ act->mods.mask |= tmp;
+ }
+ break;
+ case XkbSA_ISOLock:
+ if (act->iso.flags & XkbSA_UseModMapMods)
+ act->iso.real_mods = act->iso.mask = mods;
+ if ((tmp = XkbModActionVMods(&act->iso)) != 0) {
+ XkbVirtualModsToReal(xkb, tmp, &tmp);
+ act->iso.mask |= tmp;
+ }
+ break;
}
return;
}
@@ -363,273 +374,285 @@ unsigned tmp;
#define IBUF_SIZE 8
Bool
-XkbApplyCompatMapToKey(XkbDescPtr xkb,KeyCode key,XkbChangesPtr changes)
+XkbApplyCompatMapToKey(XkbDescPtr xkb, KeyCode key, XkbChangesPtr changes)
{
-KeySym * syms;
-unsigned char explicit,mods;
-XkbSymInterpretPtr *interps,ibuf[IBUF_SIZE];
-int n,nSyms,found;
-unsigned changed,tmp;
-
- if ((!xkb)||(!xkb->map)||(!xkb->map->key_sym_map)||
- (!xkb->compat)||(!xkb->compat->sym_interpret)||
- (key<xkb->min_key_code)||(key>xkb->max_key_code)) {
- return FALSE;
- }
- if (((!xkb->server)||(!xkb->server->key_acts))&&
- (XkbAllocServerMap(xkb,XkbAllServerInfoMask,0)!=Success)) {
- return FALSE;
- }
- changed= 0; /* keeps track of what has changed in _this_ call */
- explicit= xkb->server->explicit[key];
- if (explicit&XkbExplicitInterpretMask) /* nothing to do */
- return TRUE;
- mods= (xkb->map->modmap?xkb->map->modmap[key]:0);
- nSyms= XkbKeyNumSyms(xkb,key);
- syms= XkbKeySymsPtr(xkb,key);
- if (nSyms>IBUF_SIZE) {
- interps= calloc(nSyms, sizeof(XkbSymInterpretPtr));
- if (interps==NULL) {
- interps= ibuf;
- nSyms= IBUF_SIZE;
- }
+ KeySym *syms;
+ unsigned char explicit, mods;
+ XkbSymInterpretPtr *interps, ibuf[IBUF_SIZE];
+ int n, nSyms, found;
+ unsigned changed, tmp;
+
+ if ((!xkb) || (!xkb->map) || (!xkb->map->key_sym_map) ||
+ (!xkb->compat) || (!xkb->compat->sym_interpret) ||
+ (key < xkb->min_key_code) || (key > xkb->max_key_code)) {
+ return FALSE;
+ }
+ if (((!xkb->server) || (!xkb->server->key_acts)) &&
+ (XkbAllocServerMap(xkb, XkbAllServerInfoMask, 0) != Success)) {
+ return FALSE;
+ }
+ changed = 0; /* keeps track of what has changed in _this_ call */
+ explicit = xkb->server->explicit[key];
+ if (explicit & XkbExplicitInterpretMask) /* nothing to do */
+ return TRUE;
+ mods = (xkb->map->modmap ? xkb->map->modmap[key] : 0);
+ nSyms = XkbKeyNumSyms(xkb, key);
+ syms = XkbKeySymsPtr(xkb, key);
+ if (nSyms > IBUF_SIZE) {
+ interps = calloc(nSyms, sizeof(XkbSymInterpretPtr));
+ if (interps == NULL) {
+ interps = ibuf;
+ nSyms = IBUF_SIZE;
+ }
}
else {
- interps= ibuf;
- }
- found= 0;
- for (n=0;n<nSyms;n++) {
- unsigned level= (n%XkbKeyGroupsWidth(xkb,key));
- interps[n]= NULL;
- if (syms[n]!=NoSymbol) {
- interps[n]= _XkbFindMatchingInterp(xkb,syms[n],mods,level);
- if (interps[n]&&interps[n]->act.type!=XkbSA_NoAction)
- found++;
- else interps[n]= NULL;
- }
+ interps = ibuf;
+ }
+ found = 0;
+ for (n = 0; n < nSyms; n++) {
+ unsigned level = (n % XkbKeyGroupsWidth(xkb, key));
+
+ interps[n] = NULL;
+ if (syms[n] != NoSymbol) {
+ interps[n] = _XkbFindMatchingInterp(xkb, syms[n], mods, level);
+ if (interps[n] && interps[n]->act.type != XkbSA_NoAction)
+ found++;
+ else
+ interps[n] = NULL;
+ }
}
/* 1/28/96 (ef) -- XXX! WORKING HERE */
if (!found) {
- if (xkb->server->key_acts[key]!=0) {
- xkb->server->key_acts[key]= 0;
- changed|= XkbKeyActionsMask;
- }
+ if (xkb->server->key_acts[key] != 0) {
+ xkb->server->key_acts[key] = 0;
+ changed |= XkbKeyActionsMask;
+ }
}
else {
- XkbAction *pActs;
- unsigned int new_vmodmask;
- changed|= XkbKeyActionsMask;
- pActs= XkbResizeKeyActions(xkb,key,nSyms);
- if (!pActs) {
+ XkbAction *pActs;
+ unsigned int new_vmodmask;
+
+ changed |= XkbKeyActionsMask;
+ pActs = XkbResizeKeyActions(xkb, key, nSyms);
+ if (!pActs) {
if (nSyms > IBUF_SIZE)
free(interps);
- 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)) {
- 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)&&
- (xkb->server->vmodmap[key]!=new_vmodmask)) {
- changed|= XkbVirtualModMapMask;
- xkb->server->vmodmap[key]= new_vmodmask;
- }
- if (interps[0]) {
- if ((interps[0]->flags&XkbSI_LockingKey)&&
- ((explicit&XkbExplicitBehaviorMask)==0)) {
- xkb->server->behaviors[key].type= XkbKB_Lock;
- changed|= XkbKeyBehaviorsMask;
- }
- if (((explicit&XkbExplicitAutoRepeatMask)==0)&&(xkb->ctrls)) {
- CARD8 old;
- old= BitIsOn(xkb->ctrls->per_key_repeat, key);
- if (interps[0]->flags&XkbSI_AutoRepeat)
- SetBit(xkb->ctrls->per_key_repeat, key);
- else
- ClearBit(xkb->ctrls->per_key_repeat, key);
- if (changes && old != BitIsOn(xkb->ctrls->per_key_repeat, key))
- changes->ctrls.changed_ctrls|= XkbPerKeyRepeatMask;
- }
- }
- }
- if ((!found)||(interps[0]==NULL)) {
- if (((explicit&XkbExplicitAutoRepeatMask)==0)&&(xkb->ctrls)) {
- CARD8 old;
- old = BitIsOn(xkb->ctrls->per_key_repeat, key);
- SetBit(xkb->ctrls->per_key_repeat, key);
- if (changes && (old != BitIsOn(xkb->ctrls->per_key_repeat, key)))
- changes->ctrls.changed_ctrls|= XkbPerKeyRepeatMask;
- }
- if (((explicit&XkbExplicitBehaviorMask)==0)&&
- (xkb->server->behaviors[key].type==XkbKB_Lock)) {
- xkb->server->behaviors[key].type= XkbKB_Default;
- changed|= XkbKeyBehaviorsMask;
- }
+ 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)) {
+ 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) &&
+ (xkb->server->vmodmap[key] != new_vmodmask)) {
+ changed |= XkbVirtualModMapMask;
+ xkb->server->vmodmap[key] = new_vmodmask;
+ }
+ if (interps[0]) {
+ if ((interps[0]->flags & XkbSI_LockingKey) &&
+ ((explicit & XkbExplicitBehaviorMask) == 0)) {
+ xkb->server->behaviors[key].type = XkbKB_Lock;
+ changed |= XkbKeyBehaviorsMask;
+ }
+ if (((explicit & XkbExplicitAutoRepeatMask) == 0) && (xkb->ctrls)) {
+ CARD8 old;
+
+ old = BitIsOn(xkb->ctrls->per_key_repeat, key);
+ if (interps[0]->flags & XkbSI_AutoRepeat)
+ SetBit(xkb->ctrls->per_key_repeat, key);
+ else
+ ClearBit(xkb->ctrls->per_key_repeat, key);
+ if (changes && old != BitIsOn(xkb->ctrls->per_key_repeat, key))
+ changes->ctrls.changed_ctrls |= XkbPerKeyRepeatMask;
+ }
+ }
+ }
+ if ((!found) || (interps[0] == NULL)) {
+ if (((explicit & XkbExplicitAutoRepeatMask) == 0) && (xkb->ctrls)) {
+ CARD8 old;
+
+ old = BitIsOn(xkb->ctrls->per_key_repeat, key);
+ SetBit(xkb->ctrls->per_key_repeat, key);
+ if (changes && (old != BitIsOn(xkb->ctrls->per_key_repeat, key)))
+ changes->ctrls.changed_ctrls |= XkbPerKeyRepeatMask;
+ }
+ if (((explicit & XkbExplicitBehaviorMask) == 0) &&
+ (xkb->server->behaviors[key].type == XkbKB_Lock)) {
+ xkb->server->behaviors[key].type = XkbKB_Default;
+ changed |= XkbKeyBehaviorsMask;
+ }
}
if (changes) {
- XkbMapChangesPtr mc;
- mc= &changes->map;
- tmp= (changed&mc->changed);
- if (tmp&XkbKeyActionsMask)
- _XkbAddKeyChange(&mc->first_key_act,&mc->num_key_acts,key);
- else if (changed&XkbKeyActionsMask) {
- mc->changed|= XkbKeyActionsMask;
- mc->first_key_act= key;
- mc->num_key_acts= 1;
- }
- if (tmp&XkbKeyBehaviorsMask) {
- _XkbAddKeyChange(&mc->first_key_behavior,&mc->num_key_behaviors,
- key);
- }
- else if (changed&XkbKeyBehaviorsMask) {
- mc->changed|= XkbKeyBehaviorsMask;
- mc->first_key_behavior= key;
- mc->num_key_behaviors= 1;
- }
- if (tmp&XkbVirtualModMapMask)
- _XkbAddKeyChange(&mc->first_vmodmap_key,&mc->num_vmodmap_keys,key);
- else if (changed&XkbVirtualModMapMask) {
- mc->changed|= XkbVirtualModMapMask;
- mc->first_vmodmap_key= key;
- mc->num_vmodmap_keys= 1;
- }
- mc->changed|= changed;
- }
- if (interps!=ibuf)
- free(interps);
+ XkbMapChangesPtr mc;
+
+ mc = &changes->map;
+ tmp = (changed & mc->changed);
+ if (tmp & XkbKeyActionsMask)
+ _XkbAddKeyChange(&mc->first_key_act, &mc->num_key_acts, key);
+ else if (changed & XkbKeyActionsMask) {
+ mc->changed |= XkbKeyActionsMask;
+ mc->first_key_act = key;
+ mc->num_key_acts = 1;
+ }
+ if (tmp & XkbKeyBehaviorsMask) {
+ _XkbAddKeyChange(&mc->first_key_behavior, &mc->num_key_behaviors,
+ key);
+ }
+ else if (changed & XkbKeyBehaviorsMask) {
+ mc->changed |= XkbKeyBehaviorsMask;
+ mc->first_key_behavior = key;
+ mc->num_key_behaviors = 1;
+ }
+ if (tmp & XkbVirtualModMapMask)
+ _XkbAddKeyChange(&mc->first_vmodmap_key, &mc->num_vmodmap_keys,
+ key);
+ else if (changed & XkbVirtualModMapMask) {
+ mc->changed |= XkbVirtualModMapMask;
+ mc->first_vmodmap_key = key;
+ mc->num_vmodmap_keys = 1;
+ }
+ mc->changed |= changed;
+ }
+ if (interps != ibuf)
+ free(interps);
return TRUE;
}
Status
-XkbChangeTypesOfKey( XkbDescPtr xkb,
- int key,
- int nGroups,
- unsigned groups,
- int * newTypesIn,
- XkbMapChangesPtr changes)
+XkbChangeTypesOfKey(XkbDescPtr xkb,
+ int key,
+ int nGroups,
+ unsigned groups, int *newTypesIn, XkbMapChangesPtr changes)
{
-XkbKeyTypePtr pOldType,pNewType;
-register int i;
-int width,nOldGroups,oldWidth,newTypes[XkbNumKbdGroups];
-
- if ((!xkb) || (!XkbKeycodeInRange(xkb,key)) || (!xkb->map) ||
- (!xkb->map->types)||(!newTypesIn)||((groups&XkbAllGroupsMask)==0)||
- (nGroups>XkbNumKbdGroups)) {
- return BadMatch;
- }
- if (nGroups==0) {
- for (i=0;i<XkbNumKbdGroups;i++) {
- xkb->map->key_sym_map[key].kt_index[i]= XkbOneLevelIndex;
- }
- i= xkb->map->key_sym_map[key].group_info;
- i= XkbSetNumGroups(i,0);
- xkb->map->key_sym_map[key].group_info= i;
- XkbResizeKeySyms(xkb,key,0);
- return Success;
- }
-
- nOldGroups= XkbKeyNumGroups(xkb,key);
- oldWidth= XkbKeyGroupsWidth(xkb,key);
- for (width=i=0;i<nGroups;i++) {
- if (groups&(1<<i))
- newTypes[i]= newTypesIn[i];
- else if (i<nOldGroups)
- newTypes[i]= XkbKeyKeyTypeIndex(xkb,key,i);
- else if (nOldGroups>0)
- newTypes[i]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup1Index);
- else newTypes[i]= XkbTwoLevelIndex;
- if (newTypes[i]>xkb->map->num_types)
- return BadMatch;
- pNewType= &xkb->map->types[newTypes[i]];
- if (pNewType->num_levels>width)
- width= pNewType->num_levels;
- }
- if ((xkb->ctrls)&&(nGroups>xkb->ctrls->num_groups))
- xkb->ctrls->num_groups= nGroups;
- if ((width!=oldWidth)||(nGroups!=nOldGroups)) {
- KeySym oldSyms[XkbMaxSymsPerKey],*pSyms;
- int nCopy;
-
- if (nOldGroups==0) {
- pSyms= XkbResizeKeySyms(xkb,key,width*nGroups);
- if (pSyms!=NULL) {
- i= xkb->map->key_sym_map[key].group_info;
- i= XkbSetNumGroups(i,nGroups);
- xkb->map->key_sym_map[key].group_info= i;
- xkb->map->key_sym_map[key].width= width;
- for (i=0;i<nGroups;i++) {
- xkb->map->key_sym_map[key].kt_index[i]= newTypes[i];
- }
- return Success;
- }
- return BadAlloc;
- }
- pSyms= XkbKeySymsPtr(xkb,key);
- memcpy(oldSyms,pSyms,XkbKeyNumSyms(xkb,key)*sizeof(KeySym));
- pSyms= XkbResizeKeySyms(xkb,key,width*nGroups);
- if (pSyms==NULL)
- return BadAlloc;
- memset(pSyms, 0, width*nGroups*sizeof(KeySym));
- for (i=0;(i<nGroups)&&(i<nOldGroups);i++) {
- pOldType= XkbKeyKeyType(xkb,key,i);
- pNewType= &xkb->map->types[newTypes[i]];
- if (pNewType->num_levels>pOldType->num_levels)
- nCopy= pOldType->num_levels;
- else nCopy= pNewType->num_levels;
- memcpy(&pSyms[i*width],&oldSyms[i*oldWidth],nCopy*sizeof(KeySym));
- }
- if (XkbKeyHasActions(xkb,key)) {
- XkbAction oldActs[XkbMaxSymsPerKey],*pActs;
- pActs= XkbKeyActionsPtr(xkb,key);
- memcpy(oldActs,pActs,XkbKeyNumSyms(xkb,key)*sizeof(XkbAction));
- pActs= XkbResizeKeyActions(xkb,key,width*nGroups);
- if (pActs==NULL)
- return BadAlloc;
- memset(pActs, 0, width*nGroups*sizeof(XkbAction));
- for (i=0;(i<nGroups)&&(i<nOldGroups);i++) {
- pOldType= XkbKeyKeyType(xkb,key,i);
- pNewType= &xkb->map->types[newTypes[i]];
- if (pNewType->num_levels>pOldType->num_levels)
- nCopy= pOldType->num_levels;
- else nCopy= pNewType->num_levels;
- memcpy(&pActs[i*width],&oldActs[i*oldWidth],
- nCopy*sizeof(XkbAction));
- }
- }
- i= xkb->map->key_sym_map[key].group_info;
- i= XkbSetNumGroups(i,nGroups);
- xkb->map->key_sym_map[key].group_info= i;
- xkb->map->key_sym_map[key].width= width;
- }
- width= 0;
- for (i=0;i<nGroups;i++) {
- xkb->map->key_sym_map[key].kt_index[i]= newTypes[i];
- if (xkb->map->types[newTypes[i]].num_levels>width)
- width= xkb->map->types[newTypes[i]].num_levels;
- }
- xkb->map->key_sym_map[key].width= width;
- if (changes!=NULL) {
- if (changes->changed&XkbKeySymsMask) {
- _XkbAddKeyChange(&changes->first_key_sym,&changes->num_key_syms,
- key);
- }
- else {
- changes->changed|= XkbKeySymsMask;
- changes->first_key_sym= key;
- changes->num_key_syms= 1;
- }
+ XkbKeyTypePtr pOldType, pNewType;
+ register int i;
+ int width, nOldGroups, oldWidth, newTypes[XkbNumKbdGroups];
+
+ if ((!xkb) || (!XkbKeycodeInRange(xkb, key)) || (!xkb->map) ||
+ (!xkb->map->types) || (!newTypesIn) ||
+ ((groups & XkbAllGroupsMask) == 0) || (nGroups > XkbNumKbdGroups)) {
+ return BadMatch;
+ }
+ if (nGroups == 0) {
+ for (i = 0; i < XkbNumKbdGroups; i++) {
+ xkb->map->key_sym_map[key].kt_index[i] = XkbOneLevelIndex;
+ }
+ i = xkb->map->key_sym_map[key].group_info;
+ i = XkbSetNumGroups(i, 0);
+ xkb->map->key_sym_map[key].group_info = i;
+ XkbResizeKeySyms(xkb, key, 0);
+ return Success;
+ }
+
+ nOldGroups = XkbKeyNumGroups(xkb, key);
+ oldWidth = XkbKeyGroupsWidth(xkb, key);
+ for (width = i = 0; i < nGroups; i++) {
+ if (groups & (1 << i))
+ newTypes[i] = newTypesIn[i];
+ else if (i < nOldGroups)
+ newTypes[i] = XkbKeyKeyTypeIndex(xkb, key, i);
+ else if (nOldGroups > 0)
+ newTypes[i] = XkbKeyKeyTypeIndex(xkb, key, XkbGroup1Index);
+ else
+ newTypes[i] = XkbTwoLevelIndex;
+ if (newTypes[i] > xkb->map->num_types)
+ return BadMatch;
+ pNewType = &xkb->map->types[newTypes[i]];
+ if (pNewType->num_levels > width)
+ width = pNewType->num_levels;
+ }
+ if ((xkb->ctrls) && (nGroups > xkb->ctrls->num_groups))
+ xkb->ctrls->num_groups = nGroups;
+ if ((width != oldWidth) || (nGroups != nOldGroups)) {
+ KeySym oldSyms[XkbMaxSymsPerKey], *pSyms;
+ int nCopy;
+
+ if (nOldGroups == 0) {
+ pSyms = XkbResizeKeySyms(xkb, key, width * nGroups);
+ if (pSyms != NULL) {
+ i = xkb->map->key_sym_map[key].group_info;
+ i = XkbSetNumGroups(i, nGroups);
+ xkb->map->key_sym_map[key].group_info = i;
+ xkb->map->key_sym_map[key].width = width;
+ for (i = 0; i < nGroups; i++) {
+ xkb->map->key_sym_map[key].kt_index[i] = newTypes[i];
+ }
+ return Success;
+ }
+ return BadAlloc;
+ }
+ pSyms = XkbKeySymsPtr(xkb, key);
+ memcpy(oldSyms, pSyms, XkbKeyNumSyms(xkb, key) * sizeof(KeySym));
+ pSyms = XkbResizeKeySyms(xkb, key, width * nGroups);
+ if (pSyms == NULL)
+ return BadAlloc;
+ memset(pSyms, 0, width * nGroups * sizeof(KeySym));
+ for (i = 0; (i < nGroups) && (i < nOldGroups); i++) {
+ pOldType = XkbKeyKeyType(xkb, key, i);
+ pNewType = &xkb->map->types[newTypes[i]];
+ if (pNewType->num_levels > pOldType->num_levels)
+ nCopy = pOldType->num_levels;
+ else
+ nCopy = pNewType->num_levels;
+ memcpy(&pSyms[i * width], &oldSyms[i * oldWidth],
+ nCopy * sizeof(KeySym));
+ }
+ if (XkbKeyHasActions(xkb, key)) {
+ XkbAction oldActs[XkbMaxSymsPerKey], *pActs;
+
+ pActs = XkbKeyActionsPtr(xkb, key);
+ memcpy(oldActs, pActs, XkbKeyNumSyms(xkb, key) * sizeof(XkbAction));
+ pActs = XkbResizeKeyActions(xkb, key, width * nGroups);
+ if (pActs == NULL)
+ return BadAlloc;
+ memset(pActs, 0, width * nGroups * sizeof(XkbAction));
+ for (i = 0; (i < nGroups) && (i < nOldGroups); i++) {
+ pOldType = XkbKeyKeyType(xkb, key, i);
+ pNewType = &xkb->map->types[newTypes[i]];
+ if (pNewType->num_levels > pOldType->num_levels)
+ nCopy = pOldType->num_levels;
+ else
+ nCopy = pNewType->num_levels;
+ memcpy(&pActs[i * width], &oldActs[i * oldWidth],
+ nCopy * sizeof(XkbAction));
+ }
+ }
+ i = xkb->map->key_sym_map[key].group_info;
+ i = XkbSetNumGroups(i, nGroups);
+ xkb->map->key_sym_map[key].group_info = i;
+ xkb->map->key_sym_map[key].width = width;
+ }
+ width = 0;
+ for (i = 0; i < nGroups; i++) {
+ xkb->map->key_sym_map[key].kt_index[i] = newTypes[i];
+ if (xkb->map->types[newTypes[i]].num_levels > width)
+ width = xkb->map->types[newTypes[i]].num_levels;
+ }
+ xkb->map->key_sym_map[key].width = width;
+ if (changes != NULL) {
+ if (changes->changed & XkbKeySymsMask) {
+ _XkbAddKeyChange(&changes->first_key_sym, &changes->num_key_syms,
+ key);
+ }
+ else {
+ changes->changed |= XkbKeySymsMask;
+ changes->first_key_sym = key;
+ changes->num_key_syms = 1;
+ }
}
return Success;
}
@@ -637,204 +660,221 @@ int width,nOldGroups,oldWidth,newTypes[XkbNumKbdGroups];
/***====================================================================***/
Bool
-XkbVirtualModsToReal(XkbDescPtr xkb,unsigned virtual_mask,unsigned *mask_rtrn)
+XkbVirtualModsToReal(XkbDescPtr xkb, unsigned virtual_mask, unsigned *mask_rtrn)
{
-register int i,bit;
-register unsigned mask;
-
- if (xkb==NULL)
- return FALSE;
- if (virtual_mask==0) {
- *mask_rtrn= 0;
- return TRUE;
- }
- if (xkb->server==NULL)
- return FALSE;
- for (i=mask=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
- if (virtual_mask&bit)
- mask|= xkb->server->vmods[i];
- }
- *mask_rtrn= mask;
+ register int i, bit;
+ register unsigned mask;
+
+ if (xkb == NULL)
+ return FALSE;
+ if (virtual_mask == 0) {
+ *mask_rtrn = 0;
+ return TRUE;
+ }
+ if (xkb->server == NULL)
+ return FALSE;
+ for (i = mask = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+ if (virtual_mask & bit)
+ mask |= xkb->server->vmods[i];
+ }
+ *mask_rtrn = mask;
return TRUE;
}
/***====================================================================***/
static Bool
-XkbUpdateActionVirtualMods(XkbDescPtr xkb,XkbAction *act,unsigned changed)
+XkbUpdateActionVirtualMods(XkbDescPtr xkb, XkbAction *act, unsigned changed)
{
-unsigned int tmp;
+ unsigned int tmp;
switch (act->type) {
- case XkbSA_SetMods: case XkbSA_LatchMods: case XkbSA_LockMods:
- if (((tmp= XkbModActionVMods(&act->mods))&changed)!=0) {
- XkbVirtualModsToReal(xkb,tmp,&tmp);
- act->mods.mask= act->mods.real_mods;
- act->mods.mask|= tmp;
- return TRUE;
- }
- break;
- case XkbSA_ISOLock:
- if ((((tmp= XkbModActionVMods(&act->iso))!=0)&changed)!=0) {
- XkbVirtualModsToReal(xkb,tmp,&tmp);
- act->iso.mask= act->iso.real_mods;
- act->iso.mask|= tmp;
- return TRUE;
- }
- break;
+ case XkbSA_SetMods:
+ case XkbSA_LatchMods:
+ case XkbSA_LockMods:
+ if (((tmp = XkbModActionVMods(&act->mods)) & changed) != 0) {
+ XkbVirtualModsToReal(xkb, tmp, &tmp);
+ act->mods.mask = act->mods.real_mods;
+ act->mods.mask |= tmp;
+ return TRUE;
+ }
+ break;
+ case XkbSA_ISOLock:
+ if ((((tmp = XkbModActionVMods(&act->iso)) != 0) & changed) != 0) {
+ XkbVirtualModsToReal(xkb, tmp, &tmp);
+ act->iso.mask = act->iso.real_mods;
+ act->iso.mask |= tmp;
+ return TRUE;
+ }
+ break;
}
return FALSE;
}
static void
-XkbUpdateKeyTypeVirtualMods( XkbDescPtr xkb,
- XkbKeyTypePtr type,
- unsigned int changed,
- XkbChangesPtr changes)
+XkbUpdateKeyTypeVirtualMods(XkbDescPtr xkb,
+ XkbKeyTypePtr type,
+ unsigned int changed, XkbChangesPtr changes)
{
-register unsigned int i;
-unsigned int mask;
-
- XkbVirtualModsToReal(xkb,type->mods.vmods,&mask);
- type->mods.mask= type->mods.real_mods|mask;
- if ((type->map_count>0)&&(type->mods.vmods!=0)) {
- XkbKTMapEntryPtr entry;
- for (i=0,entry=type->map;i<type->map_count;i++,entry++) {
- if (entry->mods.vmods!=0) {
- XkbVirtualModsToReal(xkb,entry->mods.vmods,&mask);
- entry->mods.mask=entry->mods.real_mods|mask;
- /* entry is active if vmods are bound*/
- entry->active= (mask!=0);
- }
- else entry->active= 1;
- }
+ register unsigned int i;
+ unsigned int mask;
+
+ XkbVirtualModsToReal(xkb, type->mods.vmods, &mask);
+ type->mods.mask = type->mods.real_mods | mask;
+ if ((type->map_count > 0) && (type->mods.vmods != 0)) {
+ XkbKTMapEntryPtr entry;
+
+ for (i = 0, entry = type->map; i < type->map_count; i++, entry++) {
+ if (entry->mods.vmods != 0) {
+ XkbVirtualModsToReal(xkb, entry->mods.vmods, &mask);
+ entry->mods.mask = entry->mods.real_mods | mask;
+ /* entry is active if vmods are bound */
+ entry->active = (mask != 0);
+ }
+ else
+ entry->active = 1;
+ }
}
if (changes) {
- int type_ndx;
- type_ndx= type-xkb->map->types;
- if ((type_ndx<0)||(type_ndx>xkb->map->num_types))
- return;
- if (changes->map.changed&XkbKeyTypesMask) {
- int last;
- last= changes->map.first_type+changes->map.num_types-1;
- if (type_ndx<changes->map.first_type) {
- changes->map.first_type= type_ndx;
- changes->map.num_types= (last-type_ndx)+1;
- }
- else if (type_ndx>last) {
- changes->map.num_types= (type_ndx-changes->map.first_type)+1;
- }
- }
- else {
- changes->map.changed|= XkbKeyTypesMask;
- changes->map.first_type= type_ndx;
- changes->map.num_types= 1;
- }
+ int type_ndx;
+
+ type_ndx = type - xkb->map->types;
+ if ((type_ndx < 0) || (type_ndx > xkb->map->num_types))
+ return;
+ if (changes->map.changed & XkbKeyTypesMask) {
+ int last;
+
+ last = changes->map.first_type + changes->map.num_types - 1;
+ if (type_ndx < changes->map.first_type) {
+ changes->map.first_type = type_ndx;
+ changes->map.num_types = (last - type_ndx) + 1;
+ }
+ else if (type_ndx > last) {
+ changes->map.num_types =
+ (type_ndx - changes->map.first_type) + 1;
+ }
+ }
+ else {
+ changes->map.changed |= XkbKeyTypesMask;
+ changes->map.first_type = type_ndx;
+ changes->map.num_types = 1;
+ }
}
return;
}
Bool
-XkbApplyVirtualModChanges(XkbDescPtr xkb,unsigned changed,XkbChangesPtr changes)
+XkbApplyVirtualModChanges(XkbDescPtr xkb, unsigned changed,
+ XkbChangesPtr changes)
{
-register int i;
-unsigned int checkState = 0;
-
- if ((!xkb) || (!xkb->map) || (changed==0))
- return FALSE;
- for (i=0;i<xkb->map->num_types;i++) {
- if (xkb->map->types[i].mods.vmods & changed)
- XkbUpdateKeyTypeVirtualMods(xkb,&xkb->map->types[i],changed,changes);
- }
- if (changed&xkb->ctrls->internal.vmods) {
- unsigned int newMask;
- XkbVirtualModsToReal(xkb,xkb->ctrls->internal.vmods,&newMask);
- newMask|= xkb->ctrls->internal.real_mods;
- if (xkb->ctrls->internal.mask!=newMask) {
- xkb->ctrls->internal.mask= newMask;
- if (changes) {
- changes->ctrls.changed_ctrls|= XkbInternalModsMask;
- checkState= TRUE;
- }
- }
- }
- if (changed&xkb->ctrls->ignore_lock.vmods) {
- unsigned int newMask;
- XkbVirtualModsToReal(xkb,xkb->ctrls->ignore_lock.vmods,&newMask);
- newMask|= xkb->ctrls->ignore_lock.real_mods;
- if (xkb->ctrls->ignore_lock.mask!=newMask) {
- xkb->ctrls->ignore_lock.mask= newMask;
- if (changes) {
- changes->ctrls.changed_ctrls|= XkbIgnoreLockModsMask;
- checkState= TRUE;
- }
- }
- }
- if (xkb->indicators!=NULL) {
- XkbIndicatorMapPtr map;
- map= &xkb->indicators->maps[0];
- for (i=0;i<XkbNumIndicators;i++,map++) {
- if (map->mods.vmods&changed) {
- unsigned int newMask;
- XkbVirtualModsToReal(xkb,map->mods.vmods,&newMask);
- newMask|= map->mods.real_mods;
- if (newMask!=map->mods.mask) {
- map->mods.mask= newMask;
- if (changes) {
- changes->indicators.map_changes|= (1<<i);
- checkState= TRUE;
- }
- }
- }
- }
- }
- if (xkb->compat!=NULL) {
- XkbCompatMapPtr compat;
- compat= xkb->compat;
- for (i=0;i<XkbNumKbdGroups;i++) {
- unsigned int newMask;
- XkbVirtualModsToReal(xkb,compat->groups[i].vmods,&newMask);
- newMask|= compat->groups[i].real_mods;
- if (compat->groups[i].mask!=newMask) {
- compat->groups[i].mask= newMask;
- if (changes) {
- changes->compat.changed_groups|= (1<<i);
- checkState= TRUE;
- }
- }
- }
+ register int i;
+ unsigned int checkState = 0;
+
+ if ((!xkb) || (!xkb->map) || (changed == 0))
+ return FALSE;
+ for (i = 0; i < xkb->map->num_types; i++) {
+ if (xkb->map->types[i].mods.vmods & changed)
+ XkbUpdateKeyTypeVirtualMods(xkb, &xkb->map->types[i], changed,
+ changes);
+ }
+ if (changed & xkb->ctrls->internal.vmods) {
+ unsigned int newMask;
+
+ XkbVirtualModsToReal(xkb, xkb->ctrls->internal.vmods, &newMask);
+ newMask |= xkb->ctrls->internal.real_mods;
+ if (xkb->ctrls->internal.mask != newMask) {
+ xkb->ctrls->internal.mask = newMask;
+ if (changes) {
+ changes->ctrls.changed_ctrls |= XkbInternalModsMask;
+ checkState = TRUE;
+ }
+ }
+ }
+ if (changed & xkb->ctrls->ignore_lock.vmods) {
+ unsigned int newMask;
+
+ XkbVirtualModsToReal(xkb, xkb->ctrls->ignore_lock.vmods, &newMask);
+ newMask |= xkb->ctrls->ignore_lock.real_mods;
+ if (xkb->ctrls->ignore_lock.mask != newMask) {
+ xkb->ctrls->ignore_lock.mask = newMask;
+ if (changes) {
+ changes->ctrls.changed_ctrls |= XkbIgnoreLockModsMask;
+ checkState = TRUE;
+ }
+ }
+ }
+ if (xkb->indicators != NULL) {
+ XkbIndicatorMapPtr map;
+
+ map = &xkb->indicators->maps[0];
+ for (i = 0; i < XkbNumIndicators; i++, map++) {
+ if (map->mods.vmods & changed) {
+ unsigned int newMask;
+
+ XkbVirtualModsToReal(xkb, map->mods.vmods, &newMask);
+ newMask |= map->mods.real_mods;
+ if (newMask != map->mods.mask) {
+ map->mods.mask = newMask;
+ if (changes) {
+ changes->indicators.map_changes |= (1 << i);
+ checkState = TRUE;
+ }
+ }
+ }
+ }
+ }
+ if (xkb->compat != NULL) {
+ XkbCompatMapPtr compat;
+
+ compat = xkb->compat;
+ for (i = 0; i < XkbNumKbdGroups; i++) {
+ unsigned int newMask;
+
+ XkbVirtualModsToReal(xkb, compat->groups[i].vmods, &newMask);
+ newMask |= compat->groups[i].real_mods;
+ if (compat->groups[i].mask != newMask) {
+ compat->groups[i].mask = newMask;
+ if (changes) {
+ changes->compat.changed_groups |= (1 << i);
+ checkState = TRUE;
+ }
+ }
+ }
}
if (xkb->map && xkb->server) {
- int highChange = 0, lowChange = -1;
- for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
- if (XkbKeyHasActions(xkb,i)) {
- register XkbAction *pAct;
- register int n;
-
- pAct= XkbKeyActionsPtr(xkb,i);
- for (n=XkbKeyNumActions(xkb,i);n>0;n--,pAct++) {
- if ((pAct->type!=XkbSA_NoAction)&&
- XkbUpdateActionVirtualMods(xkb,pAct,changed)) {
- if (lowChange<0)
- lowChange= i;
- highChange= i;
- }
- }
- }
- }
- if (changes && (lowChange>0)) { /* something changed */
- if (changes->map.changed&XkbKeyActionsMask) {
- int last;
- if (changes->map.first_key_act<lowChange)
- lowChange= changes->map.first_key_act;
- last= changes->map.first_key_act+changes->map.num_key_acts-1;
- if (last>highChange)
- highChange= last;
- }
- changes->map.changed|= XkbKeyActionsMask;
- changes->map.first_key_act= lowChange;
- changes->map.num_key_acts= (highChange-lowChange)+1;
- }
+ int highChange = 0, lowChange = -1;
+
+ for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+ if (XkbKeyHasActions(xkb, i)) {
+ register XkbAction *pAct;
+ register int n;
+
+ pAct = XkbKeyActionsPtr(xkb, i);
+ for (n = XkbKeyNumActions(xkb, i); n > 0; n--, pAct++) {
+ if ((pAct->type != XkbSA_NoAction) &&
+ XkbUpdateActionVirtualMods(xkb, pAct, changed)) {
+ if (lowChange < 0)
+ lowChange = i;
+ highChange = i;
+ }
+ }
+ }
+ }
+ if (changes && (lowChange > 0)) { /* something changed */
+ if (changes->map.changed & XkbKeyActionsMask) {
+ int last;
+
+ if (changes->map.first_key_act < lowChange)
+ lowChange = changes->map.first_key_act;
+ last =
+ changes->map.first_key_act + changes->map.num_key_acts - 1;
+ if (last > highChange)
+ highChange = last;
+ }
+ changes->map.changed |= XkbKeyActionsMask;
+ changes->map.first_key_act = lowChange;
+ changes->map.num_key_acts = (highChange - lowChange) + 1;
+ }
}
return checkState;
}
diff --git a/xkb/ddxBeep.c b/xkb/ddxBeep.c
index 6f74cb541..f95d0ee81 100644
--- a/xkb/ddxBeep.c
+++ b/xkb/ddxBeep.c
@@ -55,23 +55,23 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#define HIGH_PITCH 2000
#define CLICK_PITCH 1500
-static unsigned long atomGeneration= 0;
-static Atom featureOn;
-static Atom featureOff;
-static Atom featureChange;
-static Atom ledOn;
-static Atom ledOff;
-static Atom ledChange;
-static Atom slowWarn;
-static Atom slowPress;
-static Atom slowReject;
-static Atom slowAccept;
-static Atom slowRelease;
-static Atom stickyLatch;
-static Atom stickyLock;
-static Atom stickyUnlock;
-static Atom bounceReject;
-static char doesPitch = 1;
+static unsigned long atomGeneration = 0;
+static Atom featureOn;
+static Atom featureOff;
+static Atom featureChange;
+static Atom ledOn;
+static Atom ledOff;
+static Atom ledChange;
+static Atom slowWarn;
+static Atom slowPress;
+static Atom slowReject;
+static Atom slowAccept;
+static Atom slowRelease;
+static Atom stickyLatch;
+static Atom stickyLock;
+static Atom stickyUnlock;
+static Atom bounceReject;
+static char doesPitch = 1;
#define FEATURE_ON "AX_FeatureOn"
#define FEATURE_OFF "AX_FeatureOff"
@@ -94,238 +94,257 @@ static char doesPitch = 1;
static void
_XkbDDXBeepInitAtoms(void)
{
- featureOn= MAKE_ATOM(FEATURE_ON);
- featureOff= MAKE_ATOM(FEATURE_OFF);
- featureChange= MAKE_ATOM(FEATURE_CHANGE);
- ledOn= MAKE_ATOM(LED_ON);
- ledOff= MAKE_ATOM(LED_OFF);
- ledChange= MAKE_ATOM(LED_CHANGE);
- slowWarn= MAKE_ATOM(SLOW_WARN);
- slowPress= MAKE_ATOM(SLOW_PRESS);
- slowReject= MAKE_ATOM(SLOW_REJECT);
- slowAccept= MAKE_ATOM(SLOW_ACCEPT);
- slowRelease= MAKE_ATOM(SLOW_RELEASE);
- stickyLatch= MAKE_ATOM(STICKY_LATCH);
- stickyLock= MAKE_ATOM(STICKY_LOCK);
- stickyUnlock= MAKE_ATOM(STICKY_UNLOCK);
- bounceReject= MAKE_ATOM(BOUNCE_REJECT);
+ featureOn = MAKE_ATOM(FEATURE_ON);
+ featureOff = MAKE_ATOM(FEATURE_OFF);
+ featureChange = MAKE_ATOM(FEATURE_CHANGE);
+ ledOn = MAKE_ATOM(LED_ON);
+ ledOff = MAKE_ATOM(LED_OFF);
+ ledChange = MAKE_ATOM(LED_CHANGE);
+ slowWarn = MAKE_ATOM(SLOW_WARN);
+ slowPress = MAKE_ATOM(SLOW_PRESS);
+ slowReject = MAKE_ATOM(SLOW_REJECT);
+ slowAccept = MAKE_ATOM(SLOW_ACCEPT);
+ slowRelease = MAKE_ATOM(SLOW_RELEASE);
+ stickyLatch = MAKE_ATOM(STICKY_LATCH);
+ stickyLock = MAKE_ATOM(STICKY_LOCK);
+ stickyUnlock = MAKE_ATOM(STICKY_UNLOCK);
+ bounceReject = MAKE_ATOM(BOUNCE_REJECT);
return;
}
static CARD32
-_XkbDDXBeepExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+_XkbDDXBeepExpire(OsTimerPtr timer, CARD32 now, pointer arg)
{
-DeviceIntPtr dev= (DeviceIntPtr)arg;
-KbdFeedbackPtr feed;
-KeybdCtrl * ctrl;
-XkbSrvInfoPtr xkbInfo;
-CARD32 next;
-int pitch,duration;
-int oldPitch,oldDuration;
-Atom name;
+ DeviceIntPtr dev = (DeviceIntPtr) arg;
+ KbdFeedbackPtr feed;
+ KeybdCtrl *ctrl;
+ XkbSrvInfoPtr xkbInfo;
+ CARD32 next;
+ int pitch, duration;
+ int oldPitch, oldDuration;
+ Atom name;
- if ((dev==NULL)||(dev->key==NULL)||(dev->key->xkbInfo==NULL)||
- (dev->kbdfeed==NULL))
- return 0;
- if (atomGeneration!=serverGeneration) {
- _XkbDDXBeepInitAtoms();
- atomGeneration= serverGeneration;
+ if ((dev == NULL) || (dev->key == NULL) || (dev->key->xkbInfo == NULL) ||
+ (dev->kbdfeed == NULL))
+ return 0;
+ if (atomGeneration != serverGeneration) {
+ _XkbDDXBeepInitAtoms();
+ atomGeneration = serverGeneration;
}
- feed= dev->kbdfeed;
- ctrl= &feed->ctrl;
- xkbInfo= dev->key->xkbInfo;
- next= 0;
- pitch= oldPitch= ctrl->bell_pitch;
- duration= oldDuration= ctrl->bell_duration;
- name= None;
+ feed = dev->kbdfeed;
+ ctrl = &feed->ctrl;
+ xkbInfo = dev->key->xkbInfo;
+ next = 0;
+ pitch = oldPitch = ctrl->bell_pitch;
+ duration = oldDuration = ctrl->bell_duration;
+ name = None;
switch (xkbInfo->beepType) {
- default:
- ErrorF("[xkb] Unknown beep type %d\n",xkbInfo->beepType);
- case _BEEP_NONE:
- duration= 0;
- break;
+ default:
+ ErrorF("[xkb] Unknown beep type %d\n", xkbInfo->beepType);
+ case _BEEP_NONE:
+ duration = 0;
+ break;
- /* When an LED is turned on, we want a high-pitched beep.
- * When the LED it turned off, we want a low-pitched beep.
- * If we cannot do pitch, we want a single beep for on and two
- * beeps for off.
+ /* When an LED is turned on, we want a high-pitched beep.
+ * When the LED it turned off, we want a low-pitched beep.
+ * If we cannot do pitch, we want a single beep for on and two
+ * beeps for off.
*/
- case _BEEP_LED_ON:
- if (name==None) name= ledOn;
- duration= SHORT_TONE;
- pitch= HIGH_PITCH;
- break;
- case _BEEP_LED_OFF:
- if (name==None) name= ledOff;
- duration= SHORT_TONE;
- pitch= LOW_PITCH;
- if (!doesPitch && xkbInfo->beepCount<1)
- next = SHORT_DELAY;
- break;
+ case _BEEP_LED_ON:
+ if (name == None)
+ name = ledOn;
+ duration = SHORT_TONE;
+ pitch = HIGH_PITCH;
+ break;
+ case _BEEP_LED_OFF:
+ if (name == None)
+ name = ledOff;
+ duration = SHORT_TONE;
+ pitch = LOW_PITCH;
+ if (!doesPitch && xkbInfo->beepCount < 1)
+ next = SHORT_DELAY;
+ break;
- /* When a Feature is turned on, we want an up-siren.
- * When a Feature is turned off, we want a down-siren.
- * If we cannot do pitch, we want a single beep for on and two
- * beeps for off.
+ /* When a Feature is turned on, we want an up-siren.
+ * When a Feature is turned off, we want a down-siren.
+ * If we cannot do pitch, we want a single beep for on and two
+ * beeps for off.
*/
- case _BEEP_FEATURE_ON:
- if (name==None) name= featureOn;
- if (xkbInfo->beepCount<1) {
- pitch= LOW_PITCH;
- duration= VERY_LONG_TONE;
- if (doesPitch)
- next= SHORT_DELAY;
- }
- else {
- pitch= MID_PITCH;
- duration= SHORT_TONE;
- }
- break;
+ case _BEEP_FEATURE_ON:
+ if (name == None)
+ name = featureOn;
+ if (xkbInfo->beepCount < 1) {
+ pitch = LOW_PITCH;
+ duration = VERY_LONG_TONE;
+ if (doesPitch)
+ next = SHORT_DELAY;
+ }
+ else {
+ pitch = MID_PITCH;
+ duration = SHORT_TONE;
+ }
+ break;
- case _BEEP_FEATURE_OFF:
- if (name==None) name= featureOff;
- if (xkbInfo->beepCount<1) {
- pitch= MID_PITCH;
- if (doesPitch)
- duration= VERY_LONG_TONE;
- else duration= SHORT_TONE;
- next= SHORT_DELAY;
- }
- else {
- pitch= LOW_PITCH;
- duration= SHORT_TONE;
- }
- break;
+ case _BEEP_FEATURE_OFF:
+ if (name == None)
+ name = featureOff;
+ if (xkbInfo->beepCount < 1) {
+ pitch = MID_PITCH;
+ if (doesPitch)
+ duration = VERY_LONG_TONE;
+ else
+ duration = SHORT_TONE;
+ next = SHORT_DELAY;
+ }
+ else {
+ pitch = LOW_PITCH;
+ duration = SHORT_TONE;
+ }
+ break;
- /* Two high beeps indicate an LED or Feature changed
- * state, but that another LED or Feature is also on.
- * [[[WDW - This is not in AccessDOS ]]]
- */
- case _BEEP_LED_CHANGE:
- if (name==None) name= ledChange;
- case _BEEP_FEATURE_CHANGE:
- if (name==None) name= featureChange;
- duration= SHORT_TONE;
- pitch= HIGH_PITCH;
- if (xkbInfo->beepCount<1) {
- next= SHORT_DELAY;
- }
- break;
+ /* Two high beeps indicate an LED or Feature changed
+ * state, but that another LED or Feature is also on.
+ * [[[WDW - This is not in AccessDOS ]]]
+ */
+ case _BEEP_LED_CHANGE:
+ if (name == None)
+ name = ledChange;
+ case _BEEP_FEATURE_CHANGE:
+ if (name == None)
+ name = featureChange;
+ duration = SHORT_TONE;
+ pitch = HIGH_PITCH;
+ if (xkbInfo->beepCount < 1) {
+ next = SHORT_DELAY;
+ }
+ break;
- /* Three high-pitched beeps are the warning that SlowKeys
- * is going to be turned on or off.
- */
- case _BEEP_SLOW_WARN:
- if (name==None) name= slowWarn;
- duration= SHORT_TONE;
- pitch= HIGH_PITCH;
- if (xkbInfo->beepCount<2)
- next= SHORT_DELAY;
- break;
+ /* Three high-pitched beeps are the warning that SlowKeys
+ * is going to be turned on or off.
+ */
+ case _BEEP_SLOW_WARN:
+ if (name == None)
+ name = slowWarn;
+ duration = SHORT_TONE;
+ pitch = HIGH_PITCH;
+ if (xkbInfo->beepCount < 2)
+ next = SHORT_DELAY;
+ break;
- /* Click on SlowKeys press and accept.
- * Deep pitch when a SlowKey or BounceKey is rejected.
- * [[[WDW - Rejects are not in AccessDOS ]]]
- * If we cannot do pitch, we want single beeps.
- */
- case _BEEP_SLOW_PRESS:
- if (name==None) name= slowPress;
- case _BEEP_SLOW_ACCEPT:
- if (name==None) name= slowAccept;
- case _BEEP_SLOW_RELEASE:
- if (name==None) name= slowRelease;
- duration= CLICK_DURATION;
- pitch= CLICK_PITCH;
- break;
- case _BEEP_BOUNCE_REJECT:
- if (name==None) name= bounceReject;
- case _BEEP_SLOW_REJECT:
- if (name==None) name= slowReject;
- duration= SHORT_TONE;
- pitch= DEEP_PITCH;
- break;
+ /* Click on SlowKeys press and accept.
+ * Deep pitch when a SlowKey or BounceKey is rejected.
+ * [[[WDW - Rejects are not in AccessDOS ]]]
+ * If we cannot do pitch, we want single beeps.
+ */
+ case _BEEP_SLOW_PRESS:
+ if (name == None)
+ name = slowPress;
+ case _BEEP_SLOW_ACCEPT:
+ if (name == None)
+ name = slowAccept;
+ case _BEEP_SLOW_RELEASE:
+ if (name == None)
+ name = slowRelease;
+ duration = CLICK_DURATION;
+ pitch = CLICK_PITCH;
+ break;
+ case _BEEP_BOUNCE_REJECT:
+ if (name == None)
+ name = bounceReject;
+ case _BEEP_SLOW_REJECT:
+ if (name == None)
+ name = slowReject;
+ duration = SHORT_TONE;
+ pitch = DEEP_PITCH;
+ break;
- /* Low followed by high pitch when a StickyKey is latched.
- * High pitch when a StickyKey is locked.
- * Low pitch when unlocked.
+ /* Low followed by high pitch when a StickyKey is latched.
+ * High pitch when a StickyKey is locked.
+ * Low pitch when unlocked.
* If we cannot do pitch, two beeps for latch, nothing for
- * lock, and two for unlock.
- */
- case _BEEP_STICKY_LATCH:
- if (name==None) name= stickyLatch;
- duration= SHORT_TONE;
- if (xkbInfo->beepCount<1) {
- next= SHORT_DELAY;
- pitch= LOW_PITCH;
- }
- else pitch= HIGH_PITCH;
- break;
- case _BEEP_STICKY_LOCK:
- if (name==None) name= stickyLock;
- if (doesPitch) {
- duration= SHORT_TONE;
- pitch= HIGH_PITCH;
- }
- break;
- case _BEEP_STICKY_UNLOCK:
- if (name==None) name= stickyUnlock;
- duration= SHORT_TONE;
- pitch= LOW_PITCH;
- if (!doesPitch && xkbInfo->beepCount<1)
- next = SHORT_DELAY;
- break;
+ * lock, and two for unlock.
+ */
+ case _BEEP_STICKY_LATCH:
+ if (name == None)
+ name = stickyLatch;
+ duration = SHORT_TONE;
+ if (xkbInfo->beepCount < 1) {
+ next = SHORT_DELAY;
+ pitch = LOW_PITCH;
+ }
+ else
+ pitch = HIGH_PITCH;
+ break;
+ case _BEEP_STICKY_LOCK:
+ if (name == None)
+ name = stickyLock;
+ if (doesPitch) {
+ duration = SHORT_TONE;
+ pitch = HIGH_PITCH;
+ }
+ break;
+ case _BEEP_STICKY_UNLOCK:
+ if (name == None)
+ name = stickyUnlock;
+ duration = SHORT_TONE;
+ pitch = LOW_PITCH;
+ if (!doesPitch && xkbInfo->beepCount < 1)
+ next = SHORT_DELAY;
+ break;
}
- if (timer == NULL && duration>0) {
- CARD32 starttime = GetTimeInMillis();
- CARD32 elapsedtime;
+ if (timer == NULL && duration > 0) {
+ CARD32 starttime = GetTimeInMillis();
+ CARD32 elapsedtime;
- ctrl->bell_duration= duration;
- ctrl->bell_pitch= pitch;
- if (xkbInfo->beepCount==0) {
- XkbHandleBell(0,0,dev,ctrl->bell,(pointer)ctrl,KbdFeedbackClass,name,None,
- NULL);
- }
- else if (xkbInfo->desc->ctrls->enabled_ctrls&XkbAudibleBellMask) {
- (*dev->kbdfeed->BellProc)(ctrl->bell,dev,(pointer)ctrl,KbdFeedbackClass);
- }
- ctrl->bell_duration= oldDuration;
- ctrl->bell_pitch= oldPitch;
- xkbInfo->beepCount++;
+ ctrl->bell_duration = duration;
+ ctrl->bell_pitch = pitch;
+ if (xkbInfo->beepCount == 0) {
+ XkbHandleBell(0, 0, dev, ctrl->bell, (pointer) ctrl,
+ KbdFeedbackClass, name, None, NULL);
+ }
+ else if (xkbInfo->desc->ctrls->enabled_ctrls & XkbAudibleBellMask) {
+ (*dev->kbdfeed->BellProc) (ctrl->bell, dev, (pointer) ctrl,
+ KbdFeedbackClass);
+ }
+ ctrl->bell_duration = oldDuration;
+ ctrl->bell_pitch = oldPitch;
+ xkbInfo->beepCount++;
- /* Some DDX schedule the beep and return immediately, others don't
- return until the beep is completed. We measure the time and if
- it's less than the beep duration, make sure not to schedule the
- next beep until after the current one finishes. */
+ /* Some DDX schedule the beep and return immediately, others don't
+ return until the beep is completed. We measure the time and if
+ it's less than the beep duration, make sure not to schedule the
+ next beep until after the current one finishes. */
- elapsedtime = GetTimeInMillis();
- if (elapsedtime > starttime) { /* watch out for millisecond counter
- overflow! */
- elapsedtime -= starttime;
- } else {
- elapsedtime = 0;
- }
- if (elapsedtime < duration) {
- next += duration - elapsedtime;
- }
+ elapsedtime = GetTimeInMillis();
+ if (elapsedtime > starttime) { /* watch out for millisecond counter
+ overflow! */
+ elapsedtime -= starttime;
+ }
+ else {
+ elapsedtime = 0;
+ }
+ if (elapsedtime < duration) {
+ next += duration - elapsedtime;
+ }
}
return next;
}
int
-XkbDDXAccessXBeep(DeviceIntPtr dev,unsigned what,unsigned which)
+XkbDDXAccessXBeep(DeviceIntPtr dev, unsigned what, unsigned which)
{
-XkbSrvInfoRec *xkbInfo= dev->key->xkbInfo;
-CARD32 next;
+ XkbSrvInfoRec *xkbInfo = dev->key->xkbInfo;
+ CARD32 next;
- xkbInfo->beepType= what;
- xkbInfo->beepCount= 0;
- next= _XkbDDXBeepExpire(NULL,0,(pointer)dev);
- if (next>0) {
- xkbInfo->beepTimer= TimerSet(xkbInfo->beepTimer,
- 0, next,
- _XkbDDXBeepExpire, (pointer)dev);
+ xkbInfo->beepType = what;
+ xkbInfo->beepCount = 0;
+ next = _XkbDDXBeepExpire(NULL, 0, (pointer) dev);
+ if (next > 0) {
+ xkbInfo->beepTimer = TimerSet(xkbInfo->beepTimer,
+ 0, next,
+ _XkbDDXBeepExpire, (pointer) dev);
}
return 1;
}
diff --git a/xkb/ddxCtrls.c b/xkb/ddxCtrls.c
index 04de608df..0805fb208 100644
--- a/xkb/ddxCtrls.c
+++ b/xkb/ddxCtrls.c
@@ -39,20 +39,19 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <X11/extensions/XI.h>
void
-XkbDDXKeybdCtrlProc(DeviceIntPtr dev,KeybdCtrl *ctrl)
+XkbDDXKeybdCtrlProc(DeviceIntPtr dev, KeybdCtrl * ctrl)
{
-int realRepeat;
+ int realRepeat;
- realRepeat= ctrl->autoRepeat;
- if ((dev->kbdfeed)&&(XkbDDXUsesSoftRepeat(dev)))
- ctrl->autoRepeat= 0;
+ realRepeat = ctrl->autoRepeat;
+ if ((dev->kbdfeed) && (XkbDDXUsesSoftRepeat(dev)))
+ ctrl->autoRepeat = 0;
if (dev->key && dev->key->xkbInfo && dev->key->xkbInfo->kbdProc)
- (*dev->key->xkbInfo->kbdProc)(dev,ctrl);
- ctrl->autoRepeat= realRepeat;
+ (*dev->key->xkbInfo->kbdProc) (dev, ctrl);
+ ctrl->autoRepeat = realRepeat;
return;
}
-
int
XkbDDXUsesSoftRepeat(DeviceIntPtr pXDev)
{
@@ -60,15 +59,15 @@ XkbDDXUsesSoftRepeat(DeviceIntPtr pXDev)
}
void
-XkbDDXChangeControls(DeviceIntPtr dev,XkbControlsPtr old,XkbControlsPtr new)
+XkbDDXChangeControls(DeviceIntPtr dev, XkbControlsPtr old, XkbControlsPtr new)
{
-unsigned changed, i;
-unsigned char *rep_old, *rep_new, *rep_fb;
+ unsigned changed, i;
+ unsigned char *rep_old, *rep_new, *rep_fb;
- changed= new->enabled_ctrls^old->enabled_ctrls;
+ changed = new->enabled_ctrls ^ old->enabled_ctrls;
for (rep_old = old->per_key_repeat,
rep_new = new->per_key_repeat,
- rep_fb = dev->kbdfeed->ctrl.autoRepeats,
+ rep_fb = dev->kbdfeed->ctrl.autoRepeats,
i = 0; i < XkbPerKeyBitArraySize; i++) {
if (rep_old[i] != rep_new[i]) {
rep_fb[i] = rep_new[i];
@@ -76,10 +75,9 @@ unsigned char *rep_old, *rep_new, *rep_fb;
}
}
- if (changed&XkbPerKeyRepeatMask) {
- if (dev->kbdfeed->CtrlProc)
- (*dev->kbdfeed->CtrlProc)(dev,&dev->kbdfeed->ctrl);
+ if (changed & XkbPerKeyRepeatMask) {
+ if (dev->kbdfeed->CtrlProc)
+ (*dev->kbdfeed->CtrlProc) (dev, &dev->kbdfeed->ctrl);
}
return;
}
-
diff --git a/xkb/ddxKillSrv.c b/xkb/ddxKillSrv.c
index 106b39587..1cabb1bd7 100644
--- a/xkb/ddxKillSrv.c
+++ b/xkb/ddxKillSrv.c
@@ -38,7 +38,7 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <xkbsrv.h>
int
-XkbDDXTerminateServer(DeviceIntPtr dev,KeyCode key,XkbAction *act)
+XkbDDXTerminateServer(DeviceIntPtr dev, KeyCode key, XkbAction *act)
{
if (dev != inputInfo.keyboard)
GiveUp(1);
diff --git a/xkb/ddxLEDs.c b/xkb/ddxLEDs.c
index 246d58c31..81b7b00e0 100644
--- a/xkb/ddxLEDs.c
+++ b/xkb/ddxLEDs.c
@@ -39,33 +39,33 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <X11/extensions/XI.h>
static void
-XkbDDXUpdateIndicators(DeviceIntPtr dev,CARD32 new)
+XkbDDXUpdateIndicators(DeviceIntPtr dev, CARD32 new)
{
- dev->kbdfeed->ctrl.leds= new;
- (*dev->kbdfeed->CtrlProc)(dev,&dev->kbdfeed->ctrl);
+ dev->kbdfeed->ctrl.leds = new;
+ (*dev->kbdfeed->CtrlProc) (dev, &dev->kbdfeed->ctrl);
return;
}
void
-XkbDDXUpdateDeviceIndicators( DeviceIntPtr dev,
- XkbSrvLedInfoPtr sli,
- CARD32 new)
+XkbDDXUpdateDeviceIndicators(DeviceIntPtr dev, XkbSrvLedInfoPtr sli, CARD32 new)
{
- if (sli->fb.kf==dev->kbdfeed)
- XkbDDXUpdateIndicators(dev,new);
- else if (sli->class==KbdFeedbackClass) {
- KbdFeedbackPtr kf;
- kf= sli->fb.kf;
- if (kf && kf->CtrlProc) {
- (*kf->CtrlProc)(dev,&kf->ctrl);
- }
+ if (sli->fb.kf == dev->kbdfeed)
+ XkbDDXUpdateIndicators(dev, new);
+ else if (sli->class == KbdFeedbackClass) {
+ KbdFeedbackPtr kf;
+
+ kf = sli->fb.kf;
+ if (kf && kf->CtrlProc) {
+ (*kf->CtrlProc) (dev, &kf->ctrl);
+ }
}
- else if (sli->class==LedFeedbackClass) {
- LedFeedbackPtr lf;
- lf= sli->fb.lf;
- if (lf && lf->CtrlProc) {
- (*lf->CtrlProc)(dev,&lf->ctrl);
- }
+ else if (sli->class == LedFeedbackClass) {
+ LedFeedbackPtr lf;
+
+ lf = sli->fb.lf;
+ if (lf && lf->CtrlProc) {
+ (*lf->CtrlProc) (dev, &lf->ctrl);
+ }
}
return;
}
diff --git a/xkb/ddxList.c b/xkb/ddxList.c
index db34c8df5..9b69b2b82 100644
--- a/xkb/ddxList.c
+++ b/xkb/ddxList.c
@@ -44,8 +44,9 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifdef WIN32
/* from ddxLoad.c */
-extern const char* Win32TempDir(void);
+extern const char *Win32TempDir(void);
extern int Win32System(const char *cmdline);
+
#undef System
#define System Win32System
@@ -54,63 +55,62 @@ extern int Win32System(const char *cmdline);
#define W32_tmplen strlen(tmpname)+3
#else
#define W32_tmparg
-#define W32_tmpfile
+#define W32_tmpfile
#define W32_tmplen 0
-#endif
+#endif
/***====================================================================***/
static const char *componentDirs[_XkbListNumComponents] = {
- "keycodes", "types", "compat", "symbols", "geometry"
+ "keycodes", "types", "compat", "symbols", "geometry"
};
/***====================================================================***/
static Status
-_AddListComponent( XkbSrvListInfoPtr list,
- int what,
- unsigned flags,
- char * str,
- ClientPtr client)
+_AddListComponent(XkbSrvListInfoPtr list,
+ int what, unsigned flags, char *str, ClientPtr client)
{
-int slen,wlen;
-unsigned char * wire8;
-unsigned short *wire16;
-char * tmp;
+ int slen, wlen;
+ unsigned char *wire8;
+ unsigned short *wire16;
+ char *tmp;
- if (list->nTotal>=list->maxRtrn) {
- list->nTotal++;
- return Success;
+ if (list->nTotal >= list->maxRtrn) {
+ list->nTotal++;
+ return Success;
}
- tmp= strchr(str,')');
- if ((tmp==NULL)&&((tmp=strchr(str,'('))==NULL)) {
- slen= strlen(str);
- while ((slen>0) && isspace(str[slen-1])) {
- slen--;
- }
+ tmp = strchr(str, ')');
+ if ((tmp == NULL) && ((tmp = strchr(str, '(')) == NULL)) {
+ slen = strlen(str);
+ while ((slen > 0) && isspace(str[slen - 1])) {
+ slen--;
+ }
}
else {
- slen= (tmp-str+1);
+ slen = (tmp - str + 1);
}
- wlen= (((slen+1)/2)*2)+4; /* four bytes for flags and length, pad to */
- /* 2-byte boundary */
- if ((list->szPool-list->nPool)<wlen) {
- if (wlen>1024) list->szPool+= XkbPaddedSize(wlen*2);
- else list->szPool+= 1024;
- list->pool= realloc(list->pool, list->szPool * sizeof(char));
- if (!list->pool)
- return BadAlloc;
+ wlen = (((slen + 1) / 2) * 2) + 4; /* four bytes for flags and length, pad to */
+ /* 2-byte boundary */
+ if ((list->szPool - list->nPool) < wlen) {
+ if (wlen > 1024)
+ list->szPool += XkbPaddedSize(wlen * 2);
+ else
+ list->szPool += 1024;
+ list->pool = realloc(list->pool, list->szPool * sizeof(char));
+ if (!list->pool)
+ return BadAlloc;
}
- wire16= (unsigned short *)&list->pool[list->nPool];
- wire8= (unsigned char *)&wire16[2];
- wire16[0]= flags;
- wire16[1]= slen;
- memcpy(wire8,str,slen);
+ wire16 = (unsigned short *) &list->pool[list->nPool];
+ wire8 = (unsigned char *) &wire16[2];
+ wire16[0] = flags;
+ wire16[1] = slen;
+ memcpy(wire8, str, slen);
if (client->swapped) {
- swaps(&wire16[0]);
- swaps(&wire16[1]);
+ swaps(&wire16[0]);
+ swaps(&wire16[1]);
}
- list->nPool+= wlen;
+ list->nPool += wlen;
list->nFound[what]++;
list->nTotal++;
return Success;
@@ -118,108 +118,104 @@ char * tmp;
/***====================================================================***/
static Status
-XkbDDXListComponent( DeviceIntPtr dev,
- int what,
- XkbSrvListInfoPtr list,
- ClientPtr client)
+XkbDDXListComponent(DeviceIntPtr dev,
+ int what, XkbSrvListInfoPtr list, ClientPtr client)
{
-char *file,*map,*tmp,*buf=NULL;
-FILE *in;
-Status status;
-Bool haveDir;
+ char *file, *map, *tmp, *buf = NULL;
+ FILE *in;
+ Status status;
+ Bool haveDir;
+
#ifdef WIN32
-char tmpname[PATH_MAX];
+ char tmpname[PATH_MAX];
#else
-int rval;
+ int rval;
#endif
- if ((list->pattern[what]==NULL)||(list->pattern[what][0]=='\0'))
- return Success;
- file= list->pattern[what];
- map= strrchr(file,'(');
- if (map!=NULL) {
- char *tmp;
- map++;
- tmp= strrchr(map,')');
- if ((tmp==NULL)||(tmp[1]!='\0')) {
- /* illegal pattern. No error, but no match */
- return Success;
- }
+ if ((list->pattern[what] == NULL) || (list->pattern[what][0] == '\0'))
+ return Success;
+ file = list->pattern[what];
+ map = strrchr(file, '(');
+ if (map != NULL) {
+ char *tmp;
+
+ map++;
+ tmp = strrchr(map, ')');
+ if ((tmp == NULL) || (tmp[1] != '\0')) {
+ /* illegal pattern. No error, but no match */
+ return Success;
+ }
}
- in= NULL;
- haveDir= TRUE;
+ in = NULL;
+ haveDir = TRUE;
#ifdef WIN32
strcpy(tmpname, Win32TempDir());
strcat(tmpname, "\\xkb_XXXXXX");
(void) mktemp(tmpname);
#endif
- if (XkbBaseDirectory!=NULL) {
- if ((list->pattern[what][0]=='*')&&(list->pattern[what][1]=='\0')) {
- if (asprintf(&buf, "%s/%s.dir", XkbBaseDirectory,
- componentDirs[what]) == -1)
- buf = NULL;
- else
- in = fopen(buf,"r");
- }
- if (!in) {
- haveDir= FALSE;
- free(buf);
- if (asprintf
- (&buf,
- "'%s/xkbcomp' '-R%s/%s' -w %ld -l -vlfhpR '%s'" W32_tmparg,
- XkbBinDirectory, XkbBaseDirectory, componentDirs[what],
- (long) ((xkbDebugFlags < 2) ? 1 :
- ((xkbDebugFlags > 10) ? 10 : xkbDebugFlags)),
- file W32_tmpfile
- ) == -1)
- buf = NULL;
- }
+ if (XkbBaseDirectory != NULL) {
+ if ((list->pattern[what][0] == '*') && (list->pattern[what][1] == '\0')) {
+ if (asprintf(&buf, "%s/%s.dir", XkbBaseDirectory,
+ componentDirs[what]) == -1)
+ buf = NULL;
+ else
+ in = fopen(buf, "r");
+ }
+ if (!in) {
+ haveDir = FALSE;
+ free(buf);
+ if (asprintf
+ (&buf,
+ "'%s/xkbcomp' '-R%s/%s' -w %ld -l -vlfhpR '%s'" W32_tmparg,
+ XkbBinDirectory, XkbBaseDirectory, componentDirs[what],
+ (long) ((xkbDebugFlags < 2) ? 1 :
+ ((xkbDebugFlags > 10) ? 10 : xkbDebugFlags)),
+ file W32_tmpfile) == -1)
+ buf = NULL;
+ }
}
else {
- if ((list->pattern[what][0]=='*')&&(list->pattern[what][1]=='\0')) {
- if (asprintf(&buf, "%s.dir", componentDirs[what]) == -1)
- buf = NULL;
- else
- in = fopen(buf,"r");
- }
- if (!in) {
- haveDir= FALSE;
- free(buf);
- if (asprintf
- (&buf,
- "xkbcomp -R%s -w %ld -l -vlfhpR '%s'" W32_tmparg,
- componentDirs[what],
- (long) ((xkbDebugFlags < 2) ? 1 :
- ((xkbDebugFlags > 10) ? 10 : xkbDebugFlags)),
- file W32_tmpfile
- ) == -1)
- buf = NULL;
- }
+ if ((list->pattern[what][0] == '*') && (list->pattern[what][1] == '\0')) {
+ if (asprintf(&buf, "%s.dir", componentDirs[what]) == -1)
+ buf = NULL;
+ else
+ in = fopen(buf, "r");
+ }
+ if (!in) {
+ haveDir = FALSE;
+ free(buf);
+ if (asprintf
+ (&buf,
+ "xkbcomp -R%s -w %ld -l -vlfhpR '%s'" W32_tmparg,
+ componentDirs[what],
+ (long) ((xkbDebugFlags < 2) ? 1 :
+ ((xkbDebugFlags > 10) ? 10 : xkbDebugFlags)),
+ file W32_tmpfile) == -1)
+ buf = NULL;
+ }
}
- status= Success;
- if (!haveDir)
- {
+ status = Success;
+ if (!haveDir) {
#ifndef WIN32
- in= Popen(buf,"r");
+ in = Popen(buf, "r");
#else
if (xkbDebugFlags)
- DebugF("[xkb] xkbList executes: %s\n",buf);
- if (System(buf) < 0)
- ErrorF("[xkb] Could not invoke keymap compiler\n");
- else
- in= fopen(tmpname, "r");
+ DebugF("[xkb] xkbList executes: %s\n", buf);
+ if (System(buf) < 0)
+ ErrorF("[xkb] Could not invoke keymap compiler\n");
+ else
+ in = fopen(tmpname, "r");
#endif
}
- if (!in)
- {
- free(buf);
+ if (!in) {
+ free(buf);
#ifdef WIN32
- unlink(tmpname);
+ unlink(tmpname);
#endif
- return BadImplementation;
+ return BadImplementation;
}
- list->nFound[what]= 0;
+ list->nFound[what] = 0;
free(buf);
buf = malloc(PATH_MAX * sizeof(char));
if (!buf) {
@@ -229,53 +225,61 @@ int rval;
#endif
return BadAlloc;
}
- while ((status==Success)&&((tmp=fgets(buf,PATH_MAX,in))!=NULL)) {
- unsigned flags;
- register unsigned int i;
- if (*tmp=='#') /* comment, skip it */
- continue;
- if (!strncmp(tmp, "Warning:", 8) || !strncmp(tmp, " ", 8))
- /* skip warnings too */
- continue;
- flags= 0;
- /* each line in the listing is supposed to start with two */
- /* groups of eight characters, which specify the general */
- /* flags and the flags that are specific to the component */
- /* if they're missing, fail with BadImplementation */
- for (i=0;(i<8)&&(status==Success);i++) { /* read the general flags */
- if (isalpha(*tmp)) flags|= (1L<<i);
- else if (*tmp!='-') status= BadImplementation;
- tmp++;
- }
- if (status != Success) break;
- if (!isspace(*tmp)) {
- status= BadImplementation;
- break;
- }
- else tmp++;
- for (i=0;(i<8)&&(status==Success);i++) { /* read the component flags */
- if (isalpha(*tmp)) flags|= (1L<<(i+8));
- else if (*tmp!='-') status= BadImplementation;
- tmp++;
- }
- if (status != Success) break;
- if (isspace(*tmp)) {
- while (isspace(*tmp)) {
- tmp++;
- }
- }
- else {
- status= BadImplementation;
- break;
- }
- status= _AddListComponent(list,what,flags,tmp,client);
+ while ((status == Success) && ((tmp = fgets(buf, PATH_MAX, in)) != NULL)) {
+ unsigned flags;
+ register unsigned int i;
+
+ if (*tmp == '#') /* comment, skip it */
+ continue;
+ if (!strncmp(tmp, "Warning:", 8) || !strncmp(tmp, " ", 8))
+ /* skip warnings too */
+ continue;
+ flags = 0;
+ /* each line in the listing is supposed to start with two */
+ /* groups of eight characters, which specify the general */
+ /* flags and the flags that are specific to the component */
+ /* if they're missing, fail with BadImplementation */
+ for (i = 0; (i < 8) && (status == Success); i++) { /* read the general flags */
+ if (isalpha(*tmp))
+ flags |= (1L << i);
+ else if (*tmp != '-')
+ status = BadImplementation;
+ tmp++;
+ }
+ if (status != Success)
+ break;
+ if (!isspace(*tmp)) {
+ status = BadImplementation;
+ break;
+ }
+ else
+ tmp++;
+ for (i = 0; (i < 8) && (status == Success); i++) { /* read the component flags */
+ if (isalpha(*tmp))
+ flags |= (1L << (i + 8));
+ else if (*tmp != '-')
+ status = BadImplementation;
+ tmp++;
+ }
+ if (status != Success)
+ break;
+ if (isspace(*tmp)) {
+ while (isspace(*tmp)) {
+ tmp++;
+ }
+ }
+ else {
+ status = BadImplementation;
+ break;
+ }
+ status = _AddListComponent(list, what, flags, tmp, client);
}
#ifndef WIN32
if (haveDir)
- fclose(in);
- else if ((rval=Pclose(in))!=0) {
- if (xkbDebugFlags)
- ErrorF("[xkb] xkbcomp returned exit code %d\n",rval);
+ fclose(in);
+ else if ((rval = Pclose(in)) != 0) {
+ if (xkbDebugFlags)
+ ErrorF("[xkb] xkbcomp returned exit code %d\n", rval);
}
#else
fclose(in);
@@ -289,18 +293,18 @@ int rval;
/* ARGSUSED */
Status
-XkbDDXList(DeviceIntPtr dev,XkbSrvListInfoPtr list,ClientPtr client)
+XkbDDXList(DeviceIntPtr dev, XkbSrvListInfoPtr list, ClientPtr client)
{
-Status status;
+ Status status;
- status= XkbDDXListComponent(dev,_XkbListKeycodes,list,client);
- if (status==Success)
- status= XkbDDXListComponent(dev,_XkbListTypes,list,client);
- if (status==Success)
- status= XkbDDXListComponent(dev,_XkbListCompat,list,client);
- if (status==Success)
- status= XkbDDXListComponent(dev,_XkbListSymbols,list,client);
- if (status==Success)
- status= XkbDDXListComponent(dev,_XkbListGeometry,list,client);
+ status = XkbDDXListComponent(dev, _XkbListKeycodes, list, client);
+ if (status == Success)
+ status = XkbDDXListComponent(dev, _XkbListTypes, list, client);
+ if (status == Success)
+ status = XkbDDXListComponent(dev, _XkbListCompat, list, client);
+ if (status == Success)
+ status = XkbDDXListComponent(dev, _XkbListSymbols, list, client);
+ if (status == Success)
+ status = XkbDDXListComponent(dev, _XkbListGeometry, list, client);
return status;
}
diff --git a/xkb/ddxLoad.c b/xkb/ddxLoad.c
index 196142318..cb2dfc31c 100644
--- a/xkb/ddxLoad.c
+++ b/xkb/ddxLoad.c
@@ -45,14 +45,14 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <X11/extensions/XI.h>
#include "xkb.h"
- /*
- * If XKM_OUTPUT_DIR specifies a path without a leading slash, it is
- * relative to the top-level XKB configuration directory.
- * Making the server write to a subdirectory of that directory
- * requires some work in the general case (install procedure
- * has to create links to /var or somesuch on many machines),
- * so we just compile into /usr/tmp for now.
- */
+ /*
+ * If XKM_OUTPUT_DIR specifies a path without a leading slash, it is
+ * relative to the top-level XKB configuration directory.
+ * Making the server write to a subdirectory of that directory
+ * requires some work in the general case (install procedure
+ * has to create links to /var or somesuch on many machines),
+ * so we just compile into /usr/tmp for now.
+ */
#ifndef XKM_OUTPUT_DIR
#define XKM_OUTPUT_DIR "compiled/"
#endif
@@ -71,18 +71,19 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifdef WIN32
#include <X11/Xwindows.h>
-const char*
+const char *
Win32TempDir()
{
static char buffer[PATH_MAX];
- if (GetTempPath(sizeof(buffer), buffer))
- {
+
+ if (GetTempPath(sizeof(buffer), buffer)) {
int len;
- buffer[sizeof(buffer)-1] = 0;
+
+ buffer[sizeof(buffer) - 1] = 0;
len = strlen(buffer);
if (len > 0)
- if (buffer[len-1] == '\\')
- buffer[len-1] = 0;
+ if (buffer[len - 1] == '\\')
+ buffer[len - 1] = 0;
return buffer;
}
if (getenv("TEMP") != NULL)
@@ -93,7 +94,7 @@ Win32TempDir()
return "/tmp";
}
-int
+int
Win32System(const char *cmdline)
{
STARTUPINFO si;
@@ -101,90 +102,82 @@ Win32System(const char *cmdline)
DWORD dwExitCode;
char *cmd = strdup(cmdline);
- ZeroMemory( &si, sizeof(si) );
+ ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
- ZeroMemory( &pi, sizeof(pi) );
-
- if (!CreateProcess(NULL, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
- {
- LPVOID buffer;
- if (!FormatMessage(
- FORMAT_MESSAGE_ALLOCATE_BUFFER |
- FORMAT_MESSAGE_FROM_SYSTEM |
- FORMAT_MESSAGE_IGNORE_INSERTS,
- NULL,
- GetLastError(),
- MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
- (LPTSTR) &buffer,
- 0,
- NULL ))
- {
- ErrorF("[xkb] Starting '%s' failed!\n", cmdline);
- }
- else
- {
- ErrorF("[xkb] Starting '%s' failed: %s", cmdline, (char *)buffer);
- LocalFree(buffer);
- }
-
- free(cmd);
- return -1;
+ ZeroMemory(&pi, sizeof(pi));
+
+ if (!CreateProcess(NULL, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
+ LPVOID buffer;
+
+ if (!FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+ FORMAT_MESSAGE_FROM_SYSTEM |
+ FORMAT_MESSAGE_IGNORE_INSERTS,
+ NULL,
+ GetLastError(),
+ MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+ (LPTSTR) & buffer, 0, NULL)) {
+ ErrorF("[xkb] Starting '%s' failed!\n", cmdline);
+ }
+ else {
+ ErrorF("[xkb] Starting '%s' failed: %s", cmdline, (char *) buffer);
+ LocalFree(buffer);
+ }
+
+ free(cmd);
+ return -1;
}
/* Wait until child process exits. */
- WaitForSingleObject( pi.hProcess, INFINITE );
+ WaitForSingleObject(pi.hProcess, INFINITE);
+
+ GetExitCodeProcess(pi.hProcess, &dwExitCode);
- GetExitCodeProcess( pi.hProcess, &dwExitCode);
-
/* Close process and thread handles. */
- CloseHandle( pi.hProcess );
- CloseHandle( pi.hThread );
+ CloseHandle(pi.hProcess);
+ CloseHandle(pi.hThread);
free(cmd);
return dwExitCode;
}
+
#undef System
#define System(x) Win32System(x)
#endif
static void
-OutputDirectory(
- char* outdir,
- size_t size)
+OutputDirectory(char *outdir, size_t size)
{
#ifndef WIN32
/* Can we write an xkm and then open it too? */
- if (access(XKM_OUTPUT_DIR, W_OK | X_OK) == 0 && (strlen(XKM_OUTPUT_DIR) < size))
- {
- (void) strcpy (outdir, XKM_OUTPUT_DIR);
- } else
+ if (access(XKM_OUTPUT_DIR, W_OK | X_OK) == 0 &&
+ (strlen(XKM_OUTPUT_DIR) < size)) {
+ (void) strcpy(outdir, XKM_OUTPUT_DIR);
+ }
+ else
#else
- if (strlen(Win32TempDir()) + 1 < size)
- {
- (void) strcpy(outdir, Win32TempDir());
- (void) strcat(outdir, "\\");
- } else
+ if (strlen(Win32TempDir()) + 1 < size) {
+ (void) strcpy(outdir, Win32TempDir());
+ (void) strcat(outdir, "\\");
+ }
+ else
#endif
- if (strlen("/tmp/") < size)
- {
- (void) strcpy (outdir, "/tmp/");
+ if (strlen("/tmp/") < size) {
+ (void) strcpy(outdir, "/tmp/");
}
}
static Bool
-XkbDDXCompileKeymapByNames( XkbDescPtr xkb,
- XkbComponentNamesPtr names,
- unsigned want,
- unsigned need,
- char * nameRtrn,
- int nameRtrnLen)
+XkbDDXCompileKeymapByNames(XkbDescPtr xkb,
+ XkbComponentNamesPtr names,
+ unsigned want,
+ unsigned need, char *nameRtrn, int nameRtrnLen)
{
- FILE * out;
- char *buf = NULL, keymap[PATH_MAX], xkm_output_dir[PATH_MAX];
+ FILE *out;
+ char *buf = NULL, keymap[PATH_MAX], xkm_output_dir[PATH_MAX];
- const char *emptystring = "";
+ const char *emptystring = "";
char *xkbbasedirflag = NULL;
- const char *xkbbindir = emptystring;
- const char *xkbbindirsep = emptystring;
+ const char *xkbbindir = emptystring;
+ const char *xkbbindirsep = emptystring;
#ifdef WIN32
/* WIN32 has no popen. The input must be stored in a file which is
@@ -206,73 +199,73 @@ XkbDDXCompileKeymapByNames( XkbDescPtr xkb,
#endif
if (XkbBaseDirectory != NULL) {
- if (asprintf(&xkbbasedirflag, "\"-R%s\"", XkbBaseDirectory) == -1)
- xkbbasedirflag = NULL;
+ if (asprintf(&xkbbasedirflag, "\"-R%s\"", XkbBaseDirectory) == -1)
+ xkbbasedirflag = NULL;
}
if (XkbBinDirectory != NULL) {
- int ld = strlen(XkbBinDirectory);
- int lps = strlen(PATHSEPARATOR);
+ int ld = strlen(XkbBinDirectory);
+ int lps = strlen(PATHSEPARATOR);
- xkbbindir = XkbBinDirectory;
+ xkbbindir = XkbBinDirectory;
- if ((ld >= lps) &&
- (strcmp(xkbbindir + ld - lps, PATHSEPARATOR) != 0)) {
- xkbbindirsep = PATHSEPARATOR;
- }
+ if ((ld >= lps) && (strcmp(xkbbindir + ld - lps, PATHSEPARATOR) != 0)) {
+ xkbbindirsep = PATHSEPARATOR;
+ }
}
if (asprintf(&buf,
- "\"%s%sxkbcomp\" -w %d %s -xkm \"%s\" "
- "-em1 %s -emp %s -eml %s \"%s%s.xkm\"",
- xkbbindir, xkbbindirsep,
- ((xkbDebugFlags < 2) ? 1 :
- ((xkbDebugFlags > 10) ? 10 : (int) xkbDebugFlags)),
- xkbbasedirflag ? xkbbasedirflag : "", xkmfile,
- PRE_ERROR_MSG, ERROR_PREFIX, POST_ERROR_MSG1,
- xkm_output_dir, keymap) == -1)
- buf = NULL;
+ "\"%s%sxkbcomp\" -w %d %s -xkm \"%s\" "
+ "-em1 %s -emp %s -eml %s \"%s%s.xkm\"",
+ xkbbindir, xkbbindirsep,
+ ((xkbDebugFlags < 2) ? 1 :
+ ((xkbDebugFlags > 10) ? 10 : (int) xkbDebugFlags)),
+ xkbbasedirflag ? xkbbasedirflag : "", xkmfile,
+ PRE_ERROR_MSG, ERROR_PREFIX, POST_ERROR_MSG1,
+ xkm_output_dir, keymap) == -1)
+ buf = NULL;
free(xkbbasedirflag);
if (!buf) {
- LogMessage(X_ERROR, "XKB: Could not invoke xkbcomp: not enough memory\n");
+ LogMessage(X_ERROR,
+ "XKB: Could not invoke xkbcomp: not enough memory\n");
return FALSE;
}
-
+
#ifndef WIN32
- out= Popen(buf,"w");
+ out = Popen(buf, "w");
#else
- out= fopen(tmpname, "w");
+ out = fopen(tmpname, "w");
#endif
-
- if (out!=NULL) {
+
+ if (out != NULL) {
#ifdef DEBUG
- if (xkbDebugFlags) {
- ErrorF("[xkb] XkbDDXCompileKeymapByNames compiling keymap:\n");
- XkbWriteXKBKeymapForNames(stderr,names,xkb,want,need);
- }
+ if (xkbDebugFlags) {
+ ErrorF("[xkb] XkbDDXCompileKeymapByNames compiling keymap:\n");
+ XkbWriteXKBKeymapForNames(stderr, names, xkb, want, need);
+ }
#endif
- XkbWriteXKBKeymapForNames(out,names,xkb,want,need);
+ XkbWriteXKBKeymapForNames(out, names, xkb, want, need);
#ifndef WIN32
- if (Pclose(out)==0)
+ if (Pclose(out) == 0)
#else
- if (fclose(out)==0 && System(buf) >= 0)
+ if (fclose(out) == 0 && System(buf) >= 0)
#endif
- {
+ {
if (xkbDebugFlags)
- DebugF("[xkb] xkb executes: %s\n",buf);
- if (nameRtrn) {
- strlcpy(nameRtrn,keymap,nameRtrnLen);
- }
+ DebugF("[xkb] xkb executes: %s\n", buf);
+ if (nameRtrn) {
+ strlcpy(nameRtrn, keymap, nameRtrnLen);
+ }
free(buf);
#ifdef WIN32
- unlink(tmpname);
+ unlink(tmpname);
#endif
- return TRUE;
- }
- else
- LogMessage(X_ERROR, "Error compiling keymap (%s)\n", keymap);
+ return TRUE;
+ }
+ else
+ LogMessage(X_ERROR, "Error compiling keymap (%s)\n", keymap);
#ifdef WIN32
/* remove the temporary file */
unlink(tmpname);
@@ -280,115 +273,117 @@ XkbDDXCompileKeymapByNames( XkbDescPtr xkb,
}
else {
#ifndef WIN32
- LogMessage(X_ERROR, "XKB: Could not invoke xkbcomp\n");
+ LogMessage(X_ERROR, "XKB: Could not invoke xkbcomp\n");
#else
- LogMessage(X_ERROR, "Could not open file %s\n", tmpname);
+ LogMessage(X_ERROR, "Could not open file %s\n", tmpname);
#endif
}
if (nameRtrn)
- nameRtrn[0]= '\0';
+ nameRtrn[0] = '\0';
free(buf);
return FALSE;
}
static FILE *
-XkbDDXOpenConfigFile(char *mapName,char *fileNameRtrn,int fileNameRtrnLen)
+XkbDDXOpenConfigFile(char *mapName, char *fileNameRtrn, int fileNameRtrnLen)
{
-char buf[PATH_MAX],xkm_output_dir[PATH_MAX];
-FILE * file;
+ char buf[PATH_MAX], xkm_output_dir[PATH_MAX];
+ FILE *file;
- buf[0]= '\0';
- if (mapName!=NULL) {
- OutputDirectory(xkm_output_dir, sizeof(xkm_output_dir));
- if ((XkbBaseDirectory!=NULL)&&(xkm_output_dir[0]!='/')
+ buf[0] = '\0';
+ if (mapName != NULL) {
+ OutputDirectory(xkm_output_dir, sizeof(xkm_output_dir));
+ if ((XkbBaseDirectory != NULL) && (xkm_output_dir[0] != '/')
#ifdef WIN32
- &&(!isalpha(xkm_output_dir[0]) || xkm_output_dir[1]!=':')
+ && (!isalpha(xkm_output_dir[0]) || xkm_output_dir[1] != ':')
#endif
- ) {
+ ) {
if (snprintf(buf, PATH_MAX, "%s/%s%s.xkm", XkbBaseDirectory,
xkm_output_dir, mapName) >= PATH_MAX)
buf[0] = '\0';
- }
- else
- {
+ }
+ else {
if (snprintf(buf, PATH_MAX, "%s%s.xkm", xkm_output_dir, mapName)
>= PATH_MAX)
buf[0] = '\0';
- }
- if (buf[0] != '\0')
- file= fopen(buf,"rb");
- else file= NULL;
+ }
+ if (buf[0] != '\0')
+ file = fopen(buf, "rb");
+ else
+ file = NULL;
}
- else file= NULL;
- if ((fileNameRtrn!=NULL)&&(fileNameRtrnLen>0)) {
- strlcpy(fileNameRtrn,buf,fileNameRtrnLen);
+ else
+ file = NULL;
+ if ((fileNameRtrn != NULL) && (fileNameRtrnLen > 0)) {
+ strlcpy(fileNameRtrn, buf, fileNameRtrnLen);
}
return file;
}
unsigned
-XkbDDXLoadKeymapByNames( DeviceIntPtr keybd,
- XkbComponentNamesPtr names,
- unsigned want,
- unsigned need,
- XkbDescPtr * xkbRtrn,
- char * nameRtrn,
- int nameRtrnLen)
+XkbDDXLoadKeymapByNames(DeviceIntPtr keybd,
+ XkbComponentNamesPtr names,
+ unsigned want,
+ unsigned need,
+ XkbDescPtr *xkbRtrn, char *nameRtrn, int nameRtrnLen)
{
-XkbDescPtr xkb;
-FILE * file;
-char fileName[PATH_MAX];
-unsigned missing;
+ XkbDescPtr xkb;
+ FILE *file;
+ char fileName[PATH_MAX];
+ unsigned missing;
*xkbRtrn = NULL;
- if ((keybd==NULL)||(keybd->key==NULL)||(keybd->key->xkbInfo==NULL))
- xkb= NULL;
- else xkb= keybd->key->xkbInfo->desc;
- if ((names->keycodes==NULL)&&(names->types==NULL)&&
- (names->compat==NULL)&&(names->symbols==NULL)&&
- (names->geometry==NULL)) {
+ if ((keybd == NULL) || (keybd->key == NULL) ||
+ (keybd->key->xkbInfo == NULL))
+ xkb = NULL;
+ else
+ xkb = keybd->key->xkbInfo->desc;
+ if ((names->keycodes == NULL) && (names->types == NULL) &&
+ (names->compat == NULL) && (names->symbols == NULL) &&
+ (names->geometry == NULL)) {
LogMessage(X_ERROR, "XKB: No components provided for device %s\n",
keybd->name ? keybd->name : "(unnamed keyboard)");
return 0;
}
- else if (!XkbDDXCompileKeymapByNames(xkb,names,want,need,
- nameRtrn,nameRtrnLen)){
- LogMessage(X_ERROR, "XKB: Couldn't compile keymap\n");
- return 0;
+ else if (!XkbDDXCompileKeymapByNames(xkb, names, want, need,
+ nameRtrn, nameRtrnLen)) {
+ LogMessage(X_ERROR, "XKB: Couldn't compile keymap\n");
+ return 0;
}
- file= XkbDDXOpenConfigFile(nameRtrn,fileName,PATH_MAX);
- if (file==NULL) {
- LogMessage(X_ERROR, "Couldn't open compiled keymap file %s\n",fileName);
- return 0;
+ file = XkbDDXOpenConfigFile(nameRtrn, fileName, PATH_MAX);
+ if (file == NULL) {
+ LogMessage(X_ERROR, "Couldn't open compiled keymap file %s\n",
+ fileName);
+ return 0;
}
- missing= XkmReadFile(file,need,want,xkbRtrn);
- if (*xkbRtrn==NULL) {
- LogMessage(X_ERROR, "Error loading keymap %s\n",fileName);
- fclose(file);
- (void) unlink (fileName);
- return 0;
+ missing = XkmReadFile(file, need, want, xkbRtrn);
+ if (*xkbRtrn == NULL) {
+ LogMessage(X_ERROR, "Error loading keymap %s\n", fileName);
+ fclose(file);
+ (void) unlink(fileName);
+ return 0;
}
else {
- DebugF("Loaded XKB keymap %s, defined=0x%x\n",fileName,(*xkbRtrn)->defined);
+ DebugF("Loaded XKB keymap %s, defined=0x%x\n", fileName,
+ (*xkbRtrn)->defined);
}
fclose(file);
- (void) unlink (fileName);
- return (need|want)&(~missing);
+ (void) unlink(fileName);
+ return (need | want) & (~missing);
}
Bool
-XkbDDXNamesFromRules( DeviceIntPtr keybd,
- char * rules_name,
- XkbRF_VarDefsPtr defs,
- XkbComponentNamesPtr names)
+XkbDDXNamesFromRules(DeviceIntPtr keybd,
+ char *rules_name,
+ XkbRF_VarDefsPtr defs, XkbComponentNamesPtr names)
{
-char buf[PATH_MAX];
-FILE * file;
-Bool complete;
-XkbRF_RulesPtr rules;
+ char buf[PATH_MAX];
+ FILE *file;
+ Bool complete;
+ XkbRF_RulesPtr rules;
if (!rules_name)
- return FALSE;
+ return FALSE;
if (snprintf(buf, PATH_MAX, "%s/rules/%s", XkbBaseDirectory, rules_name)
>= PATH_MAX) {
@@ -399,25 +394,25 @@ XkbRF_RulesPtr rules;
file = fopen(buf, "r");
if (!file) {
LogMessage(X_ERROR, "XKB: Couldn't open rules file %s\n", buf);
- return FALSE;
+ return FALSE;
}
rules = XkbRF_Create();
if (!rules) {
LogMessage(X_ERROR, "XKB: Couldn't create rules struct\n");
- fclose(file);
- return FALSE;
+ fclose(file);
+ return FALSE;
}
if (!XkbRF_LoadRules(file, rules)) {
LogMessage(X_ERROR, "XKB: Couldn't parse rules file %s\n", rules_name);
- fclose(file);
- XkbRF_Free(rules,TRUE);
- return FALSE;
+ fclose(file);
+ XkbRF_Free(rules, TRUE);
+ return FALSE;
}
memset(names, 0, sizeof(*names));
- complete = XkbRF_GetComponents(rules,defs,names);
+ complete = XkbRF_GetComponents(rules, defs, names);
fclose(file);
XkbRF_Free(rules, TRUE);
@@ -428,7 +423,8 @@ XkbRF_RulesPtr rules;
}
static Bool
-XkbRMLVOtoKcCGST(DeviceIntPtr dev, XkbRMLVOSet *rmlvo, XkbComponentNamesPtr kccgst)
+XkbRMLVOtoKcCGST(DeviceIntPtr dev, XkbRMLVOSet * rmlvo,
+ XkbComponentNamesPtr kccgst)
{
XkbRF_VarDefsRec mlvo;
@@ -446,16 +442,17 @@ XkbRMLVOtoKcCGST(DeviceIntPtr dev, XkbRMLVOSet *rmlvo, XkbComponentNamesPtr kccg
* or equal to need, the compiliation is treated as failure.
*/
static XkbDescPtr
-XkbCompileKeymapForDevice(DeviceIntPtr dev, XkbRMLVOSet *rmlvo, int need)
+XkbCompileKeymapForDevice(DeviceIntPtr dev, XkbRMLVOSet * rmlvo, int need)
{
XkbDescPtr xkb = NULL;
unsigned int provided;
- XkbComponentNamesRec kccgst = {0};
+ XkbComponentNamesRec kccgst = { 0 };
char name[PATH_MAX];
if (XkbRMLVOtoKcCGST(dev, rmlvo, &kccgst)) {
- provided = XkbDDXLoadKeymapByNames(dev, &kccgst, XkmAllIndicesMask, need,
- &xkb, name, PATH_MAX);
+ provided =
+ XkbDDXLoadKeymapByNames(dev, &kccgst, XkmAllIndicesMask, need, &xkb,
+ name, PATH_MAX);
if ((need & provided) != need) {
if (xkb) {
XkbFreeKeyboard(xkb, 0, TRUE);
@@ -469,7 +466,7 @@ XkbCompileKeymapForDevice(DeviceIntPtr dev, XkbRMLVOSet *rmlvo, int need)
}
XkbDescPtr
-XkbCompileKeymap(DeviceIntPtr dev, XkbRMLVOSet *rmlvo)
+XkbCompileKeymap(DeviceIntPtr dev, XkbRMLVOSet * rmlvo)
{
XkbDescPtr xkb;
unsigned int need;
@@ -481,8 +478,7 @@ XkbCompileKeymap(DeviceIntPtr dev, XkbRMLVOSet *rmlvo)
/* These are the components we really really need */
need = XkmSymbolsMask | XkmCompatMapMask | XkmTypesMask |
- XkmKeyNamesMask | XkmVirtualModsMask;
-
+ XkmKeyNamesMask | XkmVirtualModsMask;
xkb = XkbCompileKeymapForDevice(dev, rmlvo, need);
diff --git a/xkb/ddxPrivate.c b/xkb/ddxPrivate.c
index f1c85f6ea..fcde3a18c 100644
--- a/xkb/ddxPrivate.c
+++ b/xkb/ddxPrivate.c
@@ -8,7 +8,7 @@
#include <xkbsrv.h>
int
-XkbDDXPrivate(DeviceIntPtr dev,KeyCode key,XkbAction *act)
+XkbDDXPrivate(DeviceIntPtr dev, KeyCode key, XkbAction *act)
{
return 0;
}
diff --git a/xkb/ddxVT.c b/xkb/ddxVT.c
index cbd453706..65291026a 100644
--- a/xkb/ddxVT.c
+++ b/xkb/ddxVT.c
@@ -38,7 +38,7 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <xkbsrv.h>
int
-XkbDDXSwitchScreen(DeviceIntPtr dev,KeyCode key,XkbAction *act)
+XkbDDXSwitchScreen(DeviceIntPtr dev, KeyCode key, XkbAction *act)
{
return 1;
}
diff --git a/xkb/maprules.c b/xkb/maprules.c
index 66800478c..c6900eccb 100644
--- a/xkb/maprules.c
+++ b/xkb/maprules.c
@@ -52,54 +52,52 @@
/***====================================================================***/
-
-
#define DFLT_LINE_SIZE 128
typedef struct {
- int line_num;
- int sz_line;
- int num_line;
- char buf[DFLT_LINE_SIZE];
- char * line;
+ int line_num;
+ int sz_line;
+ int num_line;
+ char buf[DFLT_LINE_SIZE];
+ char *line;
} InputLine;
static void
-InitInputLine(InputLine *line)
+InitInputLine(InputLine * line)
{
- line->line_num= 1;
- line->num_line= 0;
- line->sz_line= DFLT_LINE_SIZE;
- line->line= line->buf;
+ line->line_num = 1;
+ line->num_line = 0;
+ line->sz_line = DFLT_LINE_SIZE;
+ line->line = line->buf;
return;
}
static void
-FreeInputLine(InputLine *line)
+FreeInputLine(InputLine * line)
{
- if (line->line!=line->buf)
- free(line->line);
- line->line_num= 1;
- line->num_line= 0;
- line->sz_line= DFLT_LINE_SIZE;
- line->line= line->buf;
+ if (line->line != line->buf)
+ free(line->line);
+ line->line_num = 1;
+ line->num_line = 0;
+ line->sz_line = DFLT_LINE_SIZE;
+ line->line = line->buf;
return;
}
static int
-InputLineAddChar(InputLine *line,int ch)
+InputLineAddChar(InputLine * line, int ch)
{
- if (line->num_line>=line->sz_line) {
- if (line->line==line->buf) {
- line->line= malloc(line->sz_line*2);
- memcpy(line->line,line->buf,line->sz_line);
- }
- else {
- line->line= realloc((char *)line->line,line->sz_line*2);
- }
- line->sz_line*= 2;
- }
- line->line[line->num_line++]= ch;
+ if (line->num_line >= line->sz_line) {
+ if (line->line == line->buf) {
+ line->line = malloc(line->sz_line * 2);
+ memcpy(line->line, line->buf, line->sz_line);
+ }
+ else {
+ line->line = realloc((char *) line->line, line->sz_line * 2);
+ }
+ line->sz_line *= 2;
+ }
+ line->line[line->num_line++] = ch;
return ch;
}
@@ -108,80 +106,80 @@ InputLineAddChar(InputLine *line,int ch)
InputLineAddChar(l,c))
static Bool
-GetInputLine(FILE *file,InputLine *line,Bool checkbang)
+GetInputLine(FILE * file, InputLine * line, Bool checkbang)
{
-int ch;
-Bool endOfFile,spacePending,slashPending,inComment;
-
- endOfFile= FALSE;
- while ((!endOfFile)&&(line->num_line==0)) {
- spacePending= slashPending= inComment= FALSE;
- while (((ch=getc(file))!='\n')&&(ch!=EOF)) {
- if (ch=='\\') {
- if ((ch=getc(file))==EOF)
- break;
- if (ch=='\n') {
- inComment= FALSE;
- ch= ' ';
- line->line_num++;
- }
- }
- if (inComment)
- continue;
- if (ch=='/') {
- if (slashPending) {
- inComment= TRUE;
- slashPending= FALSE;
- }
- else {
- slashPending= TRUE;
- }
- continue;
- }
- else if (slashPending) {
- if (spacePending) {
- ADD_CHAR(line,' ');
- spacePending= FALSE;
- }
- ADD_CHAR(line,'/');
- slashPending= FALSE;
- }
- if (isspace(ch)) {
- while (isspace(ch)&&(ch!='\n')&&(ch!=EOF)) {
- ch= getc(file);
- }
- if (ch==EOF)
- break;
- if ((ch!='\n')&&(line->num_line>0))
- spacePending= TRUE;
- ungetc(ch,file);
- }
- else {
- if (spacePending) {
- ADD_CHAR(line,' ');
- spacePending= FALSE;
- }
- if (checkbang && ch=='!') {
- if (line->num_line!=0) {
- DebugF("The '!' legal only at start of line\n");
- DebugF("Line containing '!' ignored\n");
- line->num_line= 0;
- inComment= 0;
- break;
- }
-
- }
- ADD_CHAR(line,ch);
- }
- }
- if (ch==EOF)
- endOfFile= TRUE;
+ int ch;
+ Bool endOfFile, spacePending, slashPending, inComment;
+
+ endOfFile = FALSE;
+ while ((!endOfFile) && (line->num_line == 0)) {
+ spacePending = slashPending = inComment = FALSE;
+ while (((ch = getc(file)) != '\n') && (ch != EOF)) {
+ if (ch == '\\') {
+ if ((ch = getc(file)) == EOF)
+ break;
+ if (ch == '\n') {
+ inComment = FALSE;
+ ch = ' ';
+ line->line_num++;
+ }
+ }
+ if (inComment)
+ continue;
+ if (ch == '/') {
+ if (slashPending) {
+ inComment = TRUE;
+ slashPending = FALSE;
+ }
+ else {
+ slashPending = TRUE;
+ }
+ continue;
+ }
+ else if (slashPending) {
+ if (spacePending) {
+ ADD_CHAR(line, ' ');
+ spacePending = FALSE;
+ }
+ ADD_CHAR(line, '/');
+ slashPending = FALSE;
+ }
+ if (isspace(ch)) {
+ while (isspace(ch) && (ch != '\n') && (ch != EOF)) {
+ ch = getc(file);
+ }
+ if (ch == EOF)
+ break;
+ if ((ch != '\n') && (line->num_line > 0))
+ spacePending = TRUE;
+ ungetc(ch, file);
+ }
+ else {
+ if (spacePending) {
+ ADD_CHAR(line, ' ');
+ spacePending = FALSE;
+ }
+ if (checkbang && ch == '!') {
+ if (line->num_line != 0) {
+ DebugF("The '!' legal only at start of line\n");
+ DebugF("Line containing '!' ignored\n");
+ line->num_line = 0;
+ inComment = 0;
+ break;
+ }
+
+ }
+ ADD_CHAR(line, ch);
+ }
+ }
+ if (ch == EOF)
+ endOfFile = TRUE;
/* else line->num_line++;*/
- }
- if ((line->num_line==0)&&(endOfFile))
- return FALSE;
- ADD_CHAR(line,'\0');
- return TRUE;
+ }
+ if ((line->num_line == 0) && (endOfFile))
+ return FALSE;
+ ADD_CHAR(line, '\0');
+ return TRUE;
}
/***====================================================================***/
@@ -200,164 +198,169 @@ Bool endOfFile,spacePending,slashPending,inComment;
#define PART_MASK 0x000F
#define COMPONENT_MASK 0x03F0
-static const char * cname[MAX_WORDS] = {
- "model", "layout", "variant", "option",
- "keycodes", "symbols", "types", "compat", "geometry"
+static const char *cname[MAX_WORDS] = {
+ "model", "layout", "variant", "option",
+ "keycodes", "symbols", "types", "compat", "geometry"
};
-typedef struct _RemapSpec {
- int number;
- int num_remap;
- struct {
- int word;
- int index;
- } remap[MAX_WORDS];
+typedef struct _RemapSpec {
+ int number;
+ int num_remap;
+ struct {
+ int word;
+ int index;
+ } remap[MAX_WORDS];
} RemapSpec;
typedef struct _FileSpec {
- char * name[MAX_WORDS];
- struct _FileSpec * pending;
+ char *name[MAX_WORDS];
+ struct _FileSpec *pending;
} FileSpec;
typedef struct {
- char * model;
- char * layout[XkbNumKbdGroups+1];
- char * variant[XkbNumKbdGroups+1];
- char * options;
+ char *model;
+ char *layout[XkbNumKbdGroups + 1];
+ char *variant[XkbNumKbdGroups + 1];
+ char *options;
} XkbRF_MultiDefsRec, *XkbRF_MultiDefsPtr;
#define NDX_BUFF_SIZE 4
/***====================================================================***/
-static char*
+static char *
get_index(char *str, int *ndx)
{
- char ndx_buf[NDX_BUFF_SIZE];
- char *end;
-
- if (*str != '[') {
- *ndx = 0;
- return str;
- }
- str++;
- end = strchr(str, ']');
- if (end == NULL) {
- *ndx = -1;
- return str - 1;
- }
- if ( (end - str) >= NDX_BUFF_SIZE) {
- *ndx = -1;
- return end + 1;
- }
- strlcpy(ndx_buf, str, 1 + end - str);
- *ndx = atoi(ndx_buf);
- return end + 1;
+ char ndx_buf[NDX_BUFF_SIZE];
+ char *end;
+
+ if (*str != '[') {
+ *ndx = 0;
+ return str;
+ }
+ str++;
+ end = strchr(str, ']');
+ if (end == NULL) {
+ *ndx = -1;
+ return str - 1;
+ }
+ if ((end - str) >= NDX_BUFF_SIZE) {
+ *ndx = -1;
+ return end + 1;
+ }
+ strlcpy(ndx_buf, str, 1 + end - str);
+ *ndx = atoi(ndx_buf);
+ return end + 1;
}
static void
-SetUpRemap(InputLine *line,RemapSpec *remap)
+SetUpRemap(InputLine * line, RemapSpec * remap)
{
-char * tok,*str;
-unsigned present, l_ndx_present, v_ndx_present;
-register int i;
-int len, ndx;
-_Xstrtokparams strtok_buf;
-Bool found;
-
-
- l_ndx_present = v_ndx_present = present= 0;
- str= &line->line[1];
- len = remap->number;
- memset((char *)remap, 0, sizeof(RemapSpec));
- remap->number = len;
- while ((tok=_XStrtok(str," ",strtok_buf))!=NULL) {
- found= FALSE;
- str= NULL;
- if (strcmp(tok,"=")==0)
- continue;
- for (i=0;i<MAX_WORDS;i++) {
+ char *tok, *str;
+ unsigned present, l_ndx_present, v_ndx_present;
+ register int i;
+ int len, ndx;
+ _Xstrtokparams strtok_buf;
+ Bool found;
+
+ l_ndx_present = v_ndx_present = present = 0;
+ str = &line->line[1];
+ len = remap->number;
+ memset((char *) remap, 0, sizeof(RemapSpec));
+ remap->number = len;
+ while ((tok = _XStrtok(str, " ", strtok_buf)) != NULL) {
+ found = FALSE;
+ str = NULL;
+ if (strcmp(tok, "=") == 0)
+ continue;
+ for (i = 0; i < MAX_WORDS; i++) {
len = strlen(cname[i]);
- if (strncmp(cname[i],tok,len)==0) {
- if(strlen(tok) > len) {
- char *end = get_index(tok+len, &ndx);
- if ((i != LAYOUT && i != VARIANT) ||
- *end != '\0' || ndx == -1)
- break;
- if (ndx < 1 || ndx > XkbNumKbdGroups) {
- DebugF("Illegal %s index: %d\n", cname[i], ndx);
- DebugF("Index must be in range 1..%d\n",
- XkbNumKbdGroups);
- break;
- }
- } else {
- ndx = 0;
+ if (strncmp(cname[i], tok, len) == 0) {
+ if (strlen(tok) > len) {
+ char *end = get_index(tok + len, &ndx);
+
+ if ((i != LAYOUT && i != VARIANT) ||
+ *end != '\0' || ndx == -1)
+ break;
+ if (ndx < 1 || ndx > XkbNumKbdGroups) {
+ DebugF("Illegal %s index: %d\n", cname[i], ndx);
+ DebugF("Index must be in range 1..%d\n",
+ XkbNumKbdGroups);
+ break;
+ }
}
- found= TRUE;
- if (present&(1<<i)) {
- if ((i == LAYOUT && l_ndx_present&(1<<ndx)) ||
- (i == VARIANT && v_ndx_present&(1<<ndx)) ) {
- DebugF("Component \"%s\" listed twice\n",tok);
- DebugF("Second definition ignored\n");
- break;
- }
- }
- present |= (1<<i);
+ else {
+ ndx = 0;
+ }
+ found = TRUE;
+ if (present & (1 << i)) {
+ if ((i == LAYOUT && l_ndx_present & (1 << ndx)) ||
+ (i == VARIANT && v_ndx_present & (1 << ndx))) {
+ DebugF("Component \"%s\" listed twice\n", tok);
+ DebugF("Second definition ignored\n");
+ break;
+ }
+ }
+ present |= (1 << i);
if (i == LAYOUT)
l_ndx_present |= 1 << ndx;
if (i == VARIANT)
v_ndx_present |= 1 << ndx;
- remap->remap[remap->num_remap].word= i;
- remap->remap[remap->num_remap++].index= ndx;
- break;
- }
- }
- if (!found) {
- fprintf(stderr,"Unknown component \"%s\" ignored\n",tok);
- }
- }
- if ((present&PART_MASK)==0) {
- unsigned mask= PART_MASK;
- ErrorF("Mapping needs at least one of ");
- for (i=0; (i<MAX_WORDS); i++) {
- if ((1L<<i)&mask) {
- mask&= ~(1L<<i);
- if (mask) DebugF("\"%s,\" ",cname[i]);
- else DebugF("or \"%s\"\n",cname[i]);
- }
- }
- DebugF("Illegal mapping ignored\n");
- remap->num_remap= 0;
- return;
- }
- if ((present&COMPONENT_MASK)==0) {
- DebugF("Mapping needs at least one component\n");
- DebugF("Illegal mapping ignored\n");
- remap->num_remap= 0;
- return;
- }
- remap->number++;
- return;
+ remap->remap[remap->num_remap].word = i;
+ remap->remap[remap->num_remap++].index = ndx;
+ break;
+ }
+ }
+ if (!found) {
+ fprintf(stderr, "Unknown component \"%s\" ignored\n", tok);
+ }
+ }
+ if ((present & PART_MASK) == 0) {
+ unsigned mask = PART_MASK;
+
+ ErrorF("Mapping needs at least one of ");
+ for (i = 0; (i < MAX_WORDS); i++) {
+ if ((1L << i) & mask) {
+ mask &= ~(1L << i);
+ if (mask)
+ DebugF("\"%s,\" ", cname[i]);
+ else
+ DebugF("or \"%s\"\n", cname[i]);
+ }
+ }
+ DebugF("Illegal mapping ignored\n");
+ remap->num_remap = 0;
+ return;
+ }
+ if ((present & COMPONENT_MASK) == 0) {
+ DebugF("Mapping needs at least one component\n");
+ DebugF("Illegal mapping ignored\n");
+ remap->num_remap = 0;
+ return;
+ }
+ remap->number++;
+ return;
}
static Bool
-MatchOneOf(char *wanted,char *vals_defined)
+MatchOneOf(char *wanted, char *vals_defined)
{
-char *str,*next;
-int want_len= strlen(wanted);
-
- for (str=vals_defined,next=NULL;str!=NULL;str=next) {
- int len;
- next= strchr(str,',');
- if (next) {
- len= next-str;
- next++;
- }
- else {
- len= strlen(str);
- }
- if ((len==want_len)&&(strncmp(wanted,str,len)==0))
- return TRUE;
+ char *str, *next;
+ int want_len = strlen(wanted);
+
+ for (str = vals_defined, next = NULL; str != NULL; str = next) {
+ int len;
+
+ next = strchr(str, ',');
+ if (next) {
+ len = next - str;
+ next++;
+ }
+ else {
+ len = strlen(str);
+ }
+ if ((len == want_len) && (strncmp(wanted, str, len) == 0))
+ return TRUE;
}
return FALSE;
}
@@ -365,23 +368,22 @@ int want_len= strlen(wanted);
/***====================================================================***/
static Bool
-CheckLine( InputLine * line,
- RemapSpec * remap,
- XkbRF_RulePtr rule,
- XkbRF_GroupPtr group)
+CheckLine(InputLine * line,
+ RemapSpec * remap, XkbRF_RulePtr rule, XkbRF_GroupPtr group)
{
-char * str,*tok;
-register int nread, i;
-FileSpec tmp;
-_Xstrtokparams strtok_buf;
-Bool append = FALSE;
+ char *str, *tok;
+ register int nread, i;
+ FileSpec tmp;
+ _Xstrtokparams strtok_buf;
+ Bool append = FALSE;
- if (line->line[0]=='!') {
+ if (line->line[0] == '!') {
if (line->line[1] == '$' ||
(line->line[1] == ' ' && line->line[2] == '$')) {
char *gname = strchr(line->line, '$');
char *words = strchr(gname, ' ');
- if(!words)
+
+ if (!words)
return FALSE;
*words++ = '\0';
for (; *words; words++) {
@@ -393,168 +395,178 @@ Bool append = FALSE;
group->name = Xstrdup(gname);
group->words = Xstrdup(words);
for (i = 1, words = group->words; *words; words++) {
- if ( *words == ' ') {
- *words++ = '\0';
- i++;
- }
+ if (*words == ' ') {
+ *words++ = '\0';
+ i++;
+ }
}
group->number = i;
return TRUE;
- } else {
- SetUpRemap(line,remap);
- return FALSE;
- }
- }
-
- if (remap->num_remap==0) {
- DebugF("Must have a mapping before first line of data\n");
- DebugF("Illegal line of data ignored\n");
- return FALSE;
- }
- memset((char *)&tmp, 0, sizeof(FileSpec));
- str= line->line;
- for (nread= 0;(tok=_XStrtok(str," ",strtok_buf))!=NULL;nread++) {
- str= NULL;
- if (strcmp(tok,"=")==0) {
- nread--;
- continue;
- }
- if (nread>remap->num_remap) {
- DebugF("Too many words on a line\n");
- DebugF("Extra word \"%s\" ignored\n",tok);
- continue;
- }
- tmp.name[remap->remap[nread].word]= tok;
- if (*tok == '+' || *tok == '|')
- append = TRUE;
- }
- if (nread<remap->num_remap) {
- DebugF("Too few words on a line: %s\n", line->line);
- DebugF("line ignored\n");
- return FALSE;
- }
-
- rule->flags= 0;
+ }
+ else {
+ SetUpRemap(line, remap);
+ return FALSE;
+ }
+ }
+
+ if (remap->num_remap == 0) {
+ DebugF("Must have a mapping before first line of data\n");
+ DebugF("Illegal line of data ignored\n");
+ return FALSE;
+ }
+ memset((char *) &tmp, 0, sizeof(FileSpec));
+ str = line->line;
+ for (nread = 0; (tok = _XStrtok(str, " ", strtok_buf)) != NULL; nread++) {
+ str = NULL;
+ if (strcmp(tok, "=") == 0) {
+ nread--;
+ continue;
+ }
+ if (nread > remap->num_remap) {
+ DebugF("Too many words on a line\n");
+ DebugF("Extra word \"%s\" ignored\n", tok);
+ continue;
+ }
+ tmp.name[remap->remap[nread].word] = tok;
+ if (*tok == '+' || *tok == '|')
+ append = TRUE;
+ }
+ if (nread < remap->num_remap) {
+ DebugF("Too few words on a line: %s\n", line->line);
+ DebugF("line ignored\n");
+ return FALSE;
+ }
+
+ rule->flags = 0;
rule->number = remap->number;
if (tmp.name[OPTION])
- rule->flags|= XkbRF_Option;
+ rule->flags |= XkbRF_Option;
else if (append)
- rule->flags|= XkbRF_Append;
+ rule->flags |= XkbRF_Append;
else
- rule->flags|= XkbRF_Normal;
- rule->model= Xstrdup(tmp.name[MODEL]);
- rule->layout= Xstrdup(tmp.name[LAYOUT]);
- rule->variant= Xstrdup(tmp.name[VARIANT]);
- rule->option= Xstrdup(tmp.name[OPTION]);
-
- rule->keycodes= Xstrdup(tmp.name[KEYCODES]);
- rule->symbols= Xstrdup(tmp.name[SYMBOLS]);
- rule->types= Xstrdup(tmp.name[TYPES]);
- rule->compat= Xstrdup(tmp.name[COMPAT]);
- rule->geometry= Xstrdup(tmp.name[GEOMETRY]);
+ rule->flags |= XkbRF_Normal;
+ rule->model = Xstrdup(tmp.name[MODEL]);
+ rule->layout = Xstrdup(tmp.name[LAYOUT]);
+ rule->variant = Xstrdup(tmp.name[VARIANT]);
+ rule->option = Xstrdup(tmp.name[OPTION]);
+
+ rule->keycodes = Xstrdup(tmp.name[KEYCODES]);
+ rule->symbols = Xstrdup(tmp.name[SYMBOLS]);
+ rule->types = Xstrdup(tmp.name[TYPES]);
+ rule->compat = Xstrdup(tmp.name[COMPAT]);
+ rule->geometry = Xstrdup(tmp.name[GEOMETRY]);
rule->layout_num = rule->variant_num = 0;
for (i = 0; i < nread; i++) {
if (remap->remap[i].index) {
- if (remap->remap[i].word == LAYOUT)
- rule->layout_num = remap->remap[i].index;
- if (remap->remap[i].word == VARIANT)
- rule->variant_num = remap->remap[i].index;
+ if (remap->remap[i].word == LAYOUT)
+ rule->layout_num = remap->remap[i].index;
+ if (remap->remap[i].word == VARIANT)
+ rule->variant_num = remap->remap[i].index;
}
}
return TRUE;
}
static char *
-_Concat(char *str1,char *str2)
+_Concat(char *str1, char *str2)
{
-int len;
+ int len;
- if ((!str1)||(!str2))
- return str1;
- len= strlen(str1)+strlen(str2)+1;
- str1= realloc(str1,len * sizeof(char));
+ if ((!str1) || (!str2))
+ return str1;
+ len = strlen(str1) + strlen(str2) + 1;
+ str1 = realloc(str1, len * sizeof(char));
if (str1)
- strcat(str1,str2);
+ strcat(str1, str2);
return str1;
}
static void
squeeze_spaces(char *p1)
{
- char *p2;
- for (p2 = p1; *p2; p2++) {
- *p1 = *p2;
- if (*p1 != ' ') p1++;
- }
- *p1 = '\0';
+ char *p2;
+
+ for (p2 = p1; *p2; p2++) {
+ *p1 = *p2;
+ if (*p1 != ' ')
+ p1++;
+ }
+ *p1 = '\0';
}
static Bool
MakeMultiDefs(XkbRF_MultiDefsPtr mdefs, XkbRF_VarDefsPtr defs)
{
- memset((char *)mdefs, 0, sizeof(XkbRF_MultiDefsRec));
- mdefs->model = defs->model;
- mdefs->options = Xstrdup(defs->options);
- if (mdefs->options) squeeze_spaces(mdefs->options);
-
- if (defs->layout) {
- if (!strchr(defs->layout, ',')) {
- mdefs->layout[0] = defs->layout;
- } else {
- char *p;
- int i;
- mdefs->layout[1] = Xstrdup(defs->layout);
- if (mdefs->layout[1] == NULL)
- return FALSE;
- squeeze_spaces(mdefs->layout[1]);
- p = mdefs->layout[1];
- for (i = 2; i <= XkbNumKbdGroups; i++) {
- if ((p = strchr(p, ','))) {
- *p++ = '\0';
- mdefs->layout[i] = p;
- } else {
- break;
- }
- }
- if (p && (p = strchr(p, ',')))
- *p = '\0';
- }
- }
-
- if (defs->variant) {
- if (!strchr(defs->variant, ',')) {
- mdefs->variant[0] = defs->variant;
- } else {
- char *p;
- int i;
- mdefs->variant[1] = Xstrdup(defs->variant);
- if (mdefs->variant[1] == NULL)
- return FALSE;
- squeeze_spaces(mdefs->variant[1]);
- p = mdefs->variant[1];
- for (i = 2; i <= XkbNumKbdGroups; i++) {
- if ((p = strchr(p, ','))) {
- *p++ = '\0';
- mdefs->variant[i] = p;
- } else {
- break;
- }
- }
- if (p && (p = strchr(p, ',')))
- *p = '\0';
- }
- }
- return TRUE;
+ memset((char *) mdefs, 0, sizeof(XkbRF_MultiDefsRec));
+ mdefs->model = defs->model;
+ mdefs->options = Xstrdup(defs->options);
+ if (mdefs->options)
+ squeeze_spaces(mdefs->options);
+
+ if (defs->layout) {
+ if (!strchr(defs->layout, ',')) {
+ mdefs->layout[0] = defs->layout;
+ }
+ else {
+ char *p;
+ int i;
+
+ mdefs->layout[1] = Xstrdup(defs->layout);
+ if (mdefs->layout[1] == NULL)
+ return FALSE;
+ squeeze_spaces(mdefs->layout[1]);
+ p = mdefs->layout[1];
+ for (i = 2; i <= XkbNumKbdGroups; i++) {
+ if ((p = strchr(p, ','))) {
+ *p++ = '\0';
+ mdefs->layout[i] = p;
+ }
+ else {
+ break;
+ }
+ }
+ if (p && (p = strchr(p, ',')))
+ *p = '\0';
+ }
+ }
+
+ if (defs->variant) {
+ if (!strchr(defs->variant, ',')) {
+ mdefs->variant[0] = defs->variant;
+ }
+ else {
+ char *p;
+ int i;
+
+ mdefs->variant[1] = Xstrdup(defs->variant);
+ if (mdefs->variant[1] == NULL)
+ return FALSE;
+ squeeze_spaces(mdefs->variant[1]);
+ p = mdefs->variant[1];
+ for (i = 2; i <= XkbNumKbdGroups; i++) {
+ if ((p = strchr(p, ','))) {
+ *p++ = '\0';
+ mdefs->variant[i] = p;
+ }
+ else {
+ break;
+ }
+ }
+ if (p && (p = strchr(p, ',')))
+ *p = '\0';
+ }
+ }
+ return TRUE;
}
static void
FreeMultiDefs(XkbRF_MultiDefsPtr defs)
{
- free(defs->options);
- free(defs->layout[1]);
- free(defs->variant[1]);
+ free(defs->options);
+ free(defs->layout[1]);
+ free(defs->variant[1]);
}
static void
@@ -562,168 +574,171 @@ Apply(char *src, char **dst)
{
if (src) {
if (*src == '+' || *src == '!') {
- *dst= _Concat(*dst, src);
- } else {
+ *dst = _Concat(*dst, src);
+ }
+ else {
if (*dst == NULL)
- *dst= Xstrdup(src);
+ *dst = Xstrdup(src);
}
}
}
static void
-XkbRF_ApplyRule( XkbRF_RulePtr rule,
- XkbComponentNamesPtr names)
+XkbRF_ApplyRule(XkbRF_RulePtr rule, XkbComponentNamesPtr names)
{
- rule->flags&= ~XkbRF_PendingMatch; /* clear the flag because it's applied */
+ rule->flags &= ~XkbRF_PendingMatch; /* clear the flag because it's applied */
Apply(rule->keycodes, &names->keycodes);
- Apply(rule->symbols, &names->symbols);
- Apply(rule->types, &names->types);
- Apply(rule->compat, &names->compat);
+ Apply(rule->symbols, &names->symbols);
+ Apply(rule->types, &names->types);
+ Apply(rule->compat, &names->compat);
Apply(rule->geometry, &names->geometry);
}
static Bool
-CheckGroup( XkbRF_RulesPtr rules,
- char * group_name,
- char * name)
+CheckGroup(XkbRF_RulesPtr rules, char *group_name, char *name)
{
- int i;
- char *p;
- XkbRF_GroupPtr group;
-
- for (i = 0, group = rules->groups; i < rules->num_groups; i++, group++) {
- if (! strcmp(group->name, group_name)) {
- break;
- }
- }
- if (i == rules->num_groups)
- return FALSE;
- for (i = 0, p = group->words; i < group->number; i++, p += strlen(p)+1) {
- if (! strcmp(p, name)) {
- return TRUE;
- }
- }
- return FALSE;
+ int i;
+ char *p;
+ XkbRF_GroupPtr group;
+
+ for (i = 0, group = rules->groups; i < rules->num_groups; i++, group++) {
+ if (!strcmp(group->name, group_name)) {
+ break;
+ }
+ }
+ if (i == rules->num_groups)
+ return FALSE;
+ for (i = 0, p = group->words; i < group->number; i++, p += strlen(p) + 1) {
+ if (!strcmp(p, name)) {
+ return TRUE;
+ }
+ }
+ return FALSE;
}
static int
-XkbRF_CheckApplyRule( XkbRF_RulePtr rule,
- XkbRF_MultiDefsPtr mdefs,
- XkbComponentNamesPtr names,
- XkbRF_RulesPtr rules)
+XkbRF_CheckApplyRule(XkbRF_RulePtr rule,
+ XkbRF_MultiDefsPtr mdefs,
+ XkbComponentNamesPtr names, XkbRF_RulesPtr rules)
{
Bool pending = FALSE;
if (rule->model != NULL) {
- if(mdefs->model == NULL)
+ if (mdefs->model == NULL)
return 0;
if (strcmp(rule->model, "*") == 0) {
pending = TRUE;
- } else {
+ }
+ else {
if (rule->model[0] == '$') {
- if (!CheckGroup(rules, rule->model, mdefs->model))
- return 0;
- } else {
- if (strcmp(rule->model, mdefs->model) != 0)
- return 0;
- }
- }
+ if (!CheckGroup(rules, rule->model, mdefs->model))
+ return 0;
+ }
+ else {
+ if (strcmp(rule->model, mdefs->model) != 0)
+ return 0;
+ }
+ }
}
if (rule->option != NULL) {
- if (mdefs->options == NULL)
- return 0;
- if ((!MatchOneOf(rule->option,mdefs->options)))
- return 0;
+ if (mdefs->options == NULL)
+ return 0;
+ if ((!MatchOneOf(rule->option, mdefs->options)))
+ return 0;
}
if (rule->layout != NULL) {
- if(mdefs->layout[rule->layout_num] == NULL ||
- *mdefs->layout[rule->layout_num] == '\0')
- return 0;
+ if (mdefs->layout[rule->layout_num] == NULL ||
+ *mdefs->layout[rule->layout_num] == '\0')
+ return 0;
if (strcmp(rule->layout, "*") == 0) {
pending = TRUE;
- } else {
+ }
+ else {
if (rule->layout[0] == '$') {
- if (!CheckGroup(rules, rule->layout,
- mdefs->layout[rule->layout_num]))
- return 0;
- } else {
- if (strcmp(rule->layout, mdefs->layout[rule->layout_num]) != 0)
- return 0;
- }
- }
+ if (!CheckGroup(rules, rule->layout,
+ mdefs->layout[rule->layout_num]))
+ return 0;
+ }
+ else {
+ if (strcmp(rule->layout, mdefs->layout[rule->layout_num]) != 0)
+ return 0;
+ }
+ }
}
if (rule->variant != NULL) {
- if (mdefs->variant[rule->variant_num] == NULL ||
- *mdefs->variant[rule->variant_num] == '\0')
- return 0;
+ if (mdefs->variant[rule->variant_num] == NULL ||
+ *mdefs->variant[rule->variant_num] == '\0')
+ return 0;
if (strcmp(rule->variant, "*") == 0) {
pending = TRUE;
- } else {
+ }
+ else {
if (rule->variant[0] == '$') {
- if (!CheckGroup(rules, rule->variant,
- mdefs->variant[rule->variant_num]))
- return 0;
- } else {
- if (strcmp(rule->variant,
- mdefs->variant[rule->variant_num]) != 0)
- return 0;
- }
- }
+ if (!CheckGroup(rules, rule->variant,
+ mdefs->variant[rule->variant_num]))
+ return 0;
+ }
+ else {
+ if (strcmp(rule->variant,
+ mdefs->variant[rule->variant_num]) != 0)
+ return 0;
+ }
+ }
}
if (pending) {
- rule->flags|= XkbRF_PendingMatch;
- return rule->number;
+ rule->flags |= XkbRF_PendingMatch;
+ return rule->number;
}
/* exact match, apply it now */
- XkbRF_ApplyRule(rule,names);
+ XkbRF_ApplyRule(rule, names);
return rule->number;
}
static void
XkbRF_ClearPartialMatches(XkbRF_RulesPtr rules)
{
-register int i;
-XkbRF_RulePtr rule;
+ register int i;
+ XkbRF_RulePtr rule;
- for (i=0,rule=rules->rules;i<rules->num_rules;i++,rule++) {
- rule->flags&= ~XkbRF_PendingMatch;
+ for (i = 0, rule = rules->rules; i < rules->num_rules; i++, rule++) {
+ rule->flags &= ~XkbRF_PendingMatch;
}
}
static void
-XkbRF_ApplyPartialMatches(XkbRF_RulesPtr rules,XkbComponentNamesPtr names)
+XkbRF_ApplyPartialMatches(XkbRF_RulesPtr rules, XkbComponentNamesPtr names)
{
-int i;
-XkbRF_RulePtr rule;
+ int i;
+ XkbRF_RulePtr rule;
for (rule = rules->rules, i = 0; i < rules->num_rules; i++, rule++) {
- if ((rule->flags&XkbRF_PendingMatch)==0)
- continue;
- XkbRF_ApplyRule(rule,names);
+ if ((rule->flags & XkbRF_PendingMatch) == 0)
+ continue;
+ XkbRF_ApplyRule(rule, names);
}
}
static void
-XkbRF_CheckApplyRules( XkbRF_RulesPtr rules,
- XkbRF_MultiDefsPtr mdefs,
- XkbComponentNamesPtr names,
- int flags)
+XkbRF_CheckApplyRules(XkbRF_RulesPtr rules,
+ XkbRF_MultiDefsPtr mdefs,
+ XkbComponentNamesPtr names, int flags)
{
-int i;
-XkbRF_RulePtr rule;
-int skip;
-
- for (rule = rules->rules, i=0; i < rules->num_rules; rule++, i++) {
- if ((rule->flags & flags) != flags)
- continue;
- skip = XkbRF_CheckApplyRule(rule, mdefs, names, rules);
- if (skip && !(flags & XkbRF_Option)) {
- for ( ;(i < rules->num_rules) && (rule->number == skip);
- rule++, i++);
- rule--; i--;
- }
+ int i;
+ XkbRF_RulePtr rule;
+ int skip;
+
+ for (rule = rules->rules, i = 0; i < rules->num_rules; rule++, i++) {
+ if ((rule->flags & flags) != flags)
+ continue;
+ skip = XkbRF_CheckApplyRule(rule, mdefs, names, rules);
+ if (skip && !(flags & XkbRF_Option)) {
+ for (; (i < rules->num_rules) && (rule->number == skip);
+ rule++, i++);
+ rule--;
+ i--;
+ }
}
}
@@ -732,108 +747,117 @@ int skip;
static char *
XkbRF_SubstituteVars(char *name, XkbRF_MultiDefsPtr mdefs)
{
-char *str, *outstr, *orig, *var;
-int len, ndx;
-
- orig= name;
- str= index(name,'%');
- if (str==NULL)
- return name;
- len= strlen(name);
- while (str!=NULL) {
- char pfx= str[1];
- int extra_len= 0;
- if ((pfx=='+')||(pfx=='|')||(pfx=='_')||(pfx=='-')) {
- extra_len= 1;
- str++;
- }
- else if (pfx=='(') {
- extra_len= 2;
- str++;
- }
- var = str + 1;
- str = get_index(var + 1, &ndx);
- if (ndx == -1) {
- str = index(str,'%');
- continue;
- }
- if ((*var=='l') && mdefs->layout[ndx] && *mdefs->layout[ndx])
- len+= strlen(mdefs->layout[ndx])+extra_len;
- else if ((*var=='m')&&mdefs->model)
- len+= strlen(mdefs->model)+extra_len;
- else if ((*var=='v') && mdefs->variant[ndx] && *mdefs->variant[ndx])
- len+= strlen(mdefs->variant[ndx])+extra_len;
- if ((pfx=='(')&&(*str==')')) {
- str++;
- }
- str= index(&str[0],'%');
- }
- name= malloc(len+1);
- str= orig;
- outstr= name;
- while (*str!='\0') {
- if (str[0]=='%') {
- char pfx,sfx;
- str++;
- pfx= str[0];
- sfx= '\0';
- if ((pfx=='+')||(pfx=='|')||(pfx=='_')||(pfx=='-')) {
- str++;
- }
- else if (pfx=='(') {
- sfx= ')';
- str++;
- }
- else pfx= '\0';
-
- var = str;
- str = get_index(var + 1, &ndx);
- if (ndx == -1) {
- continue;
+ char *str, *outstr, *orig, *var;
+ int len, ndx;
+
+ orig = name;
+ str = index(name, '%');
+ if (str == NULL)
+ return name;
+ len = strlen(name);
+ while (str != NULL) {
+ char pfx = str[1];
+ int extra_len = 0;
+
+ if ((pfx == '+') || (pfx == '|') || (pfx == '_') || (pfx == '-')) {
+ extra_len = 1;
+ str++;
+ }
+ else if (pfx == '(') {
+ extra_len = 2;
+ str++;
+ }
+ var = str + 1;
+ str = get_index(var + 1, &ndx);
+ if (ndx == -1) {
+ str = index(str, '%');
+ continue;
+ }
+ if ((*var == 'l') && mdefs->layout[ndx] && *mdefs->layout[ndx])
+ len += strlen(mdefs->layout[ndx]) + extra_len;
+ else if ((*var == 'm') && mdefs->model)
+ len += strlen(mdefs->model) + extra_len;
+ else if ((*var == 'v') && mdefs->variant[ndx] && *mdefs->variant[ndx])
+ len += strlen(mdefs->variant[ndx]) + extra_len;
+ if ((pfx == '(') && (*str == ')')) {
+ str++;
+ }
+ str = index(&str[0], '%');
+ }
+ name = malloc(len + 1);
+ str = orig;
+ outstr = name;
+ while (*str != '\0') {
+ if (str[0] == '%') {
+ char pfx, sfx;
+
+ str++;
+ pfx = str[0];
+ sfx = '\0';
+ if ((pfx == '+') || (pfx == '|') || (pfx == '_') || (pfx == '-')) {
+ str++;
+ }
+ else if (pfx == '(') {
+ sfx = ')';
+ str++;
}
- if ((*var=='l') && mdefs->layout[ndx] && *mdefs->layout[ndx]) {
- if (pfx) *outstr++= pfx;
- strcpy(outstr,mdefs->layout[ndx]);
- outstr+= strlen(mdefs->layout[ndx]);
- if (sfx) *outstr++= sfx;
- }
- else if ((*var=='m')&&(mdefs->model)) {
- if (pfx) *outstr++= pfx;
- strcpy(outstr,mdefs->model);
- outstr+= strlen(mdefs->model);
- if (sfx) *outstr++= sfx;
- }
- else if ((*var=='v') && mdefs->variant[ndx] && *mdefs->variant[ndx]) {
- if (pfx) *outstr++= pfx;
- strcpy(outstr,mdefs->variant[ndx]);
- outstr+= strlen(mdefs->variant[ndx]);
- if (sfx) *outstr++= sfx;
- }
- if ((pfx=='(')&&(*str==')'))
- str++;
- }
- else {
- *outstr++= *str++;
- }
- }
- *outstr++= '\0';
- if (orig!=name)
- free(orig);
+ else
+ pfx = '\0';
+
+ var = str;
+ str = get_index(var + 1, &ndx);
+ if (ndx == -1) {
+ continue;
+ }
+ if ((*var == 'l') && mdefs->layout[ndx] && *mdefs->layout[ndx]) {
+ if (pfx)
+ *outstr++ = pfx;
+ strcpy(outstr, mdefs->layout[ndx]);
+ outstr += strlen(mdefs->layout[ndx]);
+ if (sfx)
+ *outstr++ = sfx;
+ }
+ else if ((*var == 'm') && (mdefs->model)) {
+ if (pfx)
+ *outstr++ = pfx;
+ strcpy(outstr, mdefs->model);
+ outstr += strlen(mdefs->model);
+ if (sfx)
+ *outstr++ = sfx;
+ }
+ else if ((*var == 'v') && mdefs->variant[ndx] &&
+ *mdefs->variant[ndx]) {
+ if (pfx)
+ *outstr++ = pfx;
+ strcpy(outstr, mdefs->variant[ndx]);
+ outstr += strlen(mdefs->variant[ndx]);
+ if (sfx)
+ *outstr++ = sfx;
+ }
+ if ((pfx == '(') && (*str == ')'))
+ str++;
+ }
+ else {
+ *outstr++ = *str++;
+ }
+ }
+ *outstr++ = '\0';
+ if (orig != name)
+ free(orig);
return name;
}
/***====================================================================***/
Bool
-XkbRF_GetComponents( XkbRF_RulesPtr rules,
- XkbRF_VarDefsPtr defs,
- XkbComponentNamesPtr names)
+XkbRF_GetComponents(XkbRF_RulesPtr rules,
+ XkbRF_VarDefsPtr defs, XkbComponentNamesPtr names)
{
XkbRF_MultiDefsRec mdefs;
MakeMultiDefs(&mdefs, defs);
- memset((char *)names, 0, sizeof(XkbComponentNamesRec));
+ memset((char *) names, 0, sizeof(XkbComponentNamesRec));
XkbRF_ClearPartialMatches(rules);
XkbRF_CheckApplyRules(rules, &mdefs, names, XkbRF_Normal);
XkbRF_ApplyPartialMatches(rules, names);
@@ -842,125 +866,127 @@ XkbRF_GetComponents( XkbRF_RulesPtr rules,
XkbRF_CheckApplyRules(rules, &mdefs, names, XkbRF_Option);
if (names->keycodes)
- names->keycodes= XkbRF_SubstituteVars(names->keycodes, &mdefs);
- if (names->symbols)
- names->symbols= XkbRF_SubstituteVars(names->symbols, &mdefs);
+ names->keycodes = XkbRF_SubstituteVars(names->keycodes, &mdefs);
+ if (names->symbols)
+ names->symbols = XkbRF_SubstituteVars(names->symbols, &mdefs);
if (names->types)
- names->types= XkbRF_SubstituteVars(names->types, &mdefs);
+ names->types = XkbRF_SubstituteVars(names->types, &mdefs);
if (names->compat)
- names->compat= XkbRF_SubstituteVars(names->compat, &mdefs);
+ names->compat = XkbRF_SubstituteVars(names->compat, &mdefs);
if (names->geometry)
- names->geometry= XkbRF_SubstituteVars(names->geometry, &mdefs);
+ names->geometry = XkbRF_SubstituteVars(names->geometry, &mdefs);
FreeMultiDefs(&mdefs);
return (names->keycodes && names->symbols && names->types &&
- names->compat && names->geometry);
+ names->compat && names->geometry);
}
static XkbRF_RulePtr
-XkbRF_AddRule(XkbRF_RulesPtr rules)
+XkbRF_AddRule(XkbRF_RulesPtr rules)
{
- if (rules->sz_rules<1) {
- rules->sz_rules= 16;
- rules->num_rules= 0;
- rules->rules= calloc(rules->sz_rules, sizeof(XkbRF_RuleRec));
+ if (rules->sz_rules < 1) {
+ rules->sz_rules = 16;
+ rules->num_rules = 0;
+ rules->rules = calloc(rules->sz_rules, sizeof(XkbRF_RuleRec));
}
- else if (rules->num_rules>=rules->sz_rules) {
- rules->sz_rules*= 2;
- rules->rules= realloc(rules->rules,
- rules->sz_rules * sizeof(XkbRF_RuleRec));
+ else if (rules->num_rules >= rules->sz_rules) {
+ rules->sz_rules *= 2;
+ rules->rules = realloc(rules->rules,
+ rules->sz_rules * sizeof(XkbRF_RuleRec));
}
if (!rules->rules) {
- rules->sz_rules= rules->num_rules= 0;
- DebugF("Allocation failure in XkbRF_AddRule\n");
- return NULL;
+ rules->sz_rules = rules->num_rules = 0;
+ DebugF("Allocation failure in XkbRF_AddRule\n");
+ return NULL;
}
- memset((char *)&rules->rules[rules->num_rules], 0, sizeof(XkbRF_RuleRec));
+ memset((char *) &rules->rules[rules->num_rules], 0, sizeof(XkbRF_RuleRec));
return &rules->rules[rules->num_rules++];
}
static XkbRF_GroupPtr
-XkbRF_AddGroup(XkbRF_RulesPtr rules)
+XkbRF_AddGroup(XkbRF_RulesPtr rules)
{
- if (rules->sz_groups<1) {
- rules->sz_groups= 16;
- rules->num_groups= 0;
- rules->groups= calloc(rules->sz_groups, sizeof(XkbRF_GroupRec));
+ if (rules->sz_groups < 1) {
+ rules->sz_groups = 16;
+ rules->num_groups = 0;
+ rules->groups = calloc(rules->sz_groups, sizeof(XkbRF_GroupRec));
}
else if (rules->num_groups >= rules->sz_groups) {
- rules->sz_groups *= 2;
- rules->groups= realloc(rules->groups,
- rules->sz_groups * sizeof(XkbRF_GroupRec));
+ rules->sz_groups *= 2;
+ rules->groups = realloc(rules->groups,
+ rules->sz_groups * sizeof(XkbRF_GroupRec));
}
if (!rules->groups) {
- rules->sz_groups= rules->num_groups= 0;
- return NULL;
+ rules->sz_groups = rules->num_groups = 0;
+ return NULL;
}
- memset((char *)&rules->groups[rules->num_groups], 0, sizeof(XkbRF_GroupRec));
+ memset((char *) &rules->groups[rules->num_groups], 0,
+ sizeof(XkbRF_GroupRec));
return &rules->groups[rules->num_groups++];
}
Bool
-XkbRF_LoadRules(FILE *file, XkbRF_RulesPtr rules)
+XkbRF_LoadRules(FILE * file, XkbRF_RulesPtr rules)
{
-InputLine line;
-RemapSpec remap;
-XkbRF_RuleRec trule,*rule;
-XkbRF_GroupRec tgroup,*group;
+ InputLine line;
+ RemapSpec remap;
+ XkbRF_RuleRec trule, *rule;
+ XkbRF_GroupRec tgroup, *group;
if (!(rules && file))
- return FALSE;
- memset((char *)&remap, 0, sizeof(RemapSpec));
- memset((char *)&tgroup, 0, sizeof(XkbRF_GroupRec));
+ return FALSE;
+ memset((char *) &remap, 0, sizeof(RemapSpec));
+ memset((char *) &tgroup, 0, sizeof(XkbRF_GroupRec));
InitInputLine(&line);
- while (GetInputLine(file,&line,TRUE)) {
- if (CheckLine(&line,&remap,&trule,&tgroup)) {
+ while (GetInputLine(file, &line, TRUE)) {
+ if (CheckLine(&line, &remap, &trule, &tgroup)) {
if (tgroup.number) {
- if ((group= XkbRF_AddGroup(rules))!=NULL) {
- *group= tgroup;
- memset((char *)&tgroup, 0, sizeof(XkbRF_GroupRec));
- }
- } else {
- if ((rule= XkbRF_AddRule(rules))!=NULL) {
- *rule= trule;
- memset((char *)&trule, 0, sizeof(XkbRF_RuleRec));
- }
- }
- }
- line.num_line= 0;
+ if ((group = XkbRF_AddGroup(rules)) != NULL) {
+ *group = tgroup;
+ memset((char *) &tgroup, 0, sizeof(XkbRF_GroupRec));
+ }
+ }
+ else {
+ if ((rule = XkbRF_AddRule(rules)) != NULL) {
+ *rule = trule;
+ memset((char *) &trule, 0, sizeof(XkbRF_RuleRec));
+ }
+ }
+ }
+ line.num_line = 0;
}
FreeInputLine(&line);
return TRUE;
}
Bool
-XkbRF_LoadRulesByName(char *base,char *locale,XkbRF_RulesPtr rules)
+XkbRF_LoadRulesByName(char *base, char *locale, XkbRF_RulesPtr rules)
{
-FILE * file;
-char buf[PATH_MAX];
-Bool ok;
+ FILE *file;
+ char buf[PATH_MAX];
+ Bool ok;
- if ((!base)||(!rules))
- return FALSE;
+ if ((!base) || (!rules))
+ return FALSE;
if (locale) {
- if (snprintf(buf, PATH_MAX, "%s-%s", base, locale) >= PATH_MAX)
- return FALSE;
+ if (snprintf(buf, PATH_MAX, "%s-%s", base, locale) >= PATH_MAX)
+ return FALSE;
}
else {
- if (strlen(base)+1 > PATH_MAX)
- return FALSE;
- strcpy(buf,base);
+ if (strlen(base) + 1 > PATH_MAX)
+ return FALSE;
+ strcpy(buf, base);
}
- file= fopen(buf, "r");
- if ((!file)&&(locale)) { /* fallback if locale was specified */
- strcpy(buf,base);
- file= fopen(buf, "r");
+ file = fopen(buf, "r");
+ if ((!file) && (locale)) { /* fallback if locale was specified */
+ strcpy(buf, base);
+ file = fopen(buf, "r");
}
if (!file)
- return FALSE;
- ok= XkbRF_LoadRules(file,rules);
+ return FALSE;
+ ok = XkbRF_LoadRules(file, rules);
fclose(file);
return ok;
}
@@ -970,48 +996,48 @@ Bool ok;
XkbRF_RulesPtr
XkbRF_Create(void)
{
- return calloc(1, sizeof( XkbRF_RulesRec));
+ return calloc(1, sizeof(XkbRF_RulesRec));
}
/***====================================================================***/
void
-XkbRF_Free(XkbRF_RulesPtr rules,Bool freeRules)
+XkbRF_Free(XkbRF_RulesPtr rules, Bool freeRules)
{
-int i;
-XkbRF_RulePtr rule;
-XkbRF_GroupPtr group;
+ int i;
+ XkbRF_RulePtr rule;
+ XkbRF_GroupPtr group;
if (!rules)
- return;
+ return;
if (rules->rules) {
- for (i=0,rule=rules->rules;i<rules->num_rules;i++,rule++) {
- free(rule->model);
- free(rule->layout);
- free(rule->variant);
- free(rule->option);
- free(rule->keycodes);
- free(rule->symbols);
- free(rule->types);
- free(rule->compat);
- free(rule->geometry);
- memset((char *)rule, 0, sizeof(XkbRF_RuleRec));
- }
- free(rules->rules);
- rules->num_rules= rules->sz_rules= 0;
- rules->rules= NULL;
+ for (i = 0, rule = rules->rules; i < rules->num_rules; i++, rule++) {
+ free(rule->model);
+ free(rule->layout);
+ free(rule->variant);
+ free(rule->option);
+ free(rule->keycodes);
+ free(rule->symbols);
+ free(rule->types);
+ free(rule->compat);
+ free(rule->geometry);
+ memset((char *) rule, 0, sizeof(XkbRF_RuleRec));
+ }
+ free(rules->rules);
+ rules->num_rules = rules->sz_rules = 0;
+ rules->rules = NULL;
}
if (rules->groups) {
- for (i=0, group=rules->groups;i<rules->num_groups;i++,group++) {
- free(group->name);
- free(group->words);
- }
- free(rules->groups);
- rules->num_groups= 0;
- rules->groups= NULL;
+ for (i = 0, group = rules->groups; i < rules->num_groups; i++, group++) {
+ free(group->name);
+ free(group->words);
+ }
+ free(rules->groups);
+ rules->num_groups = 0;
+ rules->groups = NULL;
}
if (freeRules)
- free(rules);
+ free(rules);
return;
}
diff --git a/xkb/xkb.c b/xkb/xkb.c
index ac0b4278f..867a992d2 100644
--- a/xkb/xkb.c
+++ b/xkb/xkb.c
@@ -43,14 +43,14 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <X11/extensions/XI.h>
#include <X11/extensions/XKMformat.h>
-int XkbEventBase;
-static int XkbErrorBase;
-int XkbReqCode;
-int XkbKeyboardErrorCode;
-CARD32 xkbDebugFlags = 0;
-static CARD32 xkbDebugCtrls = 0;
+int XkbEventBase;
+static int XkbErrorBase;
+int XkbReqCode;
+int XkbKeyboardErrorCode;
+CARD32 xkbDebugFlags = 0;
+static CARD32 xkbDebugCtrls = 0;
-static RESTYPE RT_XKBCLIENT;
+static RESTYPE RT_XKBCLIENT;
/***====================================================================***/
@@ -157,28 +157,29 @@ int
ProcXkbUseExtension(ClientPtr client)
{
REQUEST(xkbUseExtensionReq);
- xkbUseExtensionReply rep;
- int supported;
+ xkbUseExtensionReply rep;
+ int supported;
REQUEST_SIZE_MATCH(xkbUseExtensionReq);
if (stuff->wantedMajor != SERVER_XKB_MAJOR_VERSION) {
- /* pre-release version 0.65 is compatible with 1.00 */
- supported= ((SERVER_XKB_MAJOR_VERSION==1)&&
- (stuff->wantedMajor==0)&&(stuff->wantedMinor==65));
+ /* pre-release version 0.65 is compatible with 1.00 */
+ supported = ((SERVER_XKB_MAJOR_VERSION == 1) &&
+ (stuff->wantedMajor == 0) && (stuff->wantedMinor == 65));
}
- else supported = 1;
+ else
+ supported = 1;
- if ((supported) && (!(client->xkbClientFlags&_XkbClientInitialized))) {
- client->xkbClientFlags= _XkbClientInitialized;
- client->vMajor= stuff->wantedMajor;
- client->vMinor= stuff->wantedMinor;
+ if ((supported) && (!(client->xkbClientFlags & _XkbClientInitialized))) {
+ client->xkbClientFlags = _XkbClientInitialized;
+ client->vMajor = stuff->wantedMajor;
+ client->vMinor = stuff->wantedMinor;
}
- else if (xkbDebugFlags&0x1) {
- ErrorF("[xkb] Rejecting client %d (0x%lx) (wants %d.%02d, have %d.%02d)\n",
- client->index,
- (long)client->clientAsMask,
- stuff->wantedMajor,stuff->wantedMinor,
- SERVER_XKB_MAJOR_VERSION,SERVER_XKB_MINOR_VERSION);
+ else if (xkbDebugFlags & 0x1) {
+ ErrorF
+ ("[xkb] Rejecting client %d (0x%lx) (wants %d.%02d, have %d.%02d)\n",
+ client->index, (long) client->clientAsMask, stuff->wantedMajor,
+ stuff->wantedMinor, SERVER_XKB_MAJOR_VERSION,
+ SERVER_XKB_MINOR_VERSION);
}
memset(&rep, 0, sizeof(xkbUseExtensionReply));
rep.type = X_Reply;
@@ -187,12 +188,12 @@ ProcXkbUseExtension(ClientPtr client)
rep.sequenceNumber = client->sequence;
rep.serverMajor = SERVER_XKB_MAJOR_VERSION;
rep.serverMinor = SERVER_XKB_MINOR_VERSION;
- if ( client->swapped ) {
- swaps(&rep.sequenceNumber);
- swaps(&rep.serverMajor);
- swaps(&rep.serverMinor);
+ if (client->swapped) {
+ swaps(&rep.sequenceNumber);
+ swaps(&rep.serverMajor);
+ swaps(&rep.serverMinor);
}
- WriteToClient(client,SIZEOF(xkbUseExtensionReply), (char *)&rep);
+ WriteToClient(client, SIZEOF(xkbUseExtensionReply), (char *) &rep);
return Success;
}
@@ -201,149 +202,158 @@ ProcXkbUseExtension(ClientPtr client)
int
ProcXkbSelectEvents(ClientPtr client)
{
- unsigned legal;
- DeviceIntPtr dev;
- XkbInterestPtr masks;
+ unsigned legal;
+ DeviceIntPtr dev;
+ XkbInterestPtr masks;
+
REQUEST(xkbSelectEventsReq);
REQUEST_AT_LEAST_SIZE(xkbSelectEventsReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_ANY_DEVICE(dev, stuff->deviceSpec, client, DixUseAccess);
- if (((stuff->affectWhich&XkbMapNotifyMask)!=0)&&(stuff->affectMap)) {
- client->mapNotifyMask&= ~stuff->affectMap;
- client->mapNotifyMask|= (stuff->affectMap&stuff->map);
+ if (((stuff->affectWhich & XkbMapNotifyMask) != 0) && (stuff->affectMap)) {
+ client->mapNotifyMask &= ~stuff->affectMap;
+ client->mapNotifyMask |= (stuff->affectMap & stuff->map);
}
- if ((stuff->affectWhich&(~XkbMapNotifyMask))==0)
- return Success;
+ if ((stuff->affectWhich & (~XkbMapNotifyMask)) == 0)
+ return Success;
+
+ masks = XkbFindClientResource((DevicePtr) dev, client);
+ if (!masks) {
+ XID id = FakeClientID(client->index);
- masks = XkbFindClientResource((DevicePtr)dev,client);
- if (!masks){
- XID id = FakeClientID(client->index);
- if (!AddResource(id,RT_XKBCLIENT,dev))
- return BadAlloc;
- masks= XkbAddClientResource((DevicePtr)dev,client,id);
+ if (!AddResource(id, RT_XKBCLIENT, dev))
+ return BadAlloc;
+ masks = XkbAddClientResource((DevicePtr) dev, client, id);
}
if (masks) {
- union {
- CARD8 *c8;
- CARD16 *c16;
- CARD32 *c32;
- } from,to;
- register unsigned bit,ndx,maskLeft,dataLeft,size;
-
- from.c8= (CARD8 *)&stuff[1];
- dataLeft= (stuff->length*4)-SIZEOF(xkbSelectEventsReq);
- maskLeft= (stuff->affectWhich&(~XkbMapNotifyMask));
- for (ndx=0,bit=1; (maskLeft!=0); ndx++, bit<<=1) {
- if ((bit&maskLeft)==0)
- continue;
- maskLeft&= ~bit;
- switch (ndx) {
- case XkbNewKeyboardNotify:
- to.c16= &client->newKeyboardNotifyMask;
- legal= XkbAllNewKeyboardEventsMask;
- size= 2;
- break;
- case XkbStateNotify:
- to.c16= &masks->stateNotifyMask;
- legal= XkbAllStateEventsMask;
- size= 2;
- break;
- case XkbControlsNotify:
- to.c32= &masks->ctrlsNotifyMask;
- legal= XkbAllControlEventsMask;
- size= 4;
- break;
- case XkbIndicatorStateNotify:
- to.c32= &masks->iStateNotifyMask;
- legal= XkbAllIndicatorEventsMask;
- size= 4;
- break;
- case XkbIndicatorMapNotify:
- to.c32= &masks->iMapNotifyMask;
- legal= XkbAllIndicatorEventsMask;
- size= 4;
- break;
- case XkbNamesNotify:
- to.c16= &masks->namesNotifyMask;
- legal= XkbAllNameEventsMask;
- size= 2;
- break;
- case XkbCompatMapNotify:
- to.c8= &masks->compatNotifyMask;
- legal= XkbAllCompatMapEventsMask;
- size= 1;
- break;
- case XkbBellNotify:
- to.c8= &masks->bellNotifyMask;
- legal= XkbAllBellEventsMask;
- size= 1;
- break;
- case XkbActionMessage:
- to.c8= &masks->actionMessageMask;
- legal= XkbAllActionMessagesMask;
- size= 1;
- break;
- case XkbAccessXNotify:
- to.c16= &masks->accessXNotifyMask;
- legal= XkbAllAccessXEventsMask;
- size= 2;
- break;
- case XkbExtensionDeviceNotify:
- to.c16= &masks->extDevNotifyMask;
- legal= XkbAllExtensionDeviceEventsMask;
- size= 2;
- break;
- default:
- client->errorValue = _XkbErrCode2(33,bit);
- return BadValue;
- }
-
- if (stuff->clear&bit) {
- if (size==2) to.c16[0]= 0;
- else if (size==4) to.c32[0]= 0;
- else to.c8[0]= 0;
- }
- else if (stuff->selectAll&bit) {
- if (size==2) to.c16[0]= ~0;
- else if (size==4) to.c32[0]= ~0;
- else to.c8[0]= ~0;
- }
- else {
- if (dataLeft<(size*2))
- return BadLength;
- if (size==2) {
- CHK_MASK_MATCH(ndx,from.c16[0],from.c16[1]);
- CHK_MASK_LEGAL(ndx,from.c16[0],legal);
- to.c16[0]&= ~from.c16[0];
- to.c16[0]|= (from.c16[0]&from.c16[1]);
- }
- else if (size==4) {
- CHK_MASK_MATCH(ndx,from.c32[0],from.c32[1]);
- CHK_MASK_LEGAL(ndx,from.c32[0],legal);
- to.c32[0]&= ~from.c32[0];
- to.c32[0]|= (from.c32[0]&from.c32[1]);
- }
- else {
- CHK_MASK_MATCH(ndx,from.c8[0],from.c8[1]);
- CHK_MASK_LEGAL(ndx,from.c8[0],legal);
- to.c8[0]&= ~from.c8[0];
- to.c8[0]|= (from.c8[0]&from.c8[1]);
- size= 2;
- }
- from.c8+= (size*2);
- dataLeft-= (size*2);
- }
- }
- if (dataLeft>2) {
- ErrorF("[xkb] Extra data (%d bytes) after SelectEvents\n",dataLeft);
- return BadLength;
- }
- return Success;
+ union {
+ CARD8 *c8;
+ CARD16 *c16;
+ CARD32 *c32;
+ } from, to;
+ register unsigned bit, ndx, maskLeft, dataLeft, size;
+
+ from.c8 = (CARD8 *) &stuff[1];
+ dataLeft = (stuff->length * 4) - SIZEOF(xkbSelectEventsReq);
+ maskLeft = (stuff->affectWhich & (~XkbMapNotifyMask));
+ for (ndx = 0, bit = 1; (maskLeft != 0); ndx++, bit <<= 1) {
+ if ((bit & maskLeft) == 0)
+ continue;
+ maskLeft &= ~bit;
+ switch (ndx) {
+ case XkbNewKeyboardNotify:
+ to.c16 = &client->newKeyboardNotifyMask;
+ legal = XkbAllNewKeyboardEventsMask;
+ size = 2;
+ break;
+ case XkbStateNotify:
+ to.c16 = &masks->stateNotifyMask;
+ legal = XkbAllStateEventsMask;
+ size = 2;
+ break;
+ case XkbControlsNotify:
+ to.c32 = &masks->ctrlsNotifyMask;
+ legal = XkbAllControlEventsMask;
+ size = 4;
+ break;
+ case XkbIndicatorStateNotify:
+ to.c32 = &masks->iStateNotifyMask;
+ legal = XkbAllIndicatorEventsMask;
+ size = 4;
+ break;
+ case XkbIndicatorMapNotify:
+ to.c32 = &masks->iMapNotifyMask;
+ legal = XkbAllIndicatorEventsMask;
+ size = 4;
+ break;
+ case XkbNamesNotify:
+ to.c16 = &masks->namesNotifyMask;
+ legal = XkbAllNameEventsMask;
+ size = 2;
+ break;
+ case XkbCompatMapNotify:
+ to.c8 = &masks->compatNotifyMask;
+ legal = XkbAllCompatMapEventsMask;
+ size = 1;
+ break;
+ case XkbBellNotify:
+ to.c8 = &masks->bellNotifyMask;
+ legal = XkbAllBellEventsMask;
+ size = 1;
+ break;
+ case XkbActionMessage:
+ to.c8 = &masks->actionMessageMask;
+ legal = XkbAllActionMessagesMask;
+ size = 1;
+ break;
+ case XkbAccessXNotify:
+ to.c16 = &masks->accessXNotifyMask;
+ legal = XkbAllAccessXEventsMask;
+ size = 2;
+ break;
+ case XkbExtensionDeviceNotify:
+ to.c16 = &masks->extDevNotifyMask;
+ legal = XkbAllExtensionDeviceEventsMask;
+ size = 2;
+ break;
+ default:
+ client->errorValue = _XkbErrCode2(33, bit);
+ return BadValue;
+ }
+
+ if (stuff->clear & bit) {
+ if (size == 2)
+ to.c16[0] = 0;
+ else if (size == 4)
+ to.c32[0] = 0;
+ else
+ to.c8[0] = 0;
+ }
+ else if (stuff->selectAll & bit) {
+ if (size == 2)
+ to.c16[0] = ~0;
+ else if (size == 4)
+ to.c32[0] = ~0;
+ else
+ to.c8[0] = ~0;
+ }
+ else {
+ if (dataLeft < (size * 2))
+ return BadLength;
+ if (size == 2) {
+ CHK_MASK_MATCH(ndx, from.c16[0], from.c16[1]);
+ CHK_MASK_LEGAL(ndx, from.c16[0], legal);
+ to.c16[0] &= ~from.c16[0];
+ to.c16[0] |= (from.c16[0] & from.c16[1]);
+ }
+ else if (size == 4) {
+ CHK_MASK_MATCH(ndx, from.c32[0], from.c32[1]);
+ CHK_MASK_LEGAL(ndx, from.c32[0], legal);
+ to.c32[0] &= ~from.c32[0];
+ to.c32[0] |= (from.c32[0] & from.c32[1]);
+ }
+ else {
+ CHK_MASK_MATCH(ndx, from.c8[0], from.c8[1]);
+ CHK_MASK_LEGAL(ndx, from.c8[0], legal);
+ to.c8[0] &= ~from.c8[0];
+ to.c8[0] |= (from.c8[0] & from.c8[1]);
+ size = 2;
+ }
+ from.c8 += (size * 2);
+ dataLeft -= (size * 2);
+ }
+ }
+ if (dataLeft > 2) {
+ ErrorF("[xkb] Extra data (%d bytes) after SelectEvents\n",
+ dataLeft);
+ return BadLength;
+ }
+ return Success;
}
return BadAlloc;
}
@@ -357,67 +367,73 @@ _XkbBell(ClientPtr client, DeviceIntPtr dev, WindowPtr pWin,
int bellClass, int bellID, int pitch, int duration,
int percent, int forceSound, int eventOnly, Atom name)
{
- int base;
- pointer ctrl;
- int oldPitch, oldDuration;
- int newPercent;
+ int base;
+ pointer ctrl;
+ int oldPitch, oldDuration;
+ int newPercent;
if (bellClass == KbdFeedbackClass) {
- KbdFeedbackPtr k;
- if (bellID==XkbDfltXIId)
- k= dev->kbdfeed;
+ KbdFeedbackPtr k;
+
+ if (bellID == XkbDfltXIId)
+ k = dev->kbdfeed;
else {
- for (k=dev->kbdfeed; k; k=k->next) {
+ for (k = dev->kbdfeed; k; k = k->next) {
if (k->ctrl.id == bellID)
break;
}
}
if (!k) {
- client->errorValue = _XkbErrCode2(0x5,bellID);
+ client->errorValue = _XkbErrCode2(0x5, bellID);
return BadValue;
}
base = k->ctrl.bell;
ctrl = (pointer) &(k->ctrl);
- oldPitch= k->ctrl.bell_pitch;
- oldDuration= k->ctrl.bell_duration;
- if (pitch!=0) {
- if (pitch==-1)
- k->ctrl.bell_pitch= defaultKeyboardControl.bell_pitch;
- else k->ctrl.bell_pitch= pitch;
+ oldPitch = k->ctrl.bell_pitch;
+ oldDuration = k->ctrl.bell_duration;
+ if (pitch != 0) {
+ if (pitch == -1)
+ k->ctrl.bell_pitch = defaultKeyboardControl.bell_pitch;
+ else
+ k->ctrl.bell_pitch = pitch;
}
- if (duration!=0) {
- if (duration==-1)
- k->ctrl.bell_duration= defaultKeyboardControl.bell_duration;
- else k->ctrl.bell_duration= duration;
+ if (duration != 0) {
+ if (duration == -1)
+ k->ctrl.bell_duration = defaultKeyboardControl.bell_duration;
+ else
+ k->ctrl.bell_duration = duration;
}
}
else if (bellClass == BellFeedbackClass) {
- BellFeedbackPtr b;
- if (bellID==XkbDfltXIId)
- b= dev->bell;
+ BellFeedbackPtr b;
+
+ if (bellID == XkbDfltXIId)
+ b = dev->bell;
else {
- for (b=dev->bell; b; b=b->next) {
+ for (b = dev->bell; b; b = b->next) {
if (b->ctrl.id == bellID)
break;
}
}
if (!b) {
- client->errorValue = _XkbErrCode2(0x6,bellID);
+ client->errorValue = _XkbErrCode2(0x6, bellID);
return BadValue;
}
base = b->ctrl.percent;
ctrl = (pointer) &(b->ctrl);
- oldPitch= b->ctrl.pitch;
- oldDuration= b->ctrl.duration;
- if (pitch!=0) {
- if (pitch==-1)
- b->ctrl.pitch= defaultKeyboardControl.bell_pitch;
- else b->ctrl.pitch= pitch;
+ oldPitch = b->ctrl.pitch;
+ oldDuration = b->ctrl.duration;
+ if (pitch != 0) {
+ if (pitch == -1)
+ b->ctrl.pitch = defaultKeyboardControl.bell_pitch;
+ else
+ b->ctrl.pitch = pitch;
}
- if (duration!=0) {
- if (duration==-1)
- b->ctrl.duration= defaultKeyboardControl.bell_duration;
- else b->ctrl.duration= duration;
+ if (duration != 0) {
+ if (duration == -1)
+ b->ctrl.duration = defaultKeyboardControl.bell_duration;
+ else
+ b->ctrl.duration = duration;
}
}
else {
@@ -425,30 +441,32 @@ _XkbBell(ClientPtr client, DeviceIntPtr dev, WindowPtr pWin,
return BadValue;
}
- newPercent = (base * percent)/100;
+ newPercent = (base * percent) / 100;
if (percent < 0)
- newPercent = base + newPercent;
- else newPercent = base - newPercent + percent;
+ newPercent = base + newPercent;
+ else
+ newPercent = base - newPercent + percent;
XkbHandleBell(forceSound, eventOnly,
- dev, newPercent, ctrl, bellClass,
- name, pWin, client);
- if ((pitch!=0)||(duration!=0)) {
+ dev, newPercent, ctrl, bellClass, name, pWin, client);
+ if ((pitch != 0) || (duration != 0)) {
if (bellClass == KbdFeedbackClass) {
- KbdFeedbackPtr k;
- k= (KbdFeedbackPtr)ctrl;
- if (pitch!=0)
- k->ctrl.bell_pitch= oldPitch;
- if (duration!=0)
- k->ctrl.bell_duration= oldDuration;
+ KbdFeedbackPtr k;
+
+ k = (KbdFeedbackPtr) ctrl;
+ if (pitch != 0)
+ k->ctrl.bell_pitch = oldPitch;
+ if (duration != 0)
+ k->ctrl.bell_duration = oldDuration;
}
else {
- BellFeedbackPtr b;
- b= (BellFeedbackPtr)ctrl;
- if (pitch!=0)
- b->ctrl.pitch= oldPitch;
- if (duration!=0)
- b->ctrl.duration= oldDuration;
+ BellFeedbackPtr b;
+
+ b = (BellFeedbackPtr) ctrl;
+ if (pitch != 0)
+ b->ctrl.pitch = oldPitch;
+ if (duration != 0)
+ b->ctrl.duration = oldDuration;
}
}
@@ -460,49 +478,52 @@ ProcXkbBell(ClientPtr client)
{
REQUEST(xkbBellReq);
DeviceIntPtr dev;
- WindowPtr pWin;
+ WindowPtr pWin;
int rc;
REQUEST_SIZE_MATCH(xkbBellReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_BELL_DEVICE(dev, stuff->deviceSpec, client, DixBellAccess);
CHK_ATOM_OR_NONE(stuff->name);
/* device-independent checks request for sane values */
- if ((stuff->forceSound)&&(stuff->eventOnly)) {
- client->errorValue=_XkbErrCode3(0x1,stuff->forceSound,stuff->eventOnly);
- return BadMatch;
+ if ((stuff->forceSound) && (stuff->eventOnly)) {
+ client->errorValue =
+ _XkbErrCode3(0x1, stuff->forceSound, stuff->eventOnly);
+ return BadMatch;
}
if (stuff->percent < -100 || stuff->percent > 100) {
- client->errorValue = _XkbErrCode2(0x2,stuff->percent);
- return BadValue;
+ client->errorValue = _XkbErrCode2(0x2, stuff->percent);
+ return BadValue;
}
- if (stuff->duration<-1) {
- client->errorValue = _XkbErrCode2(0x3,stuff->duration);
- return BadValue;
+ if (stuff->duration < -1) {
+ client->errorValue = _XkbErrCode2(0x3, stuff->duration);
+ return BadValue;
}
- if (stuff->pitch<-1) {
- client->errorValue = _XkbErrCode2(0x4,stuff->pitch);
- return BadValue;
+ if (stuff->pitch < -1) {
+ client->errorValue = _XkbErrCode2(0x4, stuff->pitch);
+ return BadValue;
}
if (stuff->bellClass == XkbDfltXIClass) {
- if (dev->kbdfeed!=NULL)
- stuff->bellClass= KbdFeedbackClass;
- else stuff->bellClass= BellFeedbackClass;
+ if (dev->kbdfeed != NULL)
+ stuff->bellClass = KbdFeedbackClass;
+ else
+ stuff->bellClass = BellFeedbackClass;
}
- if (stuff->window!=None) {
- rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
- if (rc != Success) {
- client->errorValue= stuff->window;
- return rc;
- }
+ if (stuff->window != None) {
+ rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
+ if (rc != Success) {
+ client->errorValue = stuff->window;
+ return rc;
+ }
}
- else pWin= NULL;
+ else
+ pWin = NULL;
/* Client wants to ring a bell on the core keyboard?
Ring the bell on the core keyboard (which does nothing, but if that
@@ -518,13 +539,12 @@ ProcXkbBell(ClientPtr client)
stuff->forceSound, stuff->eventOnly, stuff->name);
if ((rc == Success) && ((stuff->deviceSpec == XkbUseCoreKbd) ||
- (stuff->deviceSpec == XkbUseCorePtr)))
- {
+ (stuff->deviceSpec == XkbUseCorePtr))) {
DeviceIntPtr other;
- for (other = inputInfo.devices; other; other = other->next)
- {
- if ((other != dev) && other->key && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev)
- {
+
+ for (other = inputInfo.devices; other; other = other->next) {
+ if ((other != dev) && other->key && !IsMaster(other) &&
+ GetMaster(other, MASTER_KEYBOARD) == dev) {
rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixBellAccess);
if (rc == Success)
_XkbBell(client, other, pWin, stuff->bellClass,
@@ -533,7 +553,7 @@ ProcXkbBell(ClientPtr client)
stuff->eventOnly, stuff->name);
}
}
- rc = Success; /* reset to success, that's what we got for the VCK */
+ rc = Success; /* reset to success, that's what we got for the VCK */
}
return rc;
@@ -545,21 +565,21 @@ int
ProcXkbGetState(ClientPtr client)
{
REQUEST(xkbGetStateReq);
- DeviceIntPtr dev;
- xkbGetStateReply rep;
- XkbStateRec *xkb;
+ DeviceIntPtr dev;
+ xkbGetStateReply rep;
+ XkbStateRec *xkb;
REQUEST_SIZE_MATCH(xkbGetStateReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess);
- xkb= &dev->key->xkbInfo->state;
+ xkb = &dev->key->xkbInfo->state;
memset(&rep, 0, sizeof(xkbGetStateReply));
- rep.type= X_Reply;
- rep.sequenceNumber= client->sequence;
+ rep.type = X_Reply;
+ rep.sequenceNumber = client->sequence;
rep.length = 0;
rep.deviceID = dev->id;
rep.mods = XkbStateFieldFromRec(xkb) & 0xff;
@@ -573,10 +593,10 @@ ProcXkbGetState(ClientPtr client)
rep.compatState = xkb->compat_state;
rep.ptrBtnState = xkb->ptr_buttons;
if (client->swapped) {
- swaps(&rep.sequenceNumber);
- swaps(&rep.ptrBtnState);
+ swaps(&rep.sequenceNumber);
+ swaps(&rep.ptrBtnState);
}
- WriteToClient(client, SIZEOF(xkbGetStateReply), (char *)&rep);
+ WriteToClient(client, SIZEOF(xkbGetStateReply), (char *) &rep);
return Success;
}
@@ -587,7 +607,7 @@ ProcXkbLatchLockState(ClientPtr client)
{
int status;
DeviceIntPtr dev, tmpd;
- XkbStateRec oldState,*newState;
+ XkbStateRec oldState, *newState;
CARD16 changed;
xkbStateNotify sn;
XkbEventCauseRec cause;
@@ -596,7 +616,7 @@ ProcXkbLatchLockState(ClientPtr client)
REQUEST_SIZE_MATCH(xkbLatchLockStateReq);
if (!(client->xkbClientFlags & _XkbClientInitialized))
- return BadAccess;
+ return BadAccess;
CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixSetAttrAccess);
CHK_MASK_MATCH(0x01, stuff->affectModLocks, stuff->modLocks);
@@ -605,7 +625,8 @@ ProcXkbLatchLockState(ClientPtr client)
status = Success;
for (tmpd = inputInfo.devices; tmpd; tmpd = tmpd->next) {
- if ((tmpd == dev) || (!IsMaster(tmpd) && GetMaster(tmpd, MASTER_KEYBOARD) == dev)) {
+ if ((tmpd == dev) ||
+ (!IsMaster(tmpd) && GetMaster(tmpd, MASTER_KEYBOARD) == dev)) {
if (!tmpd->key || !tmpd->key->xkbInfo)
continue;
@@ -613,7 +634,8 @@ ProcXkbLatchLockState(ClientPtr client)
newState = &tmpd->key->xkbInfo->state;
if (stuff->affectModLocks) {
newState->locked_mods &= ~stuff->affectModLocks;
- newState->locked_mods |= (stuff->affectModLocks & stuff->modLocks);
+ newState->locked_mods |=
+ (stuff->affectModLocks & stuff->modLocks);
}
if (status == Success && stuff->lockGroup)
newState->locked_group = stuff->groupLock;
@@ -640,7 +662,7 @@ ProcXkbLatchLockState(ClientPtr client)
if (changed) {
XkbSetCauseXkbReq(&cause, X_kbLatchLockState, client);
XkbUpdateIndicators(tmpd, changed, TRUE, NULL, &cause);
- }
+ }
}
}
}
@@ -654,23 +676,23 @@ int
ProcXkbGetControls(ClientPtr client)
{
xkbGetControlsReply rep;
- XkbControlsPtr xkb;
- DeviceIntPtr dev;
+ XkbControlsPtr xkb;
+ DeviceIntPtr dev;
REQUEST(xkbGetControlsReq);
REQUEST_SIZE_MATCH(xkbGetControlsReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess);
-
+
xkb = dev->key->xkbInfo->desc->ctrls;
rep.type = X_Reply;
- rep.length = bytes_to_int32(SIZEOF(xkbGetControlsReply)-
- SIZEOF(xGenericReply));
+ rep.length = bytes_to_int32(SIZEOF(xkbGetControlsReply) -
+ SIZEOF(xGenericReply));
rep.sequenceNumber = client->sequence;
- rep.deviceID = ((DeviceIntPtr)dev)->id;
+ rep.deviceID = ((DeviceIntPtr) dev)->id;
rep.numGroups = xkb->num_groups;
rep.groupsWrap = xkb->groups_wrap;
rep.internalMods = xkb->internal.mask;
@@ -696,49 +718,49 @@ ProcXkbGetControls(ClientPtr client)
rep.axtOptsMask = xkb->axt_opts_mask;
rep.axtOptsValues = xkb->axt_opts_values;
rep.axOptions = xkb->ax_options;
- memcpy(rep.perKeyRepeat,xkb->per_key_repeat,XkbPerKeyBitArraySize);
+ memcpy(rep.perKeyRepeat, xkb->per_key_repeat, XkbPerKeyBitArraySize);
if (client->swapped) {
- swaps(&rep.sequenceNumber);
- swapl(&rep.length);
- swaps(&rep.internalVMods);
- swaps(&rep.ignoreLockVMods);
- swapl(&rep.enabledCtrls);
- swaps(&rep.repeatDelay);
- swaps(&rep.repeatInterval);
- swaps(&rep.slowKeysDelay);
- swaps(&rep.debounceDelay);
- swaps(&rep.mkDelay);
- swaps(&rep.mkInterval);
- swaps(&rep.mkTimeToMax);
- swaps(&rep.mkMaxSpeed);
- swaps(&rep.mkCurve);
- swaps(&rep.axTimeout);
- swapl(&rep.axtCtrlsMask);
- swapl(&rep.axtCtrlsValues);
- swaps(&rep.axtOptsMask);
- swaps(&rep.axtOptsValues);
- swaps(&rep.axOptions);
- }
- WriteToClient(client, SIZEOF(xkbGetControlsReply), (char *)&rep);
+ swaps(&rep.sequenceNumber);
+ swapl(&rep.length);
+ swaps(&rep.internalVMods);
+ swaps(&rep.ignoreLockVMods);
+ swapl(&rep.enabledCtrls);
+ swaps(&rep.repeatDelay);
+ swaps(&rep.repeatInterval);
+ swaps(&rep.slowKeysDelay);
+ swaps(&rep.debounceDelay);
+ swaps(&rep.mkDelay);
+ swaps(&rep.mkInterval);
+ swaps(&rep.mkTimeToMax);
+ swaps(&rep.mkMaxSpeed);
+ swaps(&rep.mkCurve);
+ swaps(&rep.axTimeout);
+ swapl(&rep.axtCtrlsMask);
+ swapl(&rep.axtCtrlsValues);
+ swaps(&rep.axtOptsMask);
+ swaps(&rep.axtOptsValues);
+ swaps(&rep.axOptions);
+ }
+ WriteToClient(client, SIZEOF(xkbGetControlsReply), (char *) &rep);
return Success;
}
int
ProcXkbSetControls(ClientPtr client)
{
- DeviceIntPtr dev, tmpd;
- XkbSrvInfoPtr xkbi;
- XkbControlsPtr ctrl;
- XkbControlsRec new,old;
- xkbControlsNotify cn;
- XkbEventCauseRec cause;
- XkbSrvLedInfoPtr sli;
+ DeviceIntPtr dev, tmpd;
+ XkbSrvInfoPtr xkbi;
+ XkbControlsPtr ctrl;
+ XkbControlsRec new, old;
+ xkbControlsNotify cn;
+ XkbEventCauseRec cause;
+ XkbSrvLedInfoPtr sli;
REQUEST(xkbSetControlsReq);
REQUEST_SIZE_MATCH(xkbSetControlsReq);
if (!(client->xkbClientFlags & _XkbClientInitialized))
- return BadAccess;
+ return BadAccess;
CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixManageAccess);
CHK_MASK_LEGAL(0x01, stuff->changeCtrls, XkbAllControlsMask);
@@ -746,7 +768,8 @@ ProcXkbSetControls(ClientPtr client)
for (tmpd = inputInfo.devices; tmpd; tmpd = tmpd->next) {
if (!tmpd->key || !tmpd->key->xkbInfo)
continue;
- if ((tmpd == dev) || (!IsMaster(tmpd) && GetMaster(tmpd, MASTER_KEYBOARD) == dev)) {
+ if ((tmpd == dev) ||
+ (!IsMaster(tmpd) && GetMaster(tmpd, MASTER_KEYBOARD) == dev)) {
xkbi = tmpd->key->xkbInfo;
ctrl = xkbi->desc->ctrls;
new = *ctrl;
@@ -765,8 +788,7 @@ ProcXkbSetControls(ClientPtr client)
new.internal.vmods |= (stuff->affectInternalVMods &
stuff->internalVMods);
new.internal.mask = new.internal.real_mods |
- XkbMaskForVMask(xkbi->desc,
- new.internal.vmods);
+ XkbMaskForVMask(xkbi->desc, new.internal.vmods);
}
if (stuff->changeCtrls & XkbIgnoreLockModsMask) {
@@ -782,8 +804,7 @@ ProcXkbSetControls(ClientPtr client)
new.ignore_lock.vmods |= (stuff->affectIgnoreLockVMods &
stuff->ignoreLockVMods);
new.ignore_lock.mask = new.ignore_lock.real_mods |
- XkbMaskForVMask(xkbi->desc,
- new.ignore_lock.vmods);
+ XkbMaskForVMask(xkbi->desc, new.ignore_lock.vmods);
}
CHK_MASK_MATCH(0x06, stuff->affectEnabledCtrls,
@@ -841,7 +862,7 @@ ProcXkbSetControls(ClientPtr client)
if (stuff->mkDelay < 1 || stuff->mkInterval < 1 ||
stuff->mkTimeToMax < 1 || stuff->mkMaxSpeed < 1 ||
stuff->mkCurve < -1000) {
- client->errorValue = _XkbErrCode2(0x0C,0);
+ client->errorValue = _XkbErrCode2(0x0C, 0);
return BadValue;
}
@@ -873,7 +894,7 @@ ProcXkbSetControls(ClientPtr client)
return BadValue;
}
- new.groups_wrap= stuff->groupsWrap;
+ new.groups_wrap = stuff->groupsWrap;
}
CHK_MASK_LEGAL(0x0F, stuff->axOptions, XkbAX_AllOptionsMask);
@@ -885,7 +906,7 @@ ProcXkbSetControls(ClientPtr client)
new.ax_options &= ~(XkbAX_SKOptionsMask);
new.ax_options |= (stuff->axOptions & XkbAX_SKOptionsMask);
}
-
+
if (stuff->changeCtrls & XkbAccessXFeedbackMask) {
new.ax_options &= ~(XkbAX_FBOptionsMask);
new.ax_options |= (stuff->axOptions & XkbAX_FBOptionsMask);
@@ -921,8 +942,8 @@ ProcXkbSetControls(ClientPtr client)
}
}
- old= *ctrl;
- *ctrl= new;
+ old = *ctrl;
+ *ctrl = new;
XkbDDXChangeControls(tmpd, &old, ctrl);
if (XkbComputeControlsNotify(tmpd, &old, ctrl, &cn, FALSE)) {
@@ -951,704 +972,725 @@ ProcXkbSetControls(ClientPtr client)
/***====================================================================***/
static int
-XkbSizeKeyTypes(XkbDescPtr xkb,xkbGetMapReply *rep)
+XkbSizeKeyTypes(XkbDescPtr xkb, xkbGetMapReply * rep)
{
- XkbKeyTypeRec *type;
- unsigned i,len;
-
- len= 0;
- if (((rep->present&XkbKeyTypesMask)==0)||(rep->nTypes<1)||
- (!xkb)||(!xkb->map)||(!xkb->map->types)) {
- rep->present&= ~XkbKeyTypesMask;
- rep->firstType= rep->nTypes= 0;
- return 0;
- }
- type= &xkb->map->types[rep->firstType];
- for (i=0;i<rep->nTypes;i++,type++){
- len+= SIZEOF(xkbKeyTypeWireDesc);
- if (type->map_count>0) {
- len+= (type->map_count*SIZEOF(xkbKTMapEntryWireDesc));
- if (type->preserve)
- len+= (type->map_count*SIZEOF(xkbModsWireDesc));
- }
+ XkbKeyTypeRec *type;
+ unsigned i, len;
+
+ len = 0;
+ if (((rep->present & XkbKeyTypesMask) == 0) || (rep->nTypes < 1) ||
+ (!xkb) || (!xkb->map) || (!xkb->map->types)) {
+ rep->present &= ~XkbKeyTypesMask;
+ rep->firstType = rep->nTypes = 0;
+ return 0;
+ }
+ type = &xkb->map->types[rep->firstType];
+ for (i = 0; i < rep->nTypes; i++, type++) {
+ len += SIZEOF(xkbKeyTypeWireDesc);
+ if (type->map_count > 0) {
+ len += (type->map_count * SIZEOF(xkbKTMapEntryWireDesc));
+ if (type->preserve)
+ len += (type->map_count * SIZEOF(xkbModsWireDesc));
+ }
}
return len;
}
static char *
-XkbWriteKeyTypes( XkbDescPtr xkb,
- xkbGetMapReply * rep,
- char * buf,
- ClientPtr client)
+XkbWriteKeyTypes(XkbDescPtr xkb,
+ xkbGetMapReply * rep, char *buf, ClientPtr client)
{
- XkbKeyTypePtr type;
- unsigned i;
+ XkbKeyTypePtr type;
+ unsigned i;
xkbKeyTypeWireDesc *wire;
- type= &xkb->map->types[rep->firstType];
- for (i=0;i<rep->nTypes;i++,type++) {
- register unsigned n;
- wire= (xkbKeyTypeWireDesc *)buf;
- wire->mask = type->mods.mask;
- wire->realMods = type->mods.real_mods;
- wire->virtualMods = type->mods.vmods;
- wire->numLevels = type->num_levels;
- wire->nMapEntries = type->map_count;
- wire->preserve = (type->preserve!=NULL);
- if (client->swapped) {
- swaps(&wire->virtualMods);
- }
-
- buf= (char *)&wire[1];
- if (wire->nMapEntries>0) {
- xkbKTMapEntryWireDesc * wire;
- XkbKTMapEntryPtr entry;
- wire= (xkbKTMapEntryWireDesc *)buf;
- entry= type->map;
- for (n=0;n<type->map_count;n++,wire++,entry++) {
- wire->active= entry->active;
- wire->mask= entry->mods.mask;
- wire->level= entry->level;
- wire->realMods= entry->mods.real_mods;
- wire->virtualMods= entry->mods.vmods;
- if (client->swapped) {
- swaps(&wire->virtualMods);
- }
- }
- buf= (char *)wire;
- if (type->preserve!=NULL) {
- xkbModsWireDesc * pwire;
- XkbModsPtr preserve;
- pwire= (xkbModsWireDesc *)buf;
- preserve= type->preserve;
- for (n=0;n<type->map_count;n++,pwire++,preserve++) {
- pwire->mask= preserve->mask;
- pwire->realMods= preserve->real_mods;
- pwire->virtualMods= preserve->vmods;
- if (client->swapped) {
- swaps(&pwire->virtualMods);
- }
- }
- buf= (char *)pwire;
- }
- }
+ type = &xkb->map->types[rep->firstType];
+ for (i = 0; i < rep->nTypes; i++, type++) {
+ register unsigned n;
+
+ wire = (xkbKeyTypeWireDesc *) buf;
+ wire->mask = type->mods.mask;
+ wire->realMods = type->mods.real_mods;
+ wire->virtualMods = type->mods.vmods;
+ wire->numLevels = type->num_levels;
+ wire->nMapEntries = type->map_count;
+ wire->preserve = (type->preserve != NULL);
+ if (client->swapped) {
+ swaps(&wire->virtualMods);
+ }
+
+ buf = (char *) &wire[1];
+ if (wire->nMapEntries > 0) {
+ xkbKTMapEntryWireDesc *wire;
+ XkbKTMapEntryPtr entry;
+
+ wire = (xkbKTMapEntryWireDesc *) buf;
+ entry = type->map;
+ for (n = 0; n < type->map_count; n++, wire++, entry++) {
+ wire->active = entry->active;
+ wire->mask = entry->mods.mask;
+ wire->level = entry->level;
+ wire->realMods = entry->mods.real_mods;
+ wire->virtualMods = entry->mods.vmods;
+ if (client->swapped) {
+ swaps(&wire->virtualMods);
+ }
+ }
+ buf = (char *) wire;
+ if (type->preserve != NULL) {
+ xkbModsWireDesc *pwire;
+ XkbModsPtr preserve;
+
+ pwire = (xkbModsWireDesc *) buf;
+ preserve = type->preserve;
+ for (n = 0; n < type->map_count; n++, pwire++, preserve++) {
+ pwire->mask = preserve->mask;
+ pwire->realMods = preserve->real_mods;
+ pwire->virtualMods = preserve->vmods;
+ if (client->swapped) {
+ swaps(&pwire->virtualMods);
+ }
+ }
+ buf = (char *) pwire;
+ }
+ }
}
return buf;
}
static int
-XkbSizeKeySyms(XkbDescPtr xkb,xkbGetMapReply *rep)
+XkbSizeKeySyms(XkbDescPtr xkb, xkbGetMapReply * rep)
{
- XkbSymMapPtr symMap;
- unsigned i,len;
- unsigned nSyms,nSymsThisKey;
-
- if (((rep->present&XkbKeySymsMask)==0)||(rep->nKeySyms<1)||
- (!xkb)||(!xkb->map)||(!xkb->map->key_sym_map)) {
- rep->present&= ~XkbKeySymsMask;
- rep->firstKeySym= rep->nKeySyms= 0;
- rep->totalSyms= 0;
- return 0;
- }
- len= rep->nKeySyms*SIZEOF(xkbSymMapWireDesc);
+ XkbSymMapPtr symMap;
+ unsigned i, len;
+ unsigned nSyms, nSymsThisKey;
+
+ if (((rep->present & XkbKeySymsMask) == 0) || (rep->nKeySyms < 1) ||
+ (!xkb) || (!xkb->map) || (!xkb->map->key_sym_map)) {
+ rep->present &= ~XkbKeySymsMask;
+ rep->firstKeySym = rep->nKeySyms = 0;
+ rep->totalSyms = 0;
+ return 0;
+ }
+ len = rep->nKeySyms * SIZEOF(xkbSymMapWireDesc);
symMap = &xkb->map->key_sym_map[rep->firstKeySym];
- for (i=nSyms=0;i<rep->nKeySyms;i++,symMap++) {
- if (symMap->offset!=0) {
- nSymsThisKey= XkbNumGroups(symMap->group_info)*symMap->width;
- nSyms+= nSymsThisKey;
- }
- }
- len+= nSyms*4;
- rep->totalSyms= nSyms;
+ for (i = nSyms = 0; i < rep->nKeySyms; i++, symMap++) {
+ if (symMap->offset != 0) {
+ nSymsThisKey = XkbNumGroups(symMap->group_info) * symMap->width;
+ nSyms += nSymsThisKey;
+ }
+ }
+ len += nSyms * 4;
+ rep->totalSyms = nSyms;
return len;
}
static int
-XkbSizeVirtualMods(XkbDescPtr xkb,xkbGetMapReply *rep)
+XkbSizeVirtualMods(XkbDescPtr xkb, xkbGetMapReply * rep)
{
-register unsigned i,nMods,bit;
+ register unsigned i, nMods, bit;
- if (((rep->present&XkbVirtualModsMask)==0)||(rep->virtualMods==0)||
- (!xkb)||(!xkb->server)) {
- rep->present&= ~XkbVirtualModsMask;
- rep->virtualMods= 0;
- return 0;
+ if (((rep->present & XkbVirtualModsMask) == 0) || (rep->virtualMods == 0) ||
+ (!xkb) || (!xkb->server)) {
+ rep->present &= ~XkbVirtualModsMask;
+ rep->virtualMods = 0;
+ return 0;
}
- for (i=nMods=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
- if (rep->virtualMods&bit)
- nMods++;
+ for (i = nMods = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+ if (rep->virtualMods & bit)
+ nMods++;
}
return XkbPaddedSize(nMods);
}
static char *
-XkbWriteKeySyms(XkbDescPtr xkb,xkbGetMapReply *rep,char *buf,ClientPtr client)
+XkbWriteKeySyms(XkbDescPtr xkb, xkbGetMapReply * rep, char *buf,
+ ClientPtr client)
{
-register KeySym * pSym;
-XkbSymMapPtr symMap;
-xkbSymMapWireDesc * outMap;
-register unsigned i;
+ register KeySym *pSym;
+ XkbSymMapPtr symMap;
+ xkbSymMapWireDesc *outMap;
+ register unsigned i;
symMap = &xkb->map->key_sym_map[rep->firstKeySym];
- for (i=0;i<rep->nKeySyms;i++,symMap++) {
- outMap = (xkbSymMapWireDesc *)buf;
- outMap->ktIndex[0] = symMap->kt_index[0];
- outMap->ktIndex[1] = symMap->kt_index[1];
- outMap->ktIndex[2] = symMap->kt_index[2];
- outMap->ktIndex[3] = symMap->kt_index[3];
- outMap->groupInfo = symMap->group_info;
- outMap->width= symMap->width;
- outMap->nSyms = symMap->width*XkbNumGroups(symMap->group_info);
- buf= (char *)&outMap[1];
- if (outMap->nSyms==0)
- continue;
-
- pSym = &xkb->map->syms[symMap->offset];
- memcpy((char *)buf,(char *)pSym,outMap->nSyms*4);
- if (client->swapped) {
- register int nSyms= outMap->nSyms;
- swaps(&outMap->nSyms);
- while (nSyms-->0) {
- swapl((int *)buf);
- buf+= 4;
- }
- }
- else buf+= outMap->nSyms*4;
+ for (i = 0; i < rep->nKeySyms; i++, symMap++) {
+ outMap = (xkbSymMapWireDesc *) buf;
+ outMap->ktIndex[0] = symMap->kt_index[0];
+ outMap->ktIndex[1] = symMap->kt_index[1];
+ outMap->ktIndex[2] = symMap->kt_index[2];
+ outMap->ktIndex[3] = symMap->kt_index[3];
+ outMap->groupInfo = symMap->group_info;
+ outMap->width = symMap->width;
+ outMap->nSyms = symMap->width * XkbNumGroups(symMap->group_info);
+ buf = (char *) &outMap[1];
+ if (outMap->nSyms == 0)
+ continue;
+
+ pSym = &xkb->map->syms[symMap->offset];
+ memcpy((char *) buf, (char *) pSym, outMap->nSyms * 4);
+ if (client->swapped) {
+ register int nSyms = outMap->nSyms;
+
+ swaps(&outMap->nSyms);
+ while (nSyms-- > 0) {
+ swapl((int *) buf);
+ buf += 4;
+ }
+ }
+ else
+ buf += outMap->nSyms * 4;
}
return buf;
}
static int
-XkbSizeKeyActions(XkbDescPtr xkb,xkbGetMapReply *rep)
+XkbSizeKeyActions(XkbDescPtr xkb, xkbGetMapReply * rep)
{
- unsigned i,len,nActs;
- register KeyCode firstKey;
-
- if (((rep->present&XkbKeyActionsMask)==0)||(rep->nKeyActs<1)||
- (!xkb)||(!xkb->server)||(!xkb->server->key_acts)) {
- rep->present&= ~XkbKeyActionsMask;
- rep->firstKeyAct= rep->nKeyActs= 0;
- rep->totalActs= 0;
- return 0;
- }
- firstKey= rep->firstKeyAct;
- for (nActs=i=0;i<rep->nKeyActs;i++) {
- if (xkb->server->key_acts[i+firstKey]!=0)
- nActs+= XkbKeyNumActions(xkb,i+firstKey);
- }
- len= XkbPaddedSize(rep->nKeyActs)+(nActs*SIZEOF(xkbActionWireDesc));
- rep->totalActs= nActs;
+ unsigned i, len, nActs;
+ register KeyCode firstKey;
+
+ if (((rep->present & XkbKeyActionsMask) == 0) || (rep->nKeyActs < 1) ||
+ (!xkb) || (!xkb->server) || (!xkb->server->key_acts)) {
+ rep->present &= ~XkbKeyActionsMask;
+ rep->firstKeyAct = rep->nKeyActs = 0;
+ rep->totalActs = 0;
+ return 0;
+ }
+ firstKey = rep->firstKeyAct;
+ for (nActs = i = 0; i < rep->nKeyActs; i++) {
+ if (xkb->server->key_acts[i + firstKey] != 0)
+ nActs += XkbKeyNumActions(xkb, i + firstKey);
+ }
+ len = XkbPaddedSize(rep->nKeyActs) + (nActs * SIZEOF(xkbActionWireDesc));
+ rep->totalActs = nActs;
return len;
}
static char *
-XkbWriteKeyActions(XkbDescPtr xkb,xkbGetMapReply *rep,char *buf,
- ClientPtr client)
+XkbWriteKeyActions(XkbDescPtr xkb, xkbGetMapReply * rep, char *buf,
+ ClientPtr client)
{
- unsigned i;
- CARD8 * numDesc;
- XkbAnyAction * actDesc;
-
- numDesc = (CARD8 *)buf;
- for (i=0;i<rep->nKeyActs;i++) {
- if (xkb->server->key_acts[i+rep->firstKeyAct]==0)
- numDesc[i] = 0;
- else numDesc[i] = XkbKeyNumActions(xkb,(i+rep->firstKeyAct));
- }
- buf+= XkbPaddedSize(rep->nKeyActs);
-
- actDesc = (XkbAnyAction *)buf;
- for (i=0;i<rep->nKeyActs;i++) {
- if (xkb->server->key_acts[i+rep->firstKeyAct]!=0) {
- unsigned int num;
- num = XkbKeyNumActions(xkb,(i+rep->firstKeyAct));
- memcpy((char *)actDesc,
- (char*)XkbKeyActionsPtr(xkb,(i+rep->firstKeyAct)),
- num*SIZEOF(xkbActionWireDesc));
- actDesc+= num;
- }
- }
- buf = (char *)actDesc;
+ unsigned i;
+ CARD8 *numDesc;
+ XkbAnyAction *actDesc;
+
+ numDesc = (CARD8 *) buf;
+ for (i = 0; i < rep->nKeyActs; i++) {
+ if (xkb->server->key_acts[i + rep->firstKeyAct] == 0)
+ numDesc[i] = 0;
+ else
+ numDesc[i] = XkbKeyNumActions(xkb, (i + rep->firstKeyAct));
+ }
+ buf += XkbPaddedSize(rep->nKeyActs);
+
+ actDesc = (XkbAnyAction *) buf;
+ for (i = 0; i < rep->nKeyActs; i++) {
+ if (xkb->server->key_acts[i + rep->firstKeyAct] != 0) {
+ unsigned int num;
+
+ num = XkbKeyNumActions(xkb, (i + rep->firstKeyAct));
+ memcpy((char *) actDesc,
+ (char *) XkbKeyActionsPtr(xkb, (i + rep->firstKeyAct)),
+ num * SIZEOF(xkbActionWireDesc));
+ actDesc += num;
+ }
+ }
+ buf = (char *) actDesc;
return buf;
}
static int
-XkbSizeKeyBehaviors(XkbDescPtr xkb,xkbGetMapReply *rep)
+XkbSizeKeyBehaviors(XkbDescPtr xkb, xkbGetMapReply * rep)
{
- unsigned i,len,nBhvr;
- XkbBehavior * bhv;
-
- if (((rep->present&XkbKeyBehaviorsMask)==0)||(rep->nKeyBehaviors<1)||
- (!xkb)||(!xkb->server)||(!xkb->server->behaviors)) {
- rep->present&= ~XkbKeyBehaviorsMask;
- rep->firstKeyBehavior= rep->nKeyBehaviors= 0;
- rep->totalKeyBehaviors= 0;
- return 0;
- }
- bhv= &xkb->server->behaviors[rep->firstKeyBehavior];
- for (nBhvr=i=0;i<rep->nKeyBehaviors;i++,bhv++) {
- if (bhv->type!=XkbKB_Default)
- nBhvr++;
- }
- len= nBhvr*SIZEOF(xkbBehaviorWireDesc);
- rep->totalKeyBehaviors= nBhvr;
+ unsigned i, len, nBhvr;
+ XkbBehavior *bhv;
+
+ if (((rep->present & XkbKeyBehaviorsMask) == 0) || (rep->nKeyBehaviors < 1)
+ || (!xkb) || (!xkb->server) || (!xkb->server->behaviors)) {
+ rep->present &= ~XkbKeyBehaviorsMask;
+ rep->firstKeyBehavior = rep->nKeyBehaviors = 0;
+ rep->totalKeyBehaviors = 0;
+ return 0;
+ }
+ bhv = &xkb->server->behaviors[rep->firstKeyBehavior];
+ for (nBhvr = i = 0; i < rep->nKeyBehaviors; i++, bhv++) {
+ if (bhv->type != XkbKB_Default)
+ nBhvr++;
+ }
+ len = nBhvr * SIZEOF(xkbBehaviorWireDesc);
+ rep->totalKeyBehaviors = nBhvr;
return len;
}
static char *
-XkbWriteKeyBehaviors(XkbDescPtr xkb,xkbGetMapReply *rep,char *buf,
- ClientPtr client)
+XkbWriteKeyBehaviors(XkbDescPtr xkb, xkbGetMapReply * rep, char *buf,
+ ClientPtr client)
{
- unsigned i;
- xkbBehaviorWireDesc *wire;
- XkbBehavior *pBhvr;
-
- wire = (xkbBehaviorWireDesc *)buf;
- pBhvr= &xkb->server->behaviors[rep->firstKeyBehavior];
- for (i=0;i<rep->nKeyBehaviors;i++,pBhvr++) {
- if (pBhvr->type!=XkbKB_Default) {
- wire->key= i+rep->firstKeyBehavior;
- wire->type= pBhvr->type;
- wire->data= pBhvr->data;
- wire++;
- }
- }
- buf = (char *)wire;
+ unsigned i;
+ xkbBehaviorWireDesc *wire;
+ XkbBehavior *pBhvr;
+
+ wire = (xkbBehaviorWireDesc *) buf;
+ pBhvr = &xkb->server->behaviors[rep->firstKeyBehavior];
+ for (i = 0; i < rep->nKeyBehaviors; i++, pBhvr++) {
+ if (pBhvr->type != XkbKB_Default) {
+ wire->key = i + rep->firstKeyBehavior;
+ wire->type = pBhvr->type;
+ wire->data = pBhvr->data;
+ wire++;
+ }
+ }
+ buf = (char *) wire;
return buf;
}
static int
-XkbSizeExplicit(XkbDescPtr xkb,xkbGetMapReply *rep)
+XkbSizeExplicit(XkbDescPtr xkb, xkbGetMapReply * rep)
{
- unsigned i,len,nRtrn;
-
- if (((rep->present&XkbExplicitComponentsMask)==0)||(rep->nKeyExplicit<1)||
- (!xkb)||(!xkb->server)||(!xkb->server->explicit)) {
- rep->present&= ~XkbExplicitComponentsMask;
- rep->firstKeyExplicit= rep->nKeyExplicit= 0;
- rep->totalKeyExplicit= 0;
- return 0;
- }
- for (nRtrn=i=0;i<rep->nKeyExplicit;i++) {
- if (xkb->server->explicit[i+rep->firstKeyExplicit]!=0)
- nRtrn++;
- }
- rep->totalKeyExplicit= nRtrn;
- len= XkbPaddedSize(nRtrn*2); /* two bytes per non-zero explicit component */
+ unsigned i, len, nRtrn;
+
+ if (((rep->present & XkbExplicitComponentsMask) == 0) ||
+ (rep->nKeyExplicit < 1) || (!xkb) || (!xkb->server) ||
+ (!xkb->server->explicit)) {
+ rep->present &= ~XkbExplicitComponentsMask;
+ rep->firstKeyExplicit = rep->nKeyExplicit = 0;
+ rep->totalKeyExplicit = 0;
+ return 0;
+ }
+ for (nRtrn = i = 0; i < rep->nKeyExplicit; i++) {
+ if (xkb->server->explicit[i + rep->firstKeyExplicit] != 0)
+ nRtrn++;
+ }
+ rep->totalKeyExplicit = nRtrn;
+ len = XkbPaddedSize(nRtrn * 2); /* two bytes per non-zero explicit component */
return len;
}
static char *
-XkbWriteExplicit(XkbDescPtr xkb,xkbGetMapReply *rep,char *buf,ClientPtr client)
+XkbWriteExplicit(XkbDescPtr xkb, xkbGetMapReply * rep, char *buf,
+ ClientPtr client)
{
-unsigned i;
-char * start;
-unsigned char * pExp;
-
- start= buf;
- pExp= &xkb->server->explicit[rep->firstKeyExplicit];
- for (i=0;i<rep->nKeyExplicit;i++,pExp++) {
- if (*pExp!=0) {
- *buf++= i+rep->firstKeyExplicit;
- *buf++= *pExp;
- }
- }
- i= XkbPaddedSize(buf-start)-(buf-start); /* pad to word boundary */
- return buf+i;
+ unsigned i;
+ char *start;
+ unsigned char *pExp;
+
+ start = buf;
+ pExp = &xkb->server->explicit[rep->firstKeyExplicit];
+ for (i = 0; i < rep->nKeyExplicit; i++, pExp++) {
+ if (*pExp != 0) {
+ *buf++ = i + rep->firstKeyExplicit;
+ *buf++ = *pExp;
+ }
+ }
+ i = XkbPaddedSize(buf - start) - (buf - start); /* pad to word boundary */
+ return buf + i;
}
static int
-XkbSizeModifierMap(XkbDescPtr xkb,xkbGetMapReply *rep)
+XkbSizeModifierMap(XkbDescPtr xkb, xkbGetMapReply * rep)
{
- unsigned i,len,nRtrn;
+ unsigned i, len, nRtrn;
- if (((rep->present&XkbModifierMapMask)==0)||(rep->nModMapKeys<1)||
- (!xkb)||(!xkb->map)||(!xkb->map->modmap)) {
- rep->present&= ~XkbModifierMapMask;
- rep->firstModMapKey= rep->nModMapKeys= 0;
- rep->totalModMapKeys= 0;
- return 0;
+ if (((rep->present & XkbModifierMapMask) == 0) || (rep->nModMapKeys < 1) ||
+ (!xkb) || (!xkb->map) || (!xkb->map->modmap)) {
+ rep->present &= ~XkbModifierMapMask;
+ rep->firstModMapKey = rep->nModMapKeys = 0;
+ rep->totalModMapKeys = 0;
+ return 0;
}
- for (nRtrn=i=0;i<rep->nModMapKeys;i++) {
- if (xkb->map->modmap[i+rep->firstModMapKey]!=0)
- nRtrn++;
+ for (nRtrn = i = 0; i < rep->nModMapKeys; i++) {
+ if (xkb->map->modmap[i + rep->firstModMapKey] != 0)
+ nRtrn++;
}
- rep->totalModMapKeys= nRtrn;
- len= XkbPaddedSize(nRtrn*2); /* two bytes per non-zero modmap component */
+ rep->totalModMapKeys = nRtrn;
+ len = XkbPaddedSize(nRtrn * 2); /* two bytes per non-zero modmap component */
return len;
}
static char *
-XkbWriteModifierMap(XkbDescPtr xkb,xkbGetMapReply *rep,char *buf,
- ClientPtr client)
+XkbWriteModifierMap(XkbDescPtr xkb, xkbGetMapReply * rep, char *buf,
+ ClientPtr client)
{
-unsigned i;
-char * start;
-unsigned char * pMap;
-
- start= buf;
- pMap= &xkb->map->modmap[rep->firstModMapKey];
- for (i=0;i<rep->nModMapKeys;i++,pMap++) {
- if (*pMap!=0) {
- *buf++= i+rep->firstModMapKey;
- *buf++= *pMap;
- }
- }
- i= XkbPaddedSize(buf-start)-(buf-start); /* pad to word boundary */
- return buf+i;
+ unsigned i;
+ char *start;
+ unsigned char *pMap;
+
+ start = buf;
+ pMap = &xkb->map->modmap[rep->firstModMapKey];
+ for (i = 0; i < rep->nModMapKeys; i++, pMap++) {
+ if (*pMap != 0) {
+ *buf++ = i + rep->firstModMapKey;
+ *buf++ = *pMap;
+ }
+ }
+ i = XkbPaddedSize(buf - start) - (buf - start); /* pad to word boundary */
+ return buf + i;
}
static int
-XkbSizeVirtualModMap(XkbDescPtr xkb,xkbGetMapReply *rep)
+XkbSizeVirtualModMap(XkbDescPtr xkb, xkbGetMapReply * rep)
{
- unsigned i,len,nRtrn;
+ unsigned i, len, nRtrn;
- if (((rep->present&XkbVirtualModMapMask)==0)||(rep->nVModMapKeys<1)||
- (!xkb)||(!xkb->server)||(!xkb->server->vmodmap)) {
- rep->present&= ~XkbVirtualModMapMask;
- rep->firstVModMapKey= rep->nVModMapKeys= 0;
- rep->totalVModMapKeys= 0;
- return 0;
+ if (((rep->present & XkbVirtualModMapMask) == 0) || (rep->nVModMapKeys < 1)
+ || (!xkb) || (!xkb->server) || (!xkb->server->vmodmap)) {
+ rep->present &= ~XkbVirtualModMapMask;
+ rep->firstVModMapKey = rep->nVModMapKeys = 0;
+ rep->totalVModMapKeys = 0;
+ return 0;
}
- for (nRtrn=i=0;i<rep->nVModMapKeys;i++) {
- if (xkb->server->vmodmap[i+rep->firstVModMapKey]!=0)
- nRtrn++;
+ for (nRtrn = i = 0; i < rep->nVModMapKeys; i++) {
+ if (xkb->server->vmodmap[i + rep->firstVModMapKey] != 0)
+ nRtrn++;
}
- rep->totalVModMapKeys= nRtrn;
- len= nRtrn*SIZEOF(xkbVModMapWireDesc);
+ rep->totalVModMapKeys = nRtrn;
+ len = nRtrn * SIZEOF(xkbVModMapWireDesc);
return len;
}
static char *
-XkbWriteVirtualModMap(XkbDescPtr xkb,xkbGetMapReply *rep,char *buf,
- ClientPtr client)
+XkbWriteVirtualModMap(XkbDescPtr xkb, xkbGetMapReply * rep, char *buf,
+ ClientPtr client)
{
-unsigned i;
-xkbVModMapWireDesc * wire;
-unsigned short * pMap;
-
- wire= (xkbVModMapWireDesc *)buf;
- pMap= &xkb->server->vmodmap[rep->firstVModMapKey];
- for (i=0;i<rep->nVModMapKeys;i++,pMap++) {
- if (*pMap!=0) {
- wire->key= i+rep->firstVModMapKey;
- wire->vmods= *pMap;
- wire++;
- }
- }
- return (char *)wire;
+ unsigned i;
+ xkbVModMapWireDesc *wire;
+ unsigned short *pMap;
+
+ wire = (xkbVModMapWireDesc *) buf;
+ pMap = &xkb->server->vmodmap[rep->firstVModMapKey];
+ for (i = 0; i < rep->nVModMapKeys; i++, pMap++) {
+ if (*pMap != 0) {
+ wire->key = i + rep->firstVModMapKey;
+ wire->vmods = *pMap;
+ wire++;
+ }
+ }
+ return (char *) wire;
}
static Status
-XkbComputeGetMapReplySize(XkbDescPtr xkb,xkbGetMapReply *rep)
+XkbComputeGetMapReplySize(XkbDescPtr xkb, xkbGetMapReply * rep)
{
-int len;
-
- rep->minKeyCode= xkb->min_key_code;
- rep->maxKeyCode= xkb->max_key_code;
- len= XkbSizeKeyTypes(xkb,rep);
- len+= XkbSizeKeySyms(xkb,rep);
- len+= XkbSizeKeyActions(xkb,rep);
- len+= XkbSizeKeyBehaviors(xkb,rep);
- len+= XkbSizeVirtualMods(xkb,rep);
- len+= XkbSizeExplicit(xkb,rep);
- len+= XkbSizeModifierMap(xkb,rep);
- len+= XkbSizeVirtualModMap(xkb,rep);
- rep->length+= (len/4);
+ int len;
+
+ rep->minKeyCode = xkb->min_key_code;
+ rep->maxKeyCode = xkb->max_key_code;
+ len = XkbSizeKeyTypes(xkb, rep);
+ len += XkbSizeKeySyms(xkb, rep);
+ len += XkbSizeKeyActions(xkb, rep);
+ len += XkbSizeKeyBehaviors(xkb, rep);
+ len += XkbSizeVirtualMods(xkb, rep);
+ len += XkbSizeExplicit(xkb, rep);
+ len += XkbSizeModifierMap(xkb, rep);
+ len += XkbSizeVirtualModMap(xkb, rep);
+ rep->length += (len / 4);
return Success;
}
static int
-XkbSendMap(ClientPtr client,XkbDescPtr xkb,xkbGetMapReply *rep)
+XkbSendMap(ClientPtr client, XkbDescPtr xkb, xkbGetMapReply * rep)
{
-unsigned i,len;
-char *desc,*start;
+ unsigned i, len;
+ char *desc, *start;
- len= (rep->length*4)-(SIZEOF(xkbGetMapReply)-SIZEOF(xGenericReply));
- start= desc= calloc(1, len);
+ len = (rep->length * 4) - (SIZEOF(xkbGetMapReply) - SIZEOF(xGenericReply));
+ start = desc = calloc(1, len);
if (!start)
- return BadAlloc;
- if ( rep->nTypes>0 )
- desc = XkbWriteKeyTypes(xkb,rep,desc,client);
- if ( rep->nKeySyms>0 )
- desc = XkbWriteKeySyms(xkb,rep,desc,client);
- if ( rep->nKeyActs>0 )
- desc = XkbWriteKeyActions(xkb,rep,desc,client);
- if ( rep->totalKeyBehaviors>0 )
- desc = XkbWriteKeyBehaviors(xkb,rep,desc,client);
- if ( rep->virtualMods ) {
- register int sz,bit;
- for (i=sz=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
- if (rep->virtualMods&bit) {
- desc[sz++]= xkb->server->vmods[i];
- }
- }
- desc+= XkbPaddedSize(sz);
- }
- if ( rep->totalKeyExplicit>0 )
- desc= XkbWriteExplicit(xkb,rep,desc,client);
- if ( rep->totalModMapKeys>0 )
- desc= XkbWriteModifierMap(xkb,rep,desc,client);
- if ( rep->totalVModMapKeys>0 )
- desc= XkbWriteVirtualModMap(xkb,rep,desc,client);
- if ((desc-start)!=(len)) {
- ErrorF("[xkb] BOGUS LENGTH in write keyboard desc, expected %d, got %ld\n",
- len, (unsigned long)(desc-start));
+ return BadAlloc;
+ if (rep->nTypes > 0)
+ desc = XkbWriteKeyTypes(xkb, rep, desc, client);
+ if (rep->nKeySyms > 0)
+ desc = XkbWriteKeySyms(xkb, rep, desc, client);
+ if (rep->nKeyActs > 0)
+ desc = XkbWriteKeyActions(xkb, rep, desc, client);
+ if (rep->totalKeyBehaviors > 0)
+ desc = XkbWriteKeyBehaviors(xkb, rep, desc, client);
+ if (rep->virtualMods) {
+ register int sz, bit;
+
+ for (i = sz = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+ if (rep->virtualMods & bit) {
+ desc[sz++] = xkb->server->vmods[i];
+ }
+ }
+ desc += XkbPaddedSize(sz);
+ }
+ if (rep->totalKeyExplicit > 0)
+ desc = XkbWriteExplicit(xkb, rep, desc, client);
+ if (rep->totalModMapKeys > 0)
+ desc = XkbWriteModifierMap(xkb, rep, desc, client);
+ if (rep->totalVModMapKeys > 0)
+ desc = XkbWriteVirtualModMap(xkb, rep, desc, client);
+ if ((desc - start) != (len)) {
+ ErrorF
+ ("[xkb] BOGUS LENGTH in write keyboard desc, expected %d, got %ld\n",
+ len, (unsigned long) (desc - start));
}
if (client->swapped) {
- swaps(&rep->sequenceNumber);
- swapl(&rep->length);
- swaps(&rep->present);
- swaps(&rep->totalSyms);
- swaps(&rep->totalActs);
+ swaps(&rep->sequenceNumber);
+ swapl(&rep->length);
+ swaps(&rep->present);
+ swaps(&rep->totalSyms);
+ swaps(&rep->totalActs);
}
- WriteToClient(client, (i=SIZEOF(xkbGetMapReply)), (char *)rep);
+ WriteToClient(client, (i = SIZEOF(xkbGetMapReply)), (char *) rep);
WriteToClient(client, len, start);
- free((char *)start);
+ free((char *) start);
return Success;
}
int
ProcXkbGetMap(ClientPtr client)
{
- DeviceIntPtr dev;
- xkbGetMapReply rep;
- XkbDescRec *xkb;
- int n,status;
+ DeviceIntPtr dev;
+ xkbGetMapReply rep;
+ XkbDescRec *xkb;
+ int n, status;
REQUEST(xkbGetMapReq);
REQUEST_SIZE_MATCH(xkbGetMapReq);
-
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess);
- CHK_MASK_OVERLAP(0x01,stuff->full,stuff->partial);
- CHK_MASK_LEGAL(0x02,stuff->full,XkbAllMapComponentsMask);
- CHK_MASK_LEGAL(0x03,stuff->partial,XkbAllMapComponentsMask);
+ CHK_MASK_OVERLAP(0x01, stuff->full, stuff->partial);
+ CHK_MASK_LEGAL(0x02, stuff->full, XkbAllMapComponentsMask);
+ CHK_MASK_LEGAL(0x03, stuff->partial, XkbAllMapComponentsMask);
- xkb= dev->key->xkbInfo->desc;
+ xkb = dev->key->xkbInfo->desc;
memset(&rep, 0, sizeof(xkbGetMapReply));
- rep.type= X_Reply;
- rep.sequenceNumber= client->sequence;
- rep.length = (SIZEOF(xkbGetMapReply)-SIZEOF(xGenericReply))>>2;
+ rep.type = X_Reply;
+ rep.sequenceNumber = client->sequence;
+ rep.length = (SIZEOF(xkbGetMapReply) - SIZEOF(xGenericReply)) >> 2;
rep.deviceID = dev->id;
- rep.present = stuff->partial|stuff->full;
+ rep.present = stuff->partial | stuff->full;
rep.minKeyCode = xkb->min_key_code;
rep.maxKeyCode = xkb->max_key_code;
- if ( stuff->full&XkbKeyTypesMask ) {
- rep.firstType = 0;
- rep.nTypes = xkb->map->num_types;
- }
- else if (stuff->partial&XkbKeyTypesMask) {
- if (((unsigned)stuff->firstType+stuff->nTypes)>xkb->map->num_types) {
- client->errorValue = _XkbErrCode4(0x04,xkb->map->num_types,
- stuff->firstType,stuff->nTypes);
- return BadValue;
- }
- rep.firstType = stuff->firstType;
- rep.nTypes = stuff->nTypes;
- }
- else rep.nTypes = 0;
+ if (stuff->full & XkbKeyTypesMask) {
+ rep.firstType = 0;
+ rep.nTypes = xkb->map->num_types;
+ }
+ else if (stuff->partial & XkbKeyTypesMask) {
+ if (((unsigned) stuff->firstType + stuff->nTypes) > xkb->map->num_types) {
+ client->errorValue = _XkbErrCode4(0x04, xkb->map->num_types,
+ stuff->firstType, stuff->nTypes);
+ return BadValue;
+ }
+ rep.firstType = stuff->firstType;
+ rep.nTypes = stuff->nTypes;
+ }
+ else
+ rep.nTypes = 0;
rep.totalTypes = xkb->map->num_types;
- n= XkbNumKeys(xkb);
- if ( stuff->full&XkbKeySymsMask ) {
- rep.firstKeySym = xkb->min_key_code;
- rep.nKeySyms = n;
- }
- else if (stuff->partial&XkbKeySymsMask) {
- CHK_KEY_RANGE(0x05,stuff->firstKeySym,stuff->nKeySyms,xkb);
- rep.firstKeySym = stuff->firstKeySym;
- rep.nKeySyms = stuff->nKeySyms;
- }
- else rep.nKeySyms = 0;
- rep.totalSyms= 0;
-
- if ( stuff->full&XkbKeyActionsMask ) {
- rep.firstKeyAct= xkb->min_key_code;
- rep.nKeyActs= n;
- }
- else if (stuff->partial&XkbKeyActionsMask) {
- CHK_KEY_RANGE(0x07,stuff->firstKeyAct,stuff->nKeyActs,xkb);
- rep.firstKeyAct= stuff->firstKeyAct;
- rep.nKeyActs= stuff->nKeyActs;
- }
- else rep.nKeyActs= 0;
- rep.totalActs= 0;
-
- if ( stuff->full&XkbKeyBehaviorsMask ) {
- rep.firstKeyBehavior = xkb->min_key_code;
- rep.nKeyBehaviors = n;
- }
- else if (stuff->partial&XkbKeyBehaviorsMask) {
- CHK_KEY_RANGE(0x09,stuff->firstKeyBehavior,stuff->nKeyBehaviors,xkb);
- rep.firstKeyBehavior= stuff->firstKeyBehavior;
- rep.nKeyBehaviors= stuff->nKeyBehaviors;
- }
- else rep.nKeyBehaviors = 0;
- rep.totalKeyBehaviors= 0;
-
- if (stuff->full&XkbVirtualModsMask)
- rep.virtualMods= ~0;
- else if (stuff->partial&XkbVirtualModsMask)
- rep.virtualMods= stuff->virtualMods;
-
- if (stuff->full&XkbExplicitComponentsMask) {
- rep.firstKeyExplicit= xkb->min_key_code;
- rep.nKeyExplicit= n;
- }
- else if (stuff->partial&XkbExplicitComponentsMask) {
- CHK_KEY_RANGE(0x0B,stuff->firstKeyExplicit,stuff->nKeyExplicit,xkb);
- rep.firstKeyExplicit= stuff->firstKeyExplicit;
- rep.nKeyExplicit= stuff->nKeyExplicit;
- }
- else rep.nKeyExplicit = 0;
- rep.totalKeyExplicit= 0;
-
- if (stuff->full&XkbModifierMapMask) {
- rep.firstModMapKey= xkb->min_key_code;
- rep.nModMapKeys= n;
- }
- else if (stuff->partial&XkbModifierMapMask) {
- CHK_KEY_RANGE(0x0D,stuff->firstModMapKey,stuff->nModMapKeys,xkb);
- rep.firstModMapKey= stuff->firstModMapKey;
- rep.nModMapKeys= stuff->nModMapKeys;
- }
- else rep.nModMapKeys = 0;
- rep.totalModMapKeys= 0;
-
- if (stuff->full&XkbVirtualModMapMask) {
- rep.firstVModMapKey= xkb->min_key_code;
- rep.nVModMapKeys= n;
- }
- else if (stuff->partial&XkbVirtualModMapMask) {
- CHK_KEY_RANGE(0x0F,stuff->firstVModMapKey,stuff->nVModMapKeys,xkb);
- rep.firstVModMapKey= stuff->firstVModMapKey;
- rep.nVModMapKeys= stuff->nVModMapKeys;
- }
- else rep.nVModMapKeys = 0;
- rep.totalVModMapKeys= 0;
-
- if ((status=XkbComputeGetMapReplySize(xkb,&rep))!=Success)
- return status;
- return XkbSendMap(client,xkb,&rep);
+ n = XkbNumKeys(xkb);
+ if (stuff->full & XkbKeySymsMask) {
+ rep.firstKeySym = xkb->min_key_code;
+ rep.nKeySyms = n;
+ }
+ else if (stuff->partial & XkbKeySymsMask) {
+ CHK_KEY_RANGE(0x05, stuff->firstKeySym, stuff->nKeySyms, xkb);
+ rep.firstKeySym = stuff->firstKeySym;
+ rep.nKeySyms = stuff->nKeySyms;
+ }
+ else
+ rep.nKeySyms = 0;
+ rep.totalSyms = 0;
+
+ if (stuff->full & XkbKeyActionsMask) {
+ rep.firstKeyAct = xkb->min_key_code;
+ rep.nKeyActs = n;
+ }
+ else if (stuff->partial & XkbKeyActionsMask) {
+ CHK_KEY_RANGE(0x07, stuff->firstKeyAct, stuff->nKeyActs, xkb);
+ rep.firstKeyAct = stuff->firstKeyAct;
+ rep.nKeyActs = stuff->nKeyActs;
+ }
+ else
+ rep.nKeyActs = 0;
+ rep.totalActs = 0;
+
+ if (stuff->full & XkbKeyBehaviorsMask) {
+ rep.firstKeyBehavior = xkb->min_key_code;
+ rep.nKeyBehaviors = n;
+ }
+ else if (stuff->partial & XkbKeyBehaviorsMask) {
+ CHK_KEY_RANGE(0x09, stuff->firstKeyBehavior, stuff->nKeyBehaviors, xkb);
+ rep.firstKeyBehavior = stuff->firstKeyBehavior;
+ rep.nKeyBehaviors = stuff->nKeyBehaviors;
+ }
+ else
+ rep.nKeyBehaviors = 0;
+ rep.totalKeyBehaviors = 0;
+
+ if (stuff->full & XkbVirtualModsMask)
+ rep.virtualMods = ~0;
+ else if (stuff->partial & XkbVirtualModsMask)
+ rep.virtualMods = stuff->virtualMods;
+
+ if (stuff->full & XkbExplicitComponentsMask) {
+ rep.firstKeyExplicit = xkb->min_key_code;
+ rep.nKeyExplicit = n;
+ }
+ else if (stuff->partial & XkbExplicitComponentsMask) {
+ CHK_KEY_RANGE(0x0B, stuff->firstKeyExplicit, stuff->nKeyExplicit, xkb);
+ rep.firstKeyExplicit = stuff->firstKeyExplicit;
+ rep.nKeyExplicit = stuff->nKeyExplicit;
+ }
+ else
+ rep.nKeyExplicit = 0;
+ rep.totalKeyExplicit = 0;
+
+ if (stuff->full & XkbModifierMapMask) {
+ rep.firstModMapKey = xkb->min_key_code;
+ rep.nModMapKeys = n;
+ }
+ else if (stuff->partial & XkbModifierMapMask) {
+ CHK_KEY_RANGE(0x0D, stuff->firstModMapKey, stuff->nModMapKeys, xkb);
+ rep.firstModMapKey = stuff->firstModMapKey;
+ rep.nModMapKeys = stuff->nModMapKeys;
+ }
+ else
+ rep.nModMapKeys = 0;
+ rep.totalModMapKeys = 0;
+
+ if (stuff->full & XkbVirtualModMapMask) {
+ rep.firstVModMapKey = xkb->min_key_code;
+ rep.nVModMapKeys = n;
+ }
+ else if (stuff->partial & XkbVirtualModMapMask) {
+ CHK_KEY_RANGE(0x0F, stuff->firstVModMapKey, stuff->nVModMapKeys, xkb);
+ rep.firstVModMapKey = stuff->firstVModMapKey;
+ rep.nVModMapKeys = stuff->nVModMapKeys;
+ }
+ else
+ rep.nVModMapKeys = 0;
+ rep.totalVModMapKeys = 0;
+
+ if ((status = XkbComputeGetMapReplySize(xkb, &rep)) != Success)
+ return status;
+ return XkbSendMap(client, xkb, &rep);
}
/***====================================================================***/
static int
-CheckKeyTypes( ClientPtr client,
- XkbDescPtr xkb,
- xkbSetMapReq * req,
- xkbKeyTypeWireDesc **wireRtrn,
- int * nMapsRtrn,
- CARD8 * mapWidthRtrn)
+CheckKeyTypes(ClientPtr client,
+ XkbDescPtr xkb,
+ xkbSetMapReq * req,
+ xkbKeyTypeWireDesc ** wireRtrn,
+ int *nMapsRtrn, CARD8 *mapWidthRtrn)
{
-unsigned nMaps;
-register unsigned i,n;
-register CARD8 * map;
-register xkbKeyTypeWireDesc *wire = *wireRtrn;
-
- if (req->firstType>((unsigned)xkb->map->num_types)) {
- *nMapsRtrn = _XkbErrCode3(0x01,req->firstType,xkb->map->num_types);
- return 0;
- }
- if (req->flags&XkbSetMapResizeTypes) {
- nMaps = req->firstType+req->nTypes;
- if (nMaps<XkbNumRequiredTypes) { /* canonical types must be there */
- *nMapsRtrn= _XkbErrCode4(0x02,req->firstType,req->nTypes,4);
- return 0;
- }
- }
- else if (req->present&XkbKeyTypesMask) {
- nMaps = xkb->map->num_types;
- if ((req->firstType+req->nTypes)>nMaps) {
- *nMapsRtrn = req->firstType+req->nTypes;
- return 0;
- }
+ unsigned nMaps;
+ register unsigned i, n;
+ register CARD8 *map;
+ register xkbKeyTypeWireDesc *wire = *wireRtrn;
+
+ if (req->firstType > ((unsigned) xkb->map->num_types)) {
+ *nMapsRtrn = _XkbErrCode3(0x01, req->firstType, xkb->map->num_types);
+ return 0;
+ }
+ if (req->flags & XkbSetMapResizeTypes) {
+ nMaps = req->firstType + req->nTypes;
+ if (nMaps < XkbNumRequiredTypes) { /* canonical types must be there */
+ *nMapsRtrn = _XkbErrCode4(0x02, req->firstType, req->nTypes, 4);
+ return 0;
+ }
+ }
+ else if (req->present & XkbKeyTypesMask) {
+ nMaps = xkb->map->num_types;
+ if ((req->firstType + req->nTypes) > nMaps) {
+ *nMapsRtrn = req->firstType + req->nTypes;
+ return 0;
+ }
}
else {
- *nMapsRtrn = xkb->map->num_types;
- for (i=0;i<xkb->map->num_types;i++) {
- mapWidthRtrn[i] = xkb->map->types[i].num_levels;
- }
- return 1;
- }
-
- for (i=0;i<req->firstType;i++) {
- mapWidthRtrn[i] = xkb->map->types[i].num_levels;
- }
- for (i=0;i<req->nTypes;i++) {
- unsigned width;
- if (client->swapped) {
- swaps(&wire->virtualMods);
- }
- n= i+req->firstType;
- width= wire->numLevels;
- if (width<1) {
- *nMapsRtrn= _XkbErrCode3(0x04,n,width);
- return 0;
- }
- else if ((n==XkbOneLevelIndex)&&(width!=1)) { /* must be width 1 */
- *nMapsRtrn= _XkbErrCode3(0x05,n,width);
- return 0;
- }
- else if ((width!=2)&&
- ((n==XkbTwoLevelIndex)||(n==XkbKeypadIndex)||
- (n==XkbAlphabeticIndex))) {
- /* TWO_LEVEL, ALPHABETIC and KEYPAD must be width 2 */
- *nMapsRtrn= _XkbErrCode3(0x05,n,width);
- return 0;
- }
- if (wire->nMapEntries>0) {
- xkbKTSetMapEntryWireDesc * mapWire;
- xkbModsWireDesc * preWire;
- mapWire= (xkbKTSetMapEntryWireDesc *)&wire[1];
- preWire= (xkbModsWireDesc *)&mapWire[wire->nMapEntries];
- for (n=0;n<wire->nMapEntries;n++) {
- if (client->swapped) {
- swaps(&mapWire[n].virtualMods);
- }
- if (mapWire[n].realMods&(~wire->realMods)) {
- *nMapsRtrn= _XkbErrCode4(0x06,n,mapWire[n].realMods,
- wire->realMods);
- return 0;
- }
- if (mapWire[n].virtualMods&(~wire->virtualMods)) {
- *nMapsRtrn= _XkbErrCode3(0x07,n,mapWire[n].virtualMods);
- return 0;
- }
- if (mapWire[n].level>=wire->numLevels) {
- *nMapsRtrn= _XkbErrCode4(0x08,n,wire->numLevels,
- mapWire[n].level);
- return 0;
- }
- if (wire->preserve) {
- if (client->swapped) {
- swaps(&preWire[n].virtualMods);
- }
- if (preWire[n].realMods&(~mapWire[n].realMods)) {
- *nMapsRtrn= _XkbErrCode4(0x09,n,preWire[n].realMods,
- mapWire[n].realMods);
- return 0;
- }
- if (preWire[n].virtualMods&(~mapWire[n].virtualMods)) {
- *nMapsRtrn=_XkbErrCode3(0x0a,n,preWire[n].virtualMods);
- return 0;
- }
- }
- }
- if (wire->preserve)
- map= (CARD8 *)&preWire[wire->nMapEntries];
- else map= (CARD8 *)&mapWire[wire->nMapEntries];
- }
- else map= (CARD8 *)&wire[1];
- mapWidthRtrn[i+req->firstType] = wire->numLevels;
- wire= (xkbKeyTypeWireDesc *)map;
- }
- for (i=req->firstType+req->nTypes;i<nMaps;i++) {
- mapWidthRtrn[i] = xkb->map->types[i].num_levels;
+ *nMapsRtrn = xkb->map->num_types;
+ for (i = 0; i < xkb->map->num_types; i++) {
+ mapWidthRtrn[i] = xkb->map->types[i].num_levels;
+ }
+ return 1;
+ }
+
+ for (i = 0; i < req->firstType; i++) {
+ mapWidthRtrn[i] = xkb->map->types[i].num_levels;
+ }
+ for (i = 0; i < req->nTypes; i++) {
+ unsigned width;
+
+ if (client->swapped) {
+ swaps(&wire->virtualMods);
+ }
+ n = i + req->firstType;
+ width = wire->numLevels;
+ if (width < 1) {
+ *nMapsRtrn = _XkbErrCode3(0x04, n, width);
+ return 0;
+ }
+ else if ((n == XkbOneLevelIndex) && (width != 1)) { /* must be width 1 */
+ *nMapsRtrn = _XkbErrCode3(0x05, n, width);
+ return 0;
+ }
+ else if ((width != 2) &&
+ ((n == XkbTwoLevelIndex) || (n == XkbKeypadIndex) ||
+ (n == XkbAlphabeticIndex))) {
+ /* TWO_LEVEL, ALPHABETIC and KEYPAD must be width 2 */
+ *nMapsRtrn = _XkbErrCode3(0x05, n, width);
+ return 0;
+ }
+ if (wire->nMapEntries > 0) {
+ xkbKTSetMapEntryWireDesc *mapWire;
+ xkbModsWireDesc *preWire;
+
+ mapWire = (xkbKTSetMapEntryWireDesc *) & wire[1];
+ preWire = (xkbModsWireDesc *) & mapWire[wire->nMapEntries];
+ for (n = 0; n < wire->nMapEntries; n++) {
+ if (client->swapped) {
+ swaps(&mapWire[n].virtualMods);
+ }
+ if (mapWire[n].realMods & (~wire->realMods)) {
+ *nMapsRtrn = _XkbErrCode4(0x06, n, mapWire[n].realMods,
+ wire->realMods);
+ return 0;
+ }
+ if (mapWire[n].virtualMods & (~wire->virtualMods)) {
+ *nMapsRtrn = _XkbErrCode3(0x07, n, mapWire[n].virtualMods);
+ return 0;
+ }
+ if (mapWire[n].level >= wire->numLevels) {
+ *nMapsRtrn = _XkbErrCode4(0x08, n, wire->numLevels,
+ mapWire[n].level);
+ return 0;
+ }
+ if (wire->preserve) {
+ if (client->swapped) {
+ swaps(&preWire[n].virtualMods);
+ }
+ if (preWire[n].realMods & (~mapWire[n].realMods)) {
+ *nMapsRtrn = _XkbErrCode4(0x09, n, preWire[n].realMods,
+ mapWire[n].realMods);
+ return 0;
+ }
+ if (preWire[n].virtualMods & (~mapWire[n].virtualMods)) {
+ *nMapsRtrn =
+ _XkbErrCode3(0x0a, n, preWire[n].virtualMods);
+ return 0;
+ }
+ }
+ }
+ if (wire->preserve)
+ map = (CARD8 *) &preWire[wire->nMapEntries];
+ else
+ map = (CARD8 *) &mapWire[wire->nMapEntries];
+ }
+ else
+ map = (CARD8 *) &wire[1];
+ mapWidthRtrn[i + req->firstType] = wire->numLevels;
+ wire = (xkbKeyTypeWireDesc *) map;
+ }
+ for (i = req->firstType + req->nTypes; i < nMaps; i++) {
+ mapWidthRtrn[i] = xkb->map->types[i].num_levels;
}
*nMapsRtrn = nMaps;
*wireRtrn = wire;
@@ -1656,660 +1698,666 @@ register xkbKeyTypeWireDesc *wire = *wireRtrn;
}
static int
-CheckKeySyms( ClientPtr client,
- XkbDescPtr xkb,
- xkbSetMapReq * req,
- int nTypes,
- CARD8 * mapWidths,
- CARD16 * symsPerKey,
- xkbSymMapWireDesc ** wireRtrn,
- int * errorRtrn)
+CheckKeySyms(ClientPtr client,
+ XkbDescPtr xkb,
+ xkbSetMapReq * req,
+ int nTypes,
+ CARD8 *mapWidths,
+ CARD16 *symsPerKey, xkbSymMapWireDesc ** wireRtrn, int *errorRtrn)
{
-register unsigned i;
-XkbSymMapPtr map;
-xkbSymMapWireDesc* wire = *wireRtrn;
-
- if (!(XkbKeySymsMask&req->present))
- return 1;
- CHK_REQ_KEY_RANGE2(0x11,req->firstKeySym,req->nKeySyms,req,(*errorRtrn),0);
- for (i=0;i<req->nKeySyms;i++) {
- KeySym *pSyms;
- register unsigned nG;
- if (client->swapped) {
- swaps(&wire->nSyms);
- }
- nG = XkbNumGroups(wire->groupInfo);
- if (nG>XkbNumKbdGroups) {
- *errorRtrn = _XkbErrCode3(0x14,i+req->firstKeySym,nG);
- return 0;
- }
- if (nG>0) {
- register int g,w;
- for (g=w=0;g<nG;g++) {
- if (wire->ktIndex[g]>=(unsigned)nTypes) {
- *errorRtrn= _XkbErrCode4(0x15,i+req->firstKeySym,g,
- wire->ktIndex[g]);
- return 0;
- }
- if (mapWidths[wire->ktIndex[g]]>w)
- w= mapWidths[wire->ktIndex[g]];
- }
- if (wire->width!=w) {
- *errorRtrn= _XkbErrCode3(0x16,i+req->firstKeySym,wire->width);
- return 0;
- }
- w*= nG;
- symsPerKey[i+req->firstKeySym] = w;
- if (w!=wire->nSyms) {
- *errorRtrn=_XkbErrCode4(0x16,i+req->firstKeySym,wire->nSyms,w);
- return 0;
- }
- }
- else if (wire->nSyms!=0) {
- *errorRtrn = _XkbErrCode3(0x17,i+req->firstKeySym,wire->nSyms);
- return 0;
- }
- pSyms = (KeySym *)&wire[1];
- wire = (xkbSymMapWireDesc *)&pSyms[wire->nSyms];
+ register unsigned i;
+ XkbSymMapPtr map;
+ xkbSymMapWireDesc *wire = *wireRtrn;
+
+ if (!(XkbKeySymsMask & req->present))
+ return 1;
+ CHK_REQ_KEY_RANGE2(0x11, req->firstKeySym, req->nKeySyms, req, (*errorRtrn),
+ 0);
+ for (i = 0; i < req->nKeySyms; i++) {
+ KeySym *pSyms;
+ register unsigned nG;
+
+ if (client->swapped) {
+ swaps(&wire->nSyms);
+ }
+ nG = XkbNumGroups(wire->groupInfo);
+ if (nG > XkbNumKbdGroups) {
+ *errorRtrn = _XkbErrCode3(0x14, i + req->firstKeySym, nG);
+ return 0;
+ }
+ if (nG > 0) {
+ register int g, w;
+
+ for (g = w = 0; g < nG; g++) {
+ if (wire->ktIndex[g] >= (unsigned) nTypes) {
+ *errorRtrn = _XkbErrCode4(0x15, i + req->firstKeySym, g,
+ wire->ktIndex[g]);
+ return 0;
+ }
+ if (mapWidths[wire->ktIndex[g]] > w)
+ w = mapWidths[wire->ktIndex[g]];
+ }
+ if (wire->width != w) {
+ *errorRtrn =
+ _XkbErrCode3(0x16, i + req->firstKeySym, wire->width);
+ return 0;
+ }
+ w *= nG;
+ symsPerKey[i + req->firstKeySym] = w;
+ if (w != wire->nSyms) {
+ *errorRtrn =
+ _XkbErrCode4(0x16, i + req->firstKeySym, wire->nSyms, w);
+ return 0;
+ }
+ }
+ else if (wire->nSyms != 0) {
+ *errorRtrn = _XkbErrCode3(0x17, i + req->firstKeySym, wire->nSyms);
+ return 0;
+ }
+ pSyms = (KeySym *) & wire[1];
+ wire = (xkbSymMapWireDesc *) & pSyms[wire->nSyms];
}
map = &xkb->map->key_sym_map[i];
- for (;i<=(unsigned)xkb->max_key_code;i++,map++) {
- register int g,nG,w;
- nG= XkbKeyNumGroups(xkb,i);
- for (w=g=0;g<nG;g++) {
- if (map->kt_index[g]>=(unsigned)nTypes) {
- *errorRtrn = _XkbErrCode4(0x18,i,g,map->kt_index[g]);
- return 0;
- }
- if (mapWidths[map->kt_index[g]]>w)
- w= mapWidths[map->kt_index[g]];
- }
- symsPerKey[i] = w*nG;
+ for (; i <= (unsigned) xkb->max_key_code; i++, map++) {
+ register int g, nG, w;
+
+ nG = XkbKeyNumGroups(xkb, i);
+ for (w = g = 0; g < nG; g++) {
+ if (map->kt_index[g] >= (unsigned) nTypes) {
+ *errorRtrn = _XkbErrCode4(0x18, i, g, map->kt_index[g]);
+ return 0;
+ }
+ if (mapWidths[map->kt_index[g]] > w)
+ w = mapWidths[map->kt_index[g]];
+ }
+ symsPerKey[i] = w * nG;
}
*wireRtrn = wire;
return 1;
}
static int
-CheckKeyActions( XkbDescPtr xkb,
- xkbSetMapReq * req,
- int nTypes,
- CARD8 * mapWidths,
- CARD16 * symsPerKey,
- CARD8 ** wireRtrn,
- int * nActsRtrn)
+CheckKeyActions(XkbDescPtr xkb,
+ xkbSetMapReq * req,
+ int nTypes,
+ CARD8 *mapWidths,
+ CARD16 *symsPerKey, CARD8 **wireRtrn, int *nActsRtrn)
{
-int nActs;
-CARD8 * wire = *wireRtrn;
-register unsigned i;
-
- if (!(XkbKeyActionsMask&req->present))
- return 1;
- CHK_REQ_KEY_RANGE2(0x21,req->firstKeyAct,req->nKeyActs,req,(*nActsRtrn),0);
- for (nActs=i=0;i<req->nKeyActs;i++) {
- if (wire[0]!=0) {
- if (wire[0]==symsPerKey[i+req->firstKeyAct])
- nActs+= wire[0];
- else {
- *nActsRtrn= _XkbErrCode3(0x23,i+req->firstKeyAct,wire[0]);
- return 0;
- }
- }
- wire++;
- }
- if (req->nKeyActs%4)
- wire+= 4-(req->nKeyActs%4);
- *wireRtrn = (CARD8 *)(((XkbAnyAction *)wire)+nActs);
+ int nActs;
+ CARD8 *wire = *wireRtrn;
+ register unsigned i;
+
+ if (!(XkbKeyActionsMask & req->present))
+ return 1;
+ CHK_REQ_KEY_RANGE2(0x21, req->firstKeyAct, req->nKeyActs, req, (*nActsRtrn),
+ 0);
+ for (nActs = i = 0; i < req->nKeyActs; i++) {
+ if (wire[0] != 0) {
+ if (wire[0] == symsPerKey[i + req->firstKeyAct])
+ nActs += wire[0];
+ else {
+ *nActsRtrn = _XkbErrCode3(0x23, i + req->firstKeyAct, wire[0]);
+ return 0;
+ }
+ }
+ wire++;
+ }
+ if (req->nKeyActs % 4)
+ wire += 4 - (req->nKeyActs % 4);
+ *wireRtrn = (CARD8 *) (((XkbAnyAction *) wire) + nActs);
*nActsRtrn = nActs;
return 1;
}
static int
-CheckKeyBehaviors( XkbDescPtr xkb,
- xkbSetMapReq * req,
- xkbBehaviorWireDesc ** wireRtrn,
- int * errorRtrn)
+CheckKeyBehaviors(XkbDescPtr xkb,
+ xkbSetMapReq * req,
+ xkbBehaviorWireDesc ** wireRtrn, int *errorRtrn)
{
-register xkbBehaviorWireDesc * wire = *wireRtrn;
-register XkbServerMapPtr server = xkb->server;
-register unsigned i;
-unsigned first,last;
-
- if (((req->present&XkbKeyBehaviorsMask)==0)||(req->nKeyBehaviors<1)) {
- req->present&= ~XkbKeyBehaviorsMask;
- req->nKeyBehaviors= 0;
- return 1;
- }
- first= req->firstKeyBehavior;
- last= req->firstKeyBehavior+req->nKeyBehaviors-1;
- if (first<req->minKeyCode) {
- *errorRtrn = _XkbErrCode3(0x31,first,req->minKeyCode);
- return 0;
- }
- if (last>req->maxKeyCode) {
- *errorRtrn = _XkbErrCode3(0x32,last,req->maxKeyCode);
- return 0;
- }
-
- for (i=0;i<req->totalKeyBehaviors;i++,wire++) {
- if ((wire->key<first)||(wire->key>last)) {
- *errorRtrn = _XkbErrCode4(0x33,first,last,wire->key);
- return 0;
- }
- if ((wire->type&XkbKB_Permanent)&&
- ((server->behaviors[wire->key].type!=wire->type)||
- (server->behaviors[wire->key].data!=wire->data))) {
- *errorRtrn = _XkbErrCode3(0x33,wire->key,wire->type);
- return 0;
- }
- if ((wire->type==XkbKB_RadioGroup)&&
- ((wire->data&(~XkbKB_RGAllowNone))>XkbMaxRadioGroups)) {
- *errorRtrn= _XkbErrCode4(0x34,wire->key,wire->data,
- XkbMaxRadioGroups);
- return 0;
- }
- if ((wire->type==XkbKB_Overlay1)||(wire->type==XkbKB_Overlay2)) {
- CHK_KEY_RANGE2(0x35,wire->key,1,xkb,*errorRtrn,0);
- }
+ register xkbBehaviorWireDesc *wire = *wireRtrn;
+ register XkbServerMapPtr server = xkb->server;
+ register unsigned i;
+ unsigned first, last;
+
+ if (((req->present & XkbKeyBehaviorsMask) == 0) || (req->nKeyBehaviors < 1)) {
+ req->present &= ~XkbKeyBehaviorsMask;
+ req->nKeyBehaviors = 0;
+ return 1;
+ }
+ first = req->firstKeyBehavior;
+ last = req->firstKeyBehavior + req->nKeyBehaviors - 1;
+ if (first < req->minKeyCode) {
+ *errorRtrn = _XkbErrCode3(0x31, first, req->minKeyCode);
+ return 0;
+ }
+ if (last > req->maxKeyCode) {
+ *errorRtrn = _XkbErrCode3(0x32, last, req->maxKeyCode);
+ return 0;
+ }
+
+ for (i = 0; i < req->totalKeyBehaviors; i++, wire++) {
+ if ((wire->key < first) || (wire->key > last)) {
+ *errorRtrn = _XkbErrCode4(0x33, first, last, wire->key);
+ return 0;
+ }
+ if ((wire->type & XkbKB_Permanent) &&
+ ((server->behaviors[wire->key].type != wire->type) ||
+ (server->behaviors[wire->key].data != wire->data))) {
+ *errorRtrn = _XkbErrCode3(0x33, wire->key, wire->type);
+ return 0;
+ }
+ if ((wire->type == XkbKB_RadioGroup) &&
+ ((wire->data & (~XkbKB_RGAllowNone)) > XkbMaxRadioGroups)) {
+ *errorRtrn = _XkbErrCode4(0x34, wire->key, wire->data,
+ XkbMaxRadioGroups);
+ return 0;
+ }
+ if ((wire->type == XkbKB_Overlay1) || (wire->type == XkbKB_Overlay2)) {
+ CHK_KEY_RANGE2(0x35, wire->key, 1, xkb, *errorRtrn, 0);
+ }
}
*wireRtrn = wire;
return 1;
}
static int
-CheckVirtualMods( XkbDescRec * xkb,
- xkbSetMapReq * req,
- CARD8 ** wireRtrn,
- int * errorRtrn)
+CheckVirtualMods(XkbDescRec * xkb,
+ xkbSetMapReq * req, CARD8 **wireRtrn, int *errorRtrn)
{
-register CARD8 *wire = *wireRtrn;
-register unsigned i,nMods,bit;
+ register CARD8 *wire = *wireRtrn;
+ register unsigned i, nMods, bit;
- if (((req->present&XkbVirtualModsMask)==0)||(req->virtualMods==0))
- return 1;
- for (i=nMods=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
- if (req->virtualMods&bit)
- nMods++;
+ if (((req->present & XkbVirtualModsMask) == 0) || (req->virtualMods == 0))
+ return 1;
+ for (i = nMods = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+ if (req->virtualMods & bit)
+ nMods++;
}
- *wireRtrn= (wire+XkbPaddedSize(nMods));
+ *wireRtrn = (wire + XkbPaddedSize(nMods));
return 1;
}
static int
-CheckKeyExplicit( XkbDescPtr xkb,
- xkbSetMapReq * req,
- CARD8 ** wireRtrn,
- int * errorRtrn)
+CheckKeyExplicit(XkbDescPtr xkb,
+ xkbSetMapReq * req, CARD8 **wireRtrn, int *errorRtrn)
{
-register CARD8 * wire = *wireRtrn;
-CARD8 * start;
-register unsigned i;
-int first,last;
-
- if (((req->present&XkbExplicitComponentsMask)==0)||(req->nKeyExplicit<1)) {
- req->present&= ~XkbExplicitComponentsMask;
- req->nKeyExplicit= 0;
- return 1;
- }
- first= req->firstKeyExplicit;
- last= first+req->nKeyExplicit-1;
- if (first<req->minKeyCode) {
- *errorRtrn = _XkbErrCode3(0x51,first,req->minKeyCode);
- return 0;
- }
- if (last>req->maxKeyCode) {
- *errorRtrn = _XkbErrCode3(0x52,last,req->maxKeyCode);
- return 0;
- }
- start= wire;
- for (i=0;i<req->totalKeyExplicit;i++,wire+=2) {
- if ((wire[0]<first)||(wire[0]>last)) {
- *errorRtrn = _XkbErrCode4(0x53,first,last,wire[0]);
- return 0;
- }
- if (wire[1]&(~XkbAllExplicitMask)) {
- *errorRtrn= _XkbErrCode3(0x52,~XkbAllExplicitMask,wire[1]);
- return 0;
- }
- }
- wire+= XkbPaddedSize(wire-start)-(wire-start);
- *wireRtrn= wire;
+ register CARD8 *wire = *wireRtrn;
+ CARD8 *start;
+ register unsigned i;
+ int first, last;
+
+ if (((req->present & XkbExplicitComponentsMask) == 0) ||
+ (req->nKeyExplicit < 1)) {
+ req->present &= ~XkbExplicitComponentsMask;
+ req->nKeyExplicit = 0;
+ return 1;
+ }
+ first = req->firstKeyExplicit;
+ last = first + req->nKeyExplicit - 1;
+ if (first < req->minKeyCode) {
+ *errorRtrn = _XkbErrCode3(0x51, first, req->minKeyCode);
+ return 0;
+ }
+ if (last > req->maxKeyCode) {
+ *errorRtrn = _XkbErrCode3(0x52, last, req->maxKeyCode);
+ return 0;
+ }
+ start = wire;
+ for (i = 0; i < req->totalKeyExplicit; i++, wire += 2) {
+ if ((wire[0] < first) || (wire[0] > last)) {
+ *errorRtrn = _XkbErrCode4(0x53, first, last, wire[0]);
+ return 0;
+ }
+ if (wire[1] & (~XkbAllExplicitMask)) {
+ *errorRtrn = _XkbErrCode3(0x52, ~XkbAllExplicitMask, wire[1]);
+ return 0;
+ }
+ }
+ wire += XkbPaddedSize(wire - start) - (wire - start);
+ *wireRtrn = wire;
return 1;
}
static int
-CheckModifierMap(XkbDescPtr xkb,xkbSetMapReq *req,CARD8 **wireRtrn,int *errRtrn)
+CheckModifierMap(XkbDescPtr xkb, xkbSetMapReq * req, CARD8 **wireRtrn,
+ int *errRtrn)
{
-register CARD8 * wire = *wireRtrn;
-CARD8 * start;
-register unsigned i;
-int first,last;
-
- if (((req->present&XkbModifierMapMask)==0)||(req->nModMapKeys<1)) {
- req->present&= ~XkbModifierMapMask;
- req->nModMapKeys= 0;
- return 1;
- }
- first= req->firstModMapKey;
- last= first+req->nModMapKeys-1;
- if (first<req->minKeyCode) {
- *errRtrn = _XkbErrCode3(0x61,first,req->minKeyCode);
- return 0;
- }
- if (last>req->maxKeyCode) {
- *errRtrn = _XkbErrCode3(0x62,last,req->maxKeyCode);
- return 0;
- }
- start= wire;
- for (i=0;i<req->totalModMapKeys;i++,wire+=2) {
- if ((wire[0]<first)||(wire[0]>last)) {
- *errRtrn = _XkbErrCode4(0x63,first,last,wire[0]);
- return 0;
- }
- }
- wire+= XkbPaddedSize(wire-start)-(wire-start);
- *wireRtrn= wire;
+ register CARD8 *wire = *wireRtrn;
+ CARD8 *start;
+ register unsigned i;
+ int first, last;
+
+ if (((req->present & XkbModifierMapMask) == 0) || (req->nModMapKeys < 1)) {
+ req->present &= ~XkbModifierMapMask;
+ req->nModMapKeys = 0;
+ return 1;
+ }
+ first = req->firstModMapKey;
+ last = first + req->nModMapKeys - 1;
+ if (first < req->minKeyCode) {
+ *errRtrn = _XkbErrCode3(0x61, first, req->minKeyCode);
+ return 0;
+ }
+ if (last > req->maxKeyCode) {
+ *errRtrn = _XkbErrCode3(0x62, last, req->maxKeyCode);
+ return 0;
+ }
+ start = wire;
+ for (i = 0; i < req->totalModMapKeys; i++, wire += 2) {
+ if ((wire[0] < first) || (wire[0] > last)) {
+ *errRtrn = _XkbErrCode4(0x63, first, last, wire[0]);
+ return 0;
+ }
+ }
+ wire += XkbPaddedSize(wire - start) - (wire - start);
+ *wireRtrn = wire;
return 1;
}
static int
-CheckVirtualModMap( XkbDescPtr xkb,
- xkbSetMapReq *req,
- xkbVModMapWireDesc **wireRtrn,
- int *errRtrn)
+CheckVirtualModMap(XkbDescPtr xkb,
+ xkbSetMapReq * req,
+ xkbVModMapWireDesc ** wireRtrn, int *errRtrn)
{
-register xkbVModMapWireDesc * wire = *wireRtrn;
-register unsigned i;
-int first,last;
-
- if (((req->present&XkbVirtualModMapMask)==0)||(req->nVModMapKeys<1)) {
- req->present&= ~XkbVirtualModMapMask;
- req->nVModMapKeys= 0;
- return 1;
- }
- first= req->firstVModMapKey;
- last= first+req->nVModMapKeys-1;
- if (first<req->minKeyCode) {
- *errRtrn = _XkbErrCode3(0x71,first,req->minKeyCode);
- return 0;
- }
- if (last>req->maxKeyCode) {
- *errRtrn = _XkbErrCode3(0x72,last,req->maxKeyCode);
- return 0;
- }
- for (i=0;i<req->totalVModMapKeys;i++,wire++) {
- if ((wire->key<first)||(wire->key>last)) {
- *errRtrn = _XkbErrCode4(0x73,first,last,wire->key);
- return 0;
- }
- }
- *wireRtrn= wire;
+ register xkbVModMapWireDesc *wire = *wireRtrn;
+ register unsigned i;
+ int first, last;
+
+ if (((req->present & XkbVirtualModMapMask) == 0) || (req->nVModMapKeys < 1)) {
+ req->present &= ~XkbVirtualModMapMask;
+ req->nVModMapKeys = 0;
+ return 1;
+ }
+ first = req->firstVModMapKey;
+ last = first + req->nVModMapKeys - 1;
+ if (first < req->minKeyCode) {
+ *errRtrn = _XkbErrCode3(0x71, first, req->minKeyCode);
+ return 0;
+ }
+ if (last > req->maxKeyCode) {
+ *errRtrn = _XkbErrCode3(0x72, last, req->maxKeyCode);
+ return 0;
+ }
+ for (i = 0; i < req->totalVModMapKeys; i++, wire++) {
+ if ((wire->key < first) || (wire->key > last)) {
+ *errRtrn = _XkbErrCode4(0x73, first, last, wire->key);
+ return 0;
+ }
+ }
+ *wireRtrn = wire;
return 1;
}
static char *
-SetKeyTypes( XkbDescPtr xkb,
- xkbSetMapReq * req,
- xkbKeyTypeWireDesc * wire,
- XkbChangesPtr changes)
+SetKeyTypes(XkbDescPtr xkb,
+ xkbSetMapReq * req,
+ xkbKeyTypeWireDesc * wire, XkbChangesPtr changes)
{
-register unsigned i;
-unsigned first,last;
-CARD8 *map;
-
- if ((unsigned)(req->firstType+req->nTypes)>xkb->map->size_types) {
- i= req->firstType+req->nTypes;
- if (XkbAllocClientMap(xkb,XkbKeyTypesMask,i)!=Success) {
- return NULL;
- }
- }
- if ((unsigned)(req->firstType+req->nTypes)>xkb->map->num_types)
- xkb->map->num_types= req->firstType+req->nTypes;
-
- for (i=0;i<req->nTypes;i++) {
- XkbKeyTypePtr pOld;
- register unsigned n;
-
- if (XkbResizeKeyType(xkb,i+req->firstType,wire->nMapEntries,
- wire->preserve,wire->numLevels)!=Success) {
- return NULL;
- }
- pOld = &xkb->map->types[i+req->firstType];
- map = (CARD8 *)&wire[1];
-
- pOld->mods.real_mods = wire->realMods;
- pOld->mods.vmods= wire->virtualMods;
- pOld->num_levels = wire->numLevels;
- pOld->map_count= wire->nMapEntries;
-
- pOld->mods.mask= pOld->mods.real_mods|
- XkbMaskForVMask(xkb,pOld->mods.vmods);
-
- if (wire->nMapEntries) {
- xkbKTSetMapEntryWireDesc *mapWire;
- xkbModsWireDesc *preWire;
- unsigned tmp;
- mapWire= (xkbKTSetMapEntryWireDesc *)map;
- preWire= (xkbModsWireDesc *)&mapWire[wire->nMapEntries];
- for (n=0;n<wire->nMapEntries;n++) {
- pOld->map[n].active= 1;
- pOld->map[n].mods.mask= mapWire[n].realMods;
- pOld->map[n].mods.real_mods= mapWire[n].realMods;
- pOld->map[n].mods.vmods= mapWire[n].virtualMods;
- pOld->map[n].level= mapWire[n].level;
- if (mapWire[n].virtualMods!=0) {
- tmp= XkbMaskForVMask(xkb,mapWire[n].virtualMods);
- pOld->map[n].active= (tmp!=0);
- pOld->map[n].mods.mask|= tmp;
- }
- if (wire->preserve) {
- pOld->preserve[n].real_mods= preWire[n].realMods;
- pOld->preserve[n].vmods= preWire[n].virtualMods;
- tmp= XkbMaskForVMask(xkb,preWire[n].virtualMods);
- pOld->preserve[n].mask= preWire[n].realMods|tmp;
- }
- }
- if (wire->preserve)
- map= (CARD8 *)&preWire[wire->nMapEntries];
- else map= (CARD8 *)&mapWire[wire->nMapEntries];
- }
- else map= (CARD8 *)&wire[1];
- wire = (xkbKeyTypeWireDesc *)map;
- }
- first= req->firstType;
- last= first+req->nTypes-1; /* last changed type */
- if (changes->map.changed&XkbKeyTypesMask) {
- int oldLast;
- oldLast= changes->map.first_type+changes->map.num_types-1;
- if (changes->map.first_type<first)
- first= changes->map.first_type;
- if (oldLast>last)
- last= oldLast;
- }
- changes->map.changed|= XkbKeyTypesMask;
+ register unsigned i;
+ unsigned first, last;
+ CARD8 *map;
+
+ if ((unsigned) (req->firstType + req->nTypes) > xkb->map->size_types) {
+ i = req->firstType + req->nTypes;
+ if (XkbAllocClientMap(xkb, XkbKeyTypesMask, i) != Success) {
+ return NULL;
+ }
+ }
+ if ((unsigned) (req->firstType + req->nTypes) > xkb->map->num_types)
+ xkb->map->num_types = req->firstType + req->nTypes;
+
+ for (i = 0; i < req->nTypes; i++) {
+ XkbKeyTypePtr pOld;
+ register unsigned n;
+
+ if (XkbResizeKeyType(xkb, i + req->firstType, wire->nMapEntries,
+ wire->preserve, wire->numLevels) != Success) {
+ return NULL;
+ }
+ pOld = &xkb->map->types[i + req->firstType];
+ map = (CARD8 *) &wire[1];
+
+ pOld->mods.real_mods = wire->realMods;
+ pOld->mods.vmods = wire->virtualMods;
+ pOld->num_levels = wire->numLevels;
+ pOld->map_count = wire->nMapEntries;
+
+ pOld->mods.mask = pOld->mods.real_mods |
+ XkbMaskForVMask(xkb, pOld->mods.vmods);
+
+ if (wire->nMapEntries) {
+ xkbKTSetMapEntryWireDesc *mapWire;
+ xkbModsWireDesc *preWire;
+ unsigned tmp;
+
+ mapWire = (xkbKTSetMapEntryWireDesc *) map;
+ preWire = (xkbModsWireDesc *) & mapWire[wire->nMapEntries];
+ for (n = 0; n < wire->nMapEntries; n++) {
+ pOld->map[n].active = 1;
+ pOld->map[n].mods.mask = mapWire[n].realMods;
+ pOld->map[n].mods.real_mods = mapWire[n].realMods;
+ pOld->map[n].mods.vmods = mapWire[n].virtualMods;
+ pOld->map[n].level = mapWire[n].level;
+ if (mapWire[n].virtualMods != 0) {
+ tmp = XkbMaskForVMask(xkb, mapWire[n].virtualMods);
+ pOld->map[n].active = (tmp != 0);
+ pOld->map[n].mods.mask |= tmp;
+ }
+ if (wire->preserve) {
+ pOld->preserve[n].real_mods = preWire[n].realMods;
+ pOld->preserve[n].vmods = preWire[n].virtualMods;
+ tmp = XkbMaskForVMask(xkb, preWire[n].virtualMods);
+ pOld->preserve[n].mask = preWire[n].realMods | tmp;
+ }
+ }
+ if (wire->preserve)
+ map = (CARD8 *) &preWire[wire->nMapEntries];
+ else
+ map = (CARD8 *) &mapWire[wire->nMapEntries];
+ }
+ else
+ map = (CARD8 *) &wire[1];
+ wire = (xkbKeyTypeWireDesc *) map;
+ }
+ first = req->firstType;
+ last = first + req->nTypes - 1; /* last changed type */
+ if (changes->map.changed & XkbKeyTypesMask) {
+ int oldLast;
+
+ oldLast = changes->map.first_type + changes->map.num_types - 1;
+ if (changes->map.first_type < first)
+ first = changes->map.first_type;
+ if (oldLast > last)
+ last = oldLast;
+ }
+ changes->map.changed |= XkbKeyTypesMask;
changes->map.first_type = first;
- changes->map.num_types = (last-first)+1;
- return (char *)wire;
+ changes->map.num_types = (last - first) + 1;
+ return (char *) wire;
}
static char *
-SetKeySyms( ClientPtr client,
- XkbDescPtr xkb,
- xkbSetMapReq * req,
- xkbSymMapWireDesc * wire,
- XkbChangesPtr changes,
- DeviceIntPtr dev)
+SetKeySyms(ClientPtr client,
+ XkbDescPtr xkb,
+ xkbSetMapReq * req,
+ xkbSymMapWireDesc * wire, XkbChangesPtr changes, DeviceIntPtr dev)
{
-register unsigned i,s;
-XkbSymMapPtr oldMap;
-KeySym * newSyms;
-KeySym * pSyms;
-unsigned first,last;
+ register unsigned i, s;
+ XkbSymMapPtr oldMap;
+ KeySym *newSyms;
+ KeySym *pSyms;
+ unsigned first, last;
oldMap = &xkb->map->key_sym_map[req->firstKeySym];
- for (i=0;i<req->nKeySyms;i++,oldMap++) {
- pSyms = (KeySym *)&wire[1];
- if (wire->nSyms>0) {
- newSyms = XkbResizeKeySyms(xkb,i+req->firstKeySym,wire->nSyms);
- for (s=0;s<wire->nSyms;s++) {
- newSyms[s]= pSyms[s];
- }
- if (client->swapped) {
- for (s=0;s<wire->nSyms;s++) {
- swapl(&newSyms[s]);
- }
- }
- }
- oldMap->kt_index[0] = wire->ktIndex[0];
- oldMap->kt_index[1] = wire->ktIndex[1];
- oldMap->kt_index[2] = wire->ktIndex[2];
- oldMap->kt_index[3] = wire->ktIndex[3];
- oldMap->group_info = wire->groupInfo;
- oldMap->width = wire->width;
- wire= (xkbSymMapWireDesc *)&pSyms[wire->nSyms];
- }
- first= req->firstKeySym;
- last= first+req->nKeySyms-1;
- if (changes->map.changed&XkbKeySymsMask) {
- int oldLast= (changes->map.first_key_sym+changes->map.num_key_syms-1);
- if (changes->map.first_key_sym<first)
- first= changes->map.first_key_sym;
- if (oldLast>last)
- last= oldLast;
- }
- changes->map.changed|= XkbKeySymsMask;
+ for (i = 0; i < req->nKeySyms; i++, oldMap++) {
+ pSyms = (KeySym *) & wire[1];
+ if (wire->nSyms > 0) {
+ newSyms = XkbResizeKeySyms(xkb, i + req->firstKeySym, wire->nSyms);
+ for (s = 0; s < wire->nSyms; s++) {
+ newSyms[s] = pSyms[s];
+ }
+ if (client->swapped) {
+ for (s = 0; s < wire->nSyms; s++) {
+ swapl(&newSyms[s]);
+ }
+ }
+ }
+ oldMap->kt_index[0] = wire->ktIndex[0];
+ oldMap->kt_index[1] = wire->ktIndex[1];
+ oldMap->kt_index[2] = wire->ktIndex[2];
+ oldMap->kt_index[3] = wire->ktIndex[3];
+ oldMap->group_info = wire->groupInfo;
+ oldMap->width = wire->width;
+ wire = (xkbSymMapWireDesc *) & pSyms[wire->nSyms];
+ }
+ first = req->firstKeySym;
+ last = first + req->nKeySyms - 1;
+ if (changes->map.changed & XkbKeySymsMask) {
+ int oldLast =
+ (changes->map.first_key_sym + changes->map.num_key_syms - 1);
+ if (changes->map.first_key_sym < first)
+ first = changes->map.first_key_sym;
+ if (oldLast > last)
+ last = oldLast;
+ }
+ changes->map.changed |= XkbKeySymsMask;
changes->map.first_key_sym = first;
- changes->map.num_key_syms = (last-first+1);
-
- s= 0;
- for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
- if (XkbKeyNumGroups(xkb,i)>s)
- s= XkbKeyNumGroups(xkb,i);
- }
- if (s!=xkb->ctrls->num_groups) {
- xkbControlsNotify cn;
- XkbControlsRec old;
- cn.keycode= 0;
- cn.eventType= 0;
- cn.requestMajor= XkbReqCode;
- cn.requestMinor= X_kbSetMap;
- old= *xkb->ctrls;
- xkb->ctrls->num_groups= s;
- if (XkbComputeControlsNotify(dev,&old,xkb->ctrls,&cn,FALSE))
- XkbSendControlsNotify(dev,&cn);
- }
- return (char *)wire;
+ changes->map.num_key_syms = (last - first + 1);
+
+ s = 0;
+ for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+ if (XkbKeyNumGroups(xkb, i) > s)
+ s = XkbKeyNumGroups(xkb, i);
+ }
+ if (s != xkb->ctrls->num_groups) {
+ xkbControlsNotify cn;
+ XkbControlsRec old;
+
+ cn.keycode = 0;
+ cn.eventType = 0;
+ cn.requestMajor = XkbReqCode;
+ cn.requestMinor = X_kbSetMap;
+ old = *xkb->ctrls;
+ xkb->ctrls->num_groups = s;
+ if (XkbComputeControlsNotify(dev, &old, xkb->ctrls, &cn, FALSE))
+ XkbSendControlsNotify(dev, &cn);
+ }
+ return (char *) wire;
}
static char *
-SetKeyActions( XkbDescPtr xkb,
- xkbSetMapReq * req,
- CARD8 * wire,
- XkbChangesPtr changes)
+SetKeyActions(XkbDescPtr xkb,
+ xkbSetMapReq * req, CARD8 *wire, XkbChangesPtr changes)
{
-register unsigned i,first,last;
-CARD8 * nActs = wire;
-XkbAction * newActs;
-
- wire+= XkbPaddedSize(req->nKeyActs);
- for (i=0;i<req->nKeyActs;i++) {
- if (nActs[i]==0)
- xkb->server->key_acts[i+req->firstKeyAct]= 0;
- else {
- newActs= XkbResizeKeyActions(xkb,i+req->firstKeyAct,nActs[i]);
- memcpy((char *)newActs,(char *)wire,
- nActs[i]*SIZEOF(xkbActionWireDesc));
- wire+= nActs[i]*SIZEOF(xkbActionWireDesc);
- }
- }
- first= req->firstKeyAct;
- last= (first+req->nKeyActs-1);
- if (changes->map.changed&XkbKeyActionsMask) {
- int oldLast;
- oldLast= changes->map.first_key_act+changes->map.num_key_acts-1;
- if (changes->map.first_key_act<first)
- first= changes->map.first_key_act;
- if (oldLast>last)
- last= oldLast;
- }
- changes->map.changed|= XkbKeyActionsMask;
- changes->map.first_key_act= first;
- changes->map.num_key_acts= (last-first+1);
- return (char *)wire;
+ register unsigned i, first, last;
+ CARD8 *nActs = wire;
+ XkbAction *newActs;
+
+ wire += XkbPaddedSize(req->nKeyActs);
+ for (i = 0; i < req->nKeyActs; i++) {
+ if (nActs[i] == 0)
+ xkb->server->key_acts[i + req->firstKeyAct] = 0;
+ else {
+ newActs = XkbResizeKeyActions(xkb, i + req->firstKeyAct, nActs[i]);
+ memcpy((char *) newActs, (char *) wire,
+ nActs[i] * SIZEOF(xkbActionWireDesc));
+ wire += nActs[i] * SIZEOF(xkbActionWireDesc);
+ }
+ }
+ first = req->firstKeyAct;
+ last = (first + req->nKeyActs - 1);
+ if (changes->map.changed & XkbKeyActionsMask) {
+ int oldLast;
+
+ oldLast = changes->map.first_key_act + changes->map.num_key_acts - 1;
+ if (changes->map.first_key_act < first)
+ first = changes->map.first_key_act;
+ if (oldLast > last)
+ last = oldLast;
+ }
+ changes->map.changed |= XkbKeyActionsMask;
+ changes->map.first_key_act = first;
+ changes->map.num_key_acts = (last - first + 1);
+ return (char *) wire;
}
static char *
-SetKeyBehaviors( XkbSrvInfoPtr xkbi,
- xkbSetMapReq *req,
- xkbBehaviorWireDesc *wire,
- XkbChangesPtr changes)
+SetKeyBehaviors(XkbSrvInfoPtr xkbi,
+ xkbSetMapReq * req,
+ xkbBehaviorWireDesc * wire, XkbChangesPtr changes)
{
-register unsigned i;
-int maxRG = -1;
-XkbDescPtr xkb = xkbi->desc;
-XkbServerMapPtr server = xkb->server;
-unsigned first,last;
-
- first= req->firstKeyBehavior;
- last= req->firstKeyBehavior+req->nKeyBehaviors-1;
- memset(&server->behaviors[first], 0, req->nKeyBehaviors*sizeof(XkbBehavior));
- for (i=0;i<req->totalKeyBehaviors;i++) {
- if ((server->behaviors[wire->key].type&XkbKB_Permanent)==0) {
- server->behaviors[wire->key].type= wire->type;
- server->behaviors[wire->key].data= wire->data;
- if ((wire->type==XkbKB_RadioGroup)&&(((int)wire->data)>maxRG))
- maxRG= wire->data + 1;
- }
- wire++;
- }
-
- if (maxRG>(int)xkbi->nRadioGroups) {
- int sz = maxRG*sizeof(XkbRadioGroupRec);
+ register unsigned i;
+ int maxRG = -1;
+ XkbDescPtr xkb = xkbi->desc;
+ XkbServerMapPtr server = xkb->server;
+ unsigned first, last;
+
+ first = req->firstKeyBehavior;
+ last = req->firstKeyBehavior + req->nKeyBehaviors - 1;
+ memset(&server->behaviors[first], 0,
+ req->nKeyBehaviors * sizeof(XkbBehavior));
+ for (i = 0; i < req->totalKeyBehaviors; i++) {
+ if ((server->behaviors[wire->key].type & XkbKB_Permanent) == 0) {
+ server->behaviors[wire->key].type = wire->type;
+ server->behaviors[wire->key].data = wire->data;
+ if ((wire->type == XkbKB_RadioGroup) &&
+ (((int) wire->data) > maxRG))
+ maxRG = wire->data + 1;
+ }
+ wire++;
+ }
+
+ if (maxRG > (int) xkbi->nRadioGroups) {
+ int sz = maxRG * sizeof(XkbRadioGroupRec);
+
if (xkbi->radioGroups)
- xkbi->radioGroups= realloc(xkbi->radioGroups,sz);
- else xkbi->radioGroups= calloc(1, sz);
+ xkbi->radioGroups = realloc(xkbi->radioGroups, sz);
+ else
+ xkbi->radioGroups = calloc(1, sz);
if (xkbi->radioGroups) {
- if (xkbi->nRadioGroups)
- memset(&xkbi->radioGroups[xkbi->nRadioGroups], 0,
- (maxRG-xkbi->nRadioGroups)*sizeof(XkbRadioGroupRec));
- xkbi->nRadioGroups= maxRG;
+ if (xkbi->nRadioGroups)
+ memset(&xkbi->radioGroups[xkbi->nRadioGroups], 0,
+ (maxRG - xkbi->nRadioGroups) * sizeof(XkbRadioGroupRec));
+ xkbi->nRadioGroups = maxRG;
}
- else xkbi->nRadioGroups= 0;
+ else
+ xkbi->nRadioGroups = 0;
/* should compute members here */
}
- if (changes->map.changed&XkbKeyBehaviorsMask) {
- unsigned oldLast;
- oldLast= changes->map.first_key_behavior+
- changes->map.num_key_behaviors-1;
- if (changes->map.first_key_behavior<req->firstKeyBehavior)
- first= changes->map.first_key_behavior;
- if (oldLast>last)
- last= oldLast;
+ if (changes->map.changed & XkbKeyBehaviorsMask) {
+ unsigned oldLast;
+
+ oldLast = changes->map.first_key_behavior +
+ changes->map.num_key_behaviors - 1;
+ if (changes->map.first_key_behavior < req->firstKeyBehavior)
+ first = changes->map.first_key_behavior;
+ if (oldLast > last)
+ last = oldLast;
}
- changes->map.changed|= XkbKeyBehaviorsMask;
+ changes->map.changed |= XkbKeyBehaviorsMask;
changes->map.first_key_behavior = first;
- changes->map.num_key_behaviors = (last-first+1);
- return (char *)wire;
+ changes->map.num_key_behaviors = (last - first + 1);
+ return (char *) wire;
}
static char *
-SetVirtualMods(XkbSrvInfoPtr xkbi,xkbSetMapReq *req,CARD8 *wire,
- XkbChangesPtr changes)
+SetVirtualMods(XkbSrvInfoPtr xkbi, xkbSetMapReq * req, CARD8 *wire,
+ XkbChangesPtr changes)
{
-register int i,bit,nMods;
-XkbServerMapPtr srv = xkbi->desc->server;
-
- if (((req->present&XkbVirtualModsMask)==0)||(req->virtualMods==0))
- return (char *)wire;
- for (i=nMods=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
- if (req->virtualMods&bit) {
- if (srv->vmods[i]!=wire[nMods]) {
- changes->map.changed|= XkbVirtualModsMask;
- changes->map.vmods|= bit;
- srv->vmods[i]= wire[nMods];
- }
- nMods++;
- }
- }
- return (char *)(wire+XkbPaddedSize(nMods));
+ register int i, bit, nMods;
+ XkbServerMapPtr srv = xkbi->desc->server;
+
+ if (((req->present & XkbVirtualModsMask) == 0) || (req->virtualMods == 0))
+ return (char *) wire;
+ for (i = nMods = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+ if (req->virtualMods & bit) {
+ if (srv->vmods[i] != wire[nMods]) {
+ changes->map.changed |= XkbVirtualModsMask;
+ changes->map.vmods |= bit;
+ srv->vmods[i] = wire[nMods];
+ }
+ nMods++;
+ }
+ }
+ return (char *) (wire + XkbPaddedSize(nMods));
}
static char *
-SetKeyExplicit(XkbSrvInfoPtr xkbi,xkbSetMapReq *req,CARD8 *wire,
- XkbChangesPtr changes)
+SetKeyExplicit(XkbSrvInfoPtr xkbi, xkbSetMapReq * req, CARD8 *wire,
+ XkbChangesPtr changes)
{
-register unsigned i,first,last;
-XkbServerMapPtr xkb = xkbi->desc->server;
-CARD8 * start;
+ register unsigned i, first, last;
+ XkbServerMapPtr xkb = xkbi->desc->server;
+ CARD8 *start;
- start= wire;
- first= req->firstKeyExplicit;
- last= req->firstKeyExplicit+req->nKeyExplicit-1;
+ start = wire;
+ first = req->firstKeyExplicit;
+ last = req->firstKeyExplicit + req->nKeyExplicit - 1;
memset(&xkb->explicit[first], 0, req->nKeyExplicit);
- for (i=0;i<req->totalKeyExplicit;i++,wire+= 2) {
- xkb->explicit[wire[0]]= wire[1];
- }
- if (first>0) {
- if (changes->map.changed&XkbExplicitComponentsMask) {
- int oldLast;
- oldLast= changes->map.first_key_explicit+
- changes->map.num_key_explicit-1;
- if (changes->map.first_key_explicit<first)
- first= changes->map.first_key_explicit;
- if (oldLast>last)
- last= oldLast;
- }
- changes->map.first_key_explicit= first;
- changes->map.num_key_explicit= (last-first)+1;
- }
- wire+= XkbPaddedSize(wire-start)-(wire-start);
- return (char *)wire;
+ for (i = 0; i < req->totalKeyExplicit; i++, wire += 2) {
+ xkb->explicit[wire[0]] = wire[1];
+ }
+ if (first > 0) {
+ if (changes->map.changed & XkbExplicitComponentsMask) {
+ int oldLast;
+
+ oldLast = changes->map.first_key_explicit +
+ changes->map.num_key_explicit - 1;
+ if (changes->map.first_key_explicit < first)
+ first = changes->map.first_key_explicit;
+ if (oldLast > last)
+ last = oldLast;
+ }
+ changes->map.first_key_explicit = first;
+ changes->map.num_key_explicit = (last - first) + 1;
+ }
+ wire += XkbPaddedSize(wire - start) - (wire - start);
+ return (char *) wire;
}
static char *
-SetModifierMap( XkbSrvInfoPtr xkbi,
- xkbSetMapReq * req,
- CARD8 * wire,
- XkbChangesPtr changes)
+SetModifierMap(XkbSrvInfoPtr xkbi,
+ xkbSetMapReq * req, CARD8 *wire, XkbChangesPtr changes)
{
-register unsigned i,first,last;
-XkbClientMapPtr xkb = xkbi->desc->map;
-CARD8 * start;
+ register unsigned i, first, last;
+ XkbClientMapPtr xkb = xkbi->desc->map;
+ CARD8 *start;
- start= wire;
- first= req->firstModMapKey;
- last= req->firstModMapKey+req->nModMapKeys-1;
+ start = wire;
+ first = req->firstModMapKey;
+ last = req->firstModMapKey + req->nModMapKeys - 1;
memset(&xkb->modmap[first], 0, req->nModMapKeys);
- for (i=0;i<req->totalModMapKeys;i++,wire+= 2) {
- xkb->modmap[wire[0]]= wire[1];
- }
- if (first>0) {
- if (changes->map.changed&XkbModifierMapMask) {
- int oldLast;
- oldLast= changes->map.first_modmap_key+
- changes->map.num_modmap_keys-1;
- if (changes->map.first_modmap_key<first)
- first= changes->map.first_modmap_key;
- if (oldLast>last)
- last= oldLast;
- }
- changes->map.first_modmap_key= first;
- changes->map.num_modmap_keys= (last-first)+1;
- }
- wire+= XkbPaddedSize(wire-start)-(wire-start);
- return (char *)wire;
+ for (i = 0; i < req->totalModMapKeys; i++, wire += 2) {
+ xkb->modmap[wire[0]] = wire[1];
+ }
+ if (first > 0) {
+ if (changes->map.changed & XkbModifierMapMask) {
+ int oldLast;
+
+ oldLast = changes->map.first_modmap_key +
+ changes->map.num_modmap_keys - 1;
+ if (changes->map.first_modmap_key < first)
+ first = changes->map.first_modmap_key;
+ if (oldLast > last)
+ last = oldLast;
+ }
+ changes->map.first_modmap_key = first;
+ changes->map.num_modmap_keys = (last - first) + 1;
+ }
+ wire += XkbPaddedSize(wire - start) - (wire - start);
+ return (char *) wire;
}
static char *
-SetVirtualModMap( XkbSrvInfoPtr xkbi,
- xkbSetMapReq * req,
- xkbVModMapWireDesc * wire,
- XkbChangesPtr changes)
+SetVirtualModMap(XkbSrvInfoPtr xkbi,
+ xkbSetMapReq * req,
+ xkbVModMapWireDesc * wire, XkbChangesPtr changes)
{
-register unsigned i,first,last;
-XkbServerMapPtr srv = xkbi->desc->server;
-
- first= req->firstVModMapKey;
- last= req->firstVModMapKey+req->nVModMapKeys-1;
- memset(&srv->vmodmap[first], 0, req->nVModMapKeys*sizeof(unsigned short));
- for (i=0;i<req->totalVModMapKeys;i++,wire++) {
- srv->vmodmap[wire->key]= wire->vmods;
- }
- if (first>0) {
- if (changes->map.changed&XkbVirtualModMapMask) {
- int oldLast;
- oldLast= changes->map.first_vmodmap_key+
- changes->map.num_vmodmap_keys-1;
- if (changes->map.first_vmodmap_key<first)
- first= changes->map.first_vmodmap_key;
- if (oldLast>last)
- last= oldLast;
- }
- changes->map.first_vmodmap_key= first;
- changes->map.num_vmodmap_keys= (last-first)+1;
- }
- return (char *)wire;
+ register unsigned i, first, last;
+ XkbServerMapPtr srv = xkbi->desc->server;
+
+ first = req->firstVModMapKey;
+ last = req->firstVModMapKey + req->nVModMapKeys - 1;
+ memset(&srv->vmodmap[first], 0, req->nVModMapKeys * sizeof(unsigned short));
+ for (i = 0; i < req->totalVModMapKeys; i++, wire++) {
+ srv->vmodmap[wire->key] = wire->vmods;
+ }
+ if (first > 0) {
+ if (changes->map.changed & XkbVirtualModMapMask) {
+ int oldLast;
+
+ oldLast = changes->map.first_vmodmap_key +
+ changes->map.num_vmodmap_keys - 1;
+ if (changes->map.first_vmodmap_key < first)
+ first = changes->map.first_vmodmap_key;
+ if (oldLast > last)
+ last = oldLast;
+ }
+ changes->map.first_vmodmap_key = first;
+ changes->map.num_vmodmap_keys = (last - first) + 1;
+ }
+ return (char *) wire;
}
/**
@@ -2317,106 +2365,112 @@ XkbServerMapPtr srv = xkbi->desc->server;
* actually do anything..
*/
static int
-_XkbSetMapChecks(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq *req, char* values)
+_XkbSetMapChecks(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq * req,
+ char *values)
{
- XkbSrvInfoPtr xkbi;
- XkbDescPtr xkb;
- int error;
- int nTypes = 0, nActions;
- CARD8 mapWidths[XkbMaxLegalKeyCode + 1] = {0};
- CARD16 symsPerKey[XkbMaxLegalKeyCode + 1] = {0};
- XkbSymMapPtr map;
- int i;
-
- xkbi= dev->key->xkbInfo;
+ XkbSrvInfoPtr xkbi;
+ XkbDescPtr xkb;
+ int error;
+ int nTypes = 0, nActions;
+ CARD8 mapWidths[XkbMaxLegalKeyCode + 1] = { 0 };
+ CARD16 symsPerKey[XkbMaxLegalKeyCode + 1] = { 0 };
+ XkbSymMapPtr map;
+ int i;
+
+ xkbi = dev->key->xkbInfo;
xkb = xkbi->desc;
- if ((xkb->min_key_code != req->minKeyCode)||
+ if ((xkb->min_key_code != req->minKeyCode) ||
(xkb->max_key_code != req->maxKeyCode)) {
- if (client->vMajor!=1) { /* pre 1.0 versions of Xlib have a bug */
- req->minKeyCode= xkb->min_key_code;
- req->maxKeyCode= xkb->max_key_code;
- }
- else {
- if (!XkbIsLegalKeycode(req->minKeyCode)) {
- client->errorValue = _XkbErrCode3(2, req->minKeyCode, req->maxKeyCode);
- return BadValue;
- }
- if (req->minKeyCode > req->maxKeyCode) {
- client->errorValue = _XkbErrCode3(3, req->minKeyCode, req->maxKeyCode);
- return BadMatch;
- }
- }
+ if (client->vMajor != 1) { /* pre 1.0 versions of Xlib have a bug */
+ req->minKeyCode = xkb->min_key_code;
+ req->maxKeyCode = xkb->max_key_code;
+ }
+ else {
+ if (!XkbIsLegalKeycode(req->minKeyCode)) {
+ client->errorValue =
+ _XkbErrCode3(2, req->minKeyCode, req->maxKeyCode);
+ return BadValue;
+ }
+ if (req->minKeyCode > req->maxKeyCode) {
+ client->errorValue =
+ _XkbErrCode3(3, req->minKeyCode, req->maxKeyCode);
+ return BadMatch;
+ }
+ }
}
if ((req->present & XkbKeyTypesMask) &&
- (!CheckKeyTypes(client,xkb,req,(xkbKeyTypeWireDesc **)&values,
- &nTypes,mapWidths))) {
- client->errorValue = nTypes;
- return BadValue;
+ (!CheckKeyTypes(client, xkb, req, (xkbKeyTypeWireDesc **) & values,
+ &nTypes, mapWidths))) {
+ client->errorValue = nTypes;
+ return BadValue;
}
/* symsPerKey/mapWidths must be filled regardless of client-side flags */
map = &xkb->map->key_sym_map[xkb->min_key_code];
- for (i=xkb->min_key_code;i<xkb->max_key_code;i++,map++) {
- register int g,ng,w;
- ng= XkbNumGroups(map->group_info);
- for (w=g=0;g<ng;g++) {
- if (map->kt_index[g]>=(unsigned)nTypes) {
- client->errorValue = _XkbErrCode4(0x13,i,g,map->kt_index[g]);
- return 0;
- }
- if (mapWidths[map->kt_index[g]]>w)
- w= mapWidths[map->kt_index[g]];
- }
- symsPerKey[i] = w*ng;
+ for (i = xkb->min_key_code; i < xkb->max_key_code; i++, map++) {
+ register int g, ng, w;
+
+ ng = XkbNumGroups(map->group_info);
+ for (w = g = 0; g < ng; g++) {
+ if (map->kt_index[g] >= (unsigned) nTypes) {
+ client->errorValue = _XkbErrCode4(0x13, i, g, map->kt_index[g]);
+ return 0;
+ }
+ if (mapWidths[map->kt_index[g]] > w)
+ w = mapWidths[map->kt_index[g]];
+ }
+ symsPerKey[i] = w * ng;
}
if ((req->present & XkbKeySymsMask) &&
- (!CheckKeySyms(client,xkb,req,nTypes,mapWidths,symsPerKey,
- (xkbSymMapWireDesc **)&values,&error))) {
- client->errorValue = error;
- return BadValue;
+ (!CheckKeySyms(client, xkb, req, nTypes, mapWidths, symsPerKey,
+ (xkbSymMapWireDesc **) & values, &error))) {
+ client->errorValue = error;
+ return BadValue;
}
if ((req->present & XkbKeyActionsMask) &&
- (!CheckKeyActions(xkb,req,nTypes,mapWidths,symsPerKey,
- (CARD8 **)&values,&nActions))) {
- client->errorValue = nActions;
- return BadValue;
+ (!CheckKeyActions(xkb, req, nTypes, mapWidths, symsPerKey,
+ (CARD8 **) &values, &nActions))) {
+ client->errorValue = nActions;
+ return BadValue;
}
if ((req->present & XkbKeyBehaviorsMask) &&
- (!CheckKeyBehaviors(xkb,req,(xkbBehaviorWireDesc**)&values,&error))) {
- client->errorValue = error;
- return BadValue;
+ (!CheckKeyBehaviors
+ (xkb, req, (xkbBehaviorWireDesc **) & values, &error))) {
+ client->errorValue = error;
+ return BadValue;
}
if ((req->present & XkbVirtualModsMask) &&
- (!CheckVirtualMods(xkb,req,(CARD8 **)&values,&error))) {
- client->errorValue= error;
- return BadValue;
+ (!CheckVirtualMods(xkb, req, (CARD8 **) &values, &error))) {
+ client->errorValue = error;
+ return BadValue;
}
- if ((req->present&XkbExplicitComponentsMask) &&
- (!CheckKeyExplicit(xkb,req,(CARD8 **)&values,&error))) {
- client->errorValue= error;
- return BadValue;
+ if ((req->present & XkbExplicitComponentsMask) &&
+ (!CheckKeyExplicit(xkb, req, (CARD8 **) &values, &error))) {
+ client->errorValue = error;
+ return BadValue;
}
- if ((req->present&XkbModifierMapMask) &&
- (!CheckModifierMap(xkb,req,(CARD8 **)&values,&error))) {
- client->errorValue= error;
- return BadValue;
+ if ((req->present & XkbModifierMapMask) &&
+ (!CheckModifierMap(xkb, req, (CARD8 **) &values, &error))) {
+ client->errorValue = error;
+ return BadValue;
}
- if ((req->present&XkbVirtualModMapMask) &&
- (!CheckVirtualModMap(xkb,req,(xkbVModMapWireDesc **)&values,&error))) {
- client->errorValue= error;
- return BadValue;
+ if ((req->present & XkbVirtualModMapMask) &&
+ (!CheckVirtualModMap
+ (xkb, req, (xkbVModMapWireDesc **) & values, &error))) {
+ client->errorValue = error;
+ return BadValue;
}
- if (((values-((char *)req))/4)!= req->length) {
- ErrorF("[xkb] Internal error! Bad length in XkbSetMap (after check)\n");
- client->errorValue = values-((char *)&req[1]);
- return BadLength;
+ if (((values - ((char *) req)) / 4) != req->length) {
+ ErrorF("[xkb] Internal error! Bad length in XkbSetMap (after check)\n");
+ client->errorValue = values - ((char *) &req[1]);
+ return BadLength;
}
return Success;
@@ -2426,124 +2480,137 @@ _XkbSetMapChecks(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq *req, char* va
* Apply the given request on the given device.
*/
static int
-_XkbSetMap(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq *req, char *values)
+_XkbSetMap(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq * req, char *values)
{
- XkbEventCauseRec cause;
- XkbChangesRec change;
- Bool sentNKN;
- XkbSrvInfoPtr xkbi;
- XkbDescPtr xkb;
+ XkbEventCauseRec cause;
+ XkbChangesRec change;
+ Bool sentNKN;
+ XkbSrvInfoPtr xkbi;
+ XkbDescPtr xkb;
- xkbi= dev->key->xkbInfo;
+ xkbi = dev->key->xkbInfo;
xkb = xkbi->desc;
- XkbSetCauseXkbReq(&cause,X_kbSetMap,client);
+ XkbSetCauseXkbReq(&cause, X_kbSetMap, client);
memset(&change, 0, sizeof(change));
sentNKN = FALSE;
- if ((xkb->min_key_code!=req->minKeyCode)||
- (xkb->max_key_code!=req->maxKeyCode)) {
- Status status;
- xkbNewKeyboardNotify nkn;
- nkn.deviceID = nkn.oldDeviceID = dev->id;
- nkn.oldMinKeyCode = xkb->min_key_code;
- nkn.oldMaxKeyCode = xkb->max_key_code;
- status= XkbChangeKeycodeRange(xkb, req->minKeyCode,
- req->maxKeyCode, &change);
- if (status != Success)
- return status; /* oh-oh. what about the other keyboards? */
- nkn.minKeyCode = xkb->min_key_code;
- nkn.maxKeyCode = xkb->max_key_code;
- nkn.requestMajor = XkbReqCode;
- nkn.requestMinor = X_kbSetMap;
- nkn.changed = XkbNKN_KeycodesMask;
- XkbSendNewKeyboardNotify(dev,&nkn);
- sentNKN = TRUE;
- }
-
- if (req->present&XkbKeyTypesMask) {
- values = SetKeyTypes(xkb,req,(xkbKeyTypeWireDesc *)values,&change);
- if (!values) goto allocFailure;
- }
- if (req->present&XkbKeySymsMask) {
- values = SetKeySyms(client,xkb,req,(xkbSymMapWireDesc *)values,&change,dev);
- if (!values) goto allocFailure;
- }
- if (req->present&XkbKeyActionsMask) {
- values = SetKeyActions(xkb,req,(CARD8 *)values,&change);
- if (!values) goto allocFailure;
- }
- if (req->present&XkbKeyBehaviorsMask) {
- values= SetKeyBehaviors(xkbi,req,(xkbBehaviorWireDesc *)values,&change);
- if (!values) goto allocFailure;
- }
- if (req->present&XkbVirtualModsMask)
- values= SetVirtualMods(xkbi,req,(CARD8 *)values,&change);
- if (req->present&XkbExplicitComponentsMask)
- values= SetKeyExplicit(xkbi,req,(CARD8 *)values,&change);
- if (req->present&XkbModifierMapMask)
- values= SetModifierMap(xkbi,req,(CARD8 *)values,&change);
- if (req->present&XkbVirtualModMapMask)
- values= SetVirtualModMap(xkbi,req,(xkbVModMapWireDesc *)values,&change);
- if (((values-((char *)req))/4)!=req->length) {
- ErrorF("[xkb] Internal error! Bad length in XkbSetMap (after set)\n");
- client->errorValue = values-((char *)&req[1]);
- return BadLength;
- }
- if (req->flags&XkbSetMapRecomputeActions) {
- KeyCode first,last,firstMM,lastMM;
- if (change.map.num_key_syms>0) {
- first= change.map.first_key_sym;
- last= first+change.map.num_key_syms-1;
- }
- else first= last= 0;
- if (change.map.num_modmap_keys>0) {
- firstMM= change.map.first_modmap_key;
- lastMM= first+change.map.num_modmap_keys-1;
- }
- else firstMM= lastMM= 0;
- if ((last>0) && (lastMM>0)) {
- if (firstMM<first)
- first= firstMM;
- if (lastMM>last)
- last= lastMM;
- }
- else if (lastMM>0) {
- first= firstMM;
- last= lastMM;
- }
- if (last>0) {
- unsigned check= 0;
- XkbUpdateActions(dev,first,(last-first+1),&change,&check,&cause);
- if (check)
- XkbCheckSecondaryEffects(xkbi,check,&change,&cause);
- }
+ if ((xkb->min_key_code != req->minKeyCode) ||
+ (xkb->max_key_code != req->maxKeyCode)) {
+ Status status;
+ xkbNewKeyboardNotify nkn;
+
+ nkn.deviceID = nkn.oldDeviceID = dev->id;
+ nkn.oldMinKeyCode = xkb->min_key_code;
+ nkn.oldMaxKeyCode = xkb->max_key_code;
+ status = XkbChangeKeycodeRange(xkb, req->minKeyCode,
+ req->maxKeyCode, &change);
+ if (status != Success)
+ return status; /* oh-oh. what about the other keyboards? */
+ nkn.minKeyCode = xkb->min_key_code;
+ nkn.maxKeyCode = xkb->max_key_code;
+ nkn.requestMajor = XkbReqCode;
+ nkn.requestMinor = X_kbSetMap;
+ nkn.changed = XkbNKN_KeycodesMask;
+ XkbSendNewKeyboardNotify(dev, &nkn);
+ sentNKN = TRUE;
+ }
+
+ if (req->present & XkbKeyTypesMask) {
+ values = SetKeyTypes(xkb, req, (xkbKeyTypeWireDesc *) values, &change);
+ if (!values)
+ goto allocFailure;
+ }
+ if (req->present & XkbKeySymsMask) {
+ values =
+ SetKeySyms(client, xkb, req, (xkbSymMapWireDesc *) values, &change,
+ dev);
+ if (!values)
+ goto allocFailure;
+ }
+ if (req->present & XkbKeyActionsMask) {
+ values = SetKeyActions(xkb, req, (CARD8 *) values, &change);
+ if (!values)
+ goto allocFailure;
+ }
+ if (req->present & XkbKeyBehaviorsMask) {
+ values =
+ SetKeyBehaviors(xkbi, req, (xkbBehaviorWireDesc *) values, &change);
+ if (!values)
+ goto allocFailure;
+ }
+ if (req->present & XkbVirtualModsMask)
+ values = SetVirtualMods(xkbi, req, (CARD8 *) values, &change);
+ if (req->present & XkbExplicitComponentsMask)
+ values = SetKeyExplicit(xkbi, req, (CARD8 *) values, &change);
+ if (req->present & XkbModifierMapMask)
+ values = SetModifierMap(xkbi, req, (CARD8 *) values, &change);
+ if (req->present & XkbVirtualModMapMask)
+ values =
+ SetVirtualModMap(xkbi, req, (xkbVModMapWireDesc *) values, &change);
+ if (((values - ((char *) req)) / 4) != req->length) {
+ ErrorF("[xkb] Internal error! Bad length in XkbSetMap (after set)\n");
+ client->errorValue = values - ((char *) &req[1]);
+ return BadLength;
+ }
+ if (req->flags & XkbSetMapRecomputeActions) {
+ KeyCode first, last, firstMM, lastMM;
+
+ if (change.map.num_key_syms > 0) {
+ first = change.map.first_key_sym;
+ last = first + change.map.num_key_syms - 1;
+ }
+ else
+ first = last = 0;
+ if (change.map.num_modmap_keys > 0) {
+ firstMM = change.map.first_modmap_key;
+ lastMM = first + change.map.num_modmap_keys - 1;
+ }
+ else
+ firstMM = lastMM = 0;
+ if ((last > 0) && (lastMM > 0)) {
+ if (firstMM < first)
+ first = firstMM;
+ if (lastMM > last)
+ last = lastMM;
+ }
+ else if (lastMM > 0) {
+ first = firstMM;
+ last = lastMM;
+ }
+ if (last > 0) {
+ unsigned check = 0;
+
+ XkbUpdateActions(dev, first, (last - first + 1), &change, &check,
+ &cause);
+ if (check)
+ XkbCheckSecondaryEffects(xkbi, check, &change, &cause);
+ }
}
if (!sentNKN)
- XkbSendNotification(dev,&change,&cause);
+ XkbSendNotification(dev, &change, &cause);
return Success;
-allocFailure:
+ allocFailure:
return BadAlloc;
}
-
int
ProcXkbSetMap(ClientPtr client)
{
- DeviceIntPtr dev;
- char * tmp;
- int rc;
+ DeviceIntPtr dev;
+ char *tmp;
+ int rc;
REQUEST(xkbSetMapReq);
REQUEST_AT_LEAST_SIZE(xkbSetMapReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixManageAccess);
- CHK_MASK_LEGAL(0x01,stuff->present,XkbAllMapComponentsMask);
+ CHK_MASK_LEGAL(0x01, stuff->present, XkbAllMapComponentsMask);
- tmp = (char *)&stuff[1];
+ tmp = (char *) &stuff[1];
/* Check if we can to the SetMap on the requested device. If this
succeeds, do the same thing for all extension devices (if needed).
@@ -2553,16 +2620,15 @@ ProcXkbSetMap(ClientPtr client)
if (rc != Success)
return rc;
- if (stuff->deviceSpec == XkbUseCoreKbd)
- {
+ if (stuff->deviceSpec == XkbUseCoreKbd) {
DeviceIntPtr other;
- for (other = inputInfo.devices; other; other = other->next)
- {
- if ((other != dev) && other->key && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev)
- {
- rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixManageAccess);
- if (rc == Success)
- {
+
+ for (other = inputInfo.devices; other; other = other->next) {
+ if ((other != dev) && other->key && !IsMaster(other) &&
+ GetMaster(other, MASTER_KEYBOARD) == dev) {
+ rc = XaceHook(XACE_DEVICE_ACCESS, client, other,
+ DixManageAccess);
+ if (rc == Success) {
rc = _XkbSetMapChecks(client, other, stuff, tmp);
if (rc != Success)
return rc;
@@ -2576,14 +2642,14 @@ ProcXkbSetMap(ClientPtr client)
if (rc != Success)
return rc;
- if (stuff->deviceSpec == XkbUseCoreKbd)
- {
+ if (stuff->deviceSpec == XkbUseCoreKbd) {
DeviceIntPtr other;
- for (other = inputInfo.devices; other; other = other->next)
- {
- if ((other != dev) && other->key && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev)
- {
- rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixManageAccess);
+
+ for (other = inputInfo.devices; other; other = other->next) {
+ if ((other != dev) && other->key && !IsMaster(other) &&
+ GetMaster(other, MASTER_KEYBOARD) == dev) {
+ rc = XaceHook(XACE_DEVICE_ACCESS, client, other,
+ DixManageAccess);
if (rc == Success)
_XkbSetMap(client, other, stuff, tmp);
/* ignore rc. if the SetMap failed although the check above
@@ -2600,84 +2666,88 @@ ProcXkbSetMap(ClientPtr client)
/***====================================================================***/
static Status
-XkbComputeGetCompatMapReplySize( XkbCompatMapPtr compat,
- xkbGetCompatMapReply * rep)
+XkbComputeGetCompatMapReplySize(XkbCompatMapPtr compat,
+ xkbGetCompatMapReply * rep)
{
-unsigned size,nGroups;
-
- nGroups= 0;
- if (rep->groups!=0) {
- register int i,bit;
- for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
- if (rep->groups&bit)
- nGroups++;
- }
- }
- size= nGroups*SIZEOF(xkbModsWireDesc);
- size+= (rep->nSI*SIZEOF(xkbSymInterpretWireDesc));
- rep->length= size/4;
+ unsigned size, nGroups;
+
+ nGroups = 0;
+ if (rep->groups != 0) {
+ register int i, bit;
+
+ for (i = 0, bit = 1; i < XkbNumKbdGroups; i++, bit <<= 1) {
+ if (rep->groups & bit)
+ nGroups++;
+ }
+ }
+ size = nGroups * SIZEOF(xkbModsWireDesc);
+ size += (rep->nSI * SIZEOF(xkbSymInterpretWireDesc));
+ rep->length = size / 4;
return Success;
}
static int
-XkbSendCompatMap( ClientPtr client,
- XkbCompatMapPtr compat,
- xkbGetCompatMapReply * rep)
+XkbSendCompatMap(ClientPtr client,
+ XkbCompatMapPtr compat, xkbGetCompatMapReply * rep)
{
-char * data;
-int size;
-
- size= rep->length*4;
- if (size>0) {
- data = malloc(size);
- if (data) {
- register unsigned i,bit;
- xkbModsWireDesc * grp;
- XkbSymInterpretPtr sym= &compat->sym_interpret[rep->firstSI];
- xkbSymInterpretWireDesc *wire = (xkbSymInterpretWireDesc *)data;
- for (i=0;i<rep->nSI;i++,sym++,wire++) {
- wire->sym= sym->sym;
- wire->mods= sym->mods;
- wire->match= sym->match;
- wire->virtualMod= sym->virtual_mod;
- wire->flags= sym->flags;
- memcpy((char*)&wire->act,(char*)&sym->act,sz_xkbActionWireDesc);
- if (client->swapped) {
- swapl(&wire->sym);
- }
- }
- if (rep->groups) {
- grp = (xkbModsWireDesc *)wire;
- for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
- if (rep->groups&bit) {
- grp->mask= compat->groups[i].mask;
- grp->realMods= compat->groups[i].real_mods;
- grp->virtualMods= compat->groups[i].vmods;
- if (client->swapped) {
- swaps(&grp->virtualMods);
- }
- grp++;
- }
- }
- wire= (xkbSymInterpretWireDesc*)grp;
- }
- }
- else return BadAlloc;
- }
- else data= NULL;
+ char *data;
+ int size;
+
+ size = rep->length * 4;
+ if (size > 0) {
+ data = malloc(size);
+ if (data) {
+ register unsigned i, bit;
+ xkbModsWireDesc *grp;
+ XkbSymInterpretPtr sym = &compat->sym_interpret[rep->firstSI];
+ xkbSymInterpretWireDesc *wire = (xkbSymInterpretWireDesc *) data;
+
+ for (i = 0; i < rep->nSI; i++, sym++, wire++) {
+ wire->sym = sym->sym;
+ wire->mods = sym->mods;
+ wire->match = sym->match;
+ wire->virtualMod = sym->virtual_mod;
+ wire->flags = sym->flags;
+ memcpy((char *) &wire->act, (char *) &sym->act,
+ sz_xkbActionWireDesc);
+ if (client->swapped) {
+ swapl(&wire->sym);
+ }
+ }
+ if (rep->groups) {
+ grp = (xkbModsWireDesc *) wire;
+ for (i = 0, bit = 1; i < XkbNumKbdGroups; i++, bit <<= 1) {
+ if (rep->groups & bit) {
+ grp->mask = compat->groups[i].mask;
+ grp->realMods = compat->groups[i].real_mods;
+ grp->virtualMods = compat->groups[i].vmods;
+ if (client->swapped) {
+ swaps(&grp->virtualMods);
+ }
+ grp++;
+ }
+ }
+ wire = (xkbSymInterpretWireDesc *) grp;
+ }
+ }
+ else
+ return BadAlloc;
+ }
+ else
+ data = NULL;
if (client->swapped) {
- swaps(&rep->sequenceNumber);
- swapl(&rep->length);
- swaps(&rep->firstSI);
- swaps(&rep->nSI);
- swaps(&rep->nTotalSI);
+ swaps(&rep->sequenceNumber);
+ swapl(&rep->length);
+ swaps(&rep->firstSI);
+ swaps(&rep->nSI);
+ swaps(&rep->nTotalSI);
}
- WriteToClient(client, SIZEOF(xkbGetCompatMapReply), (char *)rep);
+ WriteToClient(client, SIZEOF(xkbGetCompatMapReply), (char *) rep);
if (data) {
- WriteToClient(client, size, data);
- free((char *)data);
+ WriteToClient(client, size, data);
+ free((char *) data);
}
return Success;
}
@@ -2685,21 +2755,21 @@ int size;
int
ProcXkbGetCompatMap(ClientPtr client)
{
- xkbGetCompatMapReply rep;
- DeviceIntPtr dev;
- XkbDescPtr xkb;
- XkbCompatMapPtr compat;
+ xkbGetCompatMapReply rep;
+ DeviceIntPtr dev;
+ XkbDescPtr xkb;
+ XkbCompatMapPtr compat;
REQUEST(xkbGetCompatMapReq);
REQUEST_SIZE_MATCH(xkbGetCompatMapReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess);
xkb = dev->key->xkbInfo->desc;
- compat= xkb->compat;
+ compat = xkb->compat;
rep.type = X_Reply;
rep.deviceID = dev->id;
@@ -2708,18 +2778,18 @@ ProcXkbGetCompatMap(ClientPtr client)
rep.firstSI = stuff->firstSI;
rep.nSI = stuff->nSI;
if (stuff->getAllSI) {
- rep.firstSI = 0;
- rep.nSI = compat->num_si;
+ rep.firstSI = 0;
+ rep.nSI = compat->num_si;
}
- else if ((((unsigned)stuff->nSI)>0)&&
- ((unsigned)(stuff->firstSI+stuff->nSI-1)>=compat->num_si)) {
- client->errorValue = _XkbErrCode2(0x05,compat->num_si);
- return BadValue;
+ else if ((((unsigned) stuff->nSI) > 0) &&
+ ((unsigned) (stuff->firstSI + stuff->nSI - 1) >= compat->num_si)) {
+ client->errorValue = _XkbErrCode2(0x05, compat->num_si);
+ return BadValue;
}
rep.nTotalSI = compat->num_si;
- rep.groups= stuff->groups;
- XkbComputeGetCompatMapReplySize(compat,&rep);
- return XkbSendCompatMap(client,compat,&rep);
+ rep.groups = stuff->groups;
+ XkbComputeGetCompatMapReplySize(compat, &rep);
+ return XkbSendCompatMap(client, compat, &rep);
}
/**
@@ -2729,146 +2799,152 @@ ProcXkbGetCompatMap(ClientPtr client)
*/
static int
_XkbSetCompatMap(ClientPtr client, DeviceIntPtr dev,
- xkbSetCompatMapReq *req, char* data, BOOL dryRun)
+ xkbSetCompatMapReq * req, char *data, BOOL dryRun)
{
- XkbSrvInfoPtr xkbi;
- XkbDescPtr xkb;
- XkbCompatMapPtr compat;
- int nGroups;
- unsigned i,bit;
+ XkbSrvInfoPtr xkbi;
+ XkbDescPtr xkb;
+ XkbCompatMapPtr compat;
+ int nGroups;
+ unsigned i, bit;
xkbi = dev->key->xkbInfo;
xkb = xkbi->desc;
compat = xkb->compat;
- if ((req->nSI>0)||(req->truncateSI)) {
- xkbSymInterpretWireDesc *wire;
- if (req->firstSI>compat->num_si) {
- client->errorValue = _XkbErrCode2(0x02,compat->num_si);
- return BadValue;
- }
- wire= (xkbSymInterpretWireDesc *)data;
- wire+= req->nSI;
- data = (char *)wire;
+ if ((req->nSI > 0) || (req->truncateSI)) {
+ xkbSymInterpretWireDesc *wire;
+
+ if (req->firstSI > compat->num_si) {
+ client->errorValue = _XkbErrCode2(0x02, compat->num_si);
+ return BadValue;
+ }
+ wire = (xkbSymInterpretWireDesc *) data;
+ wire += req->nSI;
+ data = (char *) wire;
}
- nGroups= 0;
- if (req->groups!=0) {
- for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
- if ( req->groups&bit )
- nGroups++;
- }
+ nGroups = 0;
+ if (req->groups != 0) {
+ for (i = 0, bit = 1; i < XkbNumKbdGroups; i++, bit <<= 1) {
+ if (req->groups & bit)
+ nGroups++;
+ }
}
- data+= nGroups*SIZEOF(xkbModsWireDesc);
- if (((data-((char *)req))/4)!=req->length) {
- return BadLength;
+ data += nGroups * SIZEOF(xkbModsWireDesc);
+ if (((data - ((char *) req)) / 4) != req->length) {
+ return BadLength;
}
/* Done all the checks we can do */
if (dryRun)
return Success;
- data = (char *)&req[1];
- if (req->nSI>0) {
- xkbSymInterpretWireDesc *wire = (xkbSymInterpretWireDesc *)data;
- XkbSymInterpretPtr sym;
- unsigned int skipped = 0;
- if ((unsigned)(req->firstSI+req->nSI)>compat->num_si) {
- compat->num_si= req->firstSI+req->nSI;
- compat->sym_interpret= realloc(compat->sym_interpret,
- compat->num_si * sizeof(XkbSymInterpretRec));
- if (!compat->sym_interpret) {
- compat->num_si= 0;
- return BadAlloc;
- }
- }
- else if (req->truncateSI) {
- compat->num_si = req->firstSI+req->nSI;
- }
- sym = &compat->sym_interpret[req->firstSI];
- for (i=0;i<req->nSI;i++,wire++) {
- if (client->swapped) {
- swapl(&wire->sym);
- }
- if (wire->sym == NoSymbol && wire->match == XkbSI_AnyOfOrNone &&
- (wire->mods & 0xff) == 0xff &&
- wire->act.type == XkbSA_XFree86Private) {
- ErrorF("XKB: Skipping broken Any+AnyOfOrNone(All) -> Private "
- "action from client\n");
- skipped++;
- continue;
- }
- sym->sym= wire->sym;
- sym->mods= wire->mods;
- sym->match= wire->match;
- sym->flags= wire->flags;
- sym->virtual_mod= wire->virtualMod;
- memcpy((char *)&sym->act,(char *)&wire->act,
+ data = (char *) &req[1];
+ if (req->nSI > 0) {
+ xkbSymInterpretWireDesc *wire = (xkbSymInterpretWireDesc *) data;
+ XkbSymInterpretPtr sym;
+ unsigned int skipped = 0;
+
+ if ((unsigned) (req->firstSI + req->nSI) > compat->num_si) {
+ compat->num_si = req->firstSI + req->nSI;
+ compat->sym_interpret = realloc(compat->sym_interpret,
+ compat->num_si *
+ sizeof(XkbSymInterpretRec));
+ if (!compat->sym_interpret) {
+ compat->num_si = 0;
+ return BadAlloc;
+ }
+ }
+ else if (req->truncateSI) {
+ compat->num_si = req->firstSI + req->nSI;
+ }
+ sym = &compat->sym_interpret[req->firstSI];
+ for (i = 0; i < req->nSI; i++, wire++) {
+ if (client->swapped) {
+ swapl(&wire->sym);
+ }
+ if (wire->sym == NoSymbol && wire->match == XkbSI_AnyOfOrNone &&
+ (wire->mods & 0xff) == 0xff &&
+ wire->act.type == XkbSA_XFree86Private) {
+ ErrorF("XKB: Skipping broken Any+AnyOfOrNone(All) -> Private "
+ "action from client\n");
+ skipped++;
+ continue;
+ }
+ sym->sym = wire->sym;
+ sym->mods = wire->mods;
+ sym->match = wire->match;
+ sym->flags = wire->flags;
+ sym->virtual_mod = wire->virtualMod;
+ memcpy((char *) &sym->act, (char *) &wire->act,
SIZEOF(xkbActionWireDesc));
sym++;
- }
- if (skipped) {
- if (req->firstSI + req->nSI < compat->num_si)
- memmove(sym, sym + skipped,
- (compat->num_si - req->firstSI - req->nSI) *
- sizeof(*sym));
- compat->num_si -= skipped;
- }
- data = (char *)wire;
+ }
+ if (skipped) {
+ if (req->firstSI + req->nSI < compat->num_si)
+ memmove(sym, sym + skipped,
+ (compat->num_si - req->firstSI - req->nSI) *
+ sizeof(*sym));
+ compat->num_si -= skipped;
+ }
+ data = (char *) wire;
}
else if (req->truncateSI) {
- compat->num_si = req->firstSI;
- }
-
- if (req->groups!=0) {
- unsigned i, bit;
- xkbModsWireDesc *wire = (xkbModsWireDesc *)data;
- for (i = 0, bit = 1; i < XkbNumKbdGroups; i++, bit <<= 1) {
- if (req->groups & bit) {
- if (client->swapped) {
- swaps(&wire->virtualMods);
- }
- compat->groups[i].mask= wire->realMods;
- compat->groups[i].real_mods= wire->realMods;
- compat->groups[i].vmods= wire->virtualMods;
- if (wire->virtualMods!=0) {
- unsigned tmp;
- tmp= XkbMaskForVMask(xkb,wire->virtualMods);
- compat->groups[i].mask|= tmp;
- }
- data+= SIZEOF(xkbModsWireDesc);
- wire= (xkbModsWireDesc *)data;
- }
- }
- }
- i= XkbPaddedSize((data-((char *)req)));
- if ((i/4)!=req->length) {
- ErrorF("[xkb] Internal length error on read in _XkbSetCompatMap\n");
- return BadLength;
+ compat->num_si = req->firstSI;
+ }
+
+ if (req->groups != 0) {
+ unsigned i, bit;
+ xkbModsWireDesc *wire = (xkbModsWireDesc *) data;
+
+ for (i = 0, bit = 1; i < XkbNumKbdGroups; i++, bit <<= 1) {
+ if (req->groups & bit) {
+ if (client->swapped) {
+ swaps(&wire->virtualMods);
+ }
+ compat->groups[i].mask = wire->realMods;
+ compat->groups[i].real_mods = wire->realMods;
+ compat->groups[i].vmods = wire->virtualMods;
+ if (wire->virtualMods != 0) {
+ unsigned tmp;
+
+ tmp = XkbMaskForVMask(xkb, wire->virtualMods);
+ compat->groups[i].mask |= tmp;
+ }
+ data += SIZEOF(xkbModsWireDesc);
+ wire = (xkbModsWireDesc *) data;
+ }
+ }
+ }
+ i = XkbPaddedSize((data - ((char *) req)));
+ if ((i / 4) != req->length) {
+ ErrorF("[xkb] Internal length error on read in _XkbSetCompatMap\n");
+ return BadLength;
}
if (dev->xkb_interest) {
- xkbCompatMapNotify ev;
- ev.deviceID = dev->id;
- ev.changedGroups = req->groups;
- ev.firstSI = req->firstSI;
- ev.nSI = req->nSI;
- ev.nTotalSI = compat->num_si;
- XkbSendCompatMapNotify(dev,&ev);
+ xkbCompatMapNotify ev;
+
+ ev.deviceID = dev->id;
+ ev.changedGroups = req->groups;
+ ev.firstSI = req->firstSI;
+ ev.nSI = req->nSI;
+ ev.nTotalSI = compat->num_si;
+ XkbSendCompatMapNotify(dev, &ev);
}
if (req->recomputeActions) {
- XkbChangesRec change;
- unsigned check;
- XkbEventCauseRec cause;
-
- XkbSetCauseXkbReq(&cause,X_kbSetCompatMap,client);
- memset(&change, 0, sizeof(XkbChangesRec));
- XkbUpdateActions(dev,xkb->min_key_code,XkbNumKeys(xkb),&change,&check,
- &cause);
- if (check)
- XkbCheckSecondaryEffects(xkbi,check,&change,&cause);
- XkbSendNotification(dev,&change,&cause);
+ XkbChangesRec change;
+ unsigned check;
+ XkbEventCauseRec cause;
+
+ XkbSetCauseXkbReq(&cause, X_kbSetCompatMap, client);
+ memset(&change, 0, sizeof(XkbChangesRec));
+ XkbUpdateActions(dev, xkb->min_key_code, XkbNumKeys(xkb), &change,
+ &check, &cause);
+ if (check)
+ XkbCheckSecondaryEffects(xkbi, check, &change, &cause);
+ XkbSendNotification(dev, &change, &cause);
}
return Success;
}
@@ -2876,34 +2952,33 @@ _XkbSetCompatMap(ClientPtr client, DeviceIntPtr dev,
int
ProcXkbSetCompatMap(ClientPtr client)
{
- DeviceIntPtr dev;
- char *data;
- int rc;
+ DeviceIntPtr dev;
+ char *data;
+ int rc;
REQUEST(xkbSetCompatMapReq);
REQUEST_AT_LEAST_SIZE(xkbSetCompatMapReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixManageAccess);
- data = (char *)&stuff[1];
+ data = (char *) &stuff[1];
/* check first using a dry-run */
rc = _XkbSetCompatMap(client, dev, stuff, data, TRUE);
if (rc != Success)
return rc;
- if (stuff->deviceSpec == XkbUseCoreKbd)
- {
+ if (stuff->deviceSpec == XkbUseCoreKbd) {
DeviceIntPtr other;
- for (other = inputInfo.devices; other; other = other->next)
- {
- if ((other != dev) && other->key && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev)
- {
- rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixManageAccess);
- if (rc == Success)
- {
+
+ for (other = inputInfo.devices; other; other = other->next) {
+ if ((other != dev) && other->key && !IsMaster(other) &&
+ GetMaster(other, MASTER_KEYBOARD) == dev) {
+ rc = XaceHook(XACE_DEVICE_ACCESS, client, other,
+ DixManageAccess);
+ if (rc == Success) {
/* dry-run */
rc = _XkbSetCompatMap(client, other, stuff, data, TRUE);
if (rc != Success)
@@ -2917,16 +2992,15 @@ ProcXkbSetCompatMap(ClientPtr client)
rc = _XkbSetCompatMap(client, dev, stuff, data, FALSE);
if (rc != Success)
return rc;
- if (stuff->deviceSpec == XkbUseCoreKbd)
- {
+ if (stuff->deviceSpec == XkbUseCoreKbd) {
DeviceIntPtr other;
- for (other = inputInfo.devices; other; other = other->next)
- {
- if ((other != dev) && other->key && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev)
- {
- rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixManageAccess);
- if (rc == Success)
- {
+
+ for (other = inputInfo.devices; other; other = other->next) {
+ if ((other != dev) && other->key && !IsMaster(other) &&
+ GetMaster(other, MASTER_KEYBOARD) == dev) {
+ rc = XaceHook(XACE_DEVICE_ACCESS, client, other,
+ DixManageAccess);
+ if (rc == Success) {
rc = _XkbSetCompatMap(client, other, stuff, data, FALSE);
if (rc != Success)
return rc;
@@ -2943,22 +3017,22 @@ ProcXkbSetCompatMap(ClientPtr client)
int
ProcXkbGetIndicatorState(ClientPtr client)
{
- xkbGetIndicatorStateReply rep;
- XkbSrvLedInfoPtr sli;
- DeviceIntPtr dev;
+ xkbGetIndicatorStateReply rep;
+ XkbSrvLedInfoPtr sli;
+ DeviceIntPtr dev;
REQUEST(xkbGetIndicatorStateReq);
REQUEST_SIZE_MATCH(xkbGetIndicatorStateReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixReadAccess);
- sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,
- XkbXI_IndicatorStateMask);
+ sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId,
+ XkbXI_IndicatorStateMask);
if (!sli)
- return BadAlloc;
+ return BadAlloc;
rep.type = X_Reply;
rep.sequenceNumber = client->sequence;
@@ -2967,85 +3041,87 @@ ProcXkbGetIndicatorState(ClientPtr client)
rep.state = sli->effectiveState;
if (client->swapped) {
- swaps(&rep.sequenceNumber);
- swapl(&rep.state);
+ swaps(&rep.sequenceNumber);
+ swapl(&rep.state);
}
- WriteToClient(client, SIZEOF(xkbGetIndicatorStateReply), (char *)&rep);
+ WriteToClient(client, SIZEOF(xkbGetIndicatorStateReply), (char *) &rep);
return Success;
}
/***====================================================================***/
static Status
-XkbComputeGetIndicatorMapReplySize(
- XkbIndicatorPtr indicators,
- xkbGetIndicatorMapReply *rep)
+XkbComputeGetIndicatorMapReplySize(XkbIndicatorPtr indicators,
+ xkbGetIndicatorMapReply * rep)
{
-register int i,bit;
-int nIndicators;
+ register int i, bit;
+ int nIndicators;
rep->realIndicators = indicators->phys_indicators;
- for (i=nIndicators=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
- if (rep->which&bit)
- nIndicators++;
+ for (i = nIndicators = 0, bit = 1; i < XkbNumIndicators; i++, bit <<= 1) {
+ if (rep->which & bit)
+ nIndicators++;
}
- rep->length = (nIndicators*SIZEOF(xkbIndicatorMapWireDesc))/4;
+ rep->length = (nIndicators * SIZEOF(xkbIndicatorMapWireDesc)) / 4;
return Success;
}
static int
-XkbSendIndicatorMap( ClientPtr client,
- XkbIndicatorPtr indicators,
- xkbGetIndicatorMapReply * rep)
+XkbSendIndicatorMap(ClientPtr client,
+ XkbIndicatorPtr indicators, xkbGetIndicatorMapReply * rep)
{
-int length;
-CARD8 * map;
-register int i;
-register unsigned bit;
-
- length = rep->length*4;
- if (length>0) {
- CARD8 *to;
- to= map= malloc(length);
- if (map) {
- xkbIndicatorMapWireDesc *wire = (xkbIndicatorMapWireDesc *)to;
- for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
- if (rep->which&bit) {
- wire->flags= indicators->maps[i].flags;
- wire->whichGroups= indicators->maps[i].which_groups;
- wire->groups= indicators->maps[i].groups;
- wire->whichMods= indicators->maps[i].which_mods;
- wire->mods= indicators->maps[i].mods.mask;
- wire->realMods= indicators->maps[i].mods.real_mods;
- wire->virtualMods= indicators->maps[i].mods.vmods;
- wire->ctrls= indicators->maps[i].ctrls;
- if (client->swapped) {
- swaps(&wire->virtualMods);
- swapl(&wire->ctrls);
- }
- wire++;
- }
- }
- to = (CARD8 *)wire;
- if ((to-map)!=length) {
- client->errorValue = _XkbErrCode2(0xff,length);
- free(map);
- return BadLength;
- }
- }
- else return BadAlloc;
- }
- else map = NULL;
+ int length;
+ CARD8 *map;
+ register int i;
+ register unsigned bit;
+
+ length = rep->length * 4;
+ if (length > 0) {
+ CARD8 *to;
+
+ to = map = malloc(length);
+ if (map) {
+ xkbIndicatorMapWireDesc *wire = (xkbIndicatorMapWireDesc *) to;
+
+ for (i = 0, bit = 1; i < XkbNumIndicators; i++, bit <<= 1) {
+ if (rep->which & bit) {
+ wire->flags = indicators->maps[i].flags;
+ wire->whichGroups = indicators->maps[i].which_groups;
+ wire->groups = indicators->maps[i].groups;
+ wire->whichMods = indicators->maps[i].which_mods;
+ wire->mods = indicators->maps[i].mods.mask;
+ wire->realMods = indicators->maps[i].mods.real_mods;
+ wire->virtualMods = indicators->maps[i].mods.vmods;
+ wire->ctrls = indicators->maps[i].ctrls;
+ if (client->swapped) {
+ swaps(&wire->virtualMods);
+ swapl(&wire->ctrls);
+ }
+ wire++;
+ }
+ }
+ to = (CARD8 *) wire;
+ if ((to - map) != length) {
+ client->errorValue = _XkbErrCode2(0xff, length);
+ free(map);
+ return BadLength;
+ }
+ }
+ else
+ return BadAlloc;
+ }
+ else
+ map = NULL;
if (client->swapped) {
- swaps(&rep->sequenceNumber);
- swapl(&rep->length);
- swapl(&rep->which);
- swapl(&rep->realIndicators);
+ swaps(&rep->sequenceNumber);
+ swapl(&rep->length);
+ swapl(&rep->which);
+ swapl(&rep->realIndicators);
}
- WriteToClient(client, SIZEOF(xkbGetIndicatorMapReply), (char *)rep);
+ WriteToClient(client, SIZEOF(xkbGetIndicatorMapReply), (char *) rep);
if (map) {
- WriteToClient(client, length, (char *)map);
- free((char *)map);
+ WriteToClient(client, length, (char *) map);
+ free((char *) map);
}
return Success;
}
@@ -3053,29 +3129,29 @@ register unsigned bit;
int
ProcXkbGetIndicatorMap(ClientPtr client)
{
-xkbGetIndicatorMapReply rep;
-DeviceIntPtr dev;
-XkbDescPtr xkb;
-XkbIndicatorPtr leds;
+ xkbGetIndicatorMapReply rep;
+ DeviceIntPtr dev;
+ XkbDescPtr xkb;
+ XkbIndicatorPtr leds;
REQUEST(xkbGetIndicatorMapReq);
REQUEST_SIZE_MATCH(xkbGetIndicatorMapReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess);
- xkb= dev->key->xkbInfo->desc;
- leds= xkb->indicators;
+ xkb = dev->key->xkbInfo->desc;
+ leds = xkb->indicators;
rep.type = X_Reply;
rep.sequenceNumber = client->sequence;
rep.length = 0;
rep.deviceID = dev->id;
rep.which = stuff->which;
- XkbComputeGetIndicatorMapReplySize(leds,&rep);
- return XkbSendIndicatorMap(client,leds,&rep);
+ XkbComputeGetIndicatorMapReplySize(leds, &rep);
+ return XkbSendIndicatorMap(client, leds, &rep);
}
/**
@@ -3084,41 +3160,42 @@ XkbIndicatorPtr leds;
*/
static int
_XkbSetIndicatorMap(ClientPtr client, DeviceIntPtr dev,
- int which, xkbIndicatorMapWireDesc *desc)
+ int which, xkbIndicatorMapWireDesc * desc)
{
- XkbSrvInfoPtr xkbi;
- XkbSrvLedInfoPtr sli;
- XkbEventCauseRec cause;
- int i, bit;
+ XkbSrvInfoPtr xkbi;
+ XkbSrvLedInfoPtr sli;
+ XkbEventCauseRec cause;
+ int i, bit;
xkbi = dev->key->xkbInfo;
- sli= XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId,
- XkbXI_IndicatorMapsMask);
+ sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId,
+ XkbXI_IndicatorMapsMask);
if (!sli)
- return BadAlloc;
+ return BadAlloc;
for (i = 0, bit = 1; i < XkbNumIndicators; i++, bit <<= 1) {
- if (which & bit) {
- sli->maps[i].flags = desc->flags;
- sli->maps[i].which_groups = desc->whichGroups;
- sli->maps[i].groups = desc->groups;
- sli->maps[i].which_mods = desc->whichMods;
- sli->maps[i].mods.mask = desc->mods;
- sli->maps[i].mods.real_mods = desc->mods;
- sli->maps[i].mods.vmods= desc->virtualMods;
- sli->maps[i].ctrls = desc->ctrls;
- if (desc->virtualMods!=0) {
- unsigned tmp;
- tmp= XkbMaskForVMask(xkbi->desc,desc->virtualMods);
- sli->maps[i].mods.mask= desc->mods|tmp;
- }
- desc++;
- }
- }
-
- XkbSetCauseXkbReq(&cause,X_kbSetIndicatorMap,client);
- XkbApplyLedMapChanges(dev,sli,which,NULL,NULL,&cause);
+ if (which & bit) {
+ sli->maps[i].flags = desc->flags;
+ sli->maps[i].which_groups = desc->whichGroups;
+ sli->maps[i].groups = desc->groups;
+ sli->maps[i].which_mods = desc->whichMods;
+ sli->maps[i].mods.mask = desc->mods;
+ sli->maps[i].mods.real_mods = desc->mods;
+ sli->maps[i].mods.vmods = desc->virtualMods;
+ sli->maps[i].ctrls = desc->ctrls;
+ if (desc->virtualMods != 0) {
+ unsigned tmp;
+
+ tmp = XkbMaskForVMask(xkbi->desc, desc->virtualMods);
+ sli->maps[i].mods.mask = desc->mods | tmp;
+ }
+ desc++;
+ }
+ }
+
+ XkbSetCauseXkbReq(&cause, X_kbSetIndicatorMap, client);
+ XkbApplyLedMapChanges(dev, sli, which, NULL, NULL, &cause);
return Success;
}
@@ -3126,58 +3203,59 @@ _XkbSetIndicatorMap(ClientPtr client, DeviceIntPtr dev,
int
ProcXkbSetIndicatorMap(ClientPtr client)
{
- int i, bit;
- int nIndicators;
- DeviceIntPtr dev;
- xkbIndicatorMapWireDesc *from;
- int rc;
+ int i, bit;
+ int nIndicators;
+ DeviceIntPtr dev;
+ xkbIndicatorMapWireDesc *from;
+ int rc;
REQUEST(xkbSetIndicatorMapReq);
REQUEST_AT_LEAST_SIZE(xkbSetIndicatorMapReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixSetAttrAccess);
- if (stuff->which==0)
- return Success;
+ if (stuff->which == 0)
+ return Success;
- for (nIndicators=i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
- if (stuff->which&bit)
- nIndicators++;
+ for (nIndicators = i = 0, bit = 1; i < XkbNumIndicators; i++, bit <<= 1) {
+ if (stuff->which & bit)
+ nIndicators++;
}
- if (stuff->length!=((SIZEOF(xkbSetIndicatorMapReq)+
- (nIndicators*SIZEOF(xkbIndicatorMapWireDesc)))/4)) {
- return BadLength;
+ if (stuff->length != ((SIZEOF(xkbSetIndicatorMapReq) +
+ (nIndicators * SIZEOF(xkbIndicatorMapWireDesc))) /
+ 4)) {
+ return BadLength;
}
- from = (xkbIndicatorMapWireDesc *)&stuff[1];
- for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
- if (stuff->which&bit) {
- if (client->swapped) {
- swaps(&from->virtualMods);
- swapl(&from->ctrls);
- }
- CHK_MASK_LEGAL(i,from->whichGroups,XkbIM_UseAnyGroup);
- CHK_MASK_LEGAL(i,from->whichMods,XkbIM_UseAnyMods);
- from++;
- }
+ from = (xkbIndicatorMapWireDesc *) & stuff[1];
+ for (i = 0, bit = 1; i < XkbNumIndicators; i++, bit <<= 1) {
+ if (stuff->which & bit) {
+ if (client->swapped) {
+ swaps(&from->virtualMods);
+ swapl(&from->ctrls);
+ }
+ CHK_MASK_LEGAL(i, from->whichGroups, XkbIM_UseAnyGroup);
+ CHK_MASK_LEGAL(i, from->whichMods, XkbIM_UseAnyMods);
+ from++;
+ }
}
- from = (xkbIndicatorMapWireDesc *)&stuff[1];
+ from = (xkbIndicatorMapWireDesc *) & stuff[1];
rc = _XkbSetIndicatorMap(client, dev, stuff->which, from);
if (rc != Success)
return rc;
- if (stuff->deviceSpec == XkbUseCoreKbd)
- {
+ if (stuff->deviceSpec == XkbUseCoreKbd) {
DeviceIntPtr other;
- for (other = inputInfo.devices; other; other = other->next)
- {
- if ((other != dev) && other->key && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev)
- {
- rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixSetAttrAccess);
+
+ for (other = inputInfo.devices; other; other = other->next) {
+ if ((other != dev) && other->key && !IsMaster(other) &&
+ GetMaster(other, MASTER_KEYBOARD) == dev) {
+ rc = XaceHook(XACE_DEVICE_ACCESS, client, other,
+ DixSetAttrAccess);
if (rc == Success)
_XkbSetIndicatorMap(client, other, stuff->which, from);
}
@@ -3192,84 +3270,83 @@ ProcXkbSetIndicatorMap(ClientPtr client)
int
ProcXkbGetNamedIndicator(ClientPtr client)
{
- DeviceIntPtr dev;
- xkbGetNamedIndicatorReply rep;
- register int i = 0;
- XkbSrvLedInfoPtr sli;
- XkbIndicatorMapPtr map = NULL;
+ DeviceIntPtr dev;
+ xkbGetNamedIndicatorReply rep;
+ register int i = 0;
+ XkbSrvLedInfoPtr sli;
+ XkbIndicatorMapPtr map = NULL;
REQUEST(xkbGetNamedIndicatorReq);
REQUEST_SIZE_MATCH(xkbGetNamedIndicatorReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_LED_DEVICE(dev, stuff->deviceSpec, client, DixReadAccess);
CHK_ATOM_ONLY(stuff->indicator);
- sli= XkbFindSrvLedInfo(dev,stuff->ledClass,stuff->ledID,0);
+ sli = XkbFindSrvLedInfo(dev, stuff->ledClass, stuff->ledID, 0);
if (!sli)
- return BadAlloc;
-
- i= 0;
- map= NULL;
- if ((sli->names)&&(sli->maps)) {
- for (i=0;i<XkbNumIndicators;i++) {
- if (stuff->indicator==sli->names[i]) {
- map= &sli->maps[i];
+ return BadAlloc;
+
+ i = 0;
+ map = NULL;
+ if ((sli->names) && (sli->maps)) {
+ for (i = 0; i < XkbNumIndicators; i++) {
+ if (stuff->indicator == sli->names[i]) {
+ map = &sli->maps[i];
break;
}
}
}
- rep.type= X_Reply;
+ rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
rep.deviceID = dev->id;
- rep.indicator= stuff->indicator;
- if (map!=NULL) {
- rep.found= TRUE;
- rep.on= ((sli->effectiveState&(1<<i))!=0);
- rep.realIndicator= ((sli->physIndicators&(1<<i))!=0);
- rep.ndx= i;
- rep.flags= map->flags;
- rep.whichGroups= map->which_groups;
- rep.groups= map->groups;
- rep.whichMods= map->which_mods;
- rep.mods= map->mods.mask;
- rep.realMods= map->mods.real_mods;
- rep.virtualMods= map->mods.vmods;
- rep.ctrls= map->ctrls;
- rep.supported= TRUE;
- }
- else {
- rep.found= FALSE;
- rep.on= FALSE;
- rep.realIndicator= FALSE;
- rep.ndx= XkbNoIndicator;
- rep.flags= 0;
- rep.whichGroups= 0;
- rep.groups= 0;
- rep.whichMods= 0;
- rep.mods= 0;
- rep.realMods= 0;
- rep.virtualMods= 0;
- rep.ctrls= 0;
- rep.supported= TRUE;
- }
- if ( client->swapped ) {
- swapl(&rep.length);
- swaps(&rep.sequenceNumber);
- swapl(&rep.indicator);
- swaps(&rep.virtualMods);
- swapl(&rep.ctrls);
- }
-
- WriteToClient(client,SIZEOF(xkbGetNamedIndicatorReply), (char *)&rep);
+ rep.indicator = stuff->indicator;
+ if (map != NULL) {
+ rep.found = TRUE;
+ rep.on = ((sli->effectiveState & (1 << i)) != 0);
+ rep.realIndicator = ((sli->physIndicators & (1 << i)) != 0);
+ rep.ndx = i;
+ rep.flags = map->flags;
+ rep.whichGroups = map->which_groups;
+ rep.groups = map->groups;
+ rep.whichMods = map->which_mods;
+ rep.mods = map->mods.mask;
+ rep.realMods = map->mods.real_mods;
+ rep.virtualMods = map->mods.vmods;
+ rep.ctrls = map->ctrls;
+ rep.supported = TRUE;
+ }
+ else {
+ rep.found = FALSE;
+ rep.on = FALSE;
+ rep.realIndicator = FALSE;
+ rep.ndx = XkbNoIndicator;
+ rep.flags = 0;
+ rep.whichGroups = 0;
+ rep.groups = 0;
+ rep.whichMods = 0;
+ rep.mods = 0;
+ rep.realMods = 0;
+ rep.virtualMods = 0;
+ rep.ctrls = 0;
+ rep.supported = TRUE;
+ }
+ if (client->swapped) {
+ swapl(&rep.length);
+ swaps(&rep.sequenceNumber);
+ swapl(&rep.indicator);
+ swaps(&rep.virtualMods);
+ swapl(&rep.ctrls);
+ }
+
+ WriteToClient(client, SIZEOF(xkbGetNamedIndicatorReply), (char *) &rep);
return Success;
}
-
/**
* Find the IM on the device.
* Returns the map, or NULL if the map doesn't exist.
@@ -3277,23 +3354,22 @@ ProcXkbGetNamedIndicator(ClientPtr client)
* is set to the led index of the map.
*/
static XkbIndicatorMapPtr
-_XkbFindNamedIndicatorMap(XkbSrvLedInfoPtr sli, Atom indicator,
- int *led_return)
+_XkbFindNamedIndicatorMap(XkbSrvLedInfoPtr sli, Atom indicator, int *led_return)
{
- XkbIndicatorMapPtr map;
+ XkbIndicatorMapPtr map;
/* search for the right indicator */
map = NULL;
if (sli->names && sli->maps) {
- int led;
+ int led;
- for (led = 0; (led < XkbNumIndicators) && (map == NULL); led++) {
- if (sli->names[led] == indicator) {
- map= &sli->maps[led];
- *led_return = led;
- break;
- }
- }
+ for (led = 0; (led < XkbNumIndicators) && (map == NULL); led++) {
+ if (sli->names[led] == indicator) {
+ map = &sli->maps[led];
+ *led_return = led;
+ break;
+ }
+ }
}
return map;
@@ -3306,12 +3382,12 @@ _XkbFindNamedIndicatorMap(XkbSrvLedInfoPtr sli, Atom indicator,
static int
_XkbCreateIndicatorMap(DeviceIntPtr dev, Atom indicator,
int ledClass, int ledID,
- XkbIndicatorMapPtr *map_return, int *led_return,
+ XkbIndicatorMapPtr * map_return, int *led_return,
Bool dryRun)
{
- XkbSrvLedInfoPtr sli;
- XkbIndicatorMapPtr map;
- int led;
+ XkbSrvLedInfoPtr sli;
+ XkbIndicatorMapPtr map;
+ int led;
sli = XkbFindSrvLedInfo(dev, ledClass, ledID, XkbXI_IndicatorsMask);
if (!sli)
@@ -3319,13 +3395,12 @@ _XkbCreateIndicatorMap(DeviceIntPtr dev, Atom indicator,
map = _XkbFindNamedIndicatorMap(sli, indicator, &led);
- if (!map)
- {
+ if (!map) {
/* find first unused indicator maps and assign the name to it */
- for (led = 0, map = NULL; (led < XkbNumIndicators) && (map == NULL); led++) {
+ for (led = 0, map = NULL; (led < XkbNumIndicators) && (map == NULL);
+ led++) {
if ((sli->names) && (sli->maps) && (sli->names[led] == None) &&
- (!XkbIM_InUse(&sli->maps[led])))
- {
+ (!XkbIM_InUse(&sli->maps[led]))) {
map = &sli->maps[led];
if (!dryRun)
sli->names[led] = indicator;
@@ -3344,22 +3419,22 @@ _XkbCreateIndicatorMap(DeviceIntPtr dev, Atom indicator,
static int
_XkbSetNamedIndicator(ClientPtr client, DeviceIntPtr dev,
- xkbSetNamedIndicatorReq *stuff)
+ xkbSetNamedIndicatorReq * stuff)
{
- unsigned int extDevReason;
- unsigned int statec, namec, mapc;
- XkbSrvLedInfoPtr sli;
- int led = 0;
- XkbIndicatorMapPtr map;
- DeviceIntPtr kbd;
- XkbEventCauseRec cause;
- xkbExtensionDeviceNotify ed;
- XkbChangesRec changes;
- int rc;
+ unsigned int extDevReason;
+ unsigned int statec, namec, mapc;
+ XkbSrvLedInfoPtr sli;
+ int led = 0;
+ XkbIndicatorMapPtr map;
+ DeviceIntPtr kbd;
+ XkbEventCauseRec cause;
+ xkbExtensionDeviceNotify ed;
+ XkbChangesRec changes;
+ int rc;
rc = _XkbCreateIndicatorMap(dev, stuff->indicator, stuff->ledClass,
stuff->ledID, &map, &led, FALSE);
- if (rc != Success || !map) /* oh-oh */
+ if (rc != Success || !map) /* oh-oh */
return rc;
sli = XkbFindSrvLedInfo(dev, stuff->ledClass, stuff->ledID,
@@ -3370,7 +3445,7 @@ _XkbSetNamedIndicator(ClientPtr client, DeviceIntPtr dev,
namec = mapc = statec = 0;
extDevReason = 0;
- namec |= (1<<led);
+ namec |= (1 << led);
sli->namesPresent |= ((stuff->indicator != None) ? (1 << led) : 0);
extDevReason |= XkbXI_IndicatorNamesMask;
@@ -3381,30 +3456,31 @@ _XkbSetNamedIndicator(ClientPtr client, DeviceIntPtr dev,
map->which_mods = stuff->whichMods;
map->mods.mask = stuff->realMods;
map->mods.real_mods = stuff->realMods;
- map->mods.vmods= stuff->virtualMods;
+ map->mods.vmods = stuff->virtualMods;
map->ctrls = stuff->ctrls;
- mapc|= (1<<led);
+ mapc |= (1 << led);
}
- if ((stuff->setState) && ((map->flags & XkbIM_NoExplicit) == 0))
- {
- if (stuff->on) sli->explicitState |= (1<<led);
- else sli->explicitState &= ~(1<<led);
+ if ((stuff->setState) && ((map->flags & XkbIM_NoExplicit) == 0)) {
+ if (stuff->on)
+ sli->explicitState |= (1 << led);
+ else
+ sli->explicitState &= ~(1 << led);
statec |= ((sli->effectiveState ^ sli->explicitState) & (1 << led));
}
- memset((char *)&ed, 0, sizeof(xkbExtensionDeviceNotify));
- memset((char *)&changes, 0, sizeof(XkbChangesRec));
- XkbSetCauseXkbReq(&cause,X_kbSetNamedIndicator,client);
+ memset((char *) &ed, 0, sizeof(xkbExtensionDeviceNotify));
+ memset((char *) &changes, 0, sizeof(XkbChangesRec));
+ XkbSetCauseXkbReq(&cause, X_kbSetNamedIndicator, client);
if (namec)
- XkbApplyLedNameChanges(dev,sli,namec,&ed,&changes,&cause);
+ XkbApplyLedNameChanges(dev, sli, namec, &ed, &changes, &cause);
if (mapc)
- XkbApplyLedMapChanges(dev,sli,mapc,&ed,&changes,&cause);
+ XkbApplyLedMapChanges(dev, sli, mapc, &ed, &changes, &cause);
if (statec)
- XkbApplyLedStateChanges(dev,sli,statec,&ed,&changes,&cause);
+ XkbApplyLedStateChanges(dev, sli, statec, &ed, &changes, &cause);
kbd = dev;
- if ((sli->flags&XkbSLI_HasOwnState)==0)
+ if ((sli->flags & XkbSLI_HasOwnState) == 0)
kbd = inputInfo.keyboard;
XkbFlushLedEvents(dev, kbd, sli, &ed, &changes, &cause);
@@ -3414,42 +3490,42 @@ _XkbSetNamedIndicator(ClientPtr client, DeviceIntPtr dev,
int
ProcXkbSetNamedIndicator(ClientPtr client)
{
- int rc;
- DeviceIntPtr dev;
- int led = 0;
- XkbIndicatorMapPtr map;
+ int rc;
+ DeviceIntPtr dev;
+ int led = 0;
+ XkbIndicatorMapPtr map;
REQUEST(xkbSetNamedIndicatorReq);
REQUEST_SIZE_MATCH(xkbSetNamedIndicatorReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_LED_DEVICE(dev, stuff->deviceSpec, client, DixSetAttrAccess);
CHK_ATOM_ONLY(stuff->indicator);
- CHK_MASK_LEGAL(0x10,stuff->whichGroups,XkbIM_UseAnyGroup);
- CHK_MASK_LEGAL(0x11,stuff->whichMods,XkbIM_UseAnyMods);
+ CHK_MASK_LEGAL(0x10, stuff->whichGroups, XkbIM_UseAnyGroup);
+ CHK_MASK_LEGAL(0x11, stuff->whichMods, XkbIM_UseAnyMods);
/* Dry-run for checks */
rc = _XkbCreateIndicatorMap(dev, stuff->indicator,
stuff->ledClass, stuff->ledID,
&map, &led, TRUE);
- if (rc != Success || !map) /* couldn't be created or didn't exist */
+ if (rc != Success || !map) /* couldn't be created or didn't exist */
return rc;
if (stuff->deviceSpec == XkbUseCoreKbd ||
- stuff->deviceSpec == XkbUseCorePtr)
- {
+ stuff->deviceSpec == XkbUseCorePtr) {
DeviceIntPtr other;
- for (other = inputInfo.devices; other; other = other->next)
- {
- if ((other != dev) && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev &&
- (other->kbdfeed || other->leds) &&
- (XaceHook(XACE_DEVICE_ACCESS, client, other, DixSetAttrAccess) == Success))
- {
+
+ for (other = inputInfo.devices; other; other = other->next) {
+ if ((other != dev) && !IsMaster(other) &&
+ GetMaster(other, MASTER_KEYBOARD) == dev && (other->kbdfeed ||
+ other->leds) &&
+ (XaceHook(XACE_DEVICE_ACCESS, client, other, DixSetAttrAccess)
+ == Success)) {
rc = _XkbCreateIndicatorMap(other, stuff->indicator,
- stuff->ledClass, stuff->ledID,
- &map, &led, TRUE);
+ stuff->ledClass, stuff->ledID, &map,
+ &led, TRUE);
if (rc != Success || !map)
return rc;
}
@@ -3462,15 +3538,15 @@ ProcXkbSetNamedIndicator(ClientPtr client)
return rc;
if (stuff->deviceSpec == XkbUseCoreKbd ||
- stuff->deviceSpec == XkbUseCorePtr)
- {
+ stuff->deviceSpec == XkbUseCorePtr) {
DeviceIntPtr other;
- for (other = inputInfo.devices; other; other = other->next)
- {
- if ((other != dev) && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev &&
- (other->kbdfeed || other->leds) &&
- (XaceHook(XACE_DEVICE_ACCESS, client, other, DixSetAttrAccess) == Success))
- {
+
+ for (other = inputInfo.devices; other; other = other->next) {
+ if ((other != dev) && !IsMaster(other) &&
+ GetMaster(other, MASTER_KEYBOARD) == dev && (other->kbdfeed ||
+ other->leds) &&
+ (XaceHook(XACE_DEVICE_ACCESS, client, other, DixSetAttrAccess)
+ == Success)) {
_XkbSetNamedIndicator(client, other, stuff);
}
}
@@ -3482,393 +3558,410 @@ ProcXkbSetNamedIndicator(ClientPtr client)
/***====================================================================***/
static CARD32
-_XkbCountAtoms(Atom *atoms,int maxAtoms,int *count)
+_XkbCountAtoms(Atom *atoms, int maxAtoms, int *count)
{
-register unsigned int i,bit,nAtoms;
-register CARD32 atomsPresent;
+ register unsigned int i, bit, nAtoms;
+ register CARD32 atomsPresent;
- for (i=nAtoms=atomsPresent=0,bit=1;i<maxAtoms;i++,bit<<=1) {
- if (atoms[i]!=None) {
- atomsPresent|= bit;
- nAtoms++;
- }
+ for (i = nAtoms = atomsPresent = 0, bit = 1; i < maxAtoms; i++, bit <<= 1) {
+ if (atoms[i] != None) {
+ atomsPresent |= bit;
+ nAtoms++;
+ }
}
if (count)
- *count= nAtoms;
+ *count = nAtoms;
return atomsPresent;
}
static char *
-_XkbWriteAtoms(char *wire,Atom *atoms,int maxAtoms,int swap)
+_XkbWriteAtoms(char *wire, Atom *atoms, int maxAtoms, int swap)
{
-register unsigned int i;
-Atom *atm;
-
- atm = (Atom *)wire;
- for (i=0;i<maxAtoms;i++) {
- if (atoms[i]!=None) {
- *atm= atoms[i];
- if (swap) {
- swapl(atm);
- }
- atm++;
- }
- }
- return (char *)atm;
+ register unsigned int i;
+ Atom *atm;
+
+ atm = (Atom *) wire;
+ for (i = 0; i < maxAtoms; i++) {
+ if (atoms[i] != None) {
+ *atm = atoms[i];
+ if (swap) {
+ swapl(atm);
+ }
+ atm++;
+ }
+ }
+ return (char *) atm;
}
static Status
-XkbComputeGetNamesReplySize(XkbDescPtr xkb,xkbGetNamesReply *rep)
+XkbComputeGetNamesReplySize(XkbDescPtr xkb, xkbGetNamesReply * rep)
{
-register unsigned which,length;
-register int i;
-
- rep->minKeyCode= xkb->min_key_code;
- rep->maxKeyCode= xkb->max_key_code;
- which= rep->which;
- length= 0;
- if (xkb->names!=NULL) {
- if (which&XkbKeycodesNameMask) length++;
- if (which&XkbGeometryNameMask) length++;
- if (which&XkbSymbolsNameMask) length++;
- if (which&XkbPhysSymbolsNameMask) length++;
- if (which&XkbTypesNameMask) length++;
- if (which&XkbCompatNameMask) length++;
- }
- else which&= ~XkbComponentNamesMask;
-
- if (xkb->map!=NULL) {
- if (which&XkbKeyTypeNamesMask)
- length+= xkb->map->num_types;
- rep->nTypes= xkb->map->num_types;
- if (which&XkbKTLevelNamesMask) {
- XkbKeyTypePtr pType = xkb->map->types;
- int nKTLevels = 0;
-
- length+= XkbPaddedSize(xkb->map->num_types)/4;
- for (i=0;i<xkb->map->num_types;i++,pType++) {
- if (pType->level_names!=NULL)
- nKTLevels+= pType->num_levels;
- }
- rep->nKTLevels= nKTLevels;
- length+= nKTLevels;
- }
+ register unsigned which, length;
+ register int i;
+
+ rep->minKeyCode = xkb->min_key_code;
+ rep->maxKeyCode = xkb->max_key_code;
+ which = rep->which;
+ length = 0;
+ if (xkb->names != NULL) {
+ if (which & XkbKeycodesNameMask)
+ length++;
+ if (which & XkbGeometryNameMask)
+ length++;
+ if (which & XkbSymbolsNameMask)
+ length++;
+ if (which & XkbPhysSymbolsNameMask)
+ length++;
+ if (which & XkbTypesNameMask)
+ length++;
+ if (which & XkbCompatNameMask)
+ length++;
+ }
+ else
+ which &= ~XkbComponentNamesMask;
+
+ if (xkb->map != NULL) {
+ if (which & XkbKeyTypeNamesMask)
+ length += xkb->map->num_types;
+ rep->nTypes = xkb->map->num_types;
+ if (which & XkbKTLevelNamesMask) {
+ XkbKeyTypePtr pType = xkb->map->types;
+ int nKTLevels = 0;
+
+ length += XkbPaddedSize(xkb->map->num_types) / 4;
+ for (i = 0; i < xkb->map->num_types; i++, pType++) {
+ if (pType->level_names != NULL)
+ nKTLevels += pType->num_levels;
+ }
+ rep->nKTLevels = nKTLevels;
+ length += nKTLevels;
+ }
}
else {
- rep->nTypes= 0;
- rep->nKTLevels= 0;
- which&= ~(XkbKeyTypeNamesMask|XkbKTLevelNamesMask);
- }
-
- rep->minKeyCode= xkb->min_key_code;
- rep->maxKeyCode= xkb->max_key_code;
- rep->indicators= 0;
- rep->virtualMods= 0;
- rep->groupNames= 0;
- if (xkb->names!=NULL) {
- if (which&XkbIndicatorNamesMask) {
- int nLeds;
- rep->indicators=
- _XkbCountAtoms(xkb->names->indicators,XkbNumIndicators,&nLeds);
- length+= nLeds;
- if (nLeds==0)
- which&= ~XkbIndicatorNamesMask;
- }
-
- if (which&XkbVirtualModNamesMask) {
- int nVMods;
- rep->virtualMods=
- _XkbCountAtoms(xkb->names->vmods,XkbNumVirtualMods,&nVMods);
- length+= nVMods;
- if (nVMods==0)
- which&= ~XkbVirtualModNamesMask;
- }
-
- if (which&XkbGroupNamesMask) {
- int nGroups;
- rep->groupNames=
- _XkbCountAtoms(xkb->names->groups,XkbNumKbdGroups,&nGroups);
- length+= nGroups;
- if (nGroups==0)
- which&= ~XkbGroupNamesMask;
- }
-
- if ((which&XkbKeyNamesMask)&&(xkb->names->keys))
- length+= rep->nKeys;
- else which&= ~XkbKeyNamesMask;
-
- if ((which&XkbKeyAliasesMask)&&
- (xkb->names->key_aliases)&&(xkb->names->num_key_aliases>0)) {
- rep->nKeyAliases= xkb->names->num_key_aliases;
- length+= rep->nKeyAliases*2;
- }
- else {
- which&= ~XkbKeyAliasesMask;
- rep->nKeyAliases= 0;
- }
-
- if ((which&XkbRGNamesMask)&&(xkb->names->num_rg>0))
- length+= xkb->names->num_rg;
- else which&= ~XkbRGNamesMask;
+ rep->nTypes = 0;
+ rep->nKTLevels = 0;
+ which &= ~(XkbKeyTypeNamesMask | XkbKTLevelNamesMask);
+ }
+
+ rep->minKeyCode = xkb->min_key_code;
+ rep->maxKeyCode = xkb->max_key_code;
+ rep->indicators = 0;
+ rep->virtualMods = 0;
+ rep->groupNames = 0;
+ if (xkb->names != NULL) {
+ if (which & XkbIndicatorNamesMask) {
+ int nLeds;
+
+ rep->indicators =
+ _XkbCountAtoms(xkb->names->indicators, XkbNumIndicators,
+ &nLeds);
+ length += nLeds;
+ if (nLeds == 0)
+ which &= ~XkbIndicatorNamesMask;
+ }
+
+ if (which & XkbVirtualModNamesMask) {
+ int nVMods;
+
+ rep->virtualMods =
+ _XkbCountAtoms(xkb->names->vmods, XkbNumVirtualMods, &nVMods);
+ length += nVMods;
+ if (nVMods == 0)
+ which &= ~XkbVirtualModNamesMask;
+ }
+
+ if (which & XkbGroupNamesMask) {
+ int nGroups;
+
+ rep->groupNames =
+ _XkbCountAtoms(xkb->names->groups, XkbNumKbdGroups, &nGroups);
+ length += nGroups;
+ if (nGroups == 0)
+ which &= ~XkbGroupNamesMask;
+ }
+
+ if ((which & XkbKeyNamesMask) && (xkb->names->keys))
+ length += rep->nKeys;
+ else
+ which &= ~XkbKeyNamesMask;
+
+ if ((which & XkbKeyAliasesMask) &&
+ (xkb->names->key_aliases) && (xkb->names->num_key_aliases > 0)) {
+ rep->nKeyAliases = xkb->names->num_key_aliases;
+ length += rep->nKeyAliases * 2;
+ }
+ else {
+ which &= ~XkbKeyAliasesMask;
+ rep->nKeyAliases = 0;
+ }
+
+ if ((which & XkbRGNamesMask) && (xkb->names->num_rg > 0))
+ length += xkb->names->num_rg;
+ else
+ which &= ~XkbRGNamesMask;
}
else {
- which&= ~(XkbIndicatorNamesMask|XkbVirtualModNamesMask);
- which&= ~(XkbGroupNamesMask|XkbKeyNamesMask|XkbKeyAliasesMask);
- which&= ~XkbRGNamesMask;
+ which &= ~(XkbIndicatorNamesMask | XkbVirtualModNamesMask);
+ which &= ~(XkbGroupNamesMask | XkbKeyNamesMask | XkbKeyAliasesMask);
+ which &= ~XkbRGNamesMask;
}
- rep->length= length;
- rep->which= which;
+ rep->length = length;
+ rep->which = which;
return Success;
}
static int
-XkbSendNames(ClientPtr client,XkbDescPtr xkb,xkbGetNamesReply *rep)
+XkbSendNames(ClientPtr client, XkbDescPtr xkb, xkbGetNamesReply * rep)
{
-register unsigned i,length,which;
-char * start;
-char * desc;
+ register unsigned i, length, which;
+ char *start;
+ char *desc;
- length= rep->length*4;
- which= rep->which;
+ length = rep->length * 4;
+ which = rep->which;
if (client->swapped) {
- swaps(&rep->sequenceNumber);
- swapl(&rep->length);
- swapl(&rep->which);
- swaps(&rep->virtualMods);
- swapl(&rep->indicators);
+ swaps(&rep->sequenceNumber);
+ swapl(&rep->length);
+ swapl(&rep->which);
+ swaps(&rep->virtualMods);
+ swapl(&rep->indicators);
}
start = desc = calloc(1, length);
- if ( !start )
- return BadAlloc;
+ if (!start)
+ return BadAlloc;
if (xkb->names) {
- if (which&XkbKeycodesNameMask) {
- *((CARD32 *)desc)= xkb->names->keycodes;
+ if (which & XkbKeycodesNameMask) {
+ *((CARD32 *) desc) = xkb->names->keycodes;
if (client->swapped) {
- swapl((int *)desc);
+ swapl((int *) desc);
}
- desc+= 4;
+ desc += 4;
}
- if (which&XkbGeometryNameMask) {
- *((CARD32 *)desc)= xkb->names->geometry;
+ if (which & XkbGeometryNameMask) {
+ *((CARD32 *) desc) = xkb->names->geometry;
if (client->swapped) {
- swapl((int *)desc);
+ swapl((int *) desc);
}
- desc+= 4;
+ desc += 4;
}
- if (which&XkbSymbolsNameMask) {
- *((CARD32 *)desc)= xkb->names->symbols;
+ if (which & XkbSymbolsNameMask) {
+ *((CARD32 *) desc) = xkb->names->symbols;
if (client->swapped) {
- swapl((int *)desc);
+ swapl((int *) desc);
}
- desc+= 4;
+ desc += 4;
}
- if (which&XkbPhysSymbolsNameMask) {
- register CARD32 *atm= (CARD32 *)desc;
- atm[0]= (CARD32)xkb->names->phys_symbols;
+ if (which & XkbPhysSymbolsNameMask) {
+ register CARD32 *atm = (CARD32 *) desc;
+
+ atm[0] = (CARD32) xkb->names->phys_symbols;
if (client->swapped) {
swapl(&atm[0]);
}
- desc+= 4;
+ desc += 4;
}
- if (which&XkbTypesNameMask) {
- *((CARD32 *)desc)= (CARD32)xkb->names->types;
+ if (which & XkbTypesNameMask) {
+ *((CARD32 *) desc) = (CARD32) xkb->names->types;
if (client->swapped) {
- swapl((int *)desc);
+ swapl((int *) desc);
}
- desc+= 4;
+ desc += 4;
}
- if (which&XkbCompatNameMask) {
- *((CARD32 *)desc)= (CARD32)xkb->names->compat;
+ if (which & XkbCompatNameMask) {
+ *((CARD32 *) desc) = (CARD32) xkb->names->compat;
if (client->swapped) {
- swapl((int *)desc);
+ swapl((int *) desc);
}
- desc+= 4;
+ desc += 4;
}
- if (which&XkbKeyTypeNamesMask) {
- register CARD32 *atm= (CARD32 *)desc;
- register XkbKeyTypePtr type= xkb->map->types;
+ if (which & XkbKeyTypeNamesMask) {
+ register CARD32 *atm = (CARD32 *) desc;
+ register XkbKeyTypePtr type = xkb->map->types;
- for (i=0;i<xkb->map->num_types;i++,atm++,type++) {
- *atm= (CARD32)type->name;
+ for (i = 0; i < xkb->map->num_types; i++, atm++, type++) {
+ *atm = (CARD32) type->name;
if (client->swapped) {
swapl(atm);
}
}
- desc= (char *)atm;
+ desc = (char *) atm;
}
- if (which&XkbKTLevelNamesMask && xkb->map) {
+ if (which & XkbKTLevelNamesMask && xkb->map) {
XkbKeyTypePtr type = xkb->map->types;
register CARD32 *atm;
- for (i=0;i<rep->nTypes;i++,type++) {
+
+ for (i = 0; i < rep->nTypes; i++, type++) {
*desc++ = type->num_levels;
}
- desc+= XkbPaddedSize(rep->nTypes)-rep->nTypes;
+ desc += XkbPaddedSize(rep->nTypes) - rep->nTypes;
- atm= (CARD32 *)desc;
+ atm = (CARD32 *) desc;
type = xkb->map->types;
- for (i=0;i<xkb->map->num_types;i++,type++) {
+ for (i = 0; i < xkb->map->num_types; i++, type++) {
register unsigned l;
+
if (type->level_names) {
- for (l=0;l<type->num_levels;l++,atm++) {
- *atm= type->level_names[l];
+ for (l = 0; l < type->num_levels; l++, atm++) {
+ *atm = type->level_names[l];
if (client->swapped) {
swapl(atm);
}
}
- desc+= type->num_levels*4;
+ desc += type->num_levels * 4;
}
}
}
- if (which&XkbIndicatorNamesMask) {
- desc= _XkbWriteAtoms(desc,xkb->names->indicators,XkbNumIndicators,
- client->swapped);
+ if (which & XkbIndicatorNamesMask) {
+ desc =
+ _XkbWriteAtoms(desc, xkb->names->indicators, XkbNumIndicators,
+ client->swapped);
}
- if (which&XkbVirtualModNamesMask) {
- desc= _XkbWriteAtoms(desc,xkb->names->vmods,XkbNumVirtualMods,
- client->swapped);
+ if (which & XkbVirtualModNamesMask) {
+ desc = _XkbWriteAtoms(desc, xkb->names->vmods, XkbNumVirtualMods,
+ client->swapped);
}
- if (which&XkbGroupNamesMask) {
- desc= _XkbWriteAtoms(desc,xkb->names->groups,XkbNumKbdGroups,
- client->swapped);
+ if (which & XkbGroupNamesMask) {
+ desc = _XkbWriteAtoms(desc, xkb->names->groups, XkbNumKbdGroups,
+ client->swapped);
}
- if (which&XkbKeyNamesMask) {
- for (i=0;i<rep->nKeys;i++,desc+= sizeof(XkbKeyNameRec)) {
- *((XkbKeyNamePtr)desc)= xkb->names->keys[i+rep->firstKey];
+ if (which & XkbKeyNamesMask) {
+ for (i = 0; i < rep->nKeys; i++, desc += sizeof(XkbKeyNameRec)) {
+ *((XkbKeyNamePtr) desc) = xkb->names->keys[i + rep->firstKey];
}
}
- if (which&XkbKeyAliasesMask) {
- XkbKeyAliasPtr pAl;
- pAl= xkb->names->key_aliases;
- for (i=0;i<rep->nKeyAliases;i++,pAl++,desc+=2*XkbKeyNameLength) {
- *((XkbKeyAliasPtr)desc)= *pAl;
+ if (which & XkbKeyAliasesMask) {
+ XkbKeyAliasPtr pAl;
+
+ pAl = xkb->names->key_aliases;
+ for (i = 0; i < rep->nKeyAliases;
+ i++, pAl++, desc += 2 * XkbKeyNameLength) {
+ *((XkbKeyAliasPtr) desc) = *pAl;
}
}
- if ((which&XkbRGNamesMask)&&(rep->nRadioGroups>0)) {
- register CARD32 *atm= (CARD32 *)desc;
- for (i=0;i<rep->nRadioGroups;i++,atm++) {
- *atm= (CARD32)xkb->names->radio_groups[i];
+ if ((which & XkbRGNamesMask) && (rep->nRadioGroups > 0)) {
+ register CARD32 *atm = (CARD32 *) desc;
+
+ for (i = 0; i < rep->nRadioGroups; i++, atm++) {
+ *atm = (CARD32) xkb->names->radio_groups[i];
if (client->swapped) {
swapl(atm);
}
}
- desc+= rep->nRadioGroups*4;
+ desc += rep->nRadioGroups * 4;
}
}
- if ((desc-start)!=(length)) {
- ErrorF("[xkb] BOGUS LENGTH in write names, expected %d, got %ld\n",
- length, (unsigned long)(desc-start));
+ if ((desc - start) != (length)) {
+ ErrorF("[xkb] BOGUS LENGTH in write names, expected %d, got %ld\n",
+ length, (unsigned long) (desc - start));
}
- WriteToClient(client, SIZEOF(xkbGetNamesReply), (char *)rep);
+ WriteToClient(client, SIZEOF(xkbGetNamesReply), (char *) rep);
WriteToClient(client, length, start);
- free((char *)start);
+ free((char *) start);
return Success;
}
int
ProcXkbGetNames(ClientPtr client)
{
- DeviceIntPtr dev;
- XkbDescPtr xkb;
- xkbGetNamesReply rep;
+ DeviceIntPtr dev;
+ XkbDescPtr xkb;
+ xkbGetNamesReply rep;
REQUEST(xkbGetNamesReq);
REQUEST_SIZE_MATCH(xkbGetNamesReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess);
- CHK_MASK_LEGAL(0x01,stuff->which,XkbAllNamesMask);
+ CHK_MASK_LEGAL(0x01, stuff->which, XkbAllNamesMask);
xkb = dev->key->xkbInfo->desc;
memset(&rep, 0, sizeof(xkbGetNamesReply));
- rep.type= X_Reply;
- rep.sequenceNumber= client->sequence;
+ rep.type = X_Reply;
+ rep.sequenceNumber = client->sequence;
rep.length = 0;
rep.deviceID = dev->id;
rep.which = stuff->which;
rep.nTypes = xkb->map->num_types;
rep.firstKey = xkb->min_key_code;
rep.nKeys = XkbNumKeys(xkb);
- if (xkb->names!=NULL) {
- rep.nKeyAliases= xkb->names->num_key_aliases;
- rep.nRadioGroups = xkb->names->num_rg;
+ if (xkb->names != NULL) {
+ rep.nKeyAliases = xkb->names->num_key_aliases;
+ rep.nRadioGroups = xkb->names->num_rg;
}
else {
- rep.nKeyAliases= rep.nRadioGroups= 0;
+ rep.nKeyAliases = rep.nRadioGroups = 0;
}
- XkbComputeGetNamesReplySize(xkb,&rep);
- return XkbSendNames(client,xkb,&rep);
+ XkbComputeGetNamesReplySize(xkb, &rep);
+ return XkbSendNames(client, xkb, &rep);
}
/***====================================================================***/
static CARD32 *
-_XkbCheckAtoms(CARD32 *wire,int nAtoms,int swapped,Atom *pError)
+_XkbCheckAtoms(CARD32 *wire, int nAtoms, int swapped, Atom *pError)
{
-register int i;
+ register int i;
- for (i=0;i<nAtoms;i++,wire++) {
- if (swapped) {
- swapl(wire);
- }
- if ((((Atom)*wire)!=None)&&(!ValidAtom((Atom)*wire))) {
- *pError= ((Atom)*wire);
- return NULL;
- }
+ for (i = 0; i < nAtoms; i++, wire++) {
+ if (swapped) {
+ swapl(wire);
+ }
+ if ((((Atom) *wire) != None) && (!ValidAtom((Atom) *wire))) {
+ *pError = ((Atom) *wire);
+ return NULL;
+ }
}
return wire;
}
static CARD32 *
-_XkbCheckMaskedAtoms(CARD32 *wire,int nAtoms,CARD32 present,int swapped,
- Atom *pError)
+_XkbCheckMaskedAtoms(CARD32 *wire, int nAtoms, CARD32 present, int swapped,
+ Atom *pError)
{
-register unsigned i,bit;
-
- for (i=0,bit=1;(i<nAtoms)&&(present);i++,bit<<=1) {
- if ((present&bit)==0)
- continue;
- if (swapped) {
- swapl(wire);
- }
- if ((((Atom)*wire)!=None)&&(!ValidAtom(((Atom)*wire)))) {
- *pError= (Atom)*wire;
- return NULL;
- }
- wire++;
+ register unsigned i, bit;
+
+ for (i = 0, bit = 1; (i < nAtoms) && (present); i++, bit <<= 1) {
+ if ((present & bit) == 0)
+ continue;
+ if (swapped) {
+ swapl(wire);
+ }
+ if ((((Atom) *wire) != None) && (!ValidAtom(((Atom) *wire)))) {
+ *pError = (Atom) *wire;
+ return NULL;
+ }
+ wire++;
}
return wire;
}
static Atom *
-_XkbCopyMaskedAtoms( Atom *wire,
- Atom *dest,
- int nAtoms,
- CARD32 present)
+_XkbCopyMaskedAtoms(Atom *wire, Atom *dest, int nAtoms, CARD32 present)
{
-register int i,bit;
+ register int i, bit;
- for (i=0,bit=1;(i<nAtoms)&&(present);i++,bit<<=1) {
- if ((present&bit)==0)
- continue;
- dest[i]= *wire++;
+ for (i = 0, bit = 1; (i < nAtoms) && (present); i++, bit <<= 1) {
+ if ((present & bit) == 0)
+ continue;
+ dest[i] = *wire++;
}
return wire;
}
static Bool
-_XkbCheckTypeName(Atom name,int typeNdx)
+_XkbCheckTypeName(Atom name, int typeNdx)
{
-const char * str;
+ const char *str;
- str= NameForAtom(name);
- if ((strcmp(str,"ONE_LEVEL")==0)||(strcmp(str,"TWO_LEVEL")==0)||
- (strcmp(str,"ALPHABETIC")==0)||(strcmp(str,"KEYPAD")==0))
- return FALSE;
+ str = NameForAtom(name);
+ if ((strcmp(str, "ONE_LEVEL") == 0) || (strcmp(str, "TWO_LEVEL") == 0) ||
+ (strcmp(str, "ALPHABETIC") == 0) || (strcmp(str, "KEYPAD") == 0))
+ return FALSE;
return TRUE;
}
@@ -3878,304 +3971,310 @@ const char * str;
*/
static int
_XkbSetNamesCheck(ClientPtr client, DeviceIntPtr dev,
- xkbSetNamesReq *stuff, CARD32 *data)
+ xkbSetNamesReq * stuff, CARD32 *data)
{
- XkbDescRec *xkb;
- XkbNamesRec *names;
- CARD32 *tmp;
- Atom bad;
+ XkbDescRec *xkb;
+ XkbNamesRec *names;
+ CARD32 *tmp;
+ Atom bad;
tmp = data;
xkb = dev->key->xkbInfo->desc;
names = xkb->names;
-
if (stuff->which & XkbKeyTypeNamesMask) {
int i;
- CARD32 *old;
- if ( stuff->nTypes<1 ) {
- client->errorValue = _XkbErrCode2(0x02,stuff->nTypes);
+ CARD32 *old;
+
+ if (stuff->nTypes < 1) {
+ client->errorValue = _XkbErrCode2(0x02, stuff->nTypes);
return BadValue;
}
- if ((unsigned)(stuff->firstType+stuff->nTypes-1)>=xkb->map->num_types) {
- client->errorValue = _XkbErrCode4(0x03,stuff->firstType,
- stuff->nTypes,
- xkb->map->num_types);
+ if ((unsigned) (stuff->firstType + stuff->nTypes - 1) >=
+ xkb->map->num_types) {
+ client->errorValue =
+ _XkbErrCode4(0x03, stuff->firstType, stuff->nTypes,
+ xkb->map->num_types);
return BadValue;
}
- if (((unsigned)stuff->firstType)<=XkbLastRequiredType) {
- client->errorValue = _XkbErrCode2(0x04,stuff->firstType);
+ if (((unsigned) stuff->firstType) <= XkbLastRequiredType) {
+ client->errorValue = _XkbErrCode2(0x04, stuff->firstType);
return BadAccess;
}
- old= tmp;
- tmp= _XkbCheckAtoms(tmp,stuff->nTypes,client->swapped,&bad);
+ old = tmp;
+ tmp = _XkbCheckAtoms(tmp, stuff->nTypes, client->swapped, &bad);
if (!tmp) {
- client->errorValue= bad;
+ client->errorValue = bad;
return BadAtom;
}
- for (i=0;i<stuff->nTypes;i++,old++) {
- if (!_XkbCheckTypeName((Atom)*old,stuff->firstType+i))
- client->errorValue= _XkbErrCode2(0x05,i);
+ for (i = 0; i < stuff->nTypes; i++, old++) {
+ if (!_XkbCheckTypeName((Atom) *old, stuff->firstType + i))
+ client->errorValue = _XkbErrCode2(0x05, i);
}
}
- if (stuff->which&XkbKTLevelNamesMask) {
+ if (stuff->which & XkbKTLevelNamesMask) {
unsigned i;
- XkbKeyTypePtr type;
- CARD8 * width;
- if ( stuff->nKTLevels<1 ) {
- client->errorValue = _XkbErrCode2(0x05,stuff->nKTLevels);
+ XkbKeyTypePtr type;
+ CARD8 *width;
+
+ if (stuff->nKTLevels < 1) {
+ client->errorValue = _XkbErrCode2(0x05, stuff->nKTLevels);
return BadValue;
}
- if ((unsigned)(stuff->firstKTLevel+stuff->nKTLevels-1)>=
- xkb->map->num_types) {
- client->errorValue = _XkbErrCode4(0x06,stuff->firstKTLevel,
- stuff->nKTLevels,xkb->map->num_types);
+ if ((unsigned) (stuff->firstKTLevel + stuff->nKTLevels - 1) >=
+ xkb->map->num_types) {
+ client->errorValue = _XkbErrCode4(0x06, stuff->firstKTLevel,
+ stuff->nKTLevels,
+ xkb->map->num_types);
return BadValue;
}
- width = (CARD8 *)tmp;
- tmp= (CARD32 *)(((char *)tmp)+XkbPaddedSize(stuff->nKTLevels));
+ width = (CARD8 *) tmp;
+ tmp = (CARD32 *) (((char *) tmp) + XkbPaddedSize(stuff->nKTLevels));
type = &xkb->map->types[stuff->firstKTLevel];
- for (i=0;i<stuff->nKTLevels;i++,type++) {
- if (width[i]==0)
+ for (i = 0; i < stuff->nKTLevels; i++, type++) {
+ if (width[i] == 0)
continue;
- else if (width[i]!=type->num_levels) {
- client->errorValue= _XkbErrCode4(0x07,i+stuff->firstKTLevel,
- type->num_levels,width[i]);
+ else if (width[i] != type->num_levels) {
+ client->errorValue = _XkbErrCode4(0x07, i + stuff->firstKTLevel,
+ type->num_levels, width[i]);
return BadMatch;
}
- tmp= _XkbCheckAtoms(tmp,width[i],client->swapped,&bad);
+ tmp = _XkbCheckAtoms(tmp, width[i], client->swapped, &bad);
if (!tmp) {
- client->errorValue= bad;
+ client->errorValue = bad;
return BadAtom;
}
}
}
- if (stuff->which&XkbIndicatorNamesMask) {
- if (stuff->indicators==0) {
- client->errorValue= 0x08;
+ if (stuff->which & XkbIndicatorNamesMask) {
+ if (stuff->indicators == 0) {
+ client->errorValue = 0x08;
return BadMatch;
}
- tmp= _XkbCheckMaskedAtoms(tmp,XkbNumIndicators,stuff->indicators,
- client->swapped,&bad);
+ tmp = _XkbCheckMaskedAtoms(tmp, XkbNumIndicators, stuff->indicators,
+ client->swapped, &bad);
if (!tmp) {
- client->errorValue= bad;
+ client->errorValue = bad;
return BadAtom;
}
}
- if (stuff->which&XkbVirtualModNamesMask) {
- if (stuff->virtualMods==0) {
- client->errorValue= 0x09;
+ if (stuff->which & XkbVirtualModNamesMask) {
+ if (stuff->virtualMods == 0) {
+ client->errorValue = 0x09;
return BadMatch;
}
- tmp= _XkbCheckMaskedAtoms(tmp,XkbNumVirtualMods,
- (CARD32)stuff->virtualMods,
- client->swapped,&bad);
+ tmp = _XkbCheckMaskedAtoms(tmp, XkbNumVirtualMods,
+ (CARD32) stuff->virtualMods,
+ client->swapped, &bad);
if (!tmp) {
client->errorValue = bad;
return BadAtom;
}
}
- if (stuff->which&XkbGroupNamesMask) {
- if (stuff->groupNames==0) {
- client->errorValue= 0x0a;
+ if (stuff->which & XkbGroupNamesMask) {
+ if (stuff->groupNames == 0) {
+ client->errorValue = 0x0a;
return BadMatch;
}
- tmp= _XkbCheckMaskedAtoms(tmp,XkbNumKbdGroups,
- (CARD32)stuff->groupNames,
- client->swapped,&bad);
+ tmp = _XkbCheckMaskedAtoms(tmp, XkbNumKbdGroups,
+ (CARD32) stuff->groupNames,
+ client->swapped, &bad);
if (!tmp) {
client->errorValue = bad;
return BadAtom;
}
}
- if (stuff->which&XkbKeyNamesMask) {
- if (stuff->firstKey<(unsigned)xkb->min_key_code) {
- client->errorValue= _XkbErrCode3(0x0b,xkb->min_key_code,
- stuff->firstKey);
+ if (stuff->which & XkbKeyNamesMask) {
+ if (stuff->firstKey < (unsigned) xkb->min_key_code) {
+ client->errorValue = _XkbErrCode3(0x0b, xkb->min_key_code,
+ stuff->firstKey);
return BadValue;
}
- if (((unsigned)(stuff->firstKey+stuff->nKeys-1)>xkb->max_key_code)||
- (stuff->nKeys<1)) {
- client->errorValue= _XkbErrCode4(0x0c,xkb->max_key_code,
- stuff->firstKey,stuff->nKeys);
+ if (((unsigned) (stuff->firstKey + stuff->nKeys - 1) >
+ xkb->max_key_code) || (stuff->nKeys < 1)) {
+ client->errorValue =
+ _XkbErrCode4(0x0c, xkb->max_key_code, stuff->firstKey,
+ stuff->nKeys);
return BadValue;
}
- tmp+= stuff->nKeys;
+ tmp += stuff->nKeys;
}
- if ((stuff->which&XkbKeyAliasesMask)&&(stuff->nKeyAliases>0)) {
- tmp+= stuff->nKeyAliases*2;
+ if ((stuff->which & XkbKeyAliasesMask) && (stuff->nKeyAliases > 0)) {
+ tmp += stuff->nKeyAliases * 2;
}
- if (stuff->which&XkbRGNamesMask) {
- if ( stuff->nRadioGroups<1 ) {
- client->errorValue= _XkbErrCode2(0x0d,stuff->nRadioGroups);
+ if (stuff->which & XkbRGNamesMask) {
+ if (stuff->nRadioGroups < 1) {
+ client->errorValue = _XkbErrCode2(0x0d, stuff->nRadioGroups);
return BadValue;
}
- tmp= _XkbCheckAtoms(tmp,stuff->nRadioGroups,client->swapped,&bad);
+ tmp = _XkbCheckAtoms(tmp, stuff->nRadioGroups, client->swapped, &bad);
if (!tmp) {
- client->errorValue= bad;
+ client->errorValue = bad;
return BadAtom;
}
}
- if ((tmp-((CARD32 *)stuff))!=stuff->length) {
+ if ((tmp - ((CARD32 *) stuff)) != stuff->length) {
client->errorValue = stuff->length;
return BadLength;
}
-
-
return Success;
}
static int
-_XkbSetNames(ClientPtr client, DeviceIntPtr dev, xkbSetNamesReq *stuff)
+_XkbSetNames(ClientPtr client, DeviceIntPtr dev, xkbSetNamesReq * stuff)
{
- XkbDescRec *xkb;
- XkbNamesRec *names;
- CARD32 *tmp;
- xkbNamesNotify nn;
+ XkbDescRec *xkb;
+ XkbNamesRec *names;
+ CARD32 *tmp;
+ xkbNamesNotify nn;
- tmp = (CARD32 *)&stuff[1];
+ tmp = (CARD32 *) &stuff[1];
xkb = dev->key->xkbInfo->desc;
names = xkb->names;
- if (XkbAllocNames(xkb,stuff->which,stuff->nRadioGroups,
- stuff->nKeyAliases)!=Success) {
+ if (XkbAllocNames(xkb, stuff->which, stuff->nRadioGroups,
+ stuff->nKeyAliases) != Success) {
return BadAlloc;
}
memset(&nn, 0, sizeof(xkbNamesNotify));
- nn.changed= stuff->which;
- tmp = (CARD32 *)&stuff[1];
- if (stuff->which&XkbKeycodesNameMask)
- names->keycodes= *tmp++;
- if (stuff->which&XkbGeometryNameMask)
- names->geometry= *tmp++;
- if (stuff->which&XkbSymbolsNameMask)
- names->symbols= *tmp++;
- if (stuff->which&XkbPhysSymbolsNameMask)
- names->phys_symbols= *tmp++;
- if (stuff->which&XkbTypesNameMask)
- names->types= *tmp++;
- if (stuff->which&XkbCompatNameMask)
- names->compat= *tmp++;
- if ((stuff->which&XkbKeyTypeNamesMask)&&(stuff->nTypes>0)) {
+ nn.changed = stuff->which;
+ tmp = (CARD32 *) &stuff[1];
+ if (stuff->which & XkbKeycodesNameMask)
+ names->keycodes = *tmp++;
+ if (stuff->which & XkbGeometryNameMask)
+ names->geometry = *tmp++;
+ if (stuff->which & XkbSymbolsNameMask)
+ names->symbols = *tmp++;
+ if (stuff->which & XkbPhysSymbolsNameMask)
+ names->phys_symbols = *tmp++;
+ if (stuff->which & XkbTypesNameMask)
+ names->types = *tmp++;
+ if (stuff->which & XkbCompatNameMask)
+ names->compat = *tmp++;
+ if ((stuff->which & XkbKeyTypeNamesMask) && (stuff->nTypes > 0)) {
register unsigned i;
register XkbKeyTypePtr type;
- type= &xkb->map->types[stuff->firstType];
- for (i=0;i<stuff->nTypes;i++,type++) {
- type->name= *tmp++;
+ type = &xkb->map->types[stuff->firstType];
+ for (i = 0; i < stuff->nTypes; i++, type++) {
+ type->name = *tmp++;
}
- nn.firstType= stuff->firstType;
- nn.nTypes= stuff->nTypes;
+ nn.firstType = stuff->firstType;
+ nn.nTypes = stuff->nTypes;
}
- if (stuff->which&XkbKTLevelNamesMask) {
- register XkbKeyTypePtr type;
+ if (stuff->which & XkbKTLevelNamesMask) {
+ register XkbKeyTypePtr type;
register unsigned i;
CARD8 *width;
- width = (CARD8 *)tmp;
- tmp= (CARD32 *)(((char *)tmp)+XkbPaddedSize(stuff->nKTLevels));
- type= &xkb->map->types[stuff->firstKTLevel];
- for (i=0;i<stuff->nKTLevels;i++,type++) {
- if (width[i]>0) {
+ width = (CARD8 *) tmp;
+ tmp = (CARD32 *) (((char *) tmp) + XkbPaddedSize(stuff->nKTLevels));
+ type = &xkb->map->types[stuff->firstKTLevel];
+ for (i = 0; i < stuff->nKTLevels; i++, type++) {
+ if (width[i] > 0) {
if (type->level_names) {
register unsigned n;
- for (n=0;n<width[i];n++) {
- type->level_names[n]= tmp[n];
+
+ for (n = 0; n < width[i]; n++) {
+ type->level_names[n] = tmp[n];
}
}
- tmp+= width[i];
+ tmp += width[i];
}
}
- nn.firstLevelName= 0;
- nn.nLevelNames= stuff->nTypes;
- }
- if (stuff->which&XkbIndicatorNamesMask) {
- tmp= _XkbCopyMaskedAtoms(tmp,names->indicators,XkbNumIndicators,
- stuff->indicators);
- nn.changedIndicators= stuff->indicators;
- }
- if (stuff->which&XkbVirtualModNamesMask) {
- tmp= _XkbCopyMaskedAtoms(tmp,names->vmods,XkbNumVirtualMods,
- stuff->virtualMods);
- nn.changedVirtualMods= stuff->virtualMods;
- }
- if (stuff->which&XkbGroupNamesMask) {
- tmp= _XkbCopyMaskedAtoms(tmp,names->groups,XkbNumKbdGroups,
- stuff->groupNames);
- nn.changedVirtualMods= stuff->groupNames;
- }
- if (stuff->which&XkbKeyNamesMask) {
- memcpy((char*)&names->keys[stuff->firstKey],(char *)tmp,
- stuff->nKeys*XkbKeyNameLength);
- tmp+= stuff->nKeys;
- nn.firstKey= stuff->firstKey;
- nn.nKeys= stuff->nKeys;
- }
- if (stuff->which&XkbKeyAliasesMask) {
- if (stuff->nKeyAliases>0) {
- register int na= stuff->nKeyAliases;
- if (XkbAllocNames(xkb,XkbKeyAliasesMask,0,na)!=Success)
+ nn.firstLevelName = 0;
+ nn.nLevelNames = stuff->nTypes;
+ }
+ if (stuff->which & XkbIndicatorNamesMask) {
+ tmp = _XkbCopyMaskedAtoms(tmp, names->indicators, XkbNumIndicators,
+ stuff->indicators);
+ nn.changedIndicators = stuff->indicators;
+ }
+ if (stuff->which & XkbVirtualModNamesMask) {
+ tmp = _XkbCopyMaskedAtoms(tmp, names->vmods, XkbNumVirtualMods,
+ stuff->virtualMods);
+ nn.changedVirtualMods = stuff->virtualMods;
+ }
+ if (stuff->which & XkbGroupNamesMask) {
+ tmp = _XkbCopyMaskedAtoms(tmp, names->groups, XkbNumKbdGroups,
+ stuff->groupNames);
+ nn.changedVirtualMods = stuff->groupNames;
+ }
+ if (stuff->which & XkbKeyNamesMask) {
+ memcpy((char *) &names->keys[stuff->firstKey], (char *) tmp,
+ stuff->nKeys * XkbKeyNameLength);
+ tmp += stuff->nKeys;
+ nn.firstKey = stuff->firstKey;
+ nn.nKeys = stuff->nKeys;
+ }
+ if (stuff->which & XkbKeyAliasesMask) {
+ if (stuff->nKeyAliases > 0) {
+ register int na = stuff->nKeyAliases;
+
+ if (XkbAllocNames(xkb, XkbKeyAliasesMask, 0, na) != Success)
return BadAlloc;
- memcpy((char *)names->key_aliases,(char *)tmp,
- stuff->nKeyAliases*sizeof(XkbKeyAliasRec));
- tmp+= stuff->nKeyAliases*2;
+ memcpy((char *) names->key_aliases, (char *) tmp,
+ stuff->nKeyAliases * sizeof(XkbKeyAliasRec));
+ tmp += stuff->nKeyAliases * 2;
}
- else if (names->key_aliases!=NULL) {
+ else if (names->key_aliases != NULL) {
free(names->key_aliases);
- names->key_aliases= NULL;
- names->num_key_aliases= 0;
+ names->key_aliases = NULL;
+ names->num_key_aliases = 0;
}
- nn.nAliases= names->num_key_aliases;
+ nn.nAliases = names->num_key_aliases;
}
- if (stuff->which&XkbRGNamesMask) {
- if (stuff->nRadioGroups>0) {
- register unsigned i,nrg;
- nrg= stuff->nRadioGroups;
- if (XkbAllocNames(xkb,XkbRGNamesMask,nrg,0)!=Success)
+ if (stuff->which & XkbRGNamesMask) {
+ if (stuff->nRadioGroups > 0) {
+ register unsigned i, nrg;
+
+ nrg = stuff->nRadioGroups;
+ if (XkbAllocNames(xkb, XkbRGNamesMask, nrg, 0) != Success)
return BadAlloc;
- for (i=0;i<stuff->nRadioGroups;i++) {
- names->radio_groups[i]= tmp[i];
+ for (i = 0; i < stuff->nRadioGroups; i++) {
+ names->radio_groups[i] = tmp[i];
}
- tmp+= stuff->nRadioGroups;
+ tmp += stuff->nRadioGroups;
}
else if (names->radio_groups) {
free(names->radio_groups);
- names->radio_groups= NULL;
- names->num_rg= 0;
+ names->radio_groups = NULL;
+ names->num_rg = 0;
}
- nn.nRadioGroups= names->num_rg;
+ nn.nRadioGroups = names->num_rg;
}
if (nn.changed) {
Bool needExtEvent;
- needExtEvent= (nn.changed&XkbIndicatorNamesMask)!=0;
- XkbSendNamesNotify(dev,&nn);
+
+ needExtEvent = (nn.changed & XkbIndicatorNamesMask) != 0;
+ XkbSendNamesNotify(dev, &nn);
if (needExtEvent) {
- XkbSrvLedInfoPtr sli;
- xkbExtensionDeviceNotify edev;
- register int i;
- register unsigned bit;
-
- sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,
- XkbXI_IndicatorsMask);
- sli->namesPresent= 0;
- for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
- if (names->indicators[i]!=None)
- sli->namesPresent|= bit;
+ XkbSrvLedInfoPtr sli;
+ xkbExtensionDeviceNotify edev;
+ register int i;
+ register unsigned bit;
+
+ sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId,
+ XkbXI_IndicatorsMask);
+ sli->namesPresent = 0;
+ for (i = 0, bit = 1; i < XkbNumIndicators; i++, bit <<= 1) {
+ if (names->indicators[i] != None)
+ sli->namesPresent |= bit;
}
memset(&edev, 0, sizeof(xkbExtensionDeviceNotify));
- edev.reason= XkbXI_IndicatorNamesMask;
- edev.ledClass= KbdFeedbackClass;
- edev.ledID= dev->kbdfeed->ctrl.id;
- edev.ledsDefined= sli->namesPresent|sli->mapsPresent;
- edev.ledState= sli->effectiveState;
- edev.firstBtn= 0;
- edev.nBtns= 0;
- edev.supported= XkbXI_AllFeaturesMask;
- edev.unsupported= 0;
- XkbSendExtensionDeviceNotify(dev,client,&edev);
+ edev.reason = XkbXI_IndicatorNamesMask;
+ edev.ledClass = KbdFeedbackClass;
+ edev.ledID = dev->kbdfeed->ctrl.id;
+ edev.ledsDefined = sli->namesPresent | sli->mapsPresent;
+ edev.ledState = sli->effectiveState;
+ edev.firstBtn = 0;
+ edev.nBtns = 0;
+ edev.supported = XkbXI_AllFeaturesMask;
+ edev.unsupported = 0;
+ XkbSendExtensionDeviceNotify(dev, client, &edev);
}
}
return Success;
@@ -4184,64 +4283,64 @@ _XkbSetNames(ClientPtr client, DeviceIntPtr dev, xkbSetNamesReq *stuff)
int
ProcXkbSetNames(ClientPtr client)
{
- DeviceIntPtr dev;
- CARD32 *tmp;
- Atom bad;
- int rc;
+ DeviceIntPtr dev;
+ CARD32 *tmp;
+ Atom bad;
+ int rc;
REQUEST(xkbSetNamesReq);
REQUEST_AT_LEAST_SIZE(xkbSetNamesReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixManageAccess);
- CHK_MASK_LEGAL(0x01,stuff->which,XkbAllNamesMask);
+ CHK_MASK_LEGAL(0x01, stuff->which, XkbAllNamesMask);
/* check device-independent stuff */
- tmp = (CARD32 *)&stuff[1];
-
- if (stuff->which&XkbKeycodesNameMask) {
- tmp= _XkbCheckAtoms(tmp,1,client->swapped,&bad);
- if (!tmp) {
- client->errorValue = bad;
- return BadAtom;
- }
- }
- if (stuff->which&XkbGeometryNameMask) {
- tmp= _XkbCheckAtoms(tmp,1,client->swapped,&bad);
- if (!tmp) {
- client->errorValue = bad;
- return BadAtom;
- }
- }
- if (stuff->which&XkbSymbolsNameMask) {
- tmp= _XkbCheckAtoms(tmp,1,client->swapped,&bad);
- if (!tmp) {
- client->errorValue = bad;
- return BadAtom;
- }
- }
- if (stuff->which&XkbPhysSymbolsNameMask) {
- tmp= _XkbCheckAtoms(tmp,1,client->swapped,&bad);
- if (!tmp) {
- client->errorValue= bad;
- return BadAtom;
- }
- }
- if (stuff->which&XkbTypesNameMask) {
- tmp= _XkbCheckAtoms(tmp,1,client->swapped,&bad);
- if (!tmp) {
- client->errorValue = bad;
- return BadAtom;
- }
- }
- if (stuff->which&XkbCompatNameMask) {
- tmp= _XkbCheckAtoms(tmp,1,client->swapped,&bad);
- if (!tmp) {
- client->errorValue = bad;
- return BadAtom;
- }
+ tmp = (CARD32 *) &stuff[1];
+
+ if (stuff->which & XkbKeycodesNameMask) {
+ tmp = _XkbCheckAtoms(tmp, 1, client->swapped, &bad);
+ if (!tmp) {
+ client->errorValue = bad;
+ return BadAtom;
+ }
+ }
+ if (stuff->which & XkbGeometryNameMask) {
+ tmp = _XkbCheckAtoms(tmp, 1, client->swapped, &bad);
+ if (!tmp) {
+ client->errorValue = bad;
+ return BadAtom;
+ }
+ }
+ if (stuff->which & XkbSymbolsNameMask) {
+ tmp = _XkbCheckAtoms(tmp, 1, client->swapped, &bad);
+ if (!tmp) {
+ client->errorValue = bad;
+ return BadAtom;
+ }
+ }
+ if (stuff->which & XkbPhysSymbolsNameMask) {
+ tmp = _XkbCheckAtoms(tmp, 1, client->swapped, &bad);
+ if (!tmp) {
+ client->errorValue = bad;
+ return BadAtom;
+ }
+ }
+ if (stuff->which & XkbTypesNameMask) {
+ tmp = _XkbCheckAtoms(tmp, 1, client->swapped, &bad);
+ if (!tmp) {
+ client->errorValue = bad;
+ return BadAtom;
+ }
+ }
+ if (stuff->which & XkbCompatNameMask) {
+ tmp = _XkbCheckAtoms(tmp, 1, client->swapped, &bad);
+ if (!tmp) {
+ client->errorValue = bad;
+ return BadAtom;
+ }
}
/* start of device-dependent tests */
@@ -4249,17 +4348,16 @@ ProcXkbSetNames(ClientPtr client)
if (rc != Success)
return rc;
- if (stuff->deviceSpec == XkbUseCoreKbd)
- {
+ if (stuff->deviceSpec == XkbUseCoreKbd) {
DeviceIntPtr other;
- for (other = inputInfo.devices; other; other = other->next)
- {
- if ((other != dev) && other->key && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev)
- {
- rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixManageAccess);
- if (rc == Success)
- {
+ for (other = inputInfo.devices; other; other = other->next) {
+ if ((other != dev) && other->key && !IsMaster(other) &&
+ GetMaster(other, MASTER_KEYBOARD) == dev) {
+
+ rc = XaceHook(XACE_DEVICE_ACCESS, client, other,
+ DixManageAccess);
+ if (rc == Success) {
rc = _XkbSetNamesCheck(client, other, stuff, tmp);
if (rc != Success)
return rc;
@@ -4274,15 +4372,15 @@ ProcXkbSetNames(ClientPtr client)
if (rc != Success)
return rc;
- if (stuff->deviceSpec == XkbUseCoreKbd)
- {
+ if (stuff->deviceSpec == XkbUseCoreKbd) {
DeviceIntPtr other;
- for (other = inputInfo.devices; other; other = other->next)
- {
- if ((other != dev) && other->key && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev)
- {
- rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixManageAccess);
+ for (other = inputInfo.devices; other; other = other->next) {
+ if ((other != dev) && other->key && !IsMaster(other) &&
+ GetMaster(other, MASTER_KEYBOARD) == dev) {
+
+ rc = XaceHook(XACE_DEVICE_ACCESS, client, other,
+ DixManageAccess);
if (rc == Success)
_XkbSetNames(client, other, stuff);
}
@@ -4312,47 +4410,48 @@ ProcXkbSetNames(ClientPtr client)
* (swapped) 16 bit string length, non-zero terminated.
*/
static char *
-XkbWriteCountedString(char *wire,char *str,Bool swap)
+XkbWriteCountedString(char *wire, char *str, Bool swap)
{
- CARD16 len,*pLen, paddedLen;
+ CARD16 len, *pLen, paddedLen;
if (!str)
return wire;
- len= strlen(str);
- pLen= (CARD16 *)wire;
- *pLen= len;
+ len = strlen(str);
+ pLen = (CARD16 *) wire;
+ *pLen = len;
if (swap) {
- swaps(pLen);
+ swaps(pLen);
}
- paddedLen= pad_to_int32(sizeof(len)+len)-sizeof(len);
- strncpy(&wire[sizeof(len)],str,paddedLen);
- wire+= sizeof(len)+paddedLen;
+ paddedLen = pad_to_int32(sizeof(len) + len) - sizeof(len);
+ strncpy(&wire[sizeof(len)], str, paddedLen);
+ wire += sizeof(len) + paddedLen;
return wire;
}
static int
XkbSizeGeomProperties(XkbGeometryPtr geom)
{
-register int i,size;
-XkbPropertyPtr prop;
-
- for (size=i=0,prop=geom->properties;i<geom->num_properties;i++,prop++) {
- size+= XkbSizeCountedString(prop->name);
- size+= XkbSizeCountedString(prop->value);
+ register int i, size;
+ XkbPropertyPtr prop;
+
+ for (size = i = 0, prop = geom->properties; i < geom->num_properties;
+ i++, prop++) {
+ size += XkbSizeCountedString(prop->name);
+ size += XkbSizeCountedString(prop->value);
}
return size;
}
static char *
-XkbWriteGeomProperties(char *wire,XkbGeometryPtr geom,Bool swap)
+XkbWriteGeomProperties(char *wire, XkbGeometryPtr geom, Bool swap)
{
-register int i;
-register XkbPropertyPtr prop;
-
- for (i=0,prop=geom->properties;i<geom->num_properties;i++,prop++) {
- wire= XkbWriteCountedString(wire,prop->name,swap);
- wire= XkbWriteCountedString(wire,prop->value,swap);
+ register int i;
+ register XkbPropertyPtr prop;
+
+ for (i = 0, prop = geom->properties; i < geom->num_properties; i++, prop++) {
+ wire = XkbWriteCountedString(wire, prop->name, swap);
+ wire = XkbWriteCountedString(wire, prop->value, swap);
}
return wire;
}
@@ -4360,18 +4459,18 @@ register XkbPropertyPtr prop;
static int
XkbSizeGeomKeyAliases(XkbGeometryPtr geom)
{
- return geom->num_key_aliases*(2*XkbKeyNameLength);
+ return geom->num_key_aliases * (2 * XkbKeyNameLength);
}
static char *
-XkbWriteGeomKeyAliases(char *wire,XkbGeometryPtr geom,Bool swap)
+XkbWriteGeomKeyAliases(char *wire, XkbGeometryPtr geom, Bool swap)
{
-register int sz;
-
- sz= geom->num_key_aliases*(XkbKeyNameLength*2);
- if (sz>0) {
- memcpy(wire,(char *)geom->key_aliases,sz);
- wire+= sz;
+ register int sz;
+
+ sz = geom->num_key_aliases * (XkbKeyNameLength * 2);
+ if (sz > 0) {
+ memcpy(wire, (char *) geom->key_aliases, sz);
+ wire += sz;
}
return wire;
}
@@ -4379,23 +4478,23 @@ register int sz;
static int
XkbSizeGeomColors(XkbGeometryPtr geom)
{
-register int i,size;
-register XkbColorPtr color;
+ register int i, size;
+ register XkbColorPtr color;
- for (i=size=0,color=geom->colors;i<geom->num_colors;i++,color++) {
- size+= XkbSizeCountedString(color->spec);
+ for (i = size = 0, color = geom->colors; i < geom->num_colors; i++, color++) {
+ size += XkbSizeCountedString(color->spec);
}
return size;
}
static char *
-XkbWriteGeomColors(char *wire,XkbGeometryPtr geom,Bool swap)
+XkbWriteGeomColors(char *wire, XkbGeometryPtr geom, Bool swap)
{
-register int i;
-register XkbColorPtr color;
+ register int i;
+ register XkbColorPtr color;
- for (i=0,color=geom->colors;i<geom->num_colors;i++,color++) {
- wire= XkbWriteCountedString(wire,color->spec,swap);
+ for (i = 0, color = geom->colors; i < geom->num_colors; i++, color++) {
+ wire = XkbWriteCountedString(wire, color->spec, swap);
}
return wire;
}
@@ -4403,922 +4502,941 @@ register XkbColorPtr color;
static int
XkbSizeGeomShapes(XkbGeometryPtr geom)
{
-register int i,size;
-register XkbShapePtr shape;
-
- for (i=size=0,shape=geom->shapes;i<geom->num_shapes;i++,shape++) {
- register int n;
- register XkbOutlinePtr ol;
- size+= SIZEOF(xkbShapeWireDesc);
- for (n=0,ol=shape->outlines;n<shape->num_outlines;n++,ol++) {
- size+= SIZEOF(xkbOutlineWireDesc);
- size+= ol->num_points*SIZEOF(xkbPointWireDesc);
- }
+ register int i, size;
+ register XkbShapePtr shape;
+
+ for (i = size = 0, shape = geom->shapes; i < geom->num_shapes; i++, shape++) {
+ register int n;
+ register XkbOutlinePtr ol;
+
+ size += SIZEOF(xkbShapeWireDesc);
+ for (n = 0, ol = shape->outlines; n < shape->num_outlines; n++, ol++) {
+ size += SIZEOF(xkbOutlineWireDesc);
+ size += ol->num_points * SIZEOF(xkbPointWireDesc);
+ }
}
return size;
}
static char *
-XkbWriteGeomShapes(char *wire,XkbGeometryPtr geom,Bool swap)
+XkbWriteGeomShapes(char *wire, XkbGeometryPtr geom, Bool swap)
{
-int i;
-XkbShapePtr shape;
-xkbShapeWireDesc * shapeWire;
-
- for (i=0,shape=geom->shapes;i<geom->num_shapes;i++,shape++) {
- register int o;
- XkbOutlinePtr ol;
- xkbOutlineWireDesc * olWire;
- shapeWire= (xkbShapeWireDesc *)wire;
- shapeWire->name= shape->name;
- shapeWire->nOutlines= shape->num_outlines;
- if (shape->primary!=NULL)
- shapeWire->primaryNdx= XkbOutlineIndex(shape,shape->primary);
- else shapeWire->primaryNdx= XkbNoShape;
- if (shape->approx!=NULL)
- shapeWire->approxNdx= XkbOutlineIndex(shape,shape->approx);
- else shapeWire->approxNdx= XkbNoShape;
- shapeWire->pad= 0;
- if (swap) {
- swapl(&shapeWire->name);
- }
- wire= (char *)&shapeWire[1];
- for (o=0,ol=shape->outlines;o<shape->num_outlines;o++,ol++) {
- register int p;
- XkbPointPtr pt;
- xkbPointWireDesc * ptWire;
- olWire= (xkbOutlineWireDesc *)wire;
- olWire->nPoints= ol->num_points;
- olWire->cornerRadius= ol->corner_radius;
- olWire->pad= 0;
- wire= (char *)&olWire[1];
- ptWire= (xkbPointWireDesc *)wire;
- for (p=0,pt=ol->points;p<ol->num_points;p++,pt++) {
- ptWire[p].x= pt->x;
- ptWire[p].y= pt->y;
- if (swap) {
- swaps(&ptWire[p].x);
- swaps(&ptWire[p].y);
- }
- }
- wire= (char *)&ptWire[ol->num_points];
- }
+ int i;
+ XkbShapePtr shape;
+ xkbShapeWireDesc *shapeWire;
+
+ for (i = 0, shape = geom->shapes; i < geom->num_shapes; i++, shape++) {
+ register int o;
+ XkbOutlinePtr ol;
+ xkbOutlineWireDesc *olWire;
+
+ shapeWire = (xkbShapeWireDesc *) wire;
+ shapeWire->name = shape->name;
+ shapeWire->nOutlines = shape->num_outlines;
+ if (shape->primary != NULL)
+ shapeWire->primaryNdx = XkbOutlineIndex(shape, shape->primary);
+ else
+ shapeWire->primaryNdx = XkbNoShape;
+ if (shape->approx != NULL)
+ shapeWire->approxNdx = XkbOutlineIndex(shape, shape->approx);
+ else
+ shapeWire->approxNdx = XkbNoShape;
+ shapeWire->pad = 0;
+ if (swap) {
+ swapl(&shapeWire->name);
+ }
+ wire = (char *) &shapeWire[1];
+ for (o = 0, ol = shape->outlines; o < shape->num_outlines; o++, ol++) {
+ register int p;
+ XkbPointPtr pt;
+ xkbPointWireDesc *ptWire;
+
+ olWire = (xkbOutlineWireDesc *) wire;
+ olWire->nPoints = ol->num_points;
+ olWire->cornerRadius = ol->corner_radius;
+ olWire->pad = 0;
+ wire = (char *) &olWire[1];
+ ptWire = (xkbPointWireDesc *) wire;
+ for (p = 0, pt = ol->points; p < ol->num_points; p++, pt++) {
+ ptWire[p].x = pt->x;
+ ptWire[p].y = pt->y;
+ if (swap) {
+ swaps(&ptWire[p].x);
+ swaps(&ptWire[p].y);
+ }
+ }
+ wire = (char *) &ptWire[ol->num_points];
+ }
}
return wire;
}
static int
-XkbSizeGeomDoodads(int num_doodads,XkbDoodadPtr doodad)
+XkbSizeGeomDoodads(int num_doodads, XkbDoodadPtr doodad)
{
-register int i,size;
-
- for (i=size=0;i<num_doodads;i++,doodad++) {
- size+= SIZEOF(xkbAnyDoodadWireDesc);
- if (doodad->any.type==XkbTextDoodad) {
- size+= XkbSizeCountedString(doodad->text.text);
- size+= XkbSizeCountedString(doodad->text.font);
- }
- else if (doodad->any.type==XkbLogoDoodad) {
- size+= XkbSizeCountedString(doodad->logo.logo_name);
- }
+ register int i, size;
+
+ for (i = size = 0; i < num_doodads; i++, doodad++) {
+ size += SIZEOF(xkbAnyDoodadWireDesc);
+ if (doodad->any.type == XkbTextDoodad) {
+ size += XkbSizeCountedString(doodad->text.text);
+ size += XkbSizeCountedString(doodad->text.font);
+ }
+ else if (doodad->any.type == XkbLogoDoodad) {
+ size += XkbSizeCountedString(doodad->logo.logo_name);
+ }
}
return size;
}
static char *
-XkbWriteGeomDoodads(char *wire,int num_doodads,XkbDoodadPtr doodad,Bool swap)
+XkbWriteGeomDoodads(char *wire, int num_doodads, XkbDoodadPtr doodad, Bool swap)
{
-register int i;
-xkbDoodadWireDesc * doodadWire;
-
- for (i=0;i<num_doodads;i++,doodad++) {
- doodadWire= (xkbDoodadWireDesc *)wire;
- wire= (char *)&doodadWire[1];
- memset(doodadWire, 0, SIZEOF(xkbDoodadWireDesc));
- doodadWire->any.name= doodad->any.name;
- doodadWire->any.type= doodad->any.type;
- doodadWire->any.priority= doodad->any.priority;
- doodadWire->any.top= doodad->any.top;
- doodadWire->any.left= doodad->any.left;
- if (swap) {
- swapl(&doodadWire->any.name);
- swaps(&doodadWire->any.top);
- swaps(&doodadWire->any.left);
- }
- switch (doodad->any.type) {
- case XkbOutlineDoodad:
- case XkbSolidDoodad:
- doodadWire->shape.angle= doodad->shape.angle;
- doodadWire->shape.colorNdx= doodad->shape.color_ndx;
- doodadWire->shape.shapeNdx= doodad->shape.shape_ndx;
- if (swap) {
- swaps(&doodadWire->shape.angle);
- }
- break;
- case XkbTextDoodad:
- doodadWire->text.angle= doodad->text.angle;
- doodadWire->text.width= doodad->text.width;
- doodadWire->text.height= doodad->text.height;
- doodadWire->text.colorNdx= doodad->text.color_ndx;
- if (swap) {
- swaps(&doodadWire->text.angle);
- swaps(&doodadWire->text.width);
- swaps(&doodadWire->text.height);
- }
- wire= XkbWriteCountedString(wire,doodad->text.text,swap);
- wire= XkbWriteCountedString(wire,doodad->text.font,swap);
- break;
- case XkbIndicatorDoodad:
- doodadWire->indicator.shapeNdx= doodad->indicator.shape_ndx;
- doodadWire->indicator.onColorNdx=doodad->indicator.on_color_ndx;
- doodadWire->indicator.offColorNdx=
- doodad->indicator.off_color_ndx;
- break;
- case XkbLogoDoodad:
- doodadWire->logo.angle= doodad->logo.angle;
- doodadWire->logo.colorNdx= doodad->logo.color_ndx;
- doodadWire->logo.shapeNdx= doodad->logo.shape_ndx;
- wire= XkbWriteCountedString(wire,doodad->logo.logo_name,swap);
- break;
- default:
- ErrorF("[xkb] Unknown doodad type %d in XkbWriteGeomDoodads\n",
- doodad->any.type);
- ErrorF("[xkb] Ignored\n");
- break;
- }
+ register int i;
+ xkbDoodadWireDesc *doodadWire;
+
+ for (i = 0; i < num_doodads; i++, doodad++) {
+ doodadWire = (xkbDoodadWireDesc *) wire;
+ wire = (char *) &doodadWire[1];
+ memset(doodadWire, 0, SIZEOF(xkbDoodadWireDesc));
+ doodadWire->any.name = doodad->any.name;
+ doodadWire->any.type = doodad->any.type;
+ doodadWire->any.priority = doodad->any.priority;
+ doodadWire->any.top = doodad->any.top;
+ doodadWire->any.left = doodad->any.left;
+ if (swap) {
+ swapl(&doodadWire->any.name);
+ swaps(&doodadWire->any.top);
+ swaps(&doodadWire->any.left);
+ }
+ switch (doodad->any.type) {
+ case XkbOutlineDoodad:
+ case XkbSolidDoodad:
+ doodadWire->shape.angle = doodad->shape.angle;
+ doodadWire->shape.colorNdx = doodad->shape.color_ndx;
+ doodadWire->shape.shapeNdx = doodad->shape.shape_ndx;
+ if (swap) {
+ swaps(&doodadWire->shape.angle);
+ }
+ break;
+ case XkbTextDoodad:
+ doodadWire->text.angle = doodad->text.angle;
+ doodadWire->text.width = doodad->text.width;
+ doodadWire->text.height = doodad->text.height;
+ doodadWire->text.colorNdx = doodad->text.color_ndx;
+ if (swap) {
+ swaps(&doodadWire->text.angle);
+ swaps(&doodadWire->text.width);
+ swaps(&doodadWire->text.height);
+ }
+ wire = XkbWriteCountedString(wire, doodad->text.text, swap);
+ wire = XkbWriteCountedString(wire, doodad->text.font, swap);
+ break;
+ case XkbIndicatorDoodad:
+ doodadWire->indicator.shapeNdx = doodad->indicator.shape_ndx;
+ doodadWire->indicator.onColorNdx = doodad->indicator.on_color_ndx;
+ doodadWire->indicator.offColorNdx = doodad->indicator.off_color_ndx;
+ break;
+ case XkbLogoDoodad:
+ doodadWire->logo.angle = doodad->logo.angle;
+ doodadWire->logo.colorNdx = doodad->logo.color_ndx;
+ doodadWire->logo.shapeNdx = doodad->logo.shape_ndx;
+ wire = XkbWriteCountedString(wire, doodad->logo.logo_name, swap);
+ break;
+ default:
+ ErrorF("[xkb] Unknown doodad type %d in XkbWriteGeomDoodads\n",
+ doodad->any.type);
+ ErrorF("[xkb] Ignored\n");
+ break;
+ }
}
return wire;
}
static char *
-XkbWriteGeomOverlay(char *wire,XkbOverlayPtr ol,Bool swap)
+XkbWriteGeomOverlay(char *wire, XkbOverlayPtr ol, Bool swap)
{
-register int r;
-XkbOverlayRowPtr row;
-xkbOverlayWireDesc * olWire;
-
- olWire= (xkbOverlayWireDesc *)wire;
- olWire->name= ol->name;
- olWire->nRows= ol->num_rows;
- olWire->pad1= 0;
- olWire->pad2= 0;
- if (swap) {
- swapl(&olWire->name);
- }
- wire= (char *)&olWire[1];
- for (r=0,row=ol->rows;r<ol->num_rows;r++,row++) {
- unsigned int k;
- XkbOverlayKeyPtr key;
- xkbOverlayRowWireDesc * rowWire;
- rowWire= (xkbOverlayRowWireDesc *)wire;
- rowWire->rowUnder= row->row_under;
- rowWire->nKeys= row->num_keys;
- rowWire->pad1= 0;
- wire= (char *)&rowWire[1];
- for (k=0,key=row->keys;k<row->num_keys;k++,key++) {
- xkbOverlayKeyWireDesc * keyWire;
- keyWire= (xkbOverlayKeyWireDesc *)wire;
- memcpy(keyWire->over,key->over.name,XkbKeyNameLength);
- memcpy(keyWire->under,key->under.name,XkbKeyNameLength);
- wire= (char *)&keyWire[1];
- }
- }
- return wire;
+ register int r;
+ XkbOverlayRowPtr row;
+ xkbOverlayWireDesc *olWire;
+
+ olWire = (xkbOverlayWireDesc *) wire;
+ olWire->name = ol->name;
+ olWire->nRows = ol->num_rows;
+ olWire->pad1 = 0;
+ olWire->pad2 = 0;
+ if (swap) {
+ swapl(&olWire->name);
+ }
+ wire = (char *) &olWire[1];
+ for (r = 0, row = ol->rows; r < ol->num_rows; r++, row++) {
+ unsigned int k;
+ XkbOverlayKeyPtr key;
+ xkbOverlayRowWireDesc *rowWire;
+
+ rowWire = (xkbOverlayRowWireDesc *) wire;
+ rowWire->rowUnder = row->row_under;
+ rowWire->nKeys = row->num_keys;
+ rowWire->pad1 = 0;
+ wire = (char *) &rowWire[1];
+ for (k = 0, key = row->keys; k < row->num_keys; k++, key++) {
+ xkbOverlayKeyWireDesc *keyWire;
+
+ keyWire = (xkbOverlayKeyWireDesc *) wire;
+ memcpy(keyWire->over, key->over.name, XkbKeyNameLength);
+ memcpy(keyWire->under, key->under.name, XkbKeyNameLength);
+ wire = (char *) &keyWire[1];
+ }
+ }
+ return wire;
}
static int
XkbSizeGeomSections(XkbGeometryPtr geom)
{
-register int i,size;
-XkbSectionPtr section;
-
- for (i=size=0,section=geom->sections;i<geom->num_sections;i++,section++) {
- size+= SIZEOF(xkbSectionWireDesc);
- if (section->rows) {
- int r;
- XkbRowPtr row;
- for (r=0,row=section->rows;r<section->num_rows;row++,r++) {
- size+= SIZEOF(xkbRowWireDesc);
- size+= row->num_keys*SIZEOF(xkbKeyWireDesc);
- }
- }
- if (section->doodads)
- size+= XkbSizeGeomDoodads(section->num_doodads,section->doodads);
- if (section->overlays) {
- int o;
- XkbOverlayPtr ol;
- for (o=0,ol=section->overlays;o<section->num_overlays;o++,ol++) {
- int r;
- XkbOverlayRowPtr row;
- size+= SIZEOF(xkbOverlayWireDesc);
- for (r=0,row=ol->rows;r<ol->num_rows;r++,row++) {
- size+= SIZEOF(xkbOverlayRowWireDesc);
- size+= row->num_keys*SIZEOF(xkbOverlayKeyWireDesc);
- }
- }
- }
+ register int i, size;
+ XkbSectionPtr section;
+
+ for (i = size = 0, section = geom->sections; i < geom->num_sections;
+ i++, section++) {
+ size += SIZEOF(xkbSectionWireDesc);
+ if (section->rows) {
+ int r;
+ XkbRowPtr row;
+
+ for (r = 0, row = section->rows; r < section->num_rows; row++, r++) {
+ size += SIZEOF(xkbRowWireDesc);
+ size += row->num_keys * SIZEOF(xkbKeyWireDesc);
+ }
+ }
+ if (section->doodads)
+ size += XkbSizeGeomDoodads(section->num_doodads, section->doodads);
+ if (section->overlays) {
+ int o;
+ XkbOverlayPtr ol;
+
+ for (o = 0, ol = section->overlays; o < section->num_overlays;
+ o++, ol++) {
+ int r;
+ XkbOverlayRowPtr row;
+
+ size += SIZEOF(xkbOverlayWireDesc);
+ for (r = 0, row = ol->rows; r < ol->num_rows; r++, row++) {
+ size += SIZEOF(xkbOverlayRowWireDesc);
+ size += row->num_keys * SIZEOF(xkbOverlayKeyWireDesc);
+ }
+ }
+ }
}
return size;
}
static char *
-XkbWriteGeomSections(char *wire,XkbGeometryPtr geom,Bool swap)
+XkbWriteGeomSections(char *wire, XkbGeometryPtr geom, Bool swap)
{
-register int i;
-XkbSectionPtr section;
-xkbSectionWireDesc * sectionWire;
-
- for (i=0,section=geom->sections;i<geom->num_sections;i++,section++) {
- sectionWire= (xkbSectionWireDesc *)wire;
- sectionWire->name= section->name;
- sectionWire->top= section->top;
- sectionWire->left= section->left;
- sectionWire->width= section->width;
- sectionWire->height= section->height;
- sectionWire->angle= section->angle;
- sectionWire->priority= section->priority;
- sectionWire->nRows= section->num_rows;
- sectionWire->nDoodads= section->num_doodads;
- sectionWire->nOverlays= section->num_overlays;
- sectionWire->pad= 0;
- if (swap) {
- swapl(&sectionWire->name);
- swaps(&sectionWire->top);
- swaps(&sectionWire->left);
- swaps(&sectionWire->width);
- swaps(&sectionWire->height);
- swaps(&sectionWire->angle);
- }
- wire= (char *)&sectionWire[1];
- if (section->rows) {
- int r;
- XkbRowPtr row;
- xkbRowWireDesc * rowWire;
- for (r=0,row=section->rows;r<section->num_rows;r++,row++) {
- rowWire= (xkbRowWireDesc *)wire;
- rowWire->top= row->top;
- rowWire->left= row->left;
- rowWire->nKeys= row->num_keys;
- rowWire->vertical= row->vertical;
- rowWire->pad= 0;
- if (swap) {
- swaps(&rowWire->top);
- swaps(&rowWire->left);
- }
- wire= (char *)&rowWire[1];
- if (row->keys) {
- int k;
- XkbKeyPtr key;
- xkbKeyWireDesc * keyWire;
- keyWire= (xkbKeyWireDesc *)wire;
- for (k=0,key=row->keys;k<row->num_keys;k++,key++) {
- memcpy(keyWire[k].name,key->name.name,XkbKeyNameLength);
- keyWire[k].gap= key->gap;
- keyWire[k].shapeNdx= key->shape_ndx;
- keyWire[k].colorNdx= key->color_ndx;
- if (swap) {
- swaps(&keyWire[k].gap);
- }
- }
- wire= (char *)&keyWire[row->num_keys];
- }
- }
- }
- if (section->doodads) {
- wire= XkbWriteGeomDoodads(wire,
- section->num_doodads,section->doodads,
- swap);
- }
- if (section->overlays) {
- register int o;
- for (o=0;o<section->num_overlays;o++) {
- wire= XkbWriteGeomOverlay(wire,&section->overlays[o],swap);
- }
- }
+ register int i;
+ XkbSectionPtr section;
+ xkbSectionWireDesc *sectionWire;
+
+ for (i = 0, section = geom->sections; i < geom->num_sections;
+ i++, section++) {
+ sectionWire = (xkbSectionWireDesc *) wire;
+ sectionWire->name = section->name;
+ sectionWire->top = section->top;
+ sectionWire->left = section->left;
+ sectionWire->width = section->width;
+ sectionWire->height = section->height;
+ sectionWire->angle = section->angle;
+ sectionWire->priority = section->priority;
+ sectionWire->nRows = section->num_rows;
+ sectionWire->nDoodads = section->num_doodads;
+ sectionWire->nOverlays = section->num_overlays;
+ sectionWire->pad = 0;
+ if (swap) {
+ swapl(&sectionWire->name);
+ swaps(&sectionWire->top);
+ swaps(&sectionWire->left);
+ swaps(&sectionWire->width);
+ swaps(&sectionWire->height);
+ swaps(&sectionWire->angle);
+ }
+ wire = (char *) &sectionWire[1];
+ if (section->rows) {
+ int r;
+ XkbRowPtr row;
+ xkbRowWireDesc *rowWire;
+
+ for (r = 0, row = section->rows; r < section->num_rows; r++, row++) {
+ rowWire = (xkbRowWireDesc *) wire;
+ rowWire->top = row->top;
+ rowWire->left = row->left;
+ rowWire->nKeys = row->num_keys;
+ rowWire->vertical = row->vertical;
+ rowWire->pad = 0;
+ if (swap) {
+ swaps(&rowWire->top);
+ swaps(&rowWire->left);
+ }
+ wire = (char *) &rowWire[1];
+ if (row->keys) {
+ int k;
+ XkbKeyPtr key;
+ xkbKeyWireDesc *keyWire;
+
+ keyWire = (xkbKeyWireDesc *) wire;
+ for (k = 0, key = row->keys; k < row->num_keys; k++, key++) {
+ memcpy(keyWire[k].name, key->name.name,
+ XkbKeyNameLength);
+ keyWire[k].gap = key->gap;
+ keyWire[k].shapeNdx = key->shape_ndx;
+ keyWire[k].colorNdx = key->color_ndx;
+ if (swap) {
+ swaps(&keyWire[k].gap);
+ }
+ }
+ wire = (char *) &keyWire[row->num_keys];
+ }
+ }
+ }
+ if (section->doodads) {
+ wire = XkbWriteGeomDoodads(wire,
+ section->num_doodads, section->doodads,
+ swap);
+ }
+ if (section->overlays) {
+ register int o;
+
+ for (o = 0; o < section->num_overlays; o++) {
+ wire = XkbWriteGeomOverlay(wire, &section->overlays[o], swap);
+ }
+ }
}
return wire;
}
static Status
-XkbComputeGetGeometryReplySize( XkbGeometryPtr geom,
- xkbGetGeometryReply * rep,
- Atom name)
+XkbComputeGetGeometryReplySize(XkbGeometryPtr geom,
+ xkbGetGeometryReply * rep, Atom name)
{
-int len;
-
- if (geom!=NULL) {
- len= XkbSizeCountedString(geom->label_font);
- len+= XkbSizeGeomProperties(geom);
- len+= XkbSizeGeomColors(geom);
- len+= XkbSizeGeomShapes(geom);
- len+= XkbSizeGeomSections(geom);
- len+= XkbSizeGeomDoodads(geom->num_doodads,geom->doodads);
- len+= XkbSizeGeomKeyAliases(geom);
- rep->length= len/4;
- rep->found= TRUE;
- rep->name= geom->name;
- rep->widthMM= geom->width_mm;
- rep->heightMM= geom->height_mm;
- rep->nProperties= geom->num_properties;
- rep->nColors= geom->num_colors;
- rep->nShapes= geom->num_shapes;
- rep->nSections= geom->num_sections;
- rep->nDoodads= geom->num_doodads;
- rep->nKeyAliases= geom->num_key_aliases;
- rep->baseColorNdx= XkbGeomColorIndex(geom,geom->base_color);
- rep->labelColorNdx= XkbGeomColorIndex(geom,geom->label_color);
+ int len;
+
+ if (geom != NULL) {
+ len = XkbSizeCountedString(geom->label_font);
+ len += XkbSizeGeomProperties(geom);
+ len += XkbSizeGeomColors(geom);
+ len += XkbSizeGeomShapes(geom);
+ len += XkbSizeGeomSections(geom);
+ len += XkbSizeGeomDoodads(geom->num_doodads, geom->doodads);
+ len += XkbSizeGeomKeyAliases(geom);
+ rep->length = len / 4;
+ rep->found = TRUE;
+ rep->name = geom->name;
+ rep->widthMM = geom->width_mm;
+ rep->heightMM = geom->height_mm;
+ rep->nProperties = geom->num_properties;
+ rep->nColors = geom->num_colors;
+ rep->nShapes = geom->num_shapes;
+ rep->nSections = geom->num_sections;
+ rep->nDoodads = geom->num_doodads;
+ rep->nKeyAliases = geom->num_key_aliases;
+ rep->baseColorNdx = XkbGeomColorIndex(geom, geom->base_color);
+ rep->labelColorNdx = XkbGeomColorIndex(geom, geom->label_color);
}
else {
- rep->length= 0;
- rep->found= FALSE;
- rep->name= name;
- rep->widthMM= rep->heightMM= 0;
- rep->nProperties= rep->nColors= rep->nShapes= 0;
- rep->nSections= rep->nDoodads= 0;
- rep->nKeyAliases= 0;
- rep->labelColorNdx= rep->baseColorNdx= 0;
+ rep->length = 0;
+ rep->found = FALSE;
+ rep->name = name;
+ rep->widthMM = rep->heightMM = 0;
+ rep->nProperties = rep->nColors = rep->nShapes = 0;
+ rep->nSections = rep->nDoodads = 0;
+ rep->nKeyAliases = 0;
+ rep->labelColorNdx = rep->baseColorNdx = 0;
}
return Success;
}
static int
-XkbSendGeometry( ClientPtr client,
- XkbGeometryPtr geom,
- xkbGetGeometryReply * rep,
- Bool freeGeom)
+XkbSendGeometry(ClientPtr client,
+ XkbGeometryPtr geom, xkbGetGeometryReply * rep, Bool freeGeom)
{
- char *desc,*start;
- int len;
-
- if (geom!=NULL) {
- len= rep->length*4;
- start= desc= malloc(len);
- if (!start)
- return BadAlloc;
- desc= XkbWriteCountedString(desc,geom->label_font,client->swapped);
- if ( rep->nProperties>0 )
- desc = XkbWriteGeomProperties(desc,geom,client->swapped);
- if ( rep->nColors>0 )
- desc = XkbWriteGeomColors(desc,geom,client->swapped);
- if ( rep->nShapes>0 )
- desc = XkbWriteGeomShapes(desc,geom,client->swapped);
- if ( rep->nSections>0 )
- desc = XkbWriteGeomSections(desc,geom,client->swapped);
- if ( rep->nDoodads>0 )
- desc = XkbWriteGeomDoodads(desc,geom->num_doodads,geom->doodads,
- client->swapped);
- if ( rep->nKeyAliases>0 )
- desc = XkbWriteGeomKeyAliases(desc,geom,client->swapped);
- if ((desc-start)!=(len)) {
- ErrorF("[xkb] BOGUS LENGTH in XkbSendGeometry, expected %d, got %ld\n",
- len, (unsigned long)(desc-start));
- }
+ char *desc, *start;
+ int len;
+
+ if (geom != NULL) {
+ len = rep->length * 4;
+ start = desc = malloc(len);
+ if (!start)
+ return BadAlloc;
+ desc = XkbWriteCountedString(desc, geom->label_font, client->swapped);
+ if (rep->nProperties > 0)
+ desc = XkbWriteGeomProperties(desc, geom, client->swapped);
+ if (rep->nColors > 0)
+ desc = XkbWriteGeomColors(desc, geom, client->swapped);
+ if (rep->nShapes > 0)
+ desc = XkbWriteGeomShapes(desc, geom, client->swapped);
+ if (rep->nSections > 0)
+ desc = XkbWriteGeomSections(desc, geom, client->swapped);
+ if (rep->nDoodads > 0)
+ desc = XkbWriteGeomDoodads(desc, geom->num_doodads, geom->doodads,
+ client->swapped);
+ if (rep->nKeyAliases > 0)
+ desc = XkbWriteGeomKeyAliases(desc, geom, client->swapped);
+ if ((desc - start) != (len)) {
+ ErrorF
+ ("[xkb] BOGUS LENGTH in XkbSendGeometry, expected %d, got %ld\n",
+ len, (unsigned long) (desc - start));
+ }
}
else {
- len= 0;
- start= NULL;
+ len = 0;
+ start = NULL;
}
if (client->swapped) {
- swaps(&rep->sequenceNumber);
- swapl(&rep->length);
- swapl(&rep->name);
- swaps(&rep->widthMM);
- swaps(&rep->heightMM);
- swaps(&rep->nProperties);
- swaps(&rep->nColors);
- swaps(&rep->nShapes);
- swaps(&rep->nSections);
- swaps(&rep->nDoodads);
- swaps(&rep->nKeyAliases);
- }
- WriteToClient(client, SIZEOF(xkbGetGeometryReply), (char *)rep);
- if (len>0)
- WriteToClient(client, len, start);
- if (start!=NULL)
- free((char *)start);
+ swaps(&rep->sequenceNumber);
+ swapl(&rep->length);
+ swapl(&rep->name);
+ swaps(&rep->widthMM);
+ swaps(&rep->heightMM);
+ swaps(&rep->nProperties);
+ swaps(&rep->nColors);
+ swaps(&rep->nShapes);
+ swaps(&rep->nSections);
+ swaps(&rep->nDoodads);
+ swaps(&rep->nKeyAliases);
+ }
+ WriteToClient(client, SIZEOF(xkbGetGeometryReply), (char *) rep);
+ if (len > 0)
+ WriteToClient(client, len, start);
+ if (start != NULL)
+ free((char *) start);
if (freeGeom)
- XkbFreeGeometry(geom,XkbGeomAllMask,TRUE);
+ XkbFreeGeometry(geom, XkbGeomAllMask, TRUE);
return Success;
}
int
ProcXkbGetGeometry(ClientPtr client)
{
- DeviceIntPtr dev;
+ DeviceIntPtr dev;
xkbGetGeometryReply rep;
- XkbGeometryPtr geom;
- Bool shouldFree;
- Status status;
+ XkbGeometryPtr geom;
+ Bool shouldFree;
+ Status status;
REQUEST(xkbGetGeometryReq);
REQUEST_SIZE_MATCH(xkbGetGeometryReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess);
CHK_ATOM_OR_NONE(stuff->name);
- geom= XkbLookupNamedGeometry(dev,stuff->name,&shouldFree);
- rep.type= X_Reply;
- rep.deviceID= dev->id;
- rep.sequenceNumber= client->sequence;
- rep.length= 0;
- status= XkbComputeGetGeometryReplySize(geom,&rep,stuff->name);
- if (status!=Success)
- return status;
- else return XkbSendGeometry(client,geom,&rep,shouldFree);
+ geom = XkbLookupNamedGeometry(dev, stuff->name, &shouldFree);
+ rep.type = X_Reply;
+ rep.deviceID = dev->id;
+ rep.sequenceNumber = client->sequence;
+ rep.length = 0;
+ status = XkbComputeGetGeometryReplySize(geom, &rep, stuff->name);
+ if (status != Success)
+ return status;
+ else
+ return XkbSendGeometry(client, geom, &rep, shouldFree);
}
/***====================================================================***/
static char *
-_GetCountedString(char **wire_inout,Bool swap)
+_GetCountedString(char **wire_inout, Bool swap)
{
-char * wire,*str;
-CARD16 len,*plen;
+ char *wire, *str;
+ CARD16 len, *plen;
- wire= *wire_inout;
- plen= (CARD16 *)wire;
+ wire = *wire_inout;
+ plen = (CARD16 *) wire;
if (swap) {
- swaps(plen);
+ swaps(plen);
}
- len= *plen;
- str= malloc(len+1);
+ len = *plen;
+ str = malloc(len + 1);
if (str) {
- memcpy(str,&wire[2],len);
- str[len]= '\0';
+ memcpy(str, &wire[2], len);
+ str[len] = '\0';
}
- wire+= XkbPaddedSize(len+2);
- *wire_inout= wire;
+ wire += XkbPaddedSize(len + 2);
+ *wire_inout = wire;
return str;
}
static Status
-_CheckSetDoodad( char ** wire_inout,
- XkbGeometryPtr geom,
- XkbSectionPtr section,
- ClientPtr client)
+_CheckSetDoodad(char **wire_inout,
+ XkbGeometryPtr geom, XkbSectionPtr section, ClientPtr client)
{
-char * wire;
-xkbDoodadWireDesc * dWire;
-XkbDoodadPtr doodad;
+ char *wire;
+ xkbDoodadWireDesc *dWire;
+ XkbDoodadPtr doodad;
- dWire= (xkbDoodadWireDesc *)(*wire_inout);
- wire= (char *)&dWire[1];
+ dWire = (xkbDoodadWireDesc *) (*wire_inout);
+ wire = (char *) &dWire[1];
if (client->swapped) {
- swapl(&dWire->any.name);
- swaps(&dWire->any.top);
- swaps(&dWire->any.left);
- swaps(&dWire->any.angle);
+ swapl(&dWire->any.name);
+ swaps(&dWire->any.top);
+ swaps(&dWire->any.left);
+ swaps(&dWire->any.angle);
}
CHK_ATOM_ONLY(dWire->any.name);
- doodad= XkbAddGeomDoodad(geom,section,dWire->any.name);
+ doodad = XkbAddGeomDoodad(geom, section, dWire->any.name);
if (!doodad)
- return BadAlloc;
- doodad->any.type= dWire->any.type;
- doodad->any.priority= dWire->any.priority;
- doodad->any.top= dWire->any.top;
- doodad->any.left= dWire->any.left;
- doodad->any.angle= dWire->any.angle;
+ return BadAlloc;
+ doodad->any.type = dWire->any.type;
+ doodad->any.priority = dWire->any.priority;
+ doodad->any.top = dWire->any.top;
+ doodad->any.left = dWire->any.left;
+ doodad->any.angle = dWire->any.angle;
switch (doodad->any.type) {
- case XkbOutlineDoodad:
- case XkbSolidDoodad:
- if (dWire->shape.colorNdx>=geom->num_colors) {
- client->errorValue= _XkbErrCode3(0x40,geom->num_colors,
- dWire->shape.colorNdx);
- return BadMatch;
- }
- if (dWire->shape.shapeNdx>=geom->num_shapes) {
- client->errorValue= _XkbErrCode3(0x41,geom->num_shapes,
- dWire->shape.shapeNdx);
- return BadMatch;
- }
- doodad->shape.color_ndx= dWire->shape.colorNdx;
- doodad->shape.shape_ndx= dWire->shape.shapeNdx;
- break;
- case XkbTextDoodad:
- if (dWire->text.colorNdx>=geom->num_colors) {
- client->errorValue= _XkbErrCode3(0x42,geom->num_colors,
- dWire->text.colorNdx);
- return BadMatch;
- }
- if (client->swapped) {
- swaps(&dWire->text.width);
- swaps(&dWire->text.height);
- }
- doodad->text.width= dWire->text.width;
- doodad->text.height= dWire->text.height;
- doodad->text.color_ndx= dWire->text.colorNdx;
- doodad->text.text= _GetCountedString(&wire,client->swapped);
- doodad->text.font= _GetCountedString(&wire,client->swapped);
- break;
- case XkbIndicatorDoodad:
- if (dWire->indicator.onColorNdx>=geom->num_colors) {
- client->errorValue= _XkbErrCode3(0x43,geom->num_colors,
- dWire->indicator.onColorNdx);
- return BadMatch;
- }
- if (dWire->indicator.offColorNdx>=geom->num_colors) {
- client->errorValue= _XkbErrCode3(0x44,geom->num_colors,
- dWire->indicator.offColorNdx);
- return BadMatch;
- }
- if (dWire->indicator.shapeNdx>=geom->num_shapes) {
- client->errorValue= _XkbErrCode3(0x45,geom->num_shapes,
- dWire->indicator.shapeNdx);
- return BadMatch;
- }
- doodad->indicator.shape_ndx= dWire->indicator.shapeNdx;
- doodad->indicator.on_color_ndx= dWire->indicator.onColorNdx;
- doodad->indicator.off_color_ndx= dWire->indicator.offColorNdx;
- break;
- case XkbLogoDoodad:
- if (dWire->logo.colorNdx>=geom->num_colors) {
- client->errorValue= _XkbErrCode3(0x46,geom->num_colors,
- dWire->logo.colorNdx);
- return BadMatch;
- }
- if (dWire->logo.shapeNdx>=geom->num_shapes) {
- client->errorValue= _XkbErrCode3(0x47,geom->num_shapes,
- dWire->logo.shapeNdx);
- return BadMatch;
- }
- doodad->logo.color_ndx= dWire->logo.colorNdx;
- doodad->logo.shape_ndx= dWire->logo.shapeNdx;
- doodad->logo.logo_name= _GetCountedString(&wire,client->swapped);
- break;
- default:
- client->errorValue= _XkbErrCode2(0x4F,dWire->any.type);
- return BadValue;
- }
- *wire_inout= wire;
+ case XkbOutlineDoodad:
+ case XkbSolidDoodad:
+ if (dWire->shape.colorNdx >= geom->num_colors) {
+ client->errorValue = _XkbErrCode3(0x40, geom->num_colors,
+ dWire->shape.colorNdx);
+ return BadMatch;
+ }
+ if (dWire->shape.shapeNdx >= geom->num_shapes) {
+ client->errorValue = _XkbErrCode3(0x41, geom->num_shapes,
+ dWire->shape.shapeNdx);
+ return BadMatch;
+ }
+ doodad->shape.color_ndx = dWire->shape.colorNdx;
+ doodad->shape.shape_ndx = dWire->shape.shapeNdx;
+ break;
+ case XkbTextDoodad:
+ if (dWire->text.colorNdx >= geom->num_colors) {
+ client->errorValue = _XkbErrCode3(0x42, geom->num_colors,
+ dWire->text.colorNdx);
+ return BadMatch;
+ }
+ if (client->swapped) {
+ swaps(&dWire->text.width);
+ swaps(&dWire->text.height);
+ }
+ doodad->text.width = dWire->text.width;
+ doodad->text.height = dWire->text.height;
+ doodad->text.color_ndx = dWire->text.colorNdx;
+ doodad->text.text = _GetCountedString(&wire, client->swapped);
+ doodad->text.font = _GetCountedString(&wire, client->swapped);
+ break;
+ case XkbIndicatorDoodad:
+ if (dWire->indicator.onColorNdx >= geom->num_colors) {
+ client->errorValue = _XkbErrCode3(0x43, geom->num_colors,
+ dWire->indicator.onColorNdx);
+ return BadMatch;
+ }
+ if (dWire->indicator.offColorNdx >= geom->num_colors) {
+ client->errorValue = _XkbErrCode3(0x44, geom->num_colors,
+ dWire->indicator.offColorNdx);
+ return BadMatch;
+ }
+ if (dWire->indicator.shapeNdx >= geom->num_shapes) {
+ client->errorValue = _XkbErrCode3(0x45, geom->num_shapes,
+ dWire->indicator.shapeNdx);
+ return BadMatch;
+ }
+ doodad->indicator.shape_ndx = dWire->indicator.shapeNdx;
+ doodad->indicator.on_color_ndx = dWire->indicator.onColorNdx;
+ doodad->indicator.off_color_ndx = dWire->indicator.offColorNdx;
+ break;
+ case XkbLogoDoodad:
+ if (dWire->logo.colorNdx >= geom->num_colors) {
+ client->errorValue = _XkbErrCode3(0x46, geom->num_colors,
+ dWire->logo.colorNdx);
+ return BadMatch;
+ }
+ if (dWire->logo.shapeNdx >= geom->num_shapes) {
+ client->errorValue = _XkbErrCode3(0x47, geom->num_shapes,
+ dWire->logo.shapeNdx);
+ return BadMatch;
+ }
+ doodad->logo.color_ndx = dWire->logo.colorNdx;
+ doodad->logo.shape_ndx = dWire->logo.shapeNdx;
+ doodad->logo.logo_name = _GetCountedString(&wire, client->swapped);
+ break;
+ default:
+ client->errorValue = _XkbErrCode2(0x4F, dWire->any.type);
+ return BadValue;
+ }
+ *wire_inout = wire;
return Success;
}
static Status
-_CheckSetOverlay( char ** wire_inout,
- XkbGeometryPtr geom,
- XkbSectionPtr section,
- ClientPtr client)
+_CheckSetOverlay(char **wire_inout,
+ XkbGeometryPtr geom, XkbSectionPtr section, ClientPtr client)
{
-register int r;
-char * wire;
-XkbOverlayPtr ol;
-xkbOverlayWireDesc * olWire;
-xkbOverlayRowWireDesc * rWire;
-
- wire= *wire_inout;
- olWire= (xkbOverlayWireDesc *)wire;
+ register int r;
+ char *wire;
+ XkbOverlayPtr ol;
+ xkbOverlayWireDesc *olWire;
+ xkbOverlayRowWireDesc *rWire;
+
+ wire = *wire_inout;
+ olWire = (xkbOverlayWireDesc *) wire;
if (client->swapped) {
- swapl(&olWire->name);
+ swapl(&olWire->name);
}
CHK_ATOM_ONLY(olWire->name);
- ol= XkbAddGeomOverlay(section,olWire->name,olWire->nRows);
- rWire= (xkbOverlayRowWireDesc *)&olWire[1];
- for (r=0;r<olWire->nRows;r++) {
- register int k;
- xkbOverlayKeyWireDesc * kWire;
- XkbOverlayRowPtr row;
-
- if (rWire->rowUnder>section->num_rows) {
- client->errorValue= _XkbErrCode4(0x20,r,section->num_rows,
- rWire->rowUnder);
- return BadMatch;
- }
- row= XkbAddGeomOverlayRow(ol,rWire->rowUnder,rWire->nKeys);
- kWire= (xkbOverlayKeyWireDesc *)&rWire[1];
- for (k=0;k<rWire->nKeys;k++,kWire++) {
- if (XkbAddGeomOverlayKey(ol,row,
- (char *)kWire->over,(char *)kWire->under)==NULL) {
- client->errorValue= _XkbErrCode3(0x21,r,k);
- return BadMatch;
- }
- }
- rWire= (xkbOverlayRowWireDesc *)kWire;
- }
- olWire= (xkbOverlayWireDesc *)rWire;
- wire= (char *)olWire;
- *wire_inout= wire;
+ ol = XkbAddGeomOverlay(section, olWire->name, olWire->nRows);
+ rWire = (xkbOverlayRowWireDesc *) & olWire[1];
+ for (r = 0; r < olWire->nRows; r++) {
+ register int k;
+ xkbOverlayKeyWireDesc *kWire;
+ XkbOverlayRowPtr row;
+
+ if (rWire->rowUnder > section->num_rows) {
+ client->errorValue = _XkbErrCode4(0x20, r, section->num_rows,
+ rWire->rowUnder);
+ return BadMatch;
+ }
+ row = XkbAddGeomOverlayRow(ol, rWire->rowUnder, rWire->nKeys);
+ kWire = (xkbOverlayKeyWireDesc *) & rWire[1];
+ for (k = 0; k < rWire->nKeys; k++, kWire++) {
+ if (XkbAddGeomOverlayKey(ol, row,
+ (char *) kWire->over,
+ (char *) kWire->under) == NULL) {
+ client->errorValue = _XkbErrCode3(0x21, r, k);
+ return BadMatch;
+ }
+ }
+ rWire = (xkbOverlayRowWireDesc *) kWire;
+ }
+ olWire = (xkbOverlayWireDesc *) rWire;
+ wire = (char *) olWire;
+ *wire_inout = wire;
return Success;
}
static Status
-_CheckSetSections( XkbGeometryPtr geom,
- xkbSetGeometryReq * req,
- char ** wire_inout,
- ClientPtr client)
+_CheckSetSections(XkbGeometryPtr geom,
+ xkbSetGeometryReq * req, char **wire_inout, ClientPtr client)
{
-Status status;
-register int s;
-char * wire;
-xkbSectionWireDesc * sWire;
-XkbSectionPtr section;
-
- wire= *wire_inout;
- if (req->nSections<1)
- return Success;
- sWire= (xkbSectionWireDesc *)wire;
- for (s=0;s<req->nSections;s++) {
- register int r;
- xkbRowWireDesc * rWire;
- if (client->swapped) {
- swapl(&sWire->name);
- swaps(&sWire->top);
- swaps(&sWire->left);
- swaps(&sWire->width);
- swaps(&sWire->height);
- swaps(&sWire->angle);
- }
- CHK_ATOM_ONLY(sWire->name);
- section= XkbAddGeomSection(geom,sWire->name,sWire->nRows,
- sWire->nDoodads,sWire->nOverlays);
- if (!section)
- return BadAlloc;
- section->priority= sWire->priority;
- section->top= sWire->top;
- section->left= sWire->left;
- section->width= sWire->width;
- section->height= sWire->height;
- section->angle= sWire->angle;
- rWire= (xkbRowWireDesc *)&sWire[1];
- for (r=0;r<sWire->nRows;r++) {
- register int k;
- XkbRowPtr row;
- xkbKeyWireDesc * kWire;
- if (client->swapped) {
- swaps(&rWire->top);
- swaps(&rWire->left);
- }
- row= XkbAddGeomRow(section,rWire->nKeys);
- if (!row)
- return BadAlloc;
- row->top= rWire->top;
- row->left= rWire->left;
- row->vertical= rWire->vertical;
- kWire= (xkbKeyWireDesc *)&rWire[1];
- for (k=0;k<rWire->nKeys;k++) {
- XkbKeyPtr key;
- key= XkbAddGeomKey(row);
- if (!key)
- return BadAlloc;
- memcpy(key->name.name,kWire[k].name,XkbKeyNameLength);
- key->gap= kWire[k].gap;
- key->shape_ndx= kWire[k].shapeNdx;
- key->color_ndx= kWire[k].colorNdx;
- if (key->shape_ndx>=geom->num_shapes) {
- client->errorValue= _XkbErrCode3(0x10,key->shape_ndx,
- geom->num_shapes);
- return BadMatch;
- }
- if (key->color_ndx>=geom->num_colors) {
- client->errorValue= _XkbErrCode3(0x11,key->color_ndx,
- geom->num_colors);
- return BadMatch;
- }
- }
- rWire= (xkbRowWireDesc *)&kWire[rWire->nKeys];
- }
- wire= (char *)rWire;
- if (sWire->nDoodads>0) {
- register int d;
- for (d=0;d<sWire->nDoodads;d++) {
- status=_CheckSetDoodad(&wire,geom,section,client);
- if (status!=Success)
- return status;
- }
- }
- if (sWire->nOverlays>0) {
- register int o;
- for (o=0;o<sWire->nOverlays;o++) {
- status= _CheckSetOverlay(&wire,geom,section,client);
- if (status!=Success)
- return status;
- }
- }
- sWire= (xkbSectionWireDesc *)wire;
- }
- wire= (char *)sWire;
- *wire_inout= wire;
+ Status status;
+ register int s;
+ char *wire;
+ xkbSectionWireDesc *sWire;
+ XkbSectionPtr section;
+
+ wire = *wire_inout;
+ if (req->nSections < 1)
+ return Success;
+ sWire = (xkbSectionWireDesc *) wire;
+ for (s = 0; s < req->nSections; s++) {
+ register int r;
+ xkbRowWireDesc *rWire;
+
+ if (client->swapped) {
+ swapl(&sWire->name);
+ swaps(&sWire->top);
+ swaps(&sWire->left);
+ swaps(&sWire->width);
+ swaps(&sWire->height);
+ swaps(&sWire->angle);
+ }
+ CHK_ATOM_ONLY(sWire->name);
+ section = XkbAddGeomSection(geom, sWire->name, sWire->nRows,
+ sWire->nDoodads, sWire->nOverlays);
+ if (!section)
+ return BadAlloc;
+ section->priority = sWire->priority;
+ section->top = sWire->top;
+ section->left = sWire->left;
+ section->width = sWire->width;
+ section->height = sWire->height;
+ section->angle = sWire->angle;
+ rWire = (xkbRowWireDesc *) & sWire[1];
+ for (r = 0; r < sWire->nRows; r++) {
+ register int k;
+ XkbRowPtr row;
+ xkbKeyWireDesc *kWire;
+
+ if (client->swapped) {
+ swaps(&rWire->top);
+ swaps(&rWire->left);
+ }
+ row = XkbAddGeomRow(section, rWire->nKeys);
+ if (!row)
+ return BadAlloc;
+ row->top = rWire->top;
+ row->left = rWire->left;
+ row->vertical = rWire->vertical;
+ kWire = (xkbKeyWireDesc *) & rWire[1];
+ for (k = 0; k < rWire->nKeys; k++) {
+ XkbKeyPtr key;
+
+ key = XkbAddGeomKey(row);
+ if (!key)
+ return BadAlloc;
+ memcpy(key->name.name, kWire[k].name, XkbKeyNameLength);
+ key->gap = kWire[k].gap;
+ key->shape_ndx = kWire[k].shapeNdx;
+ key->color_ndx = kWire[k].colorNdx;
+ if (key->shape_ndx >= geom->num_shapes) {
+ client->errorValue = _XkbErrCode3(0x10, key->shape_ndx,
+ geom->num_shapes);
+ return BadMatch;
+ }
+ if (key->color_ndx >= geom->num_colors) {
+ client->errorValue = _XkbErrCode3(0x11, key->color_ndx,
+ geom->num_colors);
+ return BadMatch;
+ }
+ }
+ rWire = (xkbRowWireDesc *) & kWire[rWire->nKeys];
+ }
+ wire = (char *) rWire;
+ if (sWire->nDoodads > 0) {
+ register int d;
+
+ for (d = 0; d < sWire->nDoodads; d++) {
+ status = _CheckSetDoodad(&wire, geom, section, client);
+ if (status != Success)
+ return status;
+ }
+ }
+ if (sWire->nOverlays > 0) {
+ register int o;
+
+ for (o = 0; o < sWire->nOverlays; o++) {
+ status = _CheckSetOverlay(&wire, geom, section, client);
+ if (status != Success)
+ return status;
+ }
+ }
+ sWire = (xkbSectionWireDesc *) wire;
+ }
+ wire = (char *) sWire;
+ *wire_inout = wire;
return Success;
}
static Status
-_CheckSetShapes( XkbGeometryPtr geom,
- xkbSetGeometryReq * req,
- char ** wire_inout,
- ClientPtr client)
+_CheckSetShapes(XkbGeometryPtr geom,
+ xkbSetGeometryReq * req, char **wire_inout, ClientPtr client)
{
-register int i;
-char * wire;
+ register int i;
+ char *wire;
- wire= *wire_inout;
- if (req->nShapes<1) {
- client->errorValue= _XkbErrCode2(0x06,req->nShapes);
- return BadValue;
+ wire = *wire_inout;
+ if (req->nShapes < 1) {
+ client->errorValue = _XkbErrCode2(0x06, req->nShapes);
+ return BadValue;
}
else {
- xkbShapeWireDesc * shapeWire;
- XkbShapePtr shape;
- register int o;
- shapeWire= (xkbShapeWireDesc *)wire;
- for (i=0;i<req->nShapes;i++) {
- xkbOutlineWireDesc * olWire;
- XkbOutlinePtr ol;
- shape= XkbAddGeomShape(geom,shapeWire->name,shapeWire->nOutlines);
- if (!shape)
- return BadAlloc;
- olWire= (xkbOutlineWireDesc *)(&shapeWire[1]);
- for (o=0;o<shapeWire->nOutlines;o++) {
- register int p;
- XkbPointPtr pt;
- xkbPointWireDesc * ptWire;
-
- ol= XkbAddGeomOutline(shape,olWire->nPoints);
- if (!ol)
- return BadAlloc;
- ol->corner_radius= olWire->cornerRadius;
- ptWire= (xkbPointWireDesc *)&olWire[1];
- for (p=0,pt=ol->points;p<olWire->nPoints;p++,pt++) {
- pt->x= ptWire[p].x;
- pt->y= ptWire[p].y;
- if (client->swapped) {
- swaps(&pt->x);
- swaps(&pt->y);
- }
- }
- ol->num_points= olWire->nPoints;
- olWire= (xkbOutlineWireDesc *)(&ptWire[olWire->nPoints]);
- }
- if (shapeWire->primaryNdx!=XkbNoShape)
- shape->primary= &shape->outlines[shapeWire->primaryNdx];
- if (shapeWire->approxNdx!=XkbNoShape)
- shape->approx= &shape->outlines[shapeWire->approxNdx];
- shapeWire= (xkbShapeWireDesc *)olWire;
- }
- wire= (char *)shapeWire;
- }
- if (geom->num_shapes!=req->nShapes) {
- client->errorValue= _XkbErrCode3(0x07,geom->num_shapes,req->nShapes);
- return BadMatch;
- }
-
- *wire_inout= wire;
+ xkbShapeWireDesc *shapeWire;
+ XkbShapePtr shape;
+ register int o;
+
+ shapeWire = (xkbShapeWireDesc *) wire;
+ for (i = 0; i < req->nShapes; i++) {
+ xkbOutlineWireDesc *olWire;
+ XkbOutlinePtr ol;
+
+ shape =
+ XkbAddGeomShape(geom, shapeWire->name, shapeWire->nOutlines);
+ if (!shape)
+ return BadAlloc;
+ olWire = (xkbOutlineWireDesc *) (&shapeWire[1]);
+ for (o = 0; o < shapeWire->nOutlines; o++) {
+ register int p;
+ XkbPointPtr pt;
+ xkbPointWireDesc *ptWire;
+
+ ol = XkbAddGeomOutline(shape, olWire->nPoints);
+ if (!ol)
+ return BadAlloc;
+ ol->corner_radius = olWire->cornerRadius;
+ ptWire = (xkbPointWireDesc *) & olWire[1];
+ for (p = 0, pt = ol->points; p < olWire->nPoints; p++, pt++) {
+ pt->x = ptWire[p].x;
+ pt->y = ptWire[p].y;
+ if (client->swapped) {
+ swaps(&pt->x);
+ swaps(&pt->y);
+ }
+ }
+ ol->num_points = olWire->nPoints;
+ olWire = (xkbOutlineWireDesc *) (&ptWire[olWire->nPoints]);
+ }
+ if (shapeWire->primaryNdx != XkbNoShape)
+ shape->primary = &shape->outlines[shapeWire->primaryNdx];
+ if (shapeWire->approxNdx != XkbNoShape)
+ shape->approx = &shape->outlines[shapeWire->approxNdx];
+ shapeWire = (xkbShapeWireDesc *) olWire;
+ }
+ wire = (char *) shapeWire;
+ }
+ if (geom->num_shapes != req->nShapes) {
+ client->errorValue = _XkbErrCode3(0x07, geom->num_shapes, req->nShapes);
+ return BadMatch;
+ }
+
+ *wire_inout = wire;
return Success;
}
static Status
-_CheckSetGeom( XkbGeometryPtr geom,
- xkbSetGeometryReq * req,
- ClientPtr client)
+_CheckSetGeom(XkbGeometryPtr geom, xkbSetGeometryReq * req, ClientPtr client)
{
-register int i;
-Status status;
-char * wire;
+ register int i;
+ Status status;
+ char *wire;
+
+ wire = (char *) &req[1];
+ geom->label_font = _GetCountedString(&wire, client->swapped);
- wire= (char *)&req[1];
- geom->label_font= _GetCountedString(&wire,client->swapped);
+ for (i = 0; i < req->nProperties; i++) {
+ char *name, *val;
- for (i=0;i<req->nProperties;i++) {
- char *name,*val;
- name= _GetCountedString(&wire,client->swapped);
+ name = _GetCountedString(&wire, client->swapped);
if (!name)
return BadAlloc;
- val= _GetCountedString(&wire,client->swapped);
+ val = _GetCountedString(&wire, client->swapped);
if (!val) {
free(name);
return BadAlloc;
}
- if (XkbAddGeomProperty(geom,name,val)==NULL) {
+ if (XkbAddGeomProperty(geom, name, val) == NULL) {
free(name);
free(val);
- return BadAlloc;
+ return BadAlloc;
}
free(name);
free(val);
}
- if (req->nColors<2) {
- client->errorValue= _XkbErrCode3(0x01,2,req->nColors);
- return BadValue;
+ if (req->nColors < 2) {
+ client->errorValue = _XkbErrCode3(0x01, 2, req->nColors);
+ return BadValue;
}
- if (req->baseColorNdx>req->nColors) {
- client->errorValue=_XkbErrCode3(0x03,req->nColors,req->baseColorNdx);
- return BadMatch;
+ if (req->baseColorNdx > req->nColors) {
+ client->errorValue =
+ _XkbErrCode3(0x03, req->nColors, req->baseColorNdx);
+ return BadMatch;
}
- if (req->labelColorNdx>req->nColors) {
- client->errorValue= _XkbErrCode3(0x03,req->nColors,req->labelColorNdx);
- return BadMatch;
+ if (req->labelColorNdx > req->nColors) {
+ client->errorValue =
+ _XkbErrCode3(0x03, req->nColors, req->labelColorNdx);
+ return BadMatch;
}
- if (req->labelColorNdx==req->baseColorNdx) {
- client->errorValue= _XkbErrCode3(0x04,req->baseColorNdx,
- req->labelColorNdx);
- return BadMatch;
+ if (req->labelColorNdx == req->baseColorNdx) {
+ client->errorValue = _XkbErrCode3(0x04, req->baseColorNdx,
+ req->labelColorNdx);
+ return BadMatch;
}
- for (i=0;i<req->nColors;i++) {
- char *name;
- name= _GetCountedString(&wire,client->swapped);
- if (!name)
+ for (i = 0; i < req->nColors; i++) {
+ char *name;
+
+ name = _GetCountedString(&wire, client->swapped);
+ if (!name)
return BadAlloc;
- if (!XkbAddGeomColor(geom,name,geom->num_colors)) {
+ if (!XkbAddGeomColor(geom, name, geom->num_colors)) {
free(name);
- return BadAlloc;
+ return BadAlloc;
}
free(name);
}
- if (req->nColors!=geom->num_colors) {
- client->errorValue= _XkbErrCode3(0x05,req->nColors,geom->num_colors);
- return BadMatch;
+ if (req->nColors != geom->num_colors) {
+ client->errorValue = _XkbErrCode3(0x05, req->nColors, geom->num_colors);
+ return BadMatch;
}
- geom->label_color= &geom->colors[req->labelColorNdx];
- geom->base_color= &geom->colors[req->baseColorNdx];
+ geom->label_color = &geom->colors[req->labelColorNdx];
+ geom->base_color = &geom->colors[req->baseColorNdx];
- if ((status=_CheckSetShapes(geom,req,&wire,client))!=Success)
- return status;
+ if ((status = _CheckSetShapes(geom, req, &wire, client)) != Success)
+ return status;
- if ((status=_CheckSetSections(geom,req,&wire,client))!=Success)
- return status;
+ if ((status = _CheckSetSections(geom, req, &wire, client)) != Success)
+ return status;
- for (i=0;i<req->nDoodads;i++) {
- status=_CheckSetDoodad(&wire,geom,NULL,client);
- if (status!=Success)
- return status;
+ for (i = 0; i < req->nDoodads; i++) {
+ status = _CheckSetDoodad(&wire, geom, NULL, client);
+ if (status != Success)
+ return status;
}
- for (i=0;i<req->nKeyAliases;i++) {
- if (XkbAddGeomKeyAlias(geom,&wire[XkbKeyNameLength],wire)==NULL)
- return BadAlloc;
- wire+= 2*XkbKeyNameLength;
+ for (i = 0; i < req->nKeyAliases; i++) {
+ if (XkbAddGeomKeyAlias(geom, &wire[XkbKeyNameLength], wire) == NULL)
+ return BadAlloc;
+ wire += 2 * XkbKeyNameLength;
}
return Success;
}
static int
-_XkbSetGeometry(ClientPtr client, DeviceIntPtr dev, xkbSetGeometryReq *stuff)
+_XkbSetGeometry(ClientPtr client, DeviceIntPtr dev, xkbSetGeometryReq * stuff)
{
- XkbDescPtr xkb;
- Bool new_name;
- xkbNewKeyboardNotify nkn;
- XkbGeometryPtr geom,old;
- XkbGeometrySizesRec sizes;
- Status status;
-
- xkb= dev->key->xkbInfo->desc;
- old= xkb->geom;
- xkb->geom= NULL;
-
- sizes.which= XkbGeomAllMask;
- sizes.num_properties= stuff->nProperties;
- sizes.num_colors= stuff->nColors;
- sizes.num_shapes= stuff->nShapes;
- sizes.num_sections= stuff->nSections;
- sizes.num_doodads= stuff->nDoodads;
- sizes.num_key_aliases= stuff->nKeyAliases;
- if ((status= XkbAllocGeometry(xkb,&sizes))!=Success) {
- xkb->geom= old;
+ XkbDescPtr xkb;
+ Bool new_name;
+ xkbNewKeyboardNotify nkn;
+ XkbGeometryPtr geom, old;
+ XkbGeometrySizesRec sizes;
+ Status status;
+
+ xkb = dev->key->xkbInfo->desc;
+ old = xkb->geom;
+ xkb->geom = NULL;
+
+ sizes.which = XkbGeomAllMask;
+ sizes.num_properties = stuff->nProperties;
+ sizes.num_colors = stuff->nColors;
+ sizes.num_shapes = stuff->nShapes;
+ sizes.num_sections = stuff->nSections;
+ sizes.num_doodads = stuff->nDoodads;
+ sizes.num_key_aliases = stuff->nKeyAliases;
+ if ((status = XkbAllocGeometry(xkb, &sizes)) != Success) {
+ xkb->geom = old;
return status;
}
- geom= xkb->geom;
- geom->name= stuff->name;
- geom->width_mm= stuff->widthMM;
- geom->height_mm= stuff->heightMM;
- if ((status= _CheckSetGeom(geom,stuff,client))!=Success) {
- XkbFreeGeometry(geom,XkbGeomAllMask,TRUE);
- xkb->geom= old;
+ geom = xkb->geom;
+ geom->name = stuff->name;
+ geom->width_mm = stuff->widthMM;
+ geom->height_mm = stuff->heightMM;
+ if ((status = _CheckSetGeom(geom, stuff, client)) != Success) {
+ XkbFreeGeometry(geom, XkbGeomAllMask, TRUE);
+ xkb->geom = old;
return status;
}
- new_name= (xkb->names->geometry!=geom->name);
- xkb->names->geometry= geom->name;
+ new_name = (xkb->names->geometry != geom->name);
+ xkb->names->geometry = geom->name;
if (old)
- XkbFreeGeometry(old,XkbGeomAllMask,TRUE);
+ XkbFreeGeometry(old, XkbGeomAllMask, TRUE);
if (new_name) {
- xkbNamesNotify nn;
+ xkbNamesNotify nn;
+
memset(&nn, 0, sizeof(xkbNamesNotify));
- nn.changed= XkbGeometryNameMask;
- XkbSendNamesNotify(dev,&nn);
- }
- nkn.deviceID= nkn.oldDeviceID= dev->id;
- nkn.minKeyCode= nkn.oldMinKeyCode= xkb->min_key_code;
- nkn.maxKeyCode= nkn.oldMaxKeyCode= xkb->max_key_code;
- nkn.requestMajor= XkbReqCode;
- nkn.requestMinor= X_kbSetGeometry;
- nkn.changed= XkbNKN_GeometryMask;
- XkbSendNewKeyboardNotify(dev,&nkn);
+ nn.changed = XkbGeometryNameMask;
+ XkbSendNamesNotify(dev, &nn);
+ }
+ nkn.deviceID = nkn.oldDeviceID = dev->id;
+ nkn.minKeyCode = nkn.oldMinKeyCode = xkb->min_key_code;
+ nkn.maxKeyCode = nkn.oldMaxKeyCode = xkb->max_key_code;
+ nkn.requestMajor = XkbReqCode;
+ nkn.requestMinor = X_kbSetGeometry;
+ nkn.changed = XkbNKN_GeometryMask;
+ XkbSendNewKeyboardNotify(dev, &nkn);
return Success;
}
int
ProcXkbSetGeometry(ClientPtr client)
{
- DeviceIntPtr dev;
- int rc;
+ DeviceIntPtr dev;
+ int rc;
REQUEST(xkbSetGeometryReq);
REQUEST_AT_LEAST_SIZE(xkbSetGeometryReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixManageAccess);
CHK_ATOM_OR_NONE(stuff->name);
@@ -5327,14 +5445,14 @@ ProcXkbSetGeometry(ClientPtr client)
if (rc != Success)
return rc;
- if (stuff->deviceSpec == XkbUseCoreKbd)
- {
+ if (stuff->deviceSpec == XkbUseCoreKbd) {
DeviceIntPtr other;
- for (other = inputInfo.devices; other; other = other->next)
- {
- if ((other != dev) && other->key && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev)
- {
- rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixManageAccess);
+
+ for (other = inputInfo.devices; other; other = other->next) {
+ if ((other != dev) && other->key && !IsMaster(other) &&
+ GetMaster(other, MASTER_KEYBOARD) == dev) {
+ rc = XaceHook(XACE_DEVICE_ACCESS, client, other,
+ DixManageAccess);
if (rc == Success)
_XkbSetGeometry(client, other, stuff);
}
@@ -5349,75 +5467,78 @@ ProcXkbSetGeometry(ClientPtr client)
int
ProcXkbPerClientFlags(ClientPtr client)
{
- DeviceIntPtr dev;
- xkbPerClientFlagsReply rep;
- XkbInterestPtr interest;
+ DeviceIntPtr dev;
+ xkbPerClientFlagsReply rep;
+ XkbInterestPtr interest;
Mask access_mode = DixGetAttrAccess | DixSetAttrAccess;
REQUEST(xkbPerClientFlagsReq);
REQUEST_SIZE_MATCH(xkbPerClientFlagsReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, access_mode);
- CHK_MASK_LEGAL(0x01,stuff->change,XkbPCF_AllFlagsMask);
- CHK_MASK_MATCH(0x02,stuff->change,stuff->value);
+ CHK_MASK_LEGAL(0x01, stuff->change, XkbPCF_AllFlagsMask);
+ CHK_MASK_MATCH(0x02, stuff->change, stuff->value);
- interest = XkbFindClientResource((DevicePtr)dev,client);
+ interest = XkbFindClientResource((DevicePtr) dev, client);
memset(&rep, 0, sizeof(xkbPerClientFlagsReply));
- rep.type= X_Reply;
+ rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
if (stuff->change) {
- client->xkbClientFlags&= ~stuff->change;
- client->xkbClientFlags|= stuff->value;
- }
- if (stuff->change&XkbPCF_AutoResetControlsMask) {
- Bool want;
- want= stuff->value&XkbPCF_AutoResetControlsMask;
- if (interest && !want) {
- interest->autoCtrls= interest->autoCtrlValues= 0;
- }
- else if (want && (!interest)) {
- XID id = FakeClientID(client->index);
- if (!AddResource(id,RT_XKBCLIENT,dev))
- return BadAlloc;
- interest= XkbAddClientResource((DevicePtr)dev,client,id);
- if (!interest)
- return BadAlloc;
- }
- if (interest && want ) {
- register unsigned affect;
- affect= stuff->ctrlsToChange;
-
- CHK_MASK_LEGAL(0x03,affect,XkbAllBooleanCtrlsMask);
- CHK_MASK_MATCH(0x04,affect,stuff->autoCtrls);
- CHK_MASK_MATCH(0x05,stuff->autoCtrls,stuff->autoCtrlValues);
-
- interest->autoCtrls&= ~affect;
- interest->autoCtrlValues&= ~affect;
- interest->autoCtrls|= stuff->autoCtrls&affect;
- interest->autoCtrlValues|= stuff->autoCtrlValues&affect;
- }
+ client->xkbClientFlags &= ~stuff->change;
+ client->xkbClientFlags |= stuff->value;
+ }
+ if (stuff->change & XkbPCF_AutoResetControlsMask) {
+ Bool want;
+
+ want = stuff->value & XkbPCF_AutoResetControlsMask;
+ if (interest && !want) {
+ interest->autoCtrls = interest->autoCtrlValues = 0;
+ }
+ else if (want && (!interest)) {
+ XID id = FakeClientID(client->index);
+
+ if (!AddResource(id, RT_XKBCLIENT, dev))
+ return BadAlloc;
+ interest = XkbAddClientResource((DevicePtr) dev, client, id);
+ if (!interest)
+ return BadAlloc;
+ }
+ if (interest && want) {
+ register unsigned affect;
+
+ affect = stuff->ctrlsToChange;
+
+ CHK_MASK_LEGAL(0x03, affect, XkbAllBooleanCtrlsMask);
+ CHK_MASK_MATCH(0x04, affect, stuff->autoCtrls);
+ CHK_MASK_MATCH(0x05, stuff->autoCtrls, stuff->autoCtrlValues);
+
+ interest->autoCtrls &= ~affect;
+ interest->autoCtrlValues &= ~affect;
+ interest->autoCtrls |= stuff->autoCtrls & affect;
+ interest->autoCtrlValues |= stuff->autoCtrlValues & affect;
+ }
}
rep.supported = XkbPCF_AllFlagsMask;
- rep.value= client->xkbClientFlags&XkbPCF_AllFlagsMask;
+ rep.value = client->xkbClientFlags & XkbPCF_AllFlagsMask;
if (interest) {
- rep.autoCtrls= interest->autoCtrls;
- rep.autoCtrlValues= interest->autoCtrlValues;
+ rep.autoCtrls = interest->autoCtrls;
+ rep.autoCtrlValues = interest->autoCtrlValues;
}
else {
- rep.autoCtrls= rep.autoCtrlValues= 0;
+ rep.autoCtrls = rep.autoCtrlValues = 0;
}
- if ( client->swapped ) {
- swaps(&rep.sequenceNumber);
- swapl(&rep.supported);
- swapl(&rep.value);
- swapl(&rep.autoCtrls);
- swapl(&rep.autoCtrlValues);
+ if (client->swapped) {
+ swaps(&rep.sequenceNumber);
+ swapl(&rep.supported);
+ swapl(&rep.value);
+ swapl(&rep.autoCtrls);
+ swapl(&rep.autoCtrlValues);
}
- WriteToClient(client,SIZEOF(xkbPerClientFlagsReply), (char *)&rep);
+ WriteToClient(client, SIZEOF(xkbPerClientFlagsReply), (char *) &rep);
return Success;
}
@@ -5426,57 +5547,60 @@ ProcXkbPerClientFlags(ClientPtr client)
/* all latin-1 alphanumerics, plus parens, minus, underscore, slash */
/* and wildcards */
static unsigned char componentSpecLegal[] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xa7, 0xff, 0x87,
- 0xfe, 0xff, 0xff, 0x87, 0xfe, 0xff, 0xff, 0x07,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0xa7, 0xff, 0x87,
+ 0xfe, 0xff, 0xff, 0x87, 0xfe, 0xff, 0xff, 0x07,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff
};
/* same as above but accepts percent, plus and bar too */
static unsigned char componentExprLegal[] = {
- 0x00, 0x00, 0x00, 0x00, 0x20, 0xaf, 0xff, 0x87,
- 0xfe, 0xff, 0xff, 0x87, 0xfe, 0xff, 0xff, 0x17,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff
+ 0x00, 0x00, 0x00, 0x00, 0x20, 0xaf, 0xff, 0x87,
+ 0xfe, 0xff, 0xff, 0x87, 0xfe, 0xff, 0xff, 0x17,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff
};
static char *
-GetComponentSpec(unsigned char **pWire,Bool allowExpr,int *errRtrn)
+GetComponentSpec(unsigned char **pWire, Bool allowExpr, int *errRtrn)
{
-int len;
-register int i;
-unsigned char *wire,*str,*tmp,*legal;
-
- if (allowExpr) legal= &componentExprLegal[0];
- else legal= &componentSpecLegal[0];
-
- wire= *pWire;
- len= (*(unsigned char *)wire++);
- if (len>0) {
- str= calloc(1, len+1);
- if (str) {
- tmp= str;
- for (i=0;i<len;i++) {
- if (legal[(*wire)/8]&(1<<((*wire)%8)))
- *tmp++= *wire++;
- else wire++;
- }
- if (tmp!=str)
- *tmp++= '\0';
- else {
- free(str);
- str= NULL;
- }
- }
- else {
- *errRtrn= BadAlloc;
- }
+ int len;
+ register int i;
+ unsigned char *wire, *str, *tmp, *legal;
+
+ if (allowExpr)
+ legal = &componentExprLegal[0];
+ else
+ legal = &componentSpecLegal[0];
+
+ wire = *pWire;
+ len = (*(unsigned char *) wire++);
+ if (len > 0) {
+ str = calloc(1, len + 1);
+ if (str) {
+ tmp = str;
+ for (i = 0; i < len; i++) {
+ if (legal[(*wire) / 8] & (1 << ((*wire) % 8)))
+ *tmp++ = *wire++;
+ else
+ wire++;
+ }
+ if (tmp != str)
+ *tmp++ = '\0';
+ else {
+ free(str);
+ str = NULL;
+ }
+ }
+ else {
+ *errRtrn = BadAlloc;
+ }
}
else {
- str= NULL;
+ str = NULL;
}
- *pWire= wire;
- return (char *)str;
+ *pWire = wire;
+ return (char *) str;
}
/***====================================================================***/
@@ -5484,70 +5608,70 @@ unsigned char *wire,*str,*tmp,*legal;
int
ProcXkbListComponents(ClientPtr client)
{
- DeviceIntPtr dev;
- xkbListComponentsReply rep;
- unsigned len;
- int status;
- unsigned char * str;
- XkbSrvListInfoRec list;
+ DeviceIntPtr dev;
+ xkbListComponentsReply rep;
+ unsigned len;
+ int status;
+ unsigned char *str;
+ XkbSrvListInfoRec list;
REQUEST(xkbListComponentsReq);
REQUEST_AT_LEAST_SIZE(xkbListComponentsReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess);
- status= Success;
- str= (unsigned char *)&stuff[1];
+ status = Success;
+ str = (unsigned char *) &stuff[1];
memset(&list, 0, sizeof(XkbSrvListInfoRec));
- list.maxRtrn= stuff->maxNames;
- list.pattern[_XkbListKeycodes]= GetComponentSpec(&str,FALSE,&status);
- list.pattern[_XkbListTypes]= GetComponentSpec(&str,FALSE,&status);
- list.pattern[_XkbListCompat]= GetComponentSpec(&str,FALSE,&status);
- list.pattern[_XkbListSymbols]= GetComponentSpec(&str,FALSE,&status);
- list.pattern[_XkbListGeometry]= GetComponentSpec(&str,FALSE,&status);
- if (status!=Success)
- return status;
- len= str-((unsigned char *)stuff);
- if ((XkbPaddedSize(len)/4)!=stuff->length)
- return BadLength;
- if ((status=XkbDDXList(dev,&list,client))!=Success) {
- free(list.pool);
- list.pool = NULL;
- return status;
+ list.maxRtrn = stuff->maxNames;
+ list.pattern[_XkbListKeycodes] = GetComponentSpec(&str, FALSE, &status);
+ list.pattern[_XkbListTypes] = GetComponentSpec(&str, FALSE, &status);
+ list.pattern[_XkbListCompat] = GetComponentSpec(&str, FALSE, &status);
+ list.pattern[_XkbListSymbols] = GetComponentSpec(&str, FALSE, &status);
+ list.pattern[_XkbListGeometry] = GetComponentSpec(&str, FALSE, &status);
+ if (status != Success)
+ return status;
+ len = str - ((unsigned char *) stuff);
+ if ((XkbPaddedSize(len) / 4) != stuff->length)
+ return BadLength;
+ if ((status = XkbDDXList(dev, &list, client)) != Success) {
+ free(list.pool);
+ list.pool = NULL;
+ return status;
}
memset(&rep, 0, sizeof(xkbListComponentsReply));
- rep.type= X_Reply;
+ rep.type = X_Reply;
rep.deviceID = dev->id;
rep.sequenceNumber = client->sequence;
- rep.length = XkbPaddedSize(list.nPool)/4;
+ rep.length = XkbPaddedSize(list.nPool) / 4;
rep.nKeymaps = 0;
rep.nKeycodes = list.nFound[_XkbListKeycodes];
rep.nTypes = list.nFound[_XkbListTypes];
rep.nCompatMaps = list.nFound[_XkbListCompat];
rep.nSymbols = list.nFound[_XkbListSymbols];
rep.nGeometries = list.nFound[_XkbListGeometry];
- rep.extra= 0;
- if (list.nTotal>list.maxRtrn)
- rep.extra = (list.nTotal-list.maxRtrn);
+ rep.extra = 0;
+ if (list.nTotal > list.maxRtrn)
+ rep.extra = (list.nTotal - list.maxRtrn);
if (client->swapped) {
- swaps(&rep.sequenceNumber);
- swapl(&rep.length);
- swaps(&rep.nKeymaps);
- swaps(&rep.nKeycodes);
- swaps(&rep.nTypes);
- swaps(&rep.nCompatMaps);
- swaps(&rep.nSymbols);
- swaps(&rep.nGeometries);
- swaps(&rep.extra);
- }
- WriteToClient(client,SIZEOF(xkbListComponentsReply),(char *)&rep);
+ swaps(&rep.sequenceNumber);
+ swapl(&rep.length);
+ swaps(&rep.nKeymaps);
+ swaps(&rep.nKeycodes);
+ swaps(&rep.nTypes);
+ swaps(&rep.nCompatMaps);
+ swaps(&rep.nSymbols);
+ swaps(&rep.nGeometries);
+ swaps(&rep.extra);
+ }
+ WriteToClient(client, SIZEOF(xkbListComponentsReply), (char *) &rep);
if (list.nPool && list.pool) {
- WriteToClient(client,XkbPaddedSize(list.nPool), (char *)list.pool);
- free(list.pool);
- list.pool= NULL;
+ WriteToClient(client, XkbPaddedSize(list.nPool), (char *) list.pool);
+ free(list.pool);
+ list.pool = NULL;
}
return Success;
}
@@ -5557,303 +5681,309 @@ ProcXkbListComponents(ClientPtr client)
int
ProcXkbGetKbdByName(ClientPtr client)
{
- DeviceIntPtr dev;
- DeviceIntPtr tmpd;
- DeviceIntPtr master;
- xkbGetKbdByNameReply rep = {0};
- xkbGetMapReply mrep = {0};
- xkbGetCompatMapReply crep = {0};
- xkbGetIndicatorMapReply irep = {0};
- xkbGetNamesReply nrep = {0};
- xkbGetGeometryReply grep = {0};
- XkbComponentNamesRec names = {0};
- XkbDescPtr xkb, new;
- unsigned char * str;
- char mapFile[PATH_MAX];
- unsigned len;
- unsigned fwant,fneed,reported;
- int status;
- Bool geom_changed;
- XkbSrvLedInfoPtr old_sli;
- XkbSrvLedInfoPtr sli;
+ DeviceIntPtr dev;
+ DeviceIntPtr tmpd;
+ DeviceIntPtr master;
+ xkbGetKbdByNameReply rep = { 0 };
+ xkbGetMapReply mrep = { 0 };
+ xkbGetCompatMapReply crep = { 0 };
+ xkbGetIndicatorMapReply irep = { 0 };
+ xkbGetNamesReply nrep = { 0 };
+ xkbGetGeometryReply grep = { 0 };
+ XkbComponentNamesRec names = { 0 };
+ XkbDescPtr xkb, new;
+ unsigned char *str;
+ char mapFile[PATH_MAX];
+ unsigned len;
+ unsigned fwant, fneed, reported;
+ int status;
+ Bool geom_changed;
+ XkbSrvLedInfoPtr old_sli;
+ XkbSrvLedInfoPtr sli;
Mask access_mode = DixGetAttrAccess | DixManageAccess;
REQUEST(xkbGetKbdByNameReq);
REQUEST_AT_LEAST_SIZE(xkbGetKbdByNameReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, access_mode);
master = GetMaster(dev, MASTER_KEYBOARD);
xkb = dev->key->xkbInfo->desc;
- status= Success;
- str= (unsigned char *)&stuff[1];
- if (GetComponentSpec(&str,TRUE,&status)) /* keymap, unsupported */
+ status = Success;
+ str = (unsigned char *) &stuff[1];
+ if (GetComponentSpec(&str, TRUE, &status)) /* keymap, unsupported */
return BadMatch;
- names.keycodes= GetComponentSpec(&str,TRUE,&status);
- names.types= GetComponentSpec(&str,TRUE,&status);
- names.compat= GetComponentSpec(&str,TRUE,&status);
- names.symbols= GetComponentSpec(&str,TRUE,&status);
- names.geometry= GetComponentSpec(&str,TRUE,&status);
- if (status!=Success)
- return status;
- len= str-((unsigned char *)stuff);
- if ((XkbPaddedSize(len)/4)!=stuff->length)
- return BadLength;
-
- CHK_MASK_LEGAL(0x01,stuff->want,XkbGBN_AllComponentsMask);
- CHK_MASK_LEGAL(0x02,stuff->need,XkbGBN_AllComponentsMask);
-
+ names.keycodes = GetComponentSpec(&str, TRUE, &status);
+ names.types = GetComponentSpec(&str, TRUE, &status);
+ names.compat = GetComponentSpec(&str, TRUE, &status);
+ names.symbols = GetComponentSpec(&str, TRUE, &status);
+ names.geometry = GetComponentSpec(&str, TRUE, &status);
+ if (status != Success)
+ return status;
+ len = str - ((unsigned char *) stuff);
+ if ((XkbPaddedSize(len) / 4) != stuff->length)
+ return BadLength;
+
+ CHK_MASK_LEGAL(0x01, stuff->want, XkbGBN_AllComponentsMask);
+ CHK_MASK_LEGAL(0x02, stuff->need, XkbGBN_AllComponentsMask);
+
if (stuff->load)
- fwant= XkbGBN_AllComponentsMask;
- else fwant= stuff->want|stuff->need;
- if ((!names.compat)&&
- (fwant&(XkbGBN_CompatMapMask|XkbGBN_IndicatorMapMask))) {
- names.compat= Xstrdup("%");
+ fwant = XkbGBN_AllComponentsMask;
+ else
+ fwant = stuff->want | stuff->need;
+ if ((!names.compat) &&
+ (fwant & (XkbGBN_CompatMapMask | XkbGBN_IndicatorMapMask))) {
+ names.compat = Xstrdup("%");
}
- if ((!names.types)&&(fwant&(XkbGBN_TypesMask))) {
- names.types= Xstrdup("%");
+ if ((!names.types) && (fwant & (XkbGBN_TypesMask))) {
+ names.types = Xstrdup("%");
}
- if ((!names.symbols)&&(fwant&XkbGBN_SymbolsMask)) {
- names.symbols= Xstrdup("%");
+ if ((!names.symbols) && (fwant & XkbGBN_SymbolsMask)) {
+ names.symbols = Xstrdup("%");
}
- geom_changed= ((names.geometry!=NULL)&&(strcmp(names.geometry,"%")!=0));
- if ((!names.geometry)&&(fwant&XkbGBN_GeometryMask)) {
- names.geometry= Xstrdup("%");
- geom_changed= FALSE;
+ geom_changed = ((names.geometry != NULL) &&
+ (strcmp(names.geometry, "%") != 0));
+ if ((!names.geometry) && (fwant & XkbGBN_GeometryMask)) {
+ names.geometry = Xstrdup("%");
+ geom_changed = FALSE;
}
memset(mapFile, 0, PATH_MAX);
- rep.type= X_Reply;
+ rep.type = X_Reply;
rep.deviceID = dev->id;
rep.sequenceNumber = client->sequence;
rep.length = 0;
rep.minKeyCode = xkb->min_key_code;
rep.maxKeyCode = xkb->max_key_code;
- rep.loaded= FALSE;
- fwant= XkbConvertGetByNameComponents(TRUE,stuff->want)|XkmVirtualModsMask;
- fneed= XkbConvertGetByNameComponents(TRUE,stuff->need);
- rep.reported= XkbConvertGetByNameComponents(FALSE,fwant|fneed);
+ rep.loaded = FALSE;
+ fwant =
+ XkbConvertGetByNameComponents(TRUE, stuff->want) | XkmVirtualModsMask;
+ fneed = XkbConvertGetByNameComponents(TRUE, stuff->need);
+ rep.reported = XkbConvertGetByNameComponents(FALSE, fwant | fneed);
if (stuff->load) {
- fneed|= XkmKeymapRequired;
- fwant|= XkmKeymapLegal;
+ fneed |= XkmKeymapRequired;
+ fwant |= XkmKeymapLegal;
}
- if ((fwant|fneed)&XkmSymbolsMask) {
- fneed|= XkmKeyNamesIndex|XkmTypesIndex;
- fwant|= XkmIndicatorsIndex;
+ if ((fwant | fneed) & XkmSymbolsMask) {
+ fneed |= XkmKeyNamesIndex | XkmTypesIndex;
+ fwant |= XkmIndicatorsIndex;
}
/* We pass dev in here so we can get the old names out if needed. */
- rep.found = XkbDDXLoadKeymapByNames(dev,&names,fwant,fneed,&new,
- mapFile,PATH_MAX);
- rep.newKeyboard= FALSE;
- rep.pad1= rep.pad2= rep.pad3= rep.pad4= 0;
-
- stuff->want|= stuff->need;
- if (new==NULL)
- rep.reported= 0;
+ rep.found = XkbDDXLoadKeymapByNames(dev, &names, fwant, fneed, &new,
+ mapFile, PATH_MAX);
+ rep.newKeyboard = FALSE;
+ rep.pad1 = rep.pad2 = rep.pad3 = rep.pad4 = 0;
+
+ stuff->want |= stuff->need;
+ if (new == NULL)
+ rep.reported = 0;
else {
- if (stuff->load)
- rep.loaded= TRUE;
- if (stuff->load ||
- ((rep.reported&XkbGBN_SymbolsMask) && (new->compat))) {
- XkbChangesRec changes;
- memset(&changes, 0, sizeof(changes));
- XkbUpdateDescActions(new,
- new->min_key_code,XkbNumKeys(new),
- &changes);
- }
-
- if (new->map==NULL)
- rep.reported&= ~(XkbGBN_SymbolsMask|XkbGBN_TypesMask);
- else if (rep.reported&(XkbGBN_SymbolsMask|XkbGBN_TypesMask)) {
- mrep.type= X_Reply;
- mrep.deviceID = dev->id;
- mrep.sequenceNumber= client->sequence;
- mrep.length = ((SIZEOF(xkbGetMapReply)-SIZEOF(xGenericReply))>>2);
- mrep.minKeyCode = new->min_key_code;
- mrep.maxKeyCode = new->max_key_code;
- mrep.present = 0;
- mrep.totalSyms = mrep.totalActs =
- mrep.totalKeyBehaviors= mrep.totalKeyExplicit=
- mrep.totalModMapKeys= mrep.totalVModMapKeys= 0;
- if (rep.reported&(XkbGBN_TypesMask|XkbGBN_ClientSymbolsMask)) {
- mrep.present|= XkbKeyTypesMask;
- mrep.firstType = 0;
- mrep.nTypes = mrep.totalTypes= new->map->num_types;
- }
- else {
- mrep.firstType = mrep.nTypes= 0;
- mrep.totalTypes= 0;
- }
- if (rep.reported&XkbGBN_ClientSymbolsMask) {
- mrep.present|= (XkbKeySymsMask|XkbModifierMapMask);
- mrep.firstKeySym = mrep.firstModMapKey= new->min_key_code;
- mrep.nKeySyms = mrep.nModMapKeys= XkbNumKeys(new);
- }
- else {
- mrep.firstKeySym= mrep.firstModMapKey= 0;
- mrep.nKeySyms= mrep.nModMapKeys= 0;
- }
- if (rep.reported&XkbGBN_ServerSymbolsMask) {
- mrep.present|= XkbAllServerInfoMask;
- mrep.virtualMods= ~0;
- mrep.firstKeyAct = mrep.firstKeyBehavior =
- mrep.firstKeyExplicit = new->min_key_code;
- mrep.nKeyActs = mrep.nKeyBehaviors =
- mrep.nKeyExplicit = XkbNumKeys(new);
- mrep.firstVModMapKey= new->min_key_code;
- mrep.nVModMapKeys= XkbNumKeys(new);
- }
- else {
- mrep.virtualMods= 0;
- mrep.firstKeyAct= mrep.firstKeyBehavior=
- mrep.firstKeyExplicit = 0;
- mrep.nKeyActs= mrep.nKeyBehaviors= mrep.nKeyExplicit= 0;
- }
- XkbComputeGetMapReplySize(new,&mrep);
- rep.length+= SIZEOF(xGenericReply)/4+mrep.length;
- }
- if (new->compat==NULL)
- rep.reported&= ~XkbGBN_CompatMapMask;
- else if (rep.reported&XkbGBN_CompatMapMask) {
- crep.type= X_Reply;
- crep.deviceID= dev->id;
- crep.sequenceNumber= client->sequence;
- crep.length= 0;
- crep.groups= XkbAllGroupsMask;
- crep.firstSI= 0;
- crep.nSI= crep.nTotalSI= new->compat->num_si;
- XkbComputeGetCompatMapReplySize(new->compat,&crep);
- rep.length+= SIZEOF(xGenericReply)/4+crep.length;
- }
- if (new->indicators==NULL)
- rep.reported&= ~XkbGBN_IndicatorMapMask;
- else if (rep.reported&XkbGBN_IndicatorMapMask) {
- irep.type= X_Reply;
- irep.deviceID= dev->id;
- irep.sequenceNumber= client->sequence;
- irep.length= 0;
- irep.which= XkbAllIndicatorsMask;
- XkbComputeGetIndicatorMapReplySize(new->indicators,&irep);
- rep.length+= SIZEOF(xGenericReply)/4+irep.length;
- }
- if (new->names==NULL)
- rep.reported&= ~(XkbGBN_OtherNamesMask|XkbGBN_KeyNamesMask);
- else if (rep.reported&(XkbGBN_OtherNamesMask|XkbGBN_KeyNamesMask)) {
- nrep.type= X_Reply;
- nrep.deviceID= dev->id;
- nrep.sequenceNumber= client->sequence;
- nrep.length= 0;
- nrep.minKeyCode= new->min_key_code;
- nrep.maxKeyCode= new->max_key_code;
- if (rep.reported&XkbGBN_OtherNamesMask) {
- nrep.which= XkbAllNamesMask;
- if (new->map!=NULL)
- nrep.nTypes= new->map->num_types;
- else nrep.nTypes= 0;
- nrep.nKTLevels= 0;
- nrep.groupNames= XkbAllGroupsMask;
- nrep.virtualMods= XkbAllVirtualModsMask;
- nrep.indicators= XkbAllIndicatorsMask;
- nrep.nRadioGroups= new->names->num_rg;
- }
- else {
- nrep.which= 0;
- nrep.nTypes= 0;
- nrep.nKTLevels= 0;
- nrep.groupNames= 0;
- nrep.virtualMods= 0;
- nrep.indicators= 0;
- nrep.nRadioGroups= 0;
- }
- if (rep.reported&XkbGBN_KeyNamesMask) {
- nrep.which|= XkbKeyNamesMask;
- nrep.firstKey= new->min_key_code;
- nrep.nKeys= XkbNumKeys(new);
- nrep.nKeyAliases= new->names->num_key_aliases;
- if (nrep.nKeyAliases)
- nrep.which|= XkbKeyAliasesMask;
- }
- else {
- nrep.which&= ~(XkbKeyNamesMask|XkbKeyAliasesMask);
- nrep.firstKey= nrep.nKeys= 0;
- nrep.nKeyAliases= 0;
- }
- XkbComputeGetNamesReplySize(new,&nrep);
- rep.length+= SIZEOF(xGenericReply)/4+nrep.length;
- }
- if (new->geom==NULL)
- rep.reported&= ~XkbGBN_GeometryMask;
- else if (rep.reported&XkbGBN_GeometryMask) {
- grep.type= X_Reply;
- grep.deviceID= dev->id;
- grep.sequenceNumber= client->sequence;
- grep.length= 0;
- grep.found= TRUE;
- grep.pad= 0;
- grep.widthMM= grep.heightMM= 0;
- grep.nProperties= grep.nColors= grep.nShapes= 0;
- grep.nSections= grep.nDoodads= 0;
- grep.baseColorNdx= grep.labelColorNdx= 0;
- XkbComputeGetGeometryReplySize(new->geom,&grep,None);
- rep.length+= SIZEOF(xGenericReply)/4+grep.length;
- }
- }
-
- reported= rep.reported;
- if ( client->swapped ) {
- swaps(&rep.sequenceNumber);
- swapl(&rep.length);
- swaps(&rep.found);
- swaps(&rep.reported);
- }
- WriteToClient(client,SIZEOF(xkbGetKbdByNameReply), (char *)&rep);
- if (reported&(XkbGBN_SymbolsMask|XkbGBN_TypesMask))
- XkbSendMap(client,new,&mrep);
- if (reported&XkbGBN_CompatMapMask)
- XkbSendCompatMap(client,new->compat,&crep);
- if (reported&XkbGBN_IndicatorMapMask)
- XkbSendIndicatorMap(client,new->indicators,&irep);
- if (reported&(XkbGBN_KeyNamesMask|XkbGBN_OtherNamesMask))
- XkbSendNames(client,new,&nrep);
- if (reported&XkbGBN_GeometryMask)
- XkbSendGeometry(client,new->geom,&grep,FALSE);
+ if (stuff->load)
+ rep.loaded = TRUE;
+ if (stuff->load ||
+ ((rep.reported & XkbGBN_SymbolsMask) && (new->compat))) {
+ XkbChangesRec changes;
+
+ memset(&changes, 0, sizeof(changes));
+ XkbUpdateDescActions(new,
+ new->min_key_code, XkbNumKeys(new), &changes);
+ }
+
+ if (new->map == NULL)
+ rep.reported &= ~(XkbGBN_SymbolsMask | XkbGBN_TypesMask);
+ else if (rep.reported & (XkbGBN_SymbolsMask | XkbGBN_TypesMask)) {
+ mrep.type = X_Reply;
+ mrep.deviceID = dev->id;
+ mrep.sequenceNumber = client->sequence;
+ mrep.length =
+ ((SIZEOF(xkbGetMapReply) - SIZEOF(xGenericReply)) >> 2);
+ mrep.minKeyCode = new->min_key_code;
+ mrep.maxKeyCode = new->max_key_code;
+ mrep.present = 0;
+ mrep.totalSyms = mrep.totalActs =
+ mrep.totalKeyBehaviors = mrep.totalKeyExplicit =
+ mrep.totalModMapKeys = mrep.totalVModMapKeys = 0;
+ if (rep.reported & (XkbGBN_TypesMask | XkbGBN_ClientSymbolsMask)) {
+ mrep.present |= XkbKeyTypesMask;
+ mrep.firstType = 0;
+ mrep.nTypes = mrep.totalTypes = new->map->num_types;
+ }
+ else {
+ mrep.firstType = mrep.nTypes = 0;
+ mrep.totalTypes = 0;
+ }
+ if (rep.reported & XkbGBN_ClientSymbolsMask) {
+ mrep.present |= (XkbKeySymsMask | XkbModifierMapMask);
+ mrep.firstKeySym = mrep.firstModMapKey = new->min_key_code;
+ mrep.nKeySyms = mrep.nModMapKeys = XkbNumKeys(new);
+ }
+ else {
+ mrep.firstKeySym = mrep.firstModMapKey = 0;
+ mrep.nKeySyms = mrep.nModMapKeys = 0;
+ }
+ if (rep.reported & XkbGBN_ServerSymbolsMask) {
+ mrep.present |= XkbAllServerInfoMask;
+ mrep.virtualMods = ~0;
+ mrep.firstKeyAct = mrep.firstKeyBehavior =
+ mrep.firstKeyExplicit = new->min_key_code;
+ mrep.nKeyActs = mrep.nKeyBehaviors =
+ mrep.nKeyExplicit = XkbNumKeys(new);
+ mrep.firstVModMapKey = new->min_key_code;
+ mrep.nVModMapKeys = XkbNumKeys(new);
+ }
+ else {
+ mrep.virtualMods = 0;
+ mrep.firstKeyAct = mrep.firstKeyBehavior =
+ mrep.firstKeyExplicit = 0;
+ mrep.nKeyActs = mrep.nKeyBehaviors = mrep.nKeyExplicit = 0;
+ }
+ XkbComputeGetMapReplySize(new, &mrep);
+ rep.length += SIZEOF(xGenericReply) / 4 + mrep.length;
+ }
+ if (new->compat == NULL)
+ rep.reported &= ~XkbGBN_CompatMapMask;
+ else if (rep.reported & XkbGBN_CompatMapMask) {
+ crep.type = X_Reply;
+ crep.deviceID = dev->id;
+ crep.sequenceNumber = client->sequence;
+ crep.length = 0;
+ crep.groups = XkbAllGroupsMask;
+ crep.firstSI = 0;
+ crep.nSI = crep.nTotalSI = new->compat->num_si;
+ XkbComputeGetCompatMapReplySize(new->compat, &crep);
+ rep.length += SIZEOF(xGenericReply) / 4 + crep.length;
+ }
+ if (new->indicators == NULL)
+ rep.reported &= ~XkbGBN_IndicatorMapMask;
+ else if (rep.reported & XkbGBN_IndicatorMapMask) {
+ irep.type = X_Reply;
+ irep.deviceID = dev->id;
+ irep.sequenceNumber = client->sequence;
+ irep.length = 0;
+ irep.which = XkbAllIndicatorsMask;
+ XkbComputeGetIndicatorMapReplySize(new->indicators, &irep);
+ rep.length += SIZEOF(xGenericReply) / 4 + irep.length;
+ }
+ if (new->names == NULL)
+ rep.reported &= ~(XkbGBN_OtherNamesMask | XkbGBN_KeyNamesMask);
+ else if (rep.reported & (XkbGBN_OtherNamesMask | XkbGBN_KeyNamesMask)) {
+ nrep.type = X_Reply;
+ nrep.deviceID = dev->id;
+ nrep.sequenceNumber = client->sequence;
+ nrep.length = 0;
+ nrep.minKeyCode = new->min_key_code;
+ nrep.maxKeyCode = new->max_key_code;
+ if (rep.reported & XkbGBN_OtherNamesMask) {
+ nrep.which = XkbAllNamesMask;
+ if (new->map != NULL)
+ nrep.nTypes = new->map->num_types;
+ else
+ nrep.nTypes = 0;
+ nrep.nKTLevels = 0;
+ nrep.groupNames = XkbAllGroupsMask;
+ nrep.virtualMods = XkbAllVirtualModsMask;
+ nrep.indicators = XkbAllIndicatorsMask;
+ nrep.nRadioGroups = new->names->num_rg;
+ }
+ else {
+ nrep.which = 0;
+ nrep.nTypes = 0;
+ nrep.nKTLevels = 0;
+ nrep.groupNames = 0;
+ nrep.virtualMods = 0;
+ nrep.indicators = 0;
+ nrep.nRadioGroups = 0;
+ }
+ if (rep.reported & XkbGBN_KeyNamesMask) {
+ nrep.which |= XkbKeyNamesMask;
+ nrep.firstKey = new->min_key_code;
+ nrep.nKeys = XkbNumKeys(new);
+ nrep.nKeyAliases = new->names->num_key_aliases;
+ if (nrep.nKeyAliases)
+ nrep.which |= XkbKeyAliasesMask;
+ }
+ else {
+ nrep.which &= ~(XkbKeyNamesMask | XkbKeyAliasesMask);
+ nrep.firstKey = nrep.nKeys = 0;
+ nrep.nKeyAliases = 0;
+ }
+ XkbComputeGetNamesReplySize(new, &nrep);
+ rep.length += SIZEOF(xGenericReply) / 4 + nrep.length;
+ }
+ if (new->geom == NULL)
+ rep.reported &= ~XkbGBN_GeometryMask;
+ else if (rep.reported & XkbGBN_GeometryMask) {
+ grep.type = X_Reply;
+ grep.deviceID = dev->id;
+ grep.sequenceNumber = client->sequence;
+ grep.length = 0;
+ grep.found = TRUE;
+ grep.pad = 0;
+ grep.widthMM = grep.heightMM = 0;
+ grep.nProperties = grep.nColors = grep.nShapes = 0;
+ grep.nSections = grep.nDoodads = 0;
+ grep.baseColorNdx = grep.labelColorNdx = 0;
+ XkbComputeGetGeometryReplySize(new->geom, &grep, None);
+ rep.length += SIZEOF(xGenericReply) / 4 + grep.length;
+ }
+ }
+
+ reported = rep.reported;
+ if (client->swapped) {
+ swaps(&rep.sequenceNumber);
+ swapl(&rep.length);
+ swaps(&rep.found);
+ swaps(&rep.reported);
+ }
+ WriteToClient(client, SIZEOF(xkbGetKbdByNameReply), (char *) &rep);
+ if (reported & (XkbGBN_SymbolsMask | XkbGBN_TypesMask))
+ XkbSendMap(client, new, &mrep);
+ if (reported & XkbGBN_CompatMapMask)
+ XkbSendCompatMap(client, new->compat, &crep);
+ if (reported & XkbGBN_IndicatorMapMask)
+ XkbSendIndicatorMap(client, new->indicators, &irep);
+ if (reported & (XkbGBN_KeyNamesMask | XkbGBN_OtherNamesMask))
+ XkbSendNames(client, new, &nrep);
+ if (reported & XkbGBN_GeometryMask)
+ XkbSendGeometry(client, new->geom, &grep, FALSE);
if (rep.loaded) {
- XkbDescPtr old_xkb;
- xkbNewKeyboardNotify nkn;
- int i,nG,nTG;
- old_xkb= xkb;
- xkb= new;
- dev->key->xkbInfo->desc= xkb;
- new= old_xkb; /* so it'll get freed automatically */
-
- *xkb->ctrls= *old_xkb->ctrls;
- for (nG=nTG=0,i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
- nG= XkbKeyNumGroups(xkb,i);
- if (nG>=XkbNumKbdGroups) {
- nTG= XkbNumKbdGroups;
- break;
- }
- if (nG>nTG) {
- nTG= nG;
- }
- }
- xkb->ctrls->num_groups= nTG;
-
- nkn.deviceID= nkn.oldDeviceID= dev->id;
- nkn.minKeyCode= new->min_key_code;
- nkn.maxKeyCode= new->max_key_code;
- nkn.oldMinKeyCode= xkb->min_key_code;
- nkn.oldMaxKeyCode= xkb->max_key_code;
- nkn.requestMajor= XkbReqCode;
- nkn.requestMinor= X_kbGetKbdByName;
- nkn.changed= XkbNKN_KeycodesMask;
- if (geom_changed)
- nkn.changed|= XkbNKN_GeometryMask;
- XkbSendNewKeyboardNotify(dev,&nkn);
+ XkbDescPtr old_xkb;
+ xkbNewKeyboardNotify nkn;
+ int i, nG, nTG;
+
+ old_xkb = xkb;
+ xkb = new;
+ dev->key->xkbInfo->desc = xkb;
+ new = old_xkb; /* so it'll get freed automatically */
+
+ *xkb->ctrls = *old_xkb->ctrls;
+ for (nG = nTG = 0, i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+ nG = XkbKeyNumGroups(xkb, i);
+ if (nG >= XkbNumKbdGroups) {
+ nTG = XkbNumKbdGroups;
+ break;
+ }
+ if (nG > nTG) {
+ nTG = nG;
+ }
+ }
+ xkb->ctrls->num_groups = nTG;
+
+ nkn.deviceID = nkn.oldDeviceID = dev->id;
+ nkn.minKeyCode = new->min_key_code;
+ nkn.maxKeyCode = new->max_key_code;
+ nkn.oldMinKeyCode = xkb->min_key_code;
+ nkn.oldMaxKeyCode = xkb->max_key_code;
+ nkn.requestMajor = XkbReqCode;
+ nkn.requestMinor = X_kbGetKbdByName;
+ nkn.changed = XkbNKN_KeycodesMask;
+ if (geom_changed)
+ nkn.changed |= XkbNKN_GeometryMask;
+ XkbSendNewKeyboardNotify(dev, &nkn);
/* Update the map and LED info on the device itself, as well as
* any slaves if it's an MD, or its MD if it's an SD and was the
@@ -5879,9 +6009,9 @@ ProcXkbGetKbdByName(ClientPtr client)
}
}
}
- if ((new!=NULL)&&(new!=xkb)) {
- XkbFreeKeyboard(new,XkbAllComponentsMask,TRUE);
- new= NULL;
+ if ((new != NULL) && (new != xkb)) {
+ XkbFreeKeyboard(new, XkbAllComponentsMask, TRUE);
+ new = NULL;
}
XkbFreeComponentNames(&names, FALSE);
return Success;
@@ -5890,627 +6020,648 @@ ProcXkbGetKbdByName(ClientPtr client)
/***====================================================================***/
static int
-ComputeDeviceLedInfoSize( DeviceIntPtr dev,
- unsigned int what,
- XkbSrvLedInfoPtr sli)
+ComputeDeviceLedInfoSize(DeviceIntPtr dev,
+ unsigned int what, XkbSrvLedInfoPtr sli)
{
-int nNames,nMaps;
-register unsigned n,bit;
-
- if (sli==NULL)
- return 0;
- nNames= nMaps= 0;
- if ((what&XkbXI_IndicatorNamesMask)==0)
- sli->namesPresent= 0;
- if ((what&XkbXI_IndicatorMapsMask)==0)
- sli->mapsPresent= 0;
-
- for (n=0,bit=1;n<XkbNumIndicators;n++,bit<<=1) {
- if (sli->names && sli->names[n]!=None) {
- sli->namesPresent|= bit;
- nNames++;
- }
- if (sli->maps && XkbIM_InUse(&sli->maps[n])) {
- sli->mapsPresent|= bit;
- nMaps++;
- }
- }
- return (nNames*4)+(nMaps*SIZEOF(xkbIndicatorMapWireDesc));
+ int nNames, nMaps;
+ register unsigned n, bit;
+
+ if (sli == NULL)
+ return 0;
+ nNames = nMaps = 0;
+ if ((what & XkbXI_IndicatorNamesMask) == 0)
+ sli->namesPresent = 0;
+ if ((what & XkbXI_IndicatorMapsMask) == 0)
+ sli->mapsPresent = 0;
+
+ for (n = 0, bit = 1; n < XkbNumIndicators; n++, bit <<= 1) {
+ if (sli->names && sli->names[n] != None) {
+ sli->namesPresent |= bit;
+ nNames++;
+ }
+ if (sli->maps && XkbIM_InUse(&sli->maps[n])) {
+ sli->mapsPresent |= bit;
+ nMaps++;
+ }
+ }
+ return (nNames * 4) + (nMaps * SIZEOF(xkbIndicatorMapWireDesc));
}
-static int
-CheckDeviceLedFBs( DeviceIntPtr dev,
- int class,
- int id,
- xkbGetDeviceInfoReply * rep,
- ClientPtr client)
+static int
+CheckDeviceLedFBs(DeviceIntPtr dev,
+ int class,
+ int id, xkbGetDeviceInfoReply * rep, ClientPtr client)
{
-int nFBs= 0;
-int length= 0;
-Bool classOk;
-
- if (class==XkbDfltXIClass) {
- if (dev->kbdfeed) class= KbdFeedbackClass;
- else if (dev->leds) class= LedFeedbackClass;
- else {
- client->errorValue= _XkbErrCode2(XkbErr_BadClass,class);
- return XkbKeyboardErrorCode;
- }
- }
- classOk= FALSE;
- if ((dev->kbdfeed)&&((class==KbdFeedbackClass)||(class==XkbAllXIClasses))) {
- KbdFeedbackPtr kf;
- classOk= TRUE;
- for (kf= dev->kbdfeed;(kf);kf=kf->next) {
- if ((id!=XkbAllXIIds)&&(id!=XkbDfltXIId)&&(id!=kf->ctrl.id))
- continue;
- nFBs++;
- length+= SIZEOF(xkbDeviceLedsWireDesc);
- if (!kf->xkb_sli)
- kf->xkb_sli= XkbAllocSrvLedInfo(dev,kf,NULL,0);
- length+= ComputeDeviceLedInfoSize(dev,rep->present,kf->xkb_sli);
- if (id!=XkbAllXIIds)
- break;
- }
- }
- if ((dev->leds)&&((class==LedFeedbackClass)||(class==XkbAllXIClasses))) {
- LedFeedbackPtr lf;
- classOk= TRUE;
- for (lf= dev->leds;(lf);lf=lf->next) {
- if ((id!=XkbAllXIIds)&&(id!=XkbDfltXIId)&&(id!=lf->ctrl.id))
- continue;
- nFBs++;
- length+= SIZEOF(xkbDeviceLedsWireDesc);
- if (!lf->xkb_sli)
- lf->xkb_sli= XkbAllocSrvLedInfo(dev,NULL,lf,0);
- length+= ComputeDeviceLedInfoSize(dev,rep->present,lf->xkb_sli);
- if (id!=XkbAllXIIds)
- break;
- }
- }
- if (nFBs>0) {
- rep->nDeviceLedFBs= nFBs;
- rep->length+= (length/4);
- return Success;
- }
- if (classOk) client->errorValue= _XkbErrCode2(XkbErr_BadId,id);
- else client->errorValue= _XkbErrCode2(XkbErr_BadClass,class);
+ int nFBs = 0;
+ int length = 0;
+ Bool classOk;
+
+ if (class == XkbDfltXIClass) {
+ if (dev->kbdfeed)
+ class = KbdFeedbackClass;
+ else if (dev->leds)
+ class = LedFeedbackClass;
+ else {
+ client->errorValue = _XkbErrCode2(XkbErr_BadClass, class);
+ return XkbKeyboardErrorCode;
+ }
+ }
+ classOk = FALSE;
+ if ((dev->kbdfeed) &&
+ ((class == KbdFeedbackClass) || (class == XkbAllXIClasses))) {
+ KbdFeedbackPtr kf;
+
+ classOk = TRUE;
+ for (kf = dev->kbdfeed; (kf); kf = kf->next) {
+ if ((id != XkbAllXIIds) && (id != XkbDfltXIId) &&
+ (id != kf->ctrl.id))
+ continue;
+ nFBs++;
+ length += SIZEOF(xkbDeviceLedsWireDesc);
+ if (!kf->xkb_sli)
+ kf->xkb_sli = XkbAllocSrvLedInfo(dev, kf, NULL, 0);
+ length += ComputeDeviceLedInfoSize(dev, rep->present, kf->xkb_sli);
+ if (id != XkbAllXIIds)
+ break;
+ }
+ }
+ if ((dev->leds) &&
+ ((class == LedFeedbackClass) || (class == XkbAllXIClasses))) {
+ LedFeedbackPtr lf;
+
+ classOk = TRUE;
+ for (lf = dev->leds; (lf); lf = lf->next) {
+ if ((id != XkbAllXIIds) && (id != XkbDfltXIId) &&
+ (id != lf->ctrl.id))
+ continue;
+ nFBs++;
+ length += SIZEOF(xkbDeviceLedsWireDesc);
+ if (!lf->xkb_sli)
+ lf->xkb_sli = XkbAllocSrvLedInfo(dev, NULL, lf, 0);
+ length += ComputeDeviceLedInfoSize(dev, rep->present, lf->xkb_sli);
+ if (id != XkbAllXIIds)
+ break;
+ }
+ }
+ if (nFBs > 0) {
+ rep->nDeviceLedFBs = nFBs;
+ rep->length += (length / 4);
+ return Success;
+ }
+ if (classOk)
+ client->errorValue = _XkbErrCode2(XkbErr_BadId, id);
+ else
+ client->errorValue = _XkbErrCode2(XkbErr_BadClass, class);
return XkbKeyboardErrorCode;
}
static int
-SendDeviceLedInfo( XkbSrvLedInfoPtr sli,
- ClientPtr client)
+SendDeviceLedInfo(XkbSrvLedInfoPtr sli, ClientPtr client)
{
-xkbDeviceLedsWireDesc wire;
-int length;
-
- length= 0;
- wire.ledClass= sli->class;
- wire.ledID= sli->id;
- wire.namesPresent= sli->namesPresent;
- wire.mapsPresent= sli->mapsPresent;
- wire.physIndicators= sli->physIndicators;
- wire.state= sli->effectiveState;
+ xkbDeviceLedsWireDesc wire;
+ int length;
+
+ length = 0;
+ wire.ledClass = sli->class;
+ wire.ledID = sli->id;
+ wire.namesPresent = sli->namesPresent;
+ wire.mapsPresent = sli->mapsPresent;
+ wire.physIndicators = sli->physIndicators;
+ wire.state = sli->effectiveState;
if (client->swapped) {
- swaps(&wire.ledClass);
- swaps(&wire.ledID);
- swapl(&wire.namesPresent);
- swapl(&wire.mapsPresent);
- swapl(&wire.physIndicators);
- swapl(&wire.state);
- }
- WriteToClient(client,SIZEOF(xkbDeviceLedsWireDesc),(char *)&wire);
- length+= SIZEOF(xkbDeviceLedsWireDesc);
- if (sli->namesPresent|sli->mapsPresent) {
- register unsigned i,bit;
- if (sli->namesPresent) {
- CARD32 awire;
- for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
- if (sli->namesPresent&bit) {
- awire= (CARD32)sli->names[i];
- if (client->swapped) {
- swapl(&awire);
- }
- WriteToClient(client,4,(char *)&awire);
- length+= 4;
- }
- }
- }
- if (sli->mapsPresent) {
- for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
- xkbIndicatorMapWireDesc iwire;
- if (sli->mapsPresent&bit) {
- iwire.flags= sli->maps[i].flags;
- iwire.whichGroups= sli->maps[i].which_groups;
- iwire.groups= sli->maps[i].groups;
- iwire.whichMods= sli->maps[i].which_mods;
- iwire.mods= sli->maps[i].mods.mask;
- iwire.realMods= sli->maps[i].mods.real_mods;
- iwire.virtualMods= sli->maps[i].mods.vmods;
- iwire.ctrls= sli->maps[i].ctrls;
- if (client->swapped) {
- swaps(&iwire.virtualMods);
- swapl(&iwire.ctrls);
- }
- WriteToClient(client,SIZEOF(xkbIndicatorMapWireDesc),
- (char *)&iwire);
- length+= SIZEOF(xkbIndicatorMapWireDesc);
- }
- }
- }
+ swaps(&wire.ledClass);
+ swaps(&wire.ledID);
+ swapl(&wire.namesPresent);
+ swapl(&wire.mapsPresent);
+ swapl(&wire.physIndicators);
+ swapl(&wire.state);
+ }
+ WriteToClient(client, SIZEOF(xkbDeviceLedsWireDesc), (char *) &wire);
+ length += SIZEOF(xkbDeviceLedsWireDesc);
+ if (sli->namesPresent | sli->mapsPresent) {
+ register unsigned i, bit;
+
+ if (sli->namesPresent) {
+ CARD32 awire;
+
+ for (i = 0, bit = 1; i < XkbNumIndicators; i++, bit <<= 1) {
+ if (sli->namesPresent & bit) {
+ awire = (CARD32) sli->names[i];
+ if (client->swapped) {
+ swapl(&awire);
+ }
+ WriteToClient(client, 4, (char *) &awire);
+ length += 4;
+ }
+ }
+ }
+ if (sli->mapsPresent) {
+ for (i = 0, bit = 1; i < XkbNumIndicators; i++, bit <<= 1) {
+ xkbIndicatorMapWireDesc iwire;
+
+ if (sli->mapsPresent & bit) {
+ iwire.flags = sli->maps[i].flags;
+ iwire.whichGroups = sli->maps[i].which_groups;
+ iwire.groups = sli->maps[i].groups;
+ iwire.whichMods = sli->maps[i].which_mods;
+ iwire.mods = sli->maps[i].mods.mask;
+ iwire.realMods = sli->maps[i].mods.real_mods;
+ iwire.virtualMods = sli->maps[i].mods.vmods;
+ iwire.ctrls = sli->maps[i].ctrls;
+ if (client->swapped) {
+ swaps(&iwire.virtualMods);
+ swapl(&iwire.ctrls);
+ }
+ WriteToClient(client, SIZEOF(xkbIndicatorMapWireDesc),
+ (char *) &iwire);
+ length += SIZEOF(xkbIndicatorMapWireDesc);
+ }
+ }
+ }
}
return length;
}
static int
-SendDeviceLedFBs( DeviceIntPtr dev,
- int class,
- int id,
- unsigned wantLength,
- ClientPtr client)
+SendDeviceLedFBs(DeviceIntPtr dev,
+ int class, int id, unsigned wantLength, ClientPtr client)
{
-int length= 0;
-
- if (class==XkbDfltXIClass) {
- if (dev->kbdfeed) class= KbdFeedbackClass;
- else if (dev->leds) class= LedFeedbackClass;
- }
- if ((dev->kbdfeed)&&
- ((class==KbdFeedbackClass)||(class==XkbAllXIClasses))) {
- KbdFeedbackPtr kf;
- for (kf= dev->kbdfeed;(kf);kf=kf->next) {
- if ((id==XkbAllXIIds)||(id==XkbDfltXIId)||(id==kf->ctrl.id)) {
- length+= SendDeviceLedInfo(kf->xkb_sli,client);
- if (id!=XkbAllXIIds)
- break;
- }
- }
- }
- if ((dev->leds)&&
- ((class==LedFeedbackClass)||(class==XkbAllXIClasses))) {
- LedFeedbackPtr lf;
- for (lf= dev->leds;(lf);lf=lf->next) {
- if ((id==XkbAllXIIds)||(id==XkbDfltXIId)||(id==lf->ctrl.id)) {
- length+= SendDeviceLedInfo(lf->xkb_sli,client);
- if (id!=XkbAllXIIds)
- break;
- }
- }
- }
- if (length==wantLength)
- return Success;
- else return BadLength;
+ int length = 0;
+
+ if (class == XkbDfltXIClass) {
+ if (dev->kbdfeed)
+ class = KbdFeedbackClass;
+ else if (dev->leds)
+ class = LedFeedbackClass;
+ }
+ if ((dev->kbdfeed) &&
+ ((class == KbdFeedbackClass) || (class == XkbAllXIClasses))) {
+ KbdFeedbackPtr kf;
+
+ for (kf = dev->kbdfeed; (kf); kf = kf->next) {
+ if ((id == XkbAllXIIds) || (id == XkbDfltXIId) ||
+ (id == kf->ctrl.id)) {
+ length += SendDeviceLedInfo(kf->xkb_sli, client);
+ if (id != XkbAllXIIds)
+ break;
+ }
+ }
+ }
+ if ((dev->leds) &&
+ ((class == LedFeedbackClass) || (class == XkbAllXIClasses))) {
+ LedFeedbackPtr lf;
+
+ for (lf = dev->leds; (lf); lf = lf->next) {
+ if ((id == XkbAllXIIds) || (id == XkbDfltXIId) ||
+ (id == lf->ctrl.id)) {
+ length += SendDeviceLedInfo(lf->xkb_sli, client);
+ if (id != XkbAllXIIds)
+ break;
+ }
+ }
+ }
+ if (length == wantLength)
+ return Success;
+ else
+ return BadLength;
}
int
ProcXkbGetDeviceInfo(ClientPtr client)
{
-DeviceIntPtr dev;
-xkbGetDeviceInfoReply rep;
-int status,nDeviceLedFBs;
-unsigned length,nameLen;
-CARD16 ledClass,ledID;
-unsigned wanted;
-char * str;
+ DeviceIntPtr dev;
+ xkbGetDeviceInfoReply rep;
+ int status, nDeviceLedFBs;
+ unsigned length, nameLen;
+ CARD16 ledClass, ledID;
+ unsigned wanted;
+ char *str;
REQUEST(xkbGetDeviceInfoReq);
REQUEST_SIZE_MATCH(xkbGetDeviceInfoReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
- wanted= stuff->wanted;
+ wanted = stuff->wanted;
CHK_ANY_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess);
- CHK_MASK_LEGAL(0x01,wanted,XkbXI_AllDeviceFeaturesMask);
+ CHK_MASK_LEGAL(0x01, wanted, XkbXI_AllDeviceFeaturesMask);
- if ((!dev->button)||((stuff->nBtns<1)&&(!stuff->allBtns)))
- wanted&= ~XkbXI_ButtonActionsMask;
- if ((!dev->kbdfeed)&&(!dev->leds))
- wanted&= ~XkbXI_IndicatorsMask;
+ if ((!dev->button) || ((stuff->nBtns < 1) && (!stuff->allBtns)))
+ wanted &= ~XkbXI_ButtonActionsMask;
+ if ((!dev->kbdfeed) && (!dev->leds))
+ wanted &= ~XkbXI_IndicatorsMask;
- nameLen= XkbSizeCountedString(dev->name);
- memset((char *)&rep, 0, SIZEOF(xkbGetDeviceInfoReply));
+ nameLen = XkbSizeCountedString(dev->name);
+ memset((char *) &rep, 0, SIZEOF(xkbGetDeviceInfoReply));
rep.type = X_Reply;
- rep.deviceID= dev->id;
+ rep.deviceID = dev->id;
rep.sequenceNumber = client->sequence;
- rep.length = nameLen/4;
+ rep.length = nameLen / 4;
rep.present = wanted;
rep.supported = XkbXI_AllDeviceFeaturesMask;
rep.unsupported = 0;
rep.firstBtnWanted = rep.nBtnsWanted = 0;
rep.firstBtnRtrn = rep.nBtnsRtrn = 0;
if (dev->button)
- rep.totalBtns= dev->button->numButtons;
- else rep.totalBtns= 0;
- rep.devType= dev->xinput_type;
- rep.hasOwnState= (dev->key && dev->key->xkbInfo);
+ rep.totalBtns = dev->button->numButtons;
+ else
+ rep.totalBtns = 0;
+ rep.devType = dev->xinput_type;
+ rep.hasOwnState = (dev->key && dev->key->xkbInfo);
rep.nDeviceLedFBs = 0;
- if (dev->kbdfeed) rep.dfltKbdFB= dev->kbdfeed->ctrl.id;
- else rep.dfltKbdFB= XkbXINone;
- if (dev->leds) rep.dfltLedFB= dev->leds->ctrl.id;
- else rep.dfltLedFB= XkbXINone;
-
- ledClass= stuff->ledClass;
- ledID= stuff->ledID;
-
- rep.firstBtnWanted= rep.nBtnsWanted= 0;
- rep.firstBtnRtrn= rep.nBtnsRtrn= 0;
- if (wanted&XkbXI_ButtonActionsMask) {
- if (stuff->allBtns) {
- stuff->firstBtn= 0;
- stuff->nBtns= dev->button->numButtons;
- }
-
- if ((stuff->firstBtn+stuff->nBtns)>dev->button->numButtons) {
- client->errorValue = _XkbErrCode4(0x02,dev->button->numButtons,
- stuff->firstBtn,
- stuff->nBtns);
- return BadValue;
- }
- else {
- rep.firstBtnWanted= stuff->firstBtn;
- rep.nBtnsWanted= stuff->nBtns;
- if (dev->button->xkb_acts!=NULL) {
- XkbAction *act;
- register int i;
-
- rep.firstBtnRtrn= stuff->firstBtn;
- rep.nBtnsRtrn= stuff->nBtns;
- act= &dev->button->xkb_acts[rep.firstBtnWanted];
- for (i=0;i<rep.nBtnsRtrn;i++,act++) {
- if (act->type!=XkbSA_NoAction)
- break;
- }
- rep.firstBtnRtrn+= i;
- rep.nBtnsRtrn-= i;
- act= &dev->button->xkb_acts[rep.firstBtnRtrn+rep.nBtnsRtrn-1];
- for (i=0;i<rep.nBtnsRtrn;i++,act--) {
- if (act->type!=XkbSA_NoAction)
- break;
- }
- rep.nBtnsRtrn-= i;
- }
- rep.length+= (rep.nBtnsRtrn*SIZEOF(xkbActionWireDesc))/4;
- }
- }
-
- if (wanted&XkbXI_IndicatorsMask) {
- status= CheckDeviceLedFBs(dev,ledClass,ledID,&rep,client);
- if (status!=Success)
- return status;
- }
- length= rep.length*4;
+ if (dev->kbdfeed)
+ rep.dfltKbdFB = dev->kbdfeed->ctrl.id;
+ else
+ rep.dfltKbdFB = XkbXINone;
+ if (dev->leds)
+ rep.dfltLedFB = dev->leds->ctrl.id;
+ else
+ rep.dfltLedFB = XkbXINone;
+
+ ledClass = stuff->ledClass;
+ ledID = stuff->ledID;
+
+ rep.firstBtnWanted = rep.nBtnsWanted = 0;
+ rep.firstBtnRtrn = rep.nBtnsRtrn = 0;
+ if (wanted & XkbXI_ButtonActionsMask) {
+ if (stuff->allBtns) {
+ stuff->firstBtn = 0;
+ stuff->nBtns = dev->button->numButtons;
+ }
+
+ if ((stuff->firstBtn + stuff->nBtns) > dev->button->numButtons) {
+ client->errorValue = _XkbErrCode4(0x02, dev->button->numButtons,
+ stuff->firstBtn, stuff->nBtns);
+ return BadValue;
+ }
+ else {
+ rep.firstBtnWanted = stuff->firstBtn;
+ rep.nBtnsWanted = stuff->nBtns;
+ if (dev->button->xkb_acts != NULL) {
+ XkbAction *act;
+ register int i;
+
+ rep.firstBtnRtrn = stuff->firstBtn;
+ rep.nBtnsRtrn = stuff->nBtns;
+ act = &dev->button->xkb_acts[rep.firstBtnWanted];
+ for (i = 0; i < rep.nBtnsRtrn; i++, act++) {
+ if (act->type != XkbSA_NoAction)
+ break;
+ }
+ rep.firstBtnRtrn += i;
+ rep.nBtnsRtrn -= i;
+ act =
+ &dev->button->xkb_acts[rep.firstBtnRtrn + rep.nBtnsRtrn -
+ 1];
+ for (i = 0; i < rep.nBtnsRtrn; i++, act--) {
+ if (act->type != XkbSA_NoAction)
+ break;
+ }
+ rep.nBtnsRtrn -= i;
+ }
+ rep.length += (rep.nBtnsRtrn * SIZEOF(xkbActionWireDesc)) / 4;
+ }
+ }
+
+ if (wanted & XkbXI_IndicatorsMask) {
+ status = CheckDeviceLedFBs(dev, ledClass, ledID, &rep, client);
+ if (status != Success)
+ return status;
+ }
+ length = rep.length * 4;
nDeviceLedFBs = rep.nDeviceLedFBs;
if (client->swapped) {
- swaps(&rep.sequenceNumber);
- swapl(&rep.length);
- swaps(&rep.present);
- swaps(&rep.supported);
- swaps(&rep.unsupported);
- swaps(&rep.nDeviceLedFBs);
- swaps(&rep.dfltKbdFB);
- swaps(&rep.dfltLedFB);
- swapl(&rep.devType);
- }
- WriteToClient(client,SIZEOF(xkbGetDeviceInfoReply), (char *)&rep);
-
- str= malloc(nameLen);
- if (!str)
- return BadAlloc;
- XkbWriteCountedString(str,dev->name,client->swapped);
- WriteToClient(client,nameLen,str);
+ swaps(&rep.sequenceNumber);
+ swapl(&rep.length);
+ swaps(&rep.present);
+ swaps(&rep.supported);
+ swaps(&rep.unsupported);
+ swaps(&rep.nDeviceLedFBs);
+ swaps(&rep.dfltKbdFB);
+ swaps(&rep.dfltLedFB);
+ swapl(&rep.devType);
+ }
+ WriteToClient(client, SIZEOF(xkbGetDeviceInfoReply), (char *) &rep);
+
+ str = malloc(nameLen);
+ if (!str)
+ return BadAlloc;
+ XkbWriteCountedString(str, dev->name, client->swapped);
+ WriteToClient(client, nameLen, str);
free(str);
- length-= nameLen;
-
- if (rep.nBtnsRtrn>0) {
- int sz;
- xkbActionWireDesc * awire;
- sz= rep.nBtnsRtrn*SIZEOF(xkbActionWireDesc);
- awire= (xkbActionWireDesc *)&dev->button->xkb_acts[rep.firstBtnRtrn];
- WriteToClient(client,sz,(char *)awire);
- length-= sz;
- }
- if (nDeviceLedFBs>0) {
- status= SendDeviceLedFBs(dev,ledClass,ledID,length,client);
- if (status!=Success)
- return status;
- }
- else if (length!=0) {
- ErrorF("[xkb] Internal Error! BadLength in ProcXkbGetDeviceInfo\n");
- ErrorF("[xkb] Wrote %d fewer bytes than expected\n",length);
- return BadLength;
+ length -= nameLen;
+
+ if (rep.nBtnsRtrn > 0) {
+ int sz;
+ xkbActionWireDesc *awire;
+
+ sz = rep.nBtnsRtrn * SIZEOF(xkbActionWireDesc);
+ awire = (xkbActionWireDesc *) & dev->button->xkb_acts[rep.firstBtnRtrn];
+ WriteToClient(client, sz, (char *) awire);
+ length -= sz;
+ }
+ if (nDeviceLedFBs > 0) {
+ status = SendDeviceLedFBs(dev, ledClass, ledID, length, client);
+ if (status != Success)
+ return status;
+ }
+ else if (length != 0) {
+ ErrorF("[xkb] Internal Error! BadLength in ProcXkbGetDeviceInfo\n");
+ ErrorF("[xkb] Wrote %d fewer bytes than expected\n",
+ length);
+ return BadLength;
}
return Success;
}
static char *
-CheckSetDeviceIndicators( char * wire,
- DeviceIntPtr dev,
- int num,
- int * status_rtrn,
- ClientPtr client)
+CheckSetDeviceIndicators(char *wire,
+ DeviceIntPtr dev,
+ int num, int *status_rtrn, ClientPtr client)
{
-xkbDeviceLedsWireDesc * ledWire;
-int i;
-XkbSrvLedInfoPtr sli;
-
- ledWire= (xkbDeviceLedsWireDesc *)wire;
- for (i=0;i<num;i++) {
- if (client->swapped) {
- swaps(&ledWire->ledClass);
- swaps(&ledWire->ledID);
- swapl(&ledWire->namesPresent);
- swapl(&ledWire->mapsPresent);
- swapl(&ledWire->physIndicators);
- }
-
- sli= XkbFindSrvLedInfo(dev,ledWire->ledClass,ledWire->ledID,
- XkbXI_IndicatorsMask);
- if (sli!=NULL) {
- register int n;
- register unsigned bit;
- int nMaps,nNames;
- CARD32 *atomWire;
- xkbIndicatorMapWireDesc *mapWire;
-
- nMaps= nNames= 0;
- for (n=0,bit=1;n<XkbNumIndicators;n++,bit<<=1) {
- if (ledWire->namesPresent&bit)
- nNames++;
- if (ledWire->mapsPresent&bit)
- nMaps++;
- }
- atomWire= (CARD32 *)&ledWire[1];
- if (nNames>0) {
- for (n=0;n<nNames;n++) {
- if (client->swapped) {
- swapl(atomWire);
- }
- CHK_ATOM_OR_NONE3(((Atom)(*atomWire)),client->errorValue,
- *status_rtrn,NULL);
- atomWire++;
- }
- }
- mapWire= (xkbIndicatorMapWireDesc *)atomWire;
- if (nMaps>0) {
- for (n=0;n<nMaps;n++) {
- if (client->swapped) {
- swaps(&mapWire->virtualMods);
- swapl(&mapWire->ctrls);
- }
- CHK_MASK_LEGAL3(0x21,mapWire->whichGroups,
- XkbIM_UseAnyGroup,
- client->errorValue,
- *status_rtrn,NULL);
- CHK_MASK_LEGAL3(0x22,mapWire->whichMods,XkbIM_UseAnyMods,
- client->errorValue,
- *status_rtrn,NULL);
- mapWire++;
- }
- }
- ledWire= (xkbDeviceLedsWireDesc *)mapWire;
- }
- else {
- /* SHOULD NEVER HAPPEN */
- return (char *)ledWire;
- }
- }
- return (char *)ledWire;
+ xkbDeviceLedsWireDesc *ledWire;
+ int i;
+ XkbSrvLedInfoPtr sli;
+
+ ledWire = (xkbDeviceLedsWireDesc *) wire;
+ for (i = 0; i < num; i++) {
+ if (client->swapped) {
+ swaps(&ledWire->ledClass);
+ swaps(&ledWire->ledID);
+ swapl(&ledWire->namesPresent);
+ swapl(&ledWire->mapsPresent);
+ swapl(&ledWire->physIndicators);
+ }
+
+ sli = XkbFindSrvLedInfo(dev, ledWire->ledClass, ledWire->ledID,
+ XkbXI_IndicatorsMask);
+ if (sli != NULL) {
+ register int n;
+ register unsigned bit;
+ int nMaps, nNames;
+ CARD32 *atomWire;
+ xkbIndicatorMapWireDesc *mapWire;
+
+ nMaps = nNames = 0;
+ for (n = 0, bit = 1; n < XkbNumIndicators; n++, bit <<= 1) {
+ if (ledWire->namesPresent & bit)
+ nNames++;
+ if (ledWire->mapsPresent & bit)
+ nMaps++;
+ }
+ atomWire = (CARD32 *) &ledWire[1];
+ if (nNames > 0) {
+ for (n = 0; n < nNames; n++) {
+ if (client->swapped) {
+ swapl(atomWire);
+ }
+ CHK_ATOM_OR_NONE3(((Atom) (*atomWire)), client->errorValue,
+ *status_rtrn, NULL);
+ atomWire++;
+ }
+ }
+ mapWire = (xkbIndicatorMapWireDesc *) atomWire;
+ if (nMaps > 0) {
+ for (n = 0; n < nMaps; n++) {
+ if (client->swapped) {
+ swaps(&mapWire->virtualMods);
+ swapl(&mapWire->ctrls);
+ }
+ CHK_MASK_LEGAL3(0x21, mapWire->whichGroups,
+ XkbIM_UseAnyGroup,
+ client->errorValue, *status_rtrn, NULL);
+ CHK_MASK_LEGAL3(0x22, mapWire->whichMods, XkbIM_UseAnyMods,
+ client->errorValue, *status_rtrn, NULL);
+ mapWire++;
+ }
+ }
+ ledWire = (xkbDeviceLedsWireDesc *) mapWire;
+ }
+ else {
+ /* SHOULD NEVER HAPPEN */
+ return (char *) ledWire;
+ }
+ }
+ return (char *) ledWire;
}
static char *
-SetDeviceIndicators( char * wire,
- DeviceIntPtr dev,
- unsigned changed,
- int num,
- int * status_rtrn,
- ClientPtr client,
- xkbExtensionDeviceNotify *ev)
+SetDeviceIndicators(char *wire,
+ DeviceIntPtr dev,
+ unsigned changed,
+ int num,
+ int *status_rtrn,
+ ClientPtr client, xkbExtensionDeviceNotify * ev)
{
-xkbDeviceLedsWireDesc * ledWire;
-int i;
-XkbEventCauseRec cause;
-unsigned namec,mapc,statec;
-xkbExtensionDeviceNotify ed;
-XkbChangesRec changes;
-DeviceIntPtr kbd;
-
- memset((char *)&ed, 0, sizeof(xkbExtensionDeviceNotify));
- memset((char *)&changes, 0, sizeof(XkbChangesRec));
- XkbSetCauseXkbReq(&cause,X_kbSetDeviceInfo,client);
- ledWire= (xkbDeviceLedsWireDesc *)wire;
- for (i=0;i<num;i++) {
- register int n;
- register unsigned bit;
- CARD32 * atomWire;
- xkbIndicatorMapWireDesc * mapWire;
- XkbSrvLedInfoPtr sli;
-
- namec= mapc= statec= 0;
- sli= XkbFindSrvLedInfo(dev,ledWire->ledClass,ledWire->ledID,
- XkbXI_IndicatorMapsMask);
- if (!sli) {
- /* SHOULD NEVER HAPPEN!! */
- return (char *)ledWire;
- }
-
- atomWire= (CARD32 *)&ledWire[1];
- if (changed&XkbXI_IndicatorNamesMask) {
- namec= sli->namesPresent|ledWire->namesPresent;
- memset((char *)sli->names, 0, XkbNumIndicators*sizeof(Atom));
- }
- if (ledWire->namesPresent) {
- sli->namesPresent= ledWire->namesPresent;
- memset((char *)sli->names, 0, XkbNumIndicators*sizeof(Atom));
- for (n=0,bit=1;n<XkbNumIndicators;n++,bit<<=1) {
- if (ledWire->namesPresent&bit) {
- sli->names[n]= (Atom)*atomWire;
- if (sli->names[n]==None)
- ledWire->namesPresent&= ~bit;
- atomWire++;
- }
- }
- }
- mapWire= (xkbIndicatorMapWireDesc *)atomWire;
- if (changed&XkbXI_IndicatorMapsMask) {
- mapc= sli->mapsPresent|ledWire->mapsPresent;
- sli->mapsPresent= ledWire->mapsPresent;
- memset((char*)sli->maps, 0, XkbNumIndicators*sizeof(XkbIndicatorMapRec));
- }
- if (ledWire->mapsPresent) {
- for (n=0,bit=1;n<XkbNumIndicators;n++,bit<<=1) {
- if (ledWire->mapsPresent&bit) {
- sli->maps[n].flags= mapWire->flags;
- sli->maps[n].which_groups= mapWire->whichGroups;
- sli->maps[n].groups= mapWire->groups;
- sli->maps[n].which_mods= mapWire->whichMods;
- sli->maps[n].mods.mask= mapWire->mods;
- sli->maps[n].mods.real_mods=mapWire->realMods;
- sli->maps[n].mods.vmods= mapWire->virtualMods;
- sli->maps[n].ctrls= mapWire->ctrls;
- mapWire++;
- }
- }
- }
- if (changed&XkbXI_IndicatorStateMask) {
- statec= sli->effectiveState^ledWire->state;
- sli->explicitState&= ~statec;
- sli->explicitState|= (ledWire->state&statec);
- }
- if (namec)
- XkbApplyLedNameChanges(dev,sli,namec,&ed,&changes,&cause);
- if (mapc)
- XkbApplyLedMapChanges(dev,sli,mapc,&ed,&changes,&cause);
- if (statec)
- XkbApplyLedStateChanges(dev,sli,statec,&ed,&changes,&cause);
-
- kbd= dev;
- if ((sli->flags&XkbSLI_HasOwnState)==0)
- kbd = inputInfo.keyboard;
-
- XkbFlushLedEvents(dev,kbd,sli,&ed,&changes,&cause);
- ledWire= (xkbDeviceLedsWireDesc *)mapWire;
- }
- return (char *)ledWire;
-}
+ xkbDeviceLedsWireDesc *ledWire;
+ int i;
+ XkbEventCauseRec cause;
+ unsigned namec, mapc, statec;
+ xkbExtensionDeviceNotify ed;
+ XkbChangesRec changes;
+ DeviceIntPtr kbd;
+
+ memset((char *) &ed, 0, sizeof(xkbExtensionDeviceNotify));
+ memset((char *) &changes, 0, sizeof(XkbChangesRec));
+ XkbSetCauseXkbReq(&cause, X_kbSetDeviceInfo, client);
+ ledWire = (xkbDeviceLedsWireDesc *) wire;
+ for (i = 0; i < num; i++) {
+ register int n;
+ register unsigned bit;
+ CARD32 *atomWire;
+ xkbIndicatorMapWireDesc *mapWire;
+ XkbSrvLedInfoPtr sli;
+
+ namec = mapc = statec = 0;
+ sli = XkbFindSrvLedInfo(dev, ledWire->ledClass, ledWire->ledID,
+ XkbXI_IndicatorMapsMask);
+ if (!sli) {
+ /* SHOULD NEVER HAPPEN!! */
+ return (char *) ledWire;
+ }
+
+ atomWire = (CARD32 *) &ledWire[1];
+ if (changed & XkbXI_IndicatorNamesMask) {
+ namec = sli->namesPresent | ledWire->namesPresent;
+ memset((char *) sli->names, 0, XkbNumIndicators * sizeof(Atom));
+ }
+ if (ledWire->namesPresent) {
+ sli->namesPresent = ledWire->namesPresent;
+ memset((char *) sli->names, 0, XkbNumIndicators * sizeof(Atom));
+ for (n = 0, bit = 1; n < XkbNumIndicators; n++, bit <<= 1) {
+ if (ledWire->namesPresent & bit) {
+ sli->names[n] = (Atom) *atomWire;
+ if (sli->names[n] == None)
+ ledWire->namesPresent &= ~bit;
+ atomWire++;
+ }
+ }
+ }
+ mapWire = (xkbIndicatorMapWireDesc *) atomWire;
+ if (changed & XkbXI_IndicatorMapsMask) {
+ mapc = sli->mapsPresent | ledWire->mapsPresent;
+ sli->mapsPresent = ledWire->mapsPresent;
+ memset((char *) sli->maps, 0,
+ XkbNumIndicators * sizeof(XkbIndicatorMapRec));
+ }
+ if (ledWire->mapsPresent) {
+ for (n = 0, bit = 1; n < XkbNumIndicators; n++, bit <<= 1) {
+ if (ledWire->mapsPresent & bit) {
+ sli->maps[n].flags = mapWire->flags;
+ sli->maps[n].which_groups = mapWire->whichGroups;
+ sli->maps[n].groups = mapWire->groups;
+ sli->maps[n].which_mods = mapWire->whichMods;
+ sli->maps[n].mods.mask = mapWire->mods;
+ sli->maps[n].mods.real_mods = mapWire->realMods;
+ sli->maps[n].mods.vmods = mapWire->virtualMods;
+ sli->maps[n].ctrls = mapWire->ctrls;
+ mapWire++;
+ }
+ }
+ }
+ if (changed & XkbXI_IndicatorStateMask) {
+ statec = sli->effectiveState ^ ledWire->state;
+ sli->explicitState &= ~statec;
+ sli->explicitState |= (ledWire->state & statec);
+ }
+ if (namec)
+ XkbApplyLedNameChanges(dev, sli, namec, &ed, &changes, &cause);
+ if (mapc)
+ XkbApplyLedMapChanges(dev, sli, mapc, &ed, &changes, &cause);
+ if (statec)
+ XkbApplyLedStateChanges(dev, sli, statec, &ed, &changes, &cause);
+ kbd = dev;
+ if ((sli->flags & XkbSLI_HasOwnState) == 0)
+ kbd = inputInfo.keyboard;
+
+ XkbFlushLedEvents(dev, kbd, sli, &ed, &changes, &cause);
+ ledWire = (xkbDeviceLedsWireDesc *) mapWire;
+ }
+ return (char *) ledWire;
+}
static int
_XkbSetDeviceInfo(ClientPtr client, DeviceIntPtr dev,
- xkbSetDeviceInfoReq *stuff)
+ xkbSetDeviceInfoReq * stuff)
{
- char *wire;
-
- wire= (char *)&stuff[1];
- if (stuff->change&XkbXI_ButtonActionsMask) {
- if (!dev->button) {
- client->errorValue = _XkbErrCode2(XkbErr_BadClass,ButtonClass);
- return XkbKeyboardErrorCode;
- }
- if ((stuff->firstBtn+stuff->nBtns)>dev->button->numButtons) {
- client->errorValue= _XkbErrCode4(0x02,stuff->firstBtn,stuff->nBtns,
- dev->button->numButtons);
- return BadMatch;
- }
- wire+= (stuff->nBtns*SIZEOF(xkbActionWireDesc));
- }
- if (stuff->change&XkbXI_IndicatorsMask) {
- int status= Success;
- wire= CheckSetDeviceIndicators(wire,dev,stuff->nDeviceLedFBs,
- &status,client);
- if (status!=Success)
- return status;
- }
- if (((wire-((char *)stuff))/4)!=stuff->length)
- return BadLength;
+ char *wire;
+
+ wire = (char *) &stuff[1];
+ if (stuff->change & XkbXI_ButtonActionsMask) {
+ if (!dev->button) {
+ client->errorValue = _XkbErrCode2(XkbErr_BadClass, ButtonClass);
+ return XkbKeyboardErrorCode;
+ }
+ if ((stuff->firstBtn + stuff->nBtns) > dev->button->numButtons) {
+ client->errorValue =
+ _XkbErrCode4(0x02, stuff->firstBtn, stuff->nBtns,
+ dev->button->numButtons);
+ return BadMatch;
+ }
+ wire += (stuff->nBtns * SIZEOF(xkbActionWireDesc));
+ }
+ if (stuff->change & XkbXI_IndicatorsMask) {
+ int status = Success;
+
+ wire = CheckSetDeviceIndicators(wire, dev, stuff->nDeviceLedFBs,
+ &status, client);
+ if (status != Success)
+ return status;
+ }
+ if (((wire - ((char *) stuff)) / 4) != stuff->length)
+ return BadLength;
return Success;
}
static int
_XkbSetDeviceInfoCheck(ClientPtr client, DeviceIntPtr dev,
- xkbSetDeviceInfoReq *stuff)
+ xkbSetDeviceInfoReq * stuff)
{
- char *wire;
- xkbExtensionDeviceNotify ed;
-
- memset((char *)&ed, 0, SIZEOF(xkbExtensionDeviceNotify));
- ed.deviceID= dev->id;
- wire= (char *)&stuff[1];
- if (stuff->change&XkbXI_ButtonActionsMask) {
- int nBtns,sz,i;
- XkbAction * acts;
- DeviceIntPtr kbd;
-
- nBtns= dev->button->numButtons;
- acts= dev->button->xkb_acts;
- if (acts==NULL) {
- acts= calloc(nBtns, sizeof(XkbAction));
- if (!acts)
- return BadAlloc;
- dev->button->xkb_acts= acts;
- }
- sz= stuff->nBtns*SIZEOF(xkbActionWireDesc);
- memcpy((char *)&acts[stuff->firstBtn],(char *)wire,sz);
- wire+= sz;
- ed.reason|= XkbXI_ButtonActionsMask;
- ed.firstBtn= stuff->firstBtn;
- ed.nBtns= stuff->nBtns;
-
- if (dev->key) kbd= dev;
- else kbd= inputInfo.keyboard;
- acts= &dev->button->xkb_acts[stuff->firstBtn];
- for (i=0;i<stuff->nBtns;i++,acts++) {
- if (acts->type!=XkbSA_NoAction)
- XkbSetActionKeyMods(kbd->key->xkbInfo->desc,acts,0);
- }
- }
- if (stuff->change&XkbXI_IndicatorsMask) {
- int status= Success;
- wire= SetDeviceIndicators(wire,dev,stuff->change,
- stuff->nDeviceLedFBs, &status,client,&ed);
- if (status!=Success)
- return status;
- }
- if ((stuff->change)&&(ed.reason))
- XkbSendExtensionDeviceNotify(dev,client,&ed);
+ char *wire;
+ xkbExtensionDeviceNotify ed;
+
+ memset((char *) &ed, 0, SIZEOF(xkbExtensionDeviceNotify));
+ ed.deviceID = dev->id;
+ wire = (char *) &stuff[1];
+ if (stuff->change & XkbXI_ButtonActionsMask) {
+ int nBtns, sz, i;
+ XkbAction *acts;
+ DeviceIntPtr kbd;
+
+ nBtns = dev->button->numButtons;
+ acts = dev->button->xkb_acts;
+ if (acts == NULL) {
+ acts = calloc(nBtns, sizeof(XkbAction));
+ if (!acts)
+ return BadAlloc;
+ dev->button->xkb_acts = acts;
+ }
+ sz = stuff->nBtns * SIZEOF(xkbActionWireDesc);
+ memcpy((char *) &acts[stuff->firstBtn], (char *) wire, sz);
+ wire += sz;
+ ed.reason |= XkbXI_ButtonActionsMask;
+ ed.firstBtn = stuff->firstBtn;
+ ed.nBtns = stuff->nBtns;
+
+ if (dev->key)
+ kbd = dev;
+ else
+ kbd = inputInfo.keyboard;
+ acts = &dev->button->xkb_acts[stuff->firstBtn];
+ for (i = 0; i < stuff->nBtns; i++, acts++) {
+ if (acts->type != XkbSA_NoAction)
+ XkbSetActionKeyMods(kbd->key->xkbInfo->desc, acts, 0);
+ }
+ }
+ if (stuff->change & XkbXI_IndicatorsMask) {
+ int status = Success;
+
+ wire = SetDeviceIndicators(wire, dev, stuff->change,
+ stuff->nDeviceLedFBs, &status, client, &ed);
+ if (status != Success)
+ return status;
+ }
+ if ((stuff->change) && (ed.reason))
+ XkbSendExtensionDeviceNotify(dev, client, &ed);
return Success;
}
int
ProcXkbSetDeviceInfo(ClientPtr client)
{
- DeviceIntPtr dev;
- int rc;
+ DeviceIntPtr dev;
+ int rc;
REQUEST(xkbSetDeviceInfoReq);
REQUEST_AT_LEAST_SIZE(xkbSetDeviceInfoReq);
- if (!(client->xkbClientFlags&_XkbClientInitialized))
- return BadAccess;
+ if (!(client->xkbClientFlags & _XkbClientInitialized))
+ return BadAccess;
CHK_ANY_DEVICE(dev, stuff->deviceSpec, client, DixManageAccess);
- CHK_MASK_LEGAL(0x01,stuff->change,XkbXI_AllFeaturesMask);
+ CHK_MASK_LEGAL(0x01, stuff->change, XkbXI_AllFeaturesMask);
rc = _XkbSetDeviceInfoCheck(client, dev, stuff);
if (rc != Success)
return rc;
- if (stuff->deviceSpec == XkbUseCoreKbd || stuff->deviceSpec == XkbUseCorePtr)
- {
+ if (stuff->deviceSpec == XkbUseCoreKbd ||
+ stuff->deviceSpec == XkbUseCorePtr) {
DeviceIntPtr other;
- for (other = inputInfo.devices; other; other = other->next)
- {
- if (((other != dev) && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev) &&
+
+ for (other = inputInfo.devices; other; other = other->next) {
+ if (((other != dev) && !IsMaster(other) &&
+ GetMaster(other, MASTER_KEYBOARD) == dev) &&
((stuff->deviceSpec == XkbUseCoreKbd && other->key) ||
- (stuff->deviceSpec == XkbUseCorePtr && other->button)))
- {
- rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixManageAccess);
- if (rc == Success)
- {
+ (stuff->deviceSpec == XkbUseCorePtr && other->button))) {
+ rc = XaceHook(XACE_DEVICE_ACCESS, client, other,
+ DixManageAccess);
+ if (rc == Success) {
rc = _XkbSetDeviceInfoCheck(client, other, stuff);
if (rc != Success)
return rc;
@@ -6524,18 +6675,18 @@ ProcXkbSetDeviceInfo(ClientPtr client)
if (rc != Success)
return rc;
- if (stuff->deviceSpec == XkbUseCoreKbd || stuff->deviceSpec == XkbUseCorePtr)
- {
+ if (stuff->deviceSpec == XkbUseCoreKbd ||
+ stuff->deviceSpec == XkbUseCorePtr) {
DeviceIntPtr other;
- for (other = inputInfo.devices; other; other = other->next)
- {
- if (((other != dev) && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev) &&
+
+ for (other = inputInfo.devices; other; other = other->next) {
+ if (((other != dev) && !IsMaster(other) &&
+ GetMaster(other, MASTER_KEYBOARD) == dev) &&
((stuff->deviceSpec == XkbUseCoreKbd && other->key) ||
- (stuff->deviceSpec == XkbUseCorePtr && other->button)))
- {
- rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixManageAccess);
- if (rc == Success)
- {
+ (stuff->deviceSpec == XkbUseCorePtr && other->button))) {
+ rc = XaceHook(XACE_DEVICE_ACCESS, client, other,
+ DixManageAccess);
+ if (rc == Success) {
rc = _XkbSetDeviceInfo(client, other, stuff);
if (rc != Success)
return rc;
@@ -6552,135 +6703,139 @@ ProcXkbSetDeviceInfo(ClientPtr client)
int
ProcXkbSetDebuggingFlags(ClientPtr client)
{
-CARD32 newFlags,newCtrls,extraLength;
-xkbSetDebuggingFlagsReply rep;
-int rc;
+ CARD32 newFlags, newCtrls, extraLength;
+ xkbSetDebuggingFlagsReply rep;
+ int rc;
REQUEST(xkbSetDebuggingFlagsReq);
REQUEST_AT_LEAST_SIZE(xkbSetDebuggingFlagsReq);
rc = XaceHook(XACE_SERVER_ACCESS, client, DixDebugAccess);
if (rc != Success)
- return rc;
+ return rc;
- newFlags= xkbDebugFlags&(~stuff->affectFlags);
- newFlags|= (stuff->flags&stuff->affectFlags);
- newCtrls= xkbDebugCtrls&(~stuff->affectCtrls);
- newCtrls|= (stuff->ctrls&stuff->affectCtrls);
+ newFlags = xkbDebugFlags & (~stuff->affectFlags);
+ newFlags |= (stuff->flags & stuff->affectFlags);
+ newCtrls = xkbDebugCtrls & (~stuff->affectCtrls);
+ newCtrls |= (stuff->ctrls & stuff->affectCtrls);
if (xkbDebugFlags || newFlags || stuff->msgLength) {
- ErrorF("[xkb] XkbDebug: Setting debug flags to 0x%lx\n",(long)newFlags);
- if (newCtrls!=xkbDebugCtrls)
- ErrorF("[xkb] XkbDebug: Setting debug controls to 0x%lx\n",(long)newCtrls);
- }
- extraLength= (stuff->length<<2)-sz_xkbSetDebuggingFlagsReq;
- if (stuff->msgLength>0) {
- char *msg;
- if (extraLength<XkbPaddedSize(stuff->msgLength)) {
- ErrorF("[xkb] XkbDebug: msgLength= %d, length= %ld (should be %d)\n",
- stuff->msgLength,(long)extraLength,
- XkbPaddedSize(stuff->msgLength));
- return BadLength;
- }
- msg= (char *)&stuff[1];
- if (msg[stuff->msgLength-1]!='\0') {
- ErrorF("[xkb] XkbDebug: message not null-terminated\n");
- return BadValue;
- }
- ErrorF("[xkb] XkbDebug: %s\n",msg);
+ ErrorF("[xkb] XkbDebug: Setting debug flags to 0x%lx\n",
+ (long) newFlags);
+ if (newCtrls != xkbDebugCtrls)
+ ErrorF("[xkb] XkbDebug: Setting debug controls to 0x%lx\n",
+ (long) newCtrls);
+ }
+ extraLength = (stuff->length << 2) - sz_xkbSetDebuggingFlagsReq;
+ if (stuff->msgLength > 0) {
+ char *msg;
+
+ if (extraLength < XkbPaddedSize(stuff->msgLength)) {
+ ErrorF
+ ("[xkb] XkbDebug: msgLength= %d, length= %ld (should be %d)\n",
+ stuff->msgLength, (long) extraLength,
+ XkbPaddedSize(stuff->msgLength));
+ return BadLength;
+ }
+ msg = (char *) &stuff[1];
+ if (msg[stuff->msgLength - 1] != '\0') {
+ ErrorF("[xkb] XkbDebug: message not null-terminated\n");
+ return BadValue;
+ }
+ ErrorF("[xkb] XkbDebug: %s\n", msg);
}
xkbDebugFlags = newFlags;
xkbDebugCtrls = newCtrls;
- rep.type= X_Reply;
+ rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
rep.currentFlags = newFlags;
rep.currentCtrls = newCtrls;
rep.supportedFlags = ~0;
rep.supportedCtrls = ~0;
- if ( client->swapped ) {
- swaps(&rep.sequenceNumber);
- swapl(&rep.currentFlags);
- swapl(&rep.currentCtrls);
- swapl(&rep.supportedFlags);
- swapl(&rep.supportedCtrls);
- }
- WriteToClient(client,SIZEOF(xkbSetDebuggingFlagsReply), (char *)&rep);
+ if (client->swapped) {
+ swaps(&rep.sequenceNumber);
+ swapl(&rep.currentFlags);
+ swapl(&rep.currentCtrls);
+ swapl(&rep.supportedFlags);
+ swapl(&rep.supportedCtrls);
+ }
+ WriteToClient(client, SIZEOF(xkbSetDebuggingFlagsReply), (char *) &rep);
return Success;
}
/***====================================================================***/
static int
-ProcXkbDispatch (ClientPtr client)
+ProcXkbDispatch(ClientPtr client)
{
REQUEST(xReq);
- switch (stuff->data)
- {
+ switch (stuff->data) {
case X_kbUseExtension:
- return ProcXkbUseExtension(client);
+ return ProcXkbUseExtension(client);
case X_kbSelectEvents:
- return ProcXkbSelectEvents(client);
+ return ProcXkbSelectEvents(client);
case X_kbBell:
- return ProcXkbBell(client);
+ return ProcXkbBell(client);
case X_kbGetState:
- return ProcXkbGetState(client);
+ return ProcXkbGetState(client);
case X_kbLatchLockState:
- return ProcXkbLatchLockState(client);
+ return ProcXkbLatchLockState(client);
case X_kbGetControls:
- return ProcXkbGetControls(client);
+ return ProcXkbGetControls(client);
case X_kbSetControls:
- return ProcXkbSetControls(client);
+ return ProcXkbSetControls(client);
case X_kbGetMap:
- return ProcXkbGetMap(client);
+ return ProcXkbGetMap(client);
case X_kbSetMap:
- return ProcXkbSetMap(client);
+ return ProcXkbSetMap(client);
case X_kbGetCompatMap:
- return ProcXkbGetCompatMap(client);
+ return ProcXkbGetCompatMap(client);
case X_kbSetCompatMap:
- return ProcXkbSetCompatMap(client);
+ return ProcXkbSetCompatMap(client);
case X_kbGetIndicatorState:
- return ProcXkbGetIndicatorState(client);
+ return ProcXkbGetIndicatorState(client);
case X_kbGetIndicatorMap:
- return ProcXkbGetIndicatorMap(client);
+ return ProcXkbGetIndicatorMap(client);
case X_kbSetIndicatorMap:
- return ProcXkbSetIndicatorMap(client);
+ return ProcXkbSetIndicatorMap(client);
case X_kbGetNamedIndicator:
- return ProcXkbGetNamedIndicator(client);
+ return ProcXkbGetNamedIndicator(client);
case X_kbSetNamedIndicator:
- return ProcXkbSetNamedIndicator(client);
+ return ProcXkbSetNamedIndicator(client);
case X_kbGetNames:
- return ProcXkbGetNames(client);
+ return ProcXkbGetNames(client);
case X_kbSetNames:
- return ProcXkbSetNames(client);
+ return ProcXkbSetNames(client);
case X_kbGetGeometry:
- return ProcXkbGetGeometry(client);
+ return ProcXkbGetGeometry(client);
case X_kbSetGeometry:
- return ProcXkbSetGeometry(client);
+ return ProcXkbSetGeometry(client);
case X_kbPerClientFlags:
- return ProcXkbPerClientFlags(client);
+ return ProcXkbPerClientFlags(client);
case X_kbListComponents:
- return ProcXkbListComponents(client);
+ return ProcXkbListComponents(client);
case X_kbGetKbdByName:
- return ProcXkbGetKbdByName(client);
+ return ProcXkbGetKbdByName(client);
case X_kbGetDeviceInfo:
- return ProcXkbGetDeviceInfo(client);
+ return ProcXkbGetDeviceInfo(client);
case X_kbSetDeviceInfo:
- return ProcXkbSetDeviceInfo(client);
+ return ProcXkbSetDeviceInfo(client);
case X_kbSetDebuggingFlags:
- return ProcXkbSetDebuggingFlags(client);
+ return ProcXkbSetDebuggingFlags(client);
default:
- return BadRequest;
+ return BadRequest;
}
}
static int
-XkbClientGone(pointer data,XID id)
+XkbClientGone(pointer data, XID id)
{
- DevicePtr pXDev = (DevicePtr)data;
+ DevicePtr pXDev = (DevicePtr) data;
- if (!XkbRemoveResourceClient(pXDev,id)) {
- ErrorF("[xkb] Internal Error! bad RemoveResourceClient in XkbClientGone\n");
+ if (!XkbRemoveResourceClient(pXDev, id)) {
+ ErrorF
+ ("[xkb] Internal Error! bad RemoveResourceClient in XkbClientGone\n");
}
return 1;
}
@@ -6692,20 +6847,18 @@ XkbExtensionInit(void)
RT_XKBCLIENT = CreateNewResourceType(XkbClientGone, "XkbClient");
if (!RT_XKBCLIENT)
- return;
+ return;
if (!XkbInitPrivates())
- return;
+ return;
if ((extEntry = AddExtension(XkbName, XkbNumberEvents, XkbNumberErrors,
- ProcXkbDispatch, SProcXkbDispatch,
- NULL, StandardMinorOpcode))) {
- XkbReqCode = (unsigned char)extEntry->base;
- XkbEventBase = (unsigned char)extEntry->eventBase;
- XkbErrorBase = (unsigned char)extEntry->errorBase;
- XkbKeyboardErrorCode = XkbErrorBase+XkbKeyboard;
+ ProcXkbDispatch, SProcXkbDispatch,
+ NULL, StandardMinorOpcode))) {
+ XkbReqCode = (unsigned char) extEntry->base;
+ XkbEventBase = (unsigned char) extEntry->eventBase;
+ XkbErrorBase = (unsigned char) extEntry->errorBase;
+ XkbKeyboardErrorCode = XkbErrorBase + XkbKeyboard;
}
return;
}
-
-
diff --git a/xkb/xkbAccessX.c b/xkb/xkbAccessX.c
index d246827ea..111bf9f40 100644
--- a/xkb/xkbAccessX.c
+++ b/xkb/xkbAccessX.c
@@ -43,49 +43,52 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <sys/time.h>
#endif
-int XkbDfltRepeatDelay= 660;
-int XkbDfltRepeatInterval= 40;
+int XkbDfltRepeatDelay = 660;
+int XkbDfltRepeatInterval = 40;
#define DFLT_TIMEOUT_CTRLS (XkbAX_KRGMask|XkbStickyKeysMask|XkbMouseKeysMask)
#define DFLT_TIMEOUT_OPTS (XkbAX_IndicatorFBMask)
-unsigned short XkbDfltAccessXTimeout= 120;
-unsigned int XkbDfltAccessXTimeoutMask= DFLT_TIMEOUT_CTRLS;
-static unsigned int XkbDfltAccessXTimeoutValues= 0;
-static unsigned int XkbDfltAccessXTimeoutOptionsMask= DFLT_TIMEOUT_OPTS;
-static unsigned int XkbDfltAccessXTimeoutOptionsValues= 0;
-unsigned int XkbDfltAccessXFeedback= XkbAccessXFeedbackMask;
-unsigned short XkbDfltAccessXOptions= XkbAX_AllOptionsMask & ~(XkbAX_IndicatorFBMask|XkbAX_SKReleaseFBMask|XkbAX_SKRejectFBMask);
+unsigned short XkbDfltAccessXTimeout = 120;
+unsigned int XkbDfltAccessXTimeoutMask = DFLT_TIMEOUT_CTRLS;
+static unsigned int XkbDfltAccessXTimeoutValues = 0;
+static unsigned int XkbDfltAccessXTimeoutOptionsMask = DFLT_TIMEOUT_OPTS;
+static unsigned int XkbDfltAccessXTimeoutOptionsValues = 0;
+unsigned int XkbDfltAccessXFeedback = XkbAccessXFeedbackMask;
+unsigned short XkbDfltAccessXOptions =
+ XkbAX_AllOptionsMask & ~(XkbAX_IndicatorFBMask | XkbAX_SKReleaseFBMask |
+ XkbAX_SKRejectFBMask);
void
-AccessXComputeCurveFactor(XkbSrvInfoPtr xkbi,XkbControlsPtr ctrls)
+AccessXComputeCurveFactor(XkbSrvInfoPtr xkbi, XkbControlsPtr ctrls)
{
- xkbi->mouseKeysCurve= 1.0+(((double)ctrls->mk_curve)*0.001);
- xkbi->mouseKeysCurveFactor= ( ((double)ctrls->mk_max_speed)/
- pow((double)ctrls->mk_time_to_max,xkbi->mouseKeysCurve));
+ xkbi->mouseKeysCurve = 1.0 + (((double) ctrls->mk_curve) * 0.001);
+ xkbi->mouseKeysCurveFactor = (((double) ctrls->mk_max_speed) /
+ pow((double) ctrls->mk_time_to_max,
+ xkbi->mouseKeysCurve));
return;
}
void
AccessXInit(DeviceIntPtr keybd)
{
-XkbSrvInfoPtr xkbi = keybd->key->xkbInfo;
-XkbControlsPtr ctrls = xkbi->desc->ctrls;
-
- xkbi->shiftKeyCount= 0;
- xkbi->mouseKeysCounter= 0;
- xkbi->inactiveKey= 0;
- xkbi->slowKey= 0;
- xkbi->repeatKey= 0;
- xkbi->krgTimerActive= _OFF_TIMER;
- xkbi->beepType= _BEEP_NONE;
- xkbi->beepCount= 0;
- xkbi->mouseKeyTimer= NULL;
- xkbi->slowKeysTimer= NULL;
- xkbi->bounceKeysTimer= NULL;
- xkbi->repeatKeyTimer= NULL;
- xkbi->krgTimer= NULL;
- xkbi->beepTimer= NULL;
+ XkbSrvInfoPtr xkbi = keybd->key->xkbInfo;
+ XkbControlsPtr ctrls = xkbi->desc->ctrls;
+
+ xkbi->shiftKeyCount = 0;
+ xkbi->mouseKeysCounter = 0;
+ xkbi->inactiveKey = 0;
+ xkbi->slowKey = 0;
+ xkbi->repeatKey = 0;
+ xkbi->krgTimerActive = _OFF_TIMER;
+ xkbi->beepType = _BEEP_NONE;
+ xkbi->beepCount = 0;
+ xkbi->mouseKeyTimer = NULL;
+ xkbi->slowKeysTimer = NULL;
+ xkbi->bounceKeysTimer = NULL;
+ xkbi->repeatKeyTimer = NULL;
+ xkbi->krgTimer = NULL;
+ xkbi->beepTimer = NULL;
ctrls->repeat_delay = XkbDfltRepeatDelay;
ctrls->repeat_interval = XkbDfltRepeatInterval;
ctrls->debounce_delay = 300;
@@ -102,12 +105,12 @@ XkbControlsPtr ctrls = xkbi->desc->ctrls;
ctrls->axt_opts_mask = XkbDfltAccessXTimeoutOptionsMask;
ctrls->axt_opts_values = XkbDfltAccessXTimeoutOptionsValues;
if (XkbDfltAccessXTimeout)
- ctrls->enabled_ctrls |= XkbAccessXTimeoutMask;
+ ctrls->enabled_ctrls |= XkbAccessXTimeoutMask;
else
- ctrls->enabled_ctrls &= ~XkbAccessXTimeoutMask;
+ ctrls->enabled_ctrls &= ~XkbAccessXTimeoutMask;
ctrls->enabled_ctrls |= XkbDfltAccessXFeedback;
- ctrls->ax_options = XkbDfltAccessXOptions;
- AccessXComputeCurveFactor(xkbi,ctrls);
+ ctrls->ax_options = XkbDfltAccessXOptions;
+ AccessXComputeCurveFactor(xkbi, ctrls);
return;
}
@@ -118,11 +121,8 @@ XkbControlsPtr ctrls = xkbi->desc->ctrls;
/* Generate a synthetic keyboard event. */
/* */
/************************************************************************/
-static void
-AccessXKeyboardEvent(DeviceIntPtr keybd,
- int type,
- BYTE keyCode,
- Bool isRepeat)
+static void
+AccessXKeyboardEvent(DeviceIntPtr keybd, int type, BYTE keyCode, Bool isRepeat)
{
DeviceEvent event;
@@ -131,14 +131,14 @@ AccessXKeyboardEvent(DeviceIntPtr keybd,
event.detail.key = keyCode;
event.key_repeat = isRepeat;
- if (xkbDebugFlags&0x8) {
- DebugF("[xkb] AXKE: Key %d %s\n", keyCode,
+ if (xkbDebugFlags & 0x8) {
+ DebugF("[xkb] AXKE: Key %d %s\n", keyCode,
(event.type == ET_KeyPress ? "down" : "up"));
}
XkbProcessKeyboardEvent(&event, keybd);
return;
-} /* AccessXKeyboardEvent */
+} /* AccessXKeyboardEvent */
/************************************************************************/
/* */
@@ -148,29 +148,29 @@ AccessXKeyboardEvent(DeviceIntPtr keybd,
/* */
/************************************************************************/
static void
-AccessXKRGTurnOn(DeviceIntPtr dev,CARD16 KRGControl,xkbControlsNotify *pCN)
+AccessXKRGTurnOn(DeviceIntPtr dev, CARD16 KRGControl, xkbControlsNotify * pCN)
{
-XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
-XkbControlsPtr ctrls = xkbi->desc->ctrls;
-XkbControlsRec old;
-XkbEventCauseRec cause;
-XkbSrvLedInfoPtr sli;
-
- old= *ctrls;
- ctrls->enabled_ctrls |= (KRGControl&XkbAX_KRGMask);
- if (XkbComputeControlsNotify(dev,&old,ctrls,pCN,FALSE))
- XkbSendControlsNotify(dev,pCN);
- cause.kc= pCN->keycode;
- cause.event= pCN->eventType;
- cause.mjr= pCN->requestMajor;
- cause.mnr= pCN->requestMinor;
- sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
- XkbUpdateIndicators(dev,sli->usesControls,TRUE,NULL,&cause);
- if (XkbAX_NeedFeedback(ctrls,XkbAX_FeatureFBMask))
- XkbDDXAccessXBeep(dev,_BEEP_FEATURE_ON,KRGControl);
+ XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
+ XkbControlsPtr ctrls = xkbi->desc->ctrls;
+ XkbControlsRec old;
+ XkbEventCauseRec cause;
+ XkbSrvLedInfoPtr sli;
+
+ old = *ctrls;
+ ctrls->enabled_ctrls |= (KRGControl & XkbAX_KRGMask);
+ if (XkbComputeControlsNotify(dev, &old, ctrls, pCN, FALSE))
+ XkbSendControlsNotify(dev, pCN);
+ cause.kc = pCN->keycode;
+ cause.event = pCN->eventType;
+ cause.mjr = pCN->requestMajor;
+ cause.mnr = pCN->requestMinor;
+ sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
+ XkbUpdateIndicators(dev, sli->usesControls, TRUE, NULL, &cause);
+ if (XkbAX_NeedFeedback(ctrls, XkbAX_FeatureFBMask))
+ XkbDDXAccessXBeep(dev, _BEEP_FEATURE_ON, KRGControl);
return;
-
-} /* AccessXKRGTurnOn */
+
+} /* AccessXKRGTurnOn */
/************************************************************************/
/* */
@@ -179,32 +179,33 @@ XkbSrvLedInfoPtr sli;
/* Turn the keyboard response group off. */
/* */
/************************************************************************/
-static void
-AccessXKRGTurnOff(DeviceIntPtr dev,xkbControlsNotify *pCN)
+static void
+AccessXKRGTurnOff(DeviceIntPtr dev, xkbControlsNotify * pCN)
{
-XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
-XkbControlsPtr ctrls = xkbi->desc->ctrls;
-XkbControlsRec old;
-XkbEventCauseRec cause;
-XkbSrvLedInfoPtr sli;
+ XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
+ XkbControlsPtr ctrls = xkbi->desc->ctrls;
+ XkbControlsRec old;
+ XkbEventCauseRec cause;
+ XkbSrvLedInfoPtr sli;
old = *ctrls;
ctrls->enabled_ctrls &= ~XkbAX_KRGMask;
- if (XkbComputeControlsNotify(dev,&old,ctrls,pCN,FALSE))
- XkbSendControlsNotify(dev,pCN);
- cause.kc= pCN->keycode;
- cause.event= pCN->eventType;
- cause.mjr= pCN->requestMajor;
- cause.mnr= pCN->requestMinor;
- sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
- XkbUpdateIndicators(dev,sli->usesControls,TRUE,NULL,&cause);
- if (XkbAX_NeedFeedback(ctrls,XkbAX_FeatureFBMask)) {
- unsigned changes= old.enabled_ctrls^ctrls->enabled_ctrls;
- XkbDDXAccessXBeep(dev,_BEEP_FEATURE_OFF,changes);
+ if (XkbComputeControlsNotify(dev, &old, ctrls, pCN, FALSE))
+ XkbSendControlsNotify(dev, pCN);
+ cause.kc = pCN->keycode;
+ cause.event = pCN->eventType;
+ cause.mjr = pCN->requestMajor;
+ cause.mnr = pCN->requestMinor;
+ sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
+ XkbUpdateIndicators(dev, sli->usesControls, TRUE, NULL, &cause);
+ if (XkbAX_NeedFeedback(ctrls, XkbAX_FeatureFBMask)) {
+ unsigned changes = old.enabled_ctrls ^ ctrls->enabled_ctrls;
+
+ XkbDDXAccessXBeep(dev, _BEEP_FEATURE_OFF, changes);
}
return;
-
-} /* AccessXKRGTurnOff */
+
+} /* AccessXKRGTurnOff */
/************************************************************************/
/* */
@@ -214,31 +215,31 @@ XkbSrvLedInfoPtr sli;
/* */
/************************************************************************/
static void
-AccessXStickyKeysTurnOn(DeviceIntPtr dev,xkbControlsNotify *pCN)
+AccessXStickyKeysTurnOn(DeviceIntPtr dev, xkbControlsNotify * pCN)
{
-XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
-XkbControlsPtr ctrls = xkbi->desc->ctrls;
-XkbControlsRec old;
-XkbEventCauseRec cause;
-XkbSrvLedInfoPtr sli;
+ XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
+ XkbControlsPtr ctrls = xkbi->desc->ctrls;
+ XkbControlsRec old;
+ XkbEventCauseRec cause;
+ XkbSrvLedInfoPtr sli;
old = *ctrls;
ctrls->enabled_ctrls |= XkbStickyKeysMask;
xkbi->shiftKeyCount = 0;
- if (XkbComputeControlsNotify(dev,&old,ctrls,pCN,FALSE))
- XkbSendControlsNotify(dev,pCN);
- cause.kc= pCN->keycode;
- cause.event= pCN->eventType;
- cause.mjr= pCN->requestMajor;
- cause.mnr= pCN->requestMinor;
- sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
- XkbUpdateIndicators(dev,sli->usesControls,TRUE,NULL,&cause);
- if (XkbAX_NeedFeedback(ctrls,XkbAX_FeatureFBMask)) {
- XkbDDXAccessXBeep(dev,_BEEP_FEATURE_ON,XkbStickyKeysMask);
+ if (XkbComputeControlsNotify(dev, &old, ctrls, pCN, FALSE))
+ XkbSendControlsNotify(dev, pCN);
+ cause.kc = pCN->keycode;
+ cause.event = pCN->eventType;
+ cause.mjr = pCN->requestMajor;
+ cause.mnr = pCN->requestMinor;
+ sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
+ XkbUpdateIndicators(dev, sli->usesControls, TRUE, NULL, &cause);
+ if (XkbAX_NeedFeedback(ctrls, XkbAX_FeatureFBMask)) {
+ XkbDDXAccessXBeep(dev, _BEEP_FEATURE_ON, XkbStickyKeysMask);
}
return;
-
-} /* AccessXStickyKeysTurnOn */
+
+} /* AccessXStickyKeysTurnOn */
/************************************************************************/
/* */
@@ -248,65 +249,67 @@ XkbSrvLedInfoPtr sli;
/* */
/************************************************************************/
static void
-AccessXStickyKeysTurnOff(DeviceIntPtr dev,xkbControlsNotify *pCN)
+AccessXStickyKeysTurnOff(DeviceIntPtr dev, xkbControlsNotify * pCN)
{
-XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
-XkbControlsPtr ctrls = xkbi->desc->ctrls;
-XkbControlsRec old;
-XkbEventCauseRec cause;
-XkbSrvLedInfoPtr sli;
+ XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
+ XkbControlsPtr ctrls = xkbi->desc->ctrls;
+ XkbControlsRec old;
+ XkbEventCauseRec cause;
+ XkbSrvLedInfoPtr sli;
old = *ctrls;
ctrls->enabled_ctrls &= ~XkbStickyKeysMask;
xkbi->shiftKeyCount = 0;
- if (XkbComputeControlsNotify(dev,&old,ctrls,pCN,FALSE))
- XkbSendControlsNotify(dev,pCN);
-
- cause.kc= pCN->keycode;
- cause.event= pCN->eventType;
- cause.mjr= pCN->requestMajor;
- cause.mnr= pCN->requestMinor;
- sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
- XkbUpdateIndicators(dev,sli->usesControls,TRUE,NULL,&cause);
- if (XkbAX_NeedFeedback(ctrls,XkbAX_FeatureFBMask)) {
- XkbDDXAccessXBeep(dev,_BEEP_FEATURE_OFF,XkbStickyKeysMask);
+ if (XkbComputeControlsNotify(dev, &old, ctrls, pCN, FALSE))
+ XkbSendControlsNotify(dev, pCN);
+
+ cause.kc = pCN->keycode;
+ cause.event = pCN->eventType;
+ cause.mjr = pCN->requestMajor;
+ cause.mnr = pCN->requestMinor;
+ sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
+ XkbUpdateIndicators(dev, sli->usesControls, TRUE, NULL, &cause);
+ if (XkbAX_NeedFeedback(ctrls, XkbAX_FeatureFBMask)) {
+ XkbDDXAccessXBeep(dev, _BEEP_FEATURE_OFF, XkbStickyKeysMask);
}
#ifndef NO_CLEAR_LATCHES_FOR_STICKY_KEYS_OFF
- XkbClearAllLatchesAndLocks(dev,xkbi,FALSE,&cause);
+ XkbClearAllLatchesAndLocks(dev, xkbi, FALSE, &cause);
#endif
return;
-} /* AccessXStickyKeysTurnOff */
+} /* AccessXStickyKeysTurnOff */
static CARD32
-AccessXKRGExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+AccessXKRGExpire(OsTimerPtr timer, CARD32 now, pointer arg)
{
-XkbSrvInfoPtr xkbi= ((DeviceIntPtr)arg)->key->xkbInfo;
-xkbControlsNotify cn;
-
- if (xkbi->krgTimerActive==_KRG_WARN_TIMER) {
- XkbDDXAccessXBeep((DeviceIntPtr)arg,_BEEP_SLOW_WARN,XkbStickyKeysMask);
- xkbi->krgTimerActive= _KRG_TIMER;
- return 4000;
+ XkbSrvInfoPtr xkbi = ((DeviceIntPtr) arg)->key->xkbInfo;
+ xkbControlsNotify cn;
+
+ if (xkbi->krgTimerActive == _KRG_WARN_TIMER) {
+ XkbDDXAccessXBeep((DeviceIntPtr) arg, _BEEP_SLOW_WARN,
+ XkbStickyKeysMask);
+ xkbi->krgTimerActive = _KRG_TIMER;
+ return 4000;
}
- xkbi->krgTimerActive= _OFF_TIMER;
+ xkbi->krgTimerActive = _OFF_TIMER;
cn.keycode = 0;
cn.eventType = 0;
cn.requestMajor = 0;
cn.requestMinor = 0;
- if (xkbi->desc->ctrls->enabled_ctrls&XkbSlowKeysMask)
- AccessXKRGTurnOff((DeviceIntPtr)arg,&cn);
- else AccessXKRGTurnOn((DeviceIntPtr)arg,XkbSlowKeysMask,&cn);
+ if (xkbi->desc->ctrls->enabled_ctrls & XkbSlowKeysMask)
+ AccessXKRGTurnOff((DeviceIntPtr) arg, &cn);
+ else
+ AccessXKRGTurnOn((DeviceIntPtr) arg, XkbSlowKeysMask, &cn);
return 0;
}
static CARD32
-AccessXRepeatKeyExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+AccessXRepeatKeyExpire(OsTimerPtr timer, CARD32 now, pointer arg)
{
-DeviceIntPtr dev = (DeviceIntPtr) arg;
-XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
+ DeviceIntPtr dev = (DeviceIntPtr) arg;
+ XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
if (xkbi->repeatKey == 0)
- return 0;
+ return 0;
AccessXKeyboardEvent(dev, ET_KeyPress, xkbi->repeatKey, TRUE);
@@ -314,118 +317,122 @@ XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
}
void
-AccessXCancelRepeatKey(XkbSrvInfoPtr xkbi,KeyCode key)
+AccessXCancelRepeatKey(XkbSrvInfoPtr xkbi, KeyCode key)
{
- if (xkbi->repeatKey==key)
- xkbi->repeatKey= 0;
+ if (xkbi->repeatKey == key)
+ xkbi->repeatKey = 0;
return;
}
static CARD32
-AccessXSlowKeyExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+AccessXSlowKeyExpire(OsTimerPtr timer, CARD32 now, pointer arg)
{
-DeviceIntPtr keybd;
-XkbSrvInfoPtr xkbi;
-XkbDescPtr xkb;
-XkbControlsPtr ctrls;
-
- keybd= (DeviceIntPtr)arg;
- xkbi= keybd->key->xkbInfo;
- xkb= xkbi->desc;
- ctrls= xkb->ctrls;
- if (xkbi->slowKey!=0) {
- xkbAccessXNotify ev;
- KeySym *sym= XkbKeySymsPtr(xkb,xkbi->slowKey);
- ev.detail= XkbAXN_SKAccept;
- ev.keycode= xkbi->slowKey;
- ev.slowKeysDelay= ctrls->slow_keys_delay;
- ev.debounceDelay= ctrls->debounce_delay;
- XkbSendAccessXNotify(keybd,&ev);
- if (XkbAX_NeedFeedback(ctrls,XkbAX_SKAcceptFBMask))
- XkbDDXAccessXBeep(keybd,_BEEP_SLOW_ACCEPT,XkbSlowKeysMask);
- AccessXKeyboardEvent(keybd, ET_KeyPress,xkbi->slowKey,FALSE);
- /* check for magic sequences */
- if ((ctrls->enabled_ctrls&XkbAccessXKeysMask) &&
- ((sym[0]==XK_Shift_R)||(sym[0]==XK_Shift_L)))
- xkbi->shiftKeyCount++;
-
- /* Start repeating if necessary. Stop autorepeating if the user
- * presses a non-modifier key that doesn't autorepeat.
- */
- if (keybd->kbdfeed->ctrl.autoRepeat &&
- ((xkbi->slowKey != xkbi->mouseKey) || (!xkbi->mouseKeysAccel)) &&
- (ctrls->enabled_ctrls&XkbRepeatKeysMask)) {
- if (BitIsOn(keybd->kbdfeed->ctrl.autoRepeats,xkbi->slowKey)) {
- xkbi->repeatKey = xkbi->slowKey;
- xkbi->repeatKeyTimer= TimerSet(xkbi->repeatKeyTimer,
- 0, ctrls->repeat_delay,
- AccessXRepeatKeyExpire, (pointer)keybd);
- }
- }
+ DeviceIntPtr keybd;
+ XkbSrvInfoPtr xkbi;
+ XkbDescPtr xkb;
+ XkbControlsPtr ctrls;
+
+ keybd = (DeviceIntPtr) arg;
+ xkbi = keybd->key->xkbInfo;
+ xkb = xkbi->desc;
+ ctrls = xkb->ctrls;
+ if (xkbi->slowKey != 0) {
+ xkbAccessXNotify ev;
+ KeySym *sym = XkbKeySymsPtr(xkb, xkbi->slowKey);
+
+ ev.detail = XkbAXN_SKAccept;
+ ev.keycode = xkbi->slowKey;
+ ev.slowKeysDelay = ctrls->slow_keys_delay;
+ ev.debounceDelay = ctrls->debounce_delay;
+ XkbSendAccessXNotify(keybd, &ev);
+ if (XkbAX_NeedFeedback(ctrls, XkbAX_SKAcceptFBMask))
+ XkbDDXAccessXBeep(keybd, _BEEP_SLOW_ACCEPT, XkbSlowKeysMask);
+ AccessXKeyboardEvent(keybd, ET_KeyPress, xkbi->slowKey, FALSE);
+ /* check for magic sequences */
+ if ((ctrls->enabled_ctrls & XkbAccessXKeysMask) &&
+ ((sym[0] == XK_Shift_R) || (sym[0] == XK_Shift_L)))
+ xkbi->shiftKeyCount++;
+
+ /* Start repeating if necessary. Stop autorepeating if the user
+ * presses a non-modifier key that doesn't autorepeat.
+ */
+ if (keybd->kbdfeed->ctrl.autoRepeat &&
+ ((xkbi->slowKey != xkbi->mouseKey) || (!xkbi->mouseKeysAccel)) &&
+ (ctrls->enabled_ctrls & XkbRepeatKeysMask)) {
+ if (BitIsOn(keybd->kbdfeed->ctrl.autoRepeats, xkbi->slowKey)) {
+ xkbi->repeatKey = xkbi->slowKey;
+ xkbi->repeatKeyTimer = TimerSet(xkbi->repeatKeyTimer,
+ 0, ctrls->repeat_delay,
+ AccessXRepeatKeyExpire,
+ (pointer) keybd);
+ }
+ }
}
return 0;
}
static CARD32
-AccessXBounceKeyExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+AccessXBounceKeyExpire(OsTimerPtr timer, CARD32 now, pointer arg)
{
-XkbSrvInfoPtr xkbi= ((DeviceIntPtr)arg)->key->xkbInfo;
+ XkbSrvInfoPtr xkbi = ((DeviceIntPtr) arg)->key->xkbInfo;
- xkbi->inactiveKey= 0;
+ xkbi->inactiveKey = 0;
return 0;
}
static CARD32
-AccessXTimeoutExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+AccessXTimeoutExpire(OsTimerPtr timer, CARD32 now, pointer arg)
{
-DeviceIntPtr dev = (DeviceIntPtr)arg;
-XkbSrvInfoPtr xkbi= dev->key->xkbInfo;
-XkbControlsPtr ctrls= xkbi->desc->ctrls;
-XkbControlsRec old;
-xkbControlsNotify cn;
-XkbEventCauseRec cause;
-XkbSrvLedInfoPtr sli;
+ DeviceIntPtr dev = (DeviceIntPtr) arg;
+ XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
+ XkbControlsPtr ctrls = xkbi->desc->ctrls;
+ XkbControlsRec old;
+ xkbControlsNotify cn;
+ XkbEventCauseRec cause;
+ XkbSrvLedInfoPtr sli;
if (xkbi->lastPtrEventTime) {
- unsigned timeToWait = (ctrls->ax_timeout*1000);
- unsigned timeElapsed = (now-xkbi->lastPtrEventTime);
+ unsigned timeToWait = (ctrls->ax_timeout * 1000);
+ unsigned timeElapsed = (now - xkbi->lastPtrEventTime);
- if (timeToWait > timeElapsed)
- return timeToWait - timeElapsed;
+ if (timeToWait > timeElapsed)
+ return timeToWait - timeElapsed;
}
- old= *ctrls;
- xkbi->shiftKeyCount= 0;
- ctrls->enabled_ctrls&= ~ctrls->axt_ctrls_mask;
- ctrls->enabled_ctrls|=
- (ctrls->axt_ctrls_values&ctrls->axt_ctrls_mask);
+ old = *ctrls;
+ xkbi->shiftKeyCount = 0;
+ ctrls->enabled_ctrls &= ~ctrls->axt_ctrls_mask;
+ ctrls->enabled_ctrls |= (ctrls->axt_ctrls_values & ctrls->axt_ctrls_mask);
if (ctrls->axt_opts_mask) {
- ctrls->ax_options&= ~ctrls->axt_opts_mask;
- ctrls->ax_options|= (ctrls->axt_opts_values&ctrls->axt_opts_mask);
+ ctrls->ax_options &= ~ctrls->axt_opts_mask;
+ ctrls->ax_options |= (ctrls->axt_opts_values & ctrls->axt_opts_mask);
}
- if (XkbComputeControlsNotify(dev,&old,ctrls,&cn,FALSE)) {
- cn.keycode = 0;
- cn.eventType = 0;
- cn.requestMajor = 0;
- cn.requestMinor = 0;
- XkbSendControlsNotify(dev,&cn);
+ if (XkbComputeControlsNotify(dev, &old, ctrls, &cn, FALSE)) {
+ cn.keycode = 0;
+ cn.eventType = 0;
+ cn.requestMajor = 0;
+ cn.requestMinor = 0;
+ XkbSendControlsNotify(dev, &cn);
}
XkbSetCauseUnknown(&cause);
- sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
- XkbUpdateIndicators(dev,sli->usesControls,TRUE,NULL,&cause);
- if (ctrls->ax_options!=old.ax_options) {
- unsigned set,cleared,bell;
- set= ctrls->ax_options&(~old.ax_options);
- cleared= (~ctrls->ax_options)&old.ax_options;
- if (set && cleared) bell= _BEEP_FEATURE_CHANGE;
- else if (set) bell= _BEEP_FEATURE_ON;
- else bell= _BEEP_FEATURE_OFF;
- XkbDDXAccessXBeep(dev,bell,XkbAccessXTimeoutMask);
+ sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
+ XkbUpdateIndicators(dev, sli->usesControls, TRUE, NULL, &cause);
+ if (ctrls->ax_options != old.ax_options) {
+ unsigned set, cleared, bell;
+
+ set = ctrls->ax_options & (~old.ax_options);
+ cleared = (~ctrls->ax_options) & old.ax_options;
+ if (set && cleared)
+ bell = _BEEP_FEATURE_CHANGE;
+ else if (set)
+ bell = _BEEP_FEATURE_ON;
+ else
+ bell = _BEEP_FEATURE_OFF;
+ XkbDDXAccessXBeep(dev, bell, XkbAccessXTimeoutMask);
}
- xkbi->krgTimerActive= _OFF_TIMER;
+ xkbi->krgTimerActive = _OFF_TIMER;
return 0;
}
-
/************************************************************************/
/* */
/* AccessXFilterPressEvent */
@@ -439,125 +446,129 @@ XkbSrvLedInfoPtr sli;
/* */
/************************************************************************/
Bool
-AccessXFilterPressEvent( DeviceEvent* event,
- DeviceIntPtr keybd)
+AccessXFilterPressEvent(DeviceEvent *event, DeviceIntPtr keybd)
{
-XkbSrvInfoPtr xkbi = keybd->key->xkbInfo;
-XkbControlsPtr ctrls = xkbi->desc->ctrls;
-Bool ignoreKeyEvent = FALSE;
-KeyCode key = event->detail.key;
-KeySym * sym = XkbKeySymsPtr(xkbi->desc,key);
-
- if (ctrls->enabled_ctrls&XkbAccessXKeysMask) {
- /* check for magic sequences */
- if ((sym[0]==XK_Shift_R)||(sym[0]==XK_Shift_L)) {
- if (XkbAX_NeedFeedback(ctrls,XkbAX_SlowWarnFBMask)) {
- xkbi->krgTimerActive = _KRG_WARN_TIMER;
- xkbi->krgTimer= TimerSet(xkbi->krgTimer, 0, 4000,
- AccessXKRGExpire, (pointer)keybd);
- }
- else {
- xkbi->krgTimerActive = _KRG_TIMER;
- xkbi->krgTimer= TimerSet(xkbi->krgTimer, 0, 8000,
- AccessXKRGExpire, (pointer)keybd);
- }
- if (!(ctrls->enabled_ctrls & XkbSlowKeysMask)) {
- CARD32 now= GetTimeInMillis();
- if ((now-xkbi->lastShiftEventTime)>15000)
- xkbi->shiftKeyCount= 1;
- else xkbi->shiftKeyCount++;
- xkbi->lastShiftEventTime= now;
- }
- }
- else {
- if (xkbi->krgTimerActive) {
- xkbi->krgTimer= TimerSet(xkbi->krgTimer,0, 0, NULL, NULL);
- xkbi->krgTimerActive= _OFF_TIMER;
- }
- }
+ XkbSrvInfoPtr xkbi = keybd->key->xkbInfo;
+ XkbControlsPtr ctrls = xkbi->desc->ctrls;
+ Bool ignoreKeyEvent = FALSE;
+ KeyCode key = event->detail.key;
+ KeySym *sym = XkbKeySymsPtr(xkbi->desc, key);
+
+ if (ctrls->enabled_ctrls & XkbAccessXKeysMask) {
+ /* check for magic sequences */
+ if ((sym[0] == XK_Shift_R) || (sym[0] == XK_Shift_L)) {
+ if (XkbAX_NeedFeedback(ctrls, XkbAX_SlowWarnFBMask)) {
+ xkbi->krgTimerActive = _KRG_WARN_TIMER;
+ xkbi->krgTimer = TimerSet(xkbi->krgTimer, 0, 4000,
+ AccessXKRGExpire, (pointer) keybd);
+ }
+ else {
+ xkbi->krgTimerActive = _KRG_TIMER;
+ xkbi->krgTimer = TimerSet(xkbi->krgTimer, 0, 8000,
+ AccessXKRGExpire, (pointer) keybd);
+ }
+ if (!(ctrls->enabled_ctrls & XkbSlowKeysMask)) {
+ CARD32 now = GetTimeInMillis();
+
+ if ((now - xkbi->lastShiftEventTime) > 15000)
+ xkbi->shiftKeyCount = 1;
+ else
+ xkbi->shiftKeyCount++;
+ xkbi->lastShiftEventTime = now;
+ }
+ }
+ else {
+ if (xkbi->krgTimerActive) {
+ xkbi->krgTimer = TimerSet(xkbi->krgTimer, 0, 0, NULL, NULL);
+ xkbi->krgTimerActive = _OFF_TIMER;
+ }
+ }
}
-
+
/* Don't transmit the KeyPress if SlowKeys is turned on;
* The wakeup handler will synthesize one for us if the user
* has held the key long enough.
*/
if (ctrls->enabled_ctrls & XkbSlowKeysMask) {
- xkbAccessXNotify ev;
- /* If key was already pressed, ignore subsequent press events
- * from the server's autorepeat
- */
- if(xkbi->slowKey == key)
- return TRUE;
- ev.detail= XkbAXN_SKPress;
- ev.keycode= key;
- ev.slowKeysDelay= ctrls->slow_keys_delay;
- ev.debounceDelay= ctrls->debounce_delay;
- XkbSendAccessXNotify(keybd,&ev);
- if (XkbAX_NeedFeedback(ctrls,XkbAX_SKPressFBMask))
- XkbDDXAccessXBeep(keybd,_BEEP_SLOW_PRESS,XkbSlowKeysMask);
- xkbi->slowKey= key;
- xkbi->slowKeysTimer = TimerSet(xkbi->slowKeysTimer,
- 0, ctrls->slow_keys_delay,
- AccessXSlowKeyExpire, (pointer)keybd);
- ignoreKeyEvent = TRUE;
+ xkbAccessXNotify ev;
+
+ /* If key was already pressed, ignore subsequent press events
+ * from the server's autorepeat
+ */
+ if (xkbi->slowKey == key)
+ return TRUE;
+ ev.detail = XkbAXN_SKPress;
+ ev.keycode = key;
+ ev.slowKeysDelay = ctrls->slow_keys_delay;
+ ev.debounceDelay = ctrls->debounce_delay;
+ XkbSendAccessXNotify(keybd, &ev);
+ if (XkbAX_NeedFeedback(ctrls, XkbAX_SKPressFBMask))
+ XkbDDXAccessXBeep(keybd, _BEEP_SLOW_PRESS, XkbSlowKeysMask);
+ xkbi->slowKey = key;
+ xkbi->slowKeysTimer = TimerSet(xkbi->slowKeysTimer,
+ 0, ctrls->slow_keys_delay,
+ AccessXSlowKeyExpire, (pointer) keybd);
+ ignoreKeyEvent = TRUE;
}
/* Don't transmit the KeyPress if BounceKeys is turned on
* and the user pressed the same key within a given time period
* from the last release.
*/
- else if ((ctrls->enabled_ctrls & XkbBounceKeysMask) &&
- (key == xkbi->inactiveKey)) {
- if (XkbAX_NeedFeedback(ctrls,XkbAX_BKRejectFBMask))
- XkbDDXAccessXBeep(keybd,_BEEP_BOUNCE_REJECT,XkbBounceKeysMask);
- ignoreKeyEvent = TRUE;
+ else if ((ctrls->enabled_ctrls & XkbBounceKeysMask) &&
+ (key == xkbi->inactiveKey)) {
+ if (XkbAX_NeedFeedback(ctrls, XkbAX_BKRejectFBMask))
+ XkbDDXAccessXBeep(keybd, _BEEP_BOUNCE_REJECT, XkbBounceKeysMask);
+ ignoreKeyEvent = TRUE;
}
/* Start repeating if necessary. Stop autorepeating if the user
* presses a non-modifier key that doesn't autorepeat.
*/
if (XkbDDXUsesSoftRepeat(keybd)) {
- if ((keybd->kbdfeed->ctrl.autoRepeat) &&
- ((ctrls->enabled_ctrls&(XkbSlowKeysMask|XkbRepeatKeysMask))==
- XkbRepeatKeysMask)) {
- if (BitIsOn(keybd->kbdfeed->ctrl.autoRepeats,key)) {
- if (xkbDebugFlags&0x10)
- DebugF("Starting software autorepeat...\n");
- if (xkbi->repeatKey == key)
- ignoreKeyEvent = TRUE;
- else {
- xkbi->repeatKey = key;
- xkbi->repeatKeyTimer= TimerSet(xkbi->repeatKeyTimer,
- 0, ctrls->repeat_delay,
- AccessXRepeatKeyExpire, (pointer)keybd);
- }
- }
- }
+ if ((keybd->kbdfeed->ctrl.autoRepeat) &&
+ ((ctrls->enabled_ctrls & (XkbSlowKeysMask | XkbRepeatKeysMask)) ==
+ XkbRepeatKeysMask)) {
+ if (BitIsOn(keybd->kbdfeed->ctrl.autoRepeats, key)) {
+ if (xkbDebugFlags & 0x10)
+ DebugF("Starting software autorepeat...\n");
+ if (xkbi->repeatKey == key)
+ ignoreKeyEvent = TRUE;
+ else {
+ xkbi->repeatKey = key;
+ xkbi->repeatKeyTimer = TimerSet(xkbi->repeatKeyTimer,
+ 0, ctrls->repeat_delay,
+ AccessXRepeatKeyExpire,
+ (pointer) keybd);
+ }
+ }
+ }
}
-
+
/* Check for two keys being pressed at the same time. This section
* essentially says the following:
*
- * If StickyKeys is on, and a modifier is currently being held down,
+ * If StickyKeys is on, and a modifier is currently being held down,
* and one of the following is true: the current key is not a modifier
* or the currentKey is a modifier, but not the only modifier being
* held down, turn StickyKeys off if the TwoKeys off ctrl is set.
*/
- if ((ctrls->enabled_ctrls & XkbStickyKeysMask) &&
- (xkbi->state.base_mods!=0) &&
- (XkbAX_NeedOption(ctrls,XkbAX_TwoKeysMask))) {
- xkbControlsNotify cn;
- cn.keycode = key;
- cn.eventType = KeyPress;
- cn.requestMajor = 0;
- cn.requestMinor = 0;
- AccessXStickyKeysTurnOff(keybd,&cn);
+ if ((ctrls->enabled_ctrls & XkbStickyKeysMask) &&
+ (xkbi->state.base_mods != 0) &&
+ (XkbAX_NeedOption(ctrls, XkbAX_TwoKeysMask))) {
+ xkbControlsNotify cn;
+
+ cn.keycode = key;
+ cn.eventType = KeyPress;
+ cn.requestMajor = 0;
+ cn.requestMinor = 0;
+ AccessXStickyKeysTurnOff(keybd, &cn);
}
-
+
if (!ignoreKeyEvent)
- XkbProcessKeyboardEvent(event, keybd);
+ XkbProcessKeyboardEvent(event, keybd);
return ignoreKeyEvent;
-} /* AccessXFilterPressEvent */
+} /* AccessXFilterPressEvent */
/************************************************************************/
/* */
@@ -572,25 +583,25 @@ KeySym * sym = XkbKeySymsPtr(xkbi->desc,key);
/* */
/************************************************************************/
Bool
-AccessXFilterReleaseEvent( DeviceEvent* event,
- DeviceIntPtr keybd)
+AccessXFilterReleaseEvent(DeviceEvent *event, DeviceIntPtr keybd)
{
-XkbSrvInfoPtr xkbi = keybd->key->xkbInfo;
-XkbControlsPtr ctrls = xkbi->desc->ctrls;
-KeyCode key = event->detail.key;
-Bool ignoreKeyEvent = FALSE;
-
+ XkbSrvInfoPtr xkbi = keybd->key->xkbInfo;
+ XkbControlsPtr ctrls = xkbi->desc->ctrls;
+ KeyCode key = event->detail.key;
+ Bool ignoreKeyEvent = FALSE;
+
/* Don't transmit the KeyRelease if BounceKeys is on and
* this is the release of a key that was ignored due to
* BounceKeys.
*/
if (ctrls->enabled_ctrls & XkbBounceKeysMask) {
- if ((key!=xkbi->mouseKey)&&(!BitIsOn(keybd->key->down,key)))
- ignoreKeyEvent = TRUE;
- xkbi->inactiveKey= key;
- xkbi->bounceKeysTimer= TimerSet(xkbi->bounceKeysTimer, 0,
- ctrls->debounce_delay,
- AccessXBounceKeyExpire, (pointer)keybd);
+ if ((key != xkbi->mouseKey) && (!BitIsOn(keybd->key->down, key)))
+ ignoreKeyEvent = TRUE;
+ xkbi->inactiveKey = key;
+ xkbi->bounceKeysTimer = TimerSet(xkbi->bounceKeysTimer, 0,
+ ctrls->debounce_delay,
+ AccessXBounceKeyExpire,
+ (pointer) keybd);
}
/* Don't transmit the KeyRelease if SlowKeys is turned on and
@@ -598,75 +609,79 @@ Bool ignoreKeyEvent = FALSE;
* the key if the down bit was set by CoreProcessKeyboadEvent.
*/
if (ctrls->enabled_ctrls & XkbSlowKeysMask) {
- xkbAccessXNotify ev;
- unsigned beep_type;
- ev.keycode= key;
- ev.slowKeysDelay= ctrls->slow_keys_delay;
- ev.debounceDelay= ctrls->debounce_delay;
- if (BitIsOn(keybd->key->down,key) || (xkbi->mouseKey == key)) {
- ev.detail= XkbAXN_SKRelease;
- beep_type= _BEEP_SLOW_RELEASE;
- }
- else {
- ev.detail= XkbAXN_SKReject;
- beep_type= _BEEP_SLOW_REJECT;
- ignoreKeyEvent = TRUE;
- }
- XkbSendAccessXNotify(keybd,&ev);
- if (XkbAX_NeedFeedback(ctrls,XkbAX_SKRejectFBMask)) {
- XkbDDXAccessXBeep(keybd,beep_type,XkbSlowKeysMask);
- }
- if (xkbi->slowKey==key)
- xkbi->slowKey= 0;
+ xkbAccessXNotify ev;
+ unsigned beep_type;
+
+ ev.keycode = key;
+ ev.slowKeysDelay = ctrls->slow_keys_delay;
+ ev.debounceDelay = ctrls->debounce_delay;
+ if (BitIsOn(keybd->key->down, key) || (xkbi->mouseKey == key)) {
+ ev.detail = XkbAXN_SKRelease;
+ beep_type = _BEEP_SLOW_RELEASE;
+ }
+ else {
+ ev.detail = XkbAXN_SKReject;
+ beep_type = _BEEP_SLOW_REJECT;
+ ignoreKeyEvent = TRUE;
+ }
+ XkbSendAccessXNotify(keybd, &ev);
+ if (XkbAX_NeedFeedback(ctrls, XkbAX_SKRejectFBMask)) {
+ XkbDDXAccessXBeep(keybd, beep_type, XkbSlowKeysMask);
+ }
+ if (xkbi->slowKey == key)
+ xkbi->slowKey = 0;
}
/* Stop Repeating if the user releases the key that is currently
* repeating.
*/
- if (xkbi->repeatKey==key) {
- xkbi->repeatKey= 0;
+ if (xkbi->repeatKey == key) {
+ xkbi->repeatKey = 0;
}
- if ((ctrls->enabled_ctrls&XkbAccessXTimeoutMask)&&(ctrls->ax_timeout>0)) {
- xkbi->lastPtrEventTime= 0;
- xkbi->krgTimer= TimerSet(xkbi->krgTimer, 0,
- ctrls->ax_timeout*1000,
- AccessXTimeoutExpire, (pointer)keybd);
- xkbi->krgTimerActive= _ALL_TIMEOUT_TIMER;
+ if ((ctrls->enabled_ctrls & XkbAccessXTimeoutMask) &&
+ (ctrls->ax_timeout > 0)) {
+ xkbi->lastPtrEventTime = 0;
+ xkbi->krgTimer = TimerSet(xkbi->krgTimer, 0,
+ ctrls->ax_timeout * 1000,
+ AccessXTimeoutExpire, (pointer) keybd);
+ xkbi->krgTimerActive = _ALL_TIMEOUT_TIMER;
}
- else if (xkbi->krgTimerActive!=_OFF_TIMER) {
- xkbi->krgTimer= TimerSet(xkbi->krgTimer, 0, 0, NULL, NULL);
- xkbi->krgTimerActive= _OFF_TIMER;
+ else if (xkbi->krgTimerActive != _OFF_TIMER) {
+ xkbi->krgTimer = TimerSet(xkbi->krgTimer, 0, 0, NULL, NULL);
+ xkbi->krgTimerActive = _OFF_TIMER;
}
-
+
/* Keep track of how many times the Shift key has been pressed.
* If it has been pressed and released 5 times in a row, toggle
* the state of StickyKeys.
*/
- if ((!ignoreKeyEvent)&&(xkbi->shiftKeyCount)) {
- KeySym *pSym= XkbKeySymsPtr(xkbi->desc,key);
- if ((pSym[0]!=XK_Shift_L)&&(pSym[0]!=XK_Shift_R)) {
- xkbi->shiftKeyCount= 0;
- }
- else if (xkbi->shiftKeyCount>=5) {
- xkbControlsNotify cn;
- cn.keycode = key;
- cn.eventType = KeyPress;
- cn.requestMajor = 0;
- cn.requestMinor = 0;
- if (ctrls->enabled_ctrls & XkbStickyKeysMask)
- AccessXStickyKeysTurnOff(keybd,&cn);
- else
- AccessXStickyKeysTurnOn(keybd,&cn);
- xkbi->shiftKeyCount= 0;
- }
+ if ((!ignoreKeyEvent) && (xkbi->shiftKeyCount)) {
+ KeySym *pSym = XkbKeySymsPtr(xkbi->desc, key);
+
+ if ((pSym[0] != XK_Shift_L) && (pSym[0] != XK_Shift_R)) {
+ xkbi->shiftKeyCount = 0;
+ }
+ else if (xkbi->shiftKeyCount >= 5) {
+ xkbControlsNotify cn;
+
+ cn.keycode = key;
+ cn.eventType = KeyPress;
+ cn.requestMajor = 0;
+ cn.requestMinor = 0;
+ if (ctrls->enabled_ctrls & XkbStickyKeysMask)
+ AccessXStickyKeysTurnOff(keybd, &cn);
+ else
+ AccessXStickyKeysTurnOn(keybd, &cn);
+ xkbi->shiftKeyCount = 0;
+ }
}
-
+
if (!ignoreKeyEvent)
- XkbProcessKeyboardEvent(event, keybd);
+ XkbProcessKeyboardEvent(event, keybd);
return ignoreKeyEvent;
-
-} /* AccessXFilterReleaseEvent */
+
+} /* AccessXFilterReleaseEvent */
/************************************************************************/
/* */
@@ -681,90 +696,87 @@ Bool ignoreKeyEvent = FALSE;
extern int xkbDevicePrivateIndex;
extern void xkbUnwrapProc(DeviceIntPtr, DeviceHandleProc, pointer);
void
-ProcessPointerEvent( InternalEvent *ev,
- DeviceIntPtr mouse)
+ProcessPointerEvent(InternalEvent *ev, DeviceIntPtr mouse)
{
-DeviceIntPtr dev;
-XkbSrvInfoPtr xkbi = NULL;
-unsigned changed = 0;
-ProcessInputProc backupproc;
-xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(mouse);
-DeviceEvent *event = &ev->device_event;
+ DeviceIntPtr dev;
+ XkbSrvInfoPtr xkbi = NULL;
+ unsigned changed = 0;
+ ProcessInputProc backupproc;
+ xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(mouse);
+ DeviceEvent *event = &ev->device_event;
dev = IsFloating(mouse) ? mouse : GetMaster(mouse, MASTER_KEYBOARD);
- if (dev && dev->key)
- {
- xkbi = dev->key->xkbInfo;
- xkbi->shiftKeyCount = 0;
- xkbi->lastPtrEventTime= event->time;
+ if (dev && dev->key) {
+ xkbi = dev->key->xkbInfo;
+ xkbi->shiftKeyCount = 0;
+ xkbi->lastPtrEventTime = event->time;
}
if (event->type == ET_ButtonPress) {
- changed |= XkbPointerButtonMask;
+ changed |= XkbPointerButtonMask;
}
else if (event->type == ET_ButtonRelease) {
- if (xkbi) {
- xkbi->lockedPtrButtons&= ~(1 << (event->detail.key & 0x7));
+ if (xkbi) {
+ xkbi->lockedPtrButtons &= ~(1 << (event->detail.key & 0x7));
- if (IsMaster(dev))
- {
+ if (IsMaster(dev)) {
DeviceIntPtr source;
int rc;
- rc = dixLookupDevice(&source, event->sourceid, serverClient, DixWriteAccess);
+
+ rc = dixLookupDevice(&source, event->sourceid, serverClient,
+ DixWriteAccess);
if (rc != Success)
- ErrorF("[xkb] bad sourceid '%d' on button release event.\n", event->sourceid);
+ ErrorF("[xkb] bad sourceid '%d' on button release event.\n",
+ event->sourceid);
else if (!IsXTestDevice(source, GetMaster(dev, MASTER_POINTER)))
XkbFakeDeviceButton(dev, FALSE, event->detail.key);
}
- }
+ }
- changed |= XkbPointerButtonMask;
+ changed |= XkbPointerButtonMask;
}
UNWRAP_PROCESS_INPUT_PROC(mouse, xkbPrivPtr, backupproc);
mouse->public.processInputProc(ev, mouse);
- COND_WRAP_PROCESS_INPUT_PROC(mouse, xkbPrivPtr,
- backupproc, xkbUnwrapProc);
+ COND_WRAP_PROCESS_INPUT_PROC(mouse, xkbPrivPtr, backupproc, xkbUnwrapProc);
if (!xkbi)
- return;
+ return;
xkbi->state.ptr_buttons = (mouse->button) ? mouse->button->state : 0;
-
- /* clear any latched modifiers */
- if ( xkbi->state.latched_mods && (event->type == ET_ButtonRelease) ) {
- unsigned changed_leds;
- XkbStateRec oldState;
- XkbSrvLedInfoPtr sli;
-
- sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
- oldState= xkbi->state;
- XkbLatchModifiers(dev,0xFF,0x00);
-
- XkbComputeDerivedState(xkbi);
- changed |= XkbStateChangedFlags(&oldState,&xkbi->state);
- if (changed&sli->usedComponents) {
- changed_leds= XkbIndicatorsToUpdate(dev,changed,FALSE);
- if (changed_leds) {
- XkbEventCauseRec cause;
- XkbSetCauseKey(&cause,(event->detail.key & 0x7), event->type);
- XkbUpdateIndicators(dev,changed_leds,TRUE,NULL,&cause);
- }
- }
- }
- if (((xkbi->flags&_XkbStateNotifyInProgress)==0)&&(changed!=0)) {
- xkbStateNotify sn;
- sn.keycode= event->detail.key;
- sn.eventType= event->type;
- sn.requestMajor = sn.requestMinor = 0;
- sn.changed= changed;
- XkbSendStateNotify(dev,&sn);
+ /* clear any latched modifiers */
+ if (xkbi->state.latched_mods && (event->type == ET_ButtonRelease)) {
+ unsigned changed_leds;
+ XkbStateRec oldState;
+ XkbSrvLedInfoPtr sli;
+
+ sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
+ oldState = xkbi->state;
+ XkbLatchModifiers(dev, 0xFF, 0x00);
+
+ XkbComputeDerivedState(xkbi);
+ changed |= XkbStateChangedFlags(&oldState, &xkbi->state);
+ if (changed & sli->usedComponents) {
+ changed_leds = XkbIndicatorsToUpdate(dev, changed, FALSE);
+ if (changed_leds) {
+ XkbEventCauseRec cause;
+
+ XkbSetCauseKey(&cause, (event->detail.key & 0x7), event->type);
+ XkbUpdateIndicators(dev, changed_leds, TRUE, NULL, &cause);
+ }
+ }
}
-} /* ProcessPointerEvent */
-
-
+ if (((xkbi->flags & _XkbStateNotifyInProgress) == 0) && (changed != 0)) {
+ xkbStateNotify sn;
+ sn.keycode = event->detail.key;
+ sn.eventType = event->type;
+ sn.requestMajor = sn.requestMinor = 0;
+ sn.changed = changed;
+ XkbSendStateNotify(dev, &sn);
+ }
+} /* ProcessPointerEvent */
diff --git a/xkb/xkbActions.c b/xkb/xkbActions.c
index da0bdea69..c473df17c 100644
--- a/xkb/xkbActions.c
+++ b/xkb/xkbActions.c
@@ -47,122 +47,129 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
DevPrivateKeyRec xkbDevicePrivateKeyRec;
-void XkbFakeDeviceButton(DeviceIntPtr dev,Bool press,int button);
-static void XkbFakePointerMotion(DeviceIntPtr dev, unsigned flags,int x,int y);
+void XkbFakeDeviceButton(DeviceIntPtr dev, Bool press, int button);
+static void XkbFakePointerMotion(DeviceIntPtr dev, unsigned flags, int x,
+ int y);
void
-xkbUnwrapProc(DeviceIntPtr device, DeviceHandleProc proc,
- pointer data)
+xkbUnwrapProc(DeviceIntPtr device, DeviceHandleProc proc, pointer data)
{
xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(device);
ProcessInputProc backupproc;
- if(xkbPrivPtr->unwrapProc)
- xkbPrivPtr->unwrapProc = NULL;
- UNWRAP_PROCESS_INPUT_PROC(device,xkbPrivPtr, backupproc);
- proc(device,data);
- COND_WRAP_PROCESS_INPUT_PROC(device,xkbPrivPtr,
- backupproc,xkbUnwrapProc);
+ if (xkbPrivPtr->unwrapProc)
+ xkbPrivPtr->unwrapProc = NULL;
+
+ UNWRAP_PROCESS_INPUT_PROC(device, xkbPrivPtr, backupproc);
+ proc(device, data);
+ COND_WRAP_PROCESS_INPUT_PROC(device, xkbPrivPtr, backupproc, xkbUnwrapProc);
}
Bool
XkbInitPrivates(void)
{
- return dixRegisterPrivateKey(&xkbDevicePrivateKeyRec, PRIVATE_DEVICE, sizeof(xkbDeviceInfoRec));
+ return dixRegisterPrivateKey(&xkbDevicePrivateKeyRec, PRIVATE_DEVICE,
+ sizeof(xkbDeviceInfoRec));
}
void
XkbSetExtension(DeviceIntPtr device, ProcessInputProc proc)
{
xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(device);
+
WRAP_PROCESS_INPUT_PROC(device, xkbPrivPtr, proc, xkbUnwrapProc);
}
/***====================================================================***/
static XkbAction
-_FixUpAction(XkbDescPtr xkb,XkbAction *act)
+_FixUpAction(XkbDescPtr xkb, XkbAction *act)
{
-static XkbAction fake;
+ static XkbAction fake;
- if (XkbIsPtrAction(act)&&(!(xkb->ctrls->enabled_ctrls&XkbMouseKeysMask))) {
- fake.type = XkbSA_NoAction;
- return fake;
+ if (XkbIsPtrAction(act) &&
+ (!(xkb->ctrls->enabled_ctrls & XkbMouseKeysMask))) {
+ fake.type = XkbSA_NoAction;
+ return fake;
}
- if (xkb->ctrls->enabled_ctrls&XkbStickyKeysMask) {
- if (act->any.type==XkbSA_SetMods) {
- fake.mods.type = XkbSA_LatchMods;
- fake.mods.mask = act->mods.mask;
- if (XkbAX_NeedOption(xkb->ctrls,XkbAX_LatchToLockMask))
- fake.mods.flags= XkbSA_ClearLocks|XkbSA_LatchToLock;
- else fake.mods.flags= XkbSA_ClearLocks;
- return fake;
- }
- if (act->any.type==XkbSA_SetGroup) {
- fake.group.type = XkbSA_LatchGroup;
- if (XkbAX_NeedOption(xkb->ctrls,XkbAX_LatchToLockMask))
- fake.group.flags= XkbSA_ClearLocks|XkbSA_LatchToLock;
- else fake.group.flags= XkbSA_ClearLocks;
- XkbSASetGroup(&fake.group,XkbSAGroup(&act->group));
- return fake;
- }
+ if (xkb->ctrls->enabled_ctrls & XkbStickyKeysMask) {
+ if (act->any.type == XkbSA_SetMods) {
+ fake.mods.type = XkbSA_LatchMods;
+ fake.mods.mask = act->mods.mask;
+ if (XkbAX_NeedOption(xkb->ctrls, XkbAX_LatchToLockMask))
+ fake.mods.flags = XkbSA_ClearLocks | XkbSA_LatchToLock;
+ else
+ fake.mods.flags = XkbSA_ClearLocks;
+ return fake;
+ }
+ if (act->any.type == XkbSA_SetGroup) {
+ fake.group.type = XkbSA_LatchGroup;
+ if (XkbAX_NeedOption(xkb->ctrls, XkbAX_LatchToLockMask))
+ fake.group.flags = XkbSA_ClearLocks | XkbSA_LatchToLock;
+ else
+ fake.group.flags = XkbSA_ClearLocks;
+ XkbSASetGroup(&fake.group, XkbSAGroup(&act->group));
+ return fake;
+ }
}
return *act;
}
static XkbAction
-XkbGetKeyAction(XkbSrvInfoPtr xkbi,XkbStatePtr xkbState,CARD8 key)
+XkbGetKeyAction(XkbSrvInfoPtr xkbi, XkbStatePtr xkbState, CARD8 key)
{
-int effectiveGroup;
-int col;
-XkbDescPtr xkb;
-XkbKeyTypePtr type;
-XkbAction * pActs;
-static XkbAction fake;
-
- xkb= xkbi->desc;
- if (!XkbKeyHasActions(xkb,key) || !XkbKeycodeInRange(xkb,key)) {
- fake.type = XkbSA_NoAction;
- return fake;
+ int effectiveGroup;
+ int col;
+ XkbDescPtr xkb;
+ XkbKeyTypePtr type;
+ XkbAction *pActs;
+ static XkbAction fake;
+
+ xkb = xkbi->desc;
+ if (!XkbKeyHasActions(xkb, key) || !XkbKeycodeInRange(xkb, key)) {
+ fake.type = XkbSA_NoAction;
+ return fake;
}
- pActs= XkbKeyActionsPtr(xkb,key);
- col= 0;
+ pActs = XkbKeyActionsPtr(xkb, key);
+ col = 0;
effectiveGroup = XkbGetEffectiveGroup(xkbi, xkbState, key);
if (effectiveGroup != XkbGroup1Index)
col += (effectiveGroup * XkbKeyGroupsWidth(xkb, key));
- type= XkbKeyKeyType(xkb,key,effectiveGroup);
- if (type->map!=NULL) {
- register unsigned i,mods;
- register XkbKTMapEntryPtr entry;
- mods= xkbState->mods&type->mods.mask;
- for (entry= type->map,i=0;i<type->map_count;i++,entry++) {
- if ((entry->active)&&(entry->mods.mask==mods)) {
- col+= entry->level;
- break;
- }
- }
+ type = XkbKeyKeyType(xkb, key, effectiveGroup);
+ if (type->map != NULL) {
+ register unsigned i, mods;
+ register XkbKTMapEntryPtr entry;
+
+ mods = xkbState->mods & type->mods.mask;
+ for (entry = type->map, i = 0; i < type->map_count; i++, entry++) {
+ if ((entry->active) && (entry->mods.mask == mods)) {
+ col += entry->level;
+ break;
+ }
+ }
}
- if (pActs[col].any.type==XkbSA_NoAction)
- return pActs[col];
- fake= _FixUpAction(xkb,&pActs[col]);
+ if (pActs[col].any.type == XkbSA_NoAction)
+ return pActs[col];
+ fake = _FixUpAction(xkb, &pActs[col]);
return fake;
}
static XkbAction
-XkbGetButtonAction(DeviceIntPtr kbd,DeviceIntPtr dev,int button)
+XkbGetButtonAction(DeviceIntPtr kbd, DeviceIntPtr dev, int button)
{
-XkbAction fake;
- if ((dev->button)&&(dev->button->xkb_acts)) {
- if (dev->button->xkb_acts[button-1].any.type!=XkbSA_NoAction) {
- fake= _FixUpAction(kbd->key->xkbInfo->desc,
- &dev->button->xkb_acts[button-1]);
- return fake;
- }
- }
- fake.any.type= XkbSA_NoAction;
- return fake;
+ XkbAction fake;
+
+ if ((dev->button) && (dev->button->xkb_acts)) {
+ if (dev->button->xkb_acts[button - 1].any.type != XkbSA_NoAction) {
+ fake = _FixUpAction(kbd->key->xkbInfo->desc,
+ &dev->button->xkb_acts[button - 1]);
+ return fake;
+ }
+ }
+ fake.any.type = XkbSA_NoAction;
+ return fake;
}
/***====================================================================***/
@@ -171,47 +178,45 @@ XkbAction fake;
#define BTN_ACT_FLAG 0x100
static int
-_XkbFilterSetState( XkbSrvInfoPtr xkbi,
- XkbFilterPtr filter,
- unsigned keycode,
- XkbAction *pAction)
+_XkbFilterSetState(XkbSrvInfoPtr xkbi,
+ XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)
{
- if (filter->keycode==0) { /* initial press */
- filter->keycode = keycode;
- filter->active = 1;
- filter->filterOthers = ((pAction->mods.mask&XkbSA_ClearLocks)!=0);
- filter->priv = 0;
- filter->filter = _XkbFilterSetState;
- if (pAction->type==XkbSA_SetMods) {
- filter->upAction = *pAction;
- xkbi->setMods= pAction->mods.mask;
- }
- else {
- xkbi->groupChange = XkbSAGroup(&pAction->group);
- if (pAction->group.flags&XkbSA_GroupAbsolute)
- xkbi->groupChange-= xkbi->state.base_group;
- filter->upAction= *pAction;
- XkbSASetGroup(&filter->upAction.group,xkbi->groupChange);
- }
+ if (filter->keycode == 0) { /* initial press */
+ filter->keycode = keycode;
+ filter->active = 1;
+ filter->filterOthers = ((pAction->mods.mask & XkbSA_ClearLocks) != 0);
+ filter->priv = 0;
+ filter->filter = _XkbFilterSetState;
+ if (pAction->type == XkbSA_SetMods) {
+ filter->upAction = *pAction;
+ xkbi->setMods = pAction->mods.mask;
+ }
+ else {
+ xkbi->groupChange = XkbSAGroup(&pAction->group);
+ if (pAction->group.flags & XkbSA_GroupAbsolute)
+ xkbi->groupChange -= xkbi->state.base_group;
+ filter->upAction = *pAction;
+ XkbSASetGroup(&filter->upAction.group, xkbi->groupChange);
+ }
}
- else if (filter->keycode==keycode) {
- if (filter->upAction.type==XkbSA_SetMods) {
- xkbi->clearMods = filter->upAction.mods.mask;
- if (filter->upAction.mods.flags&XkbSA_ClearLocks) {
- xkbi->state.locked_mods&= ~filter->upAction.mods.mask;
- }
- }
- else {
- if (filter->upAction.group.flags&XkbSA_ClearLocks) {
- xkbi->state.locked_group = 0;
- }
- xkbi->groupChange = -XkbSAGroup(&filter->upAction.group);
- }
- filter->active = 0;
+ else if (filter->keycode == keycode) {
+ if (filter->upAction.type == XkbSA_SetMods) {
+ xkbi->clearMods = filter->upAction.mods.mask;
+ if (filter->upAction.mods.flags & XkbSA_ClearLocks) {
+ xkbi->state.locked_mods &= ~filter->upAction.mods.mask;
+ }
+ }
+ else {
+ if (filter->upAction.group.flags & XkbSA_ClearLocks) {
+ xkbi->state.locked_group = 0;
+ }
+ xkbi->groupChange = -XkbSAGroup(&filter->upAction.group);
+ }
+ filter->active = 0;
}
else {
- filter->upAction.mods.flags&= ~XkbSA_ClearLocks;
- filter->filterOthers = 0;
+ filter->upAction.mods.flags &= ~XkbSA_ClearLocks;
+ filter->filterOthers = 0;
}
return 1;
}
@@ -221,141 +226,147 @@ _XkbFilterSetState( XkbSrvInfoPtr xkbi,
#define NO_LATCH 3
static int
-_XkbFilterLatchState( XkbSrvInfoPtr xkbi,
- XkbFilterPtr filter,
- unsigned keycode,
- XkbAction * pAction)
+_XkbFilterLatchState(XkbSrvInfoPtr xkbi,
+ XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)
{
- if (filter->keycode==0) { /* initial press */
- filter->keycode = keycode;
- filter->active = 1;
- filter->filterOthers = 1;
- filter->priv = LATCH_KEY_DOWN;
- filter->filter = _XkbFilterLatchState;
- if (pAction->type==XkbSA_LatchMods) {
- filter->upAction = *pAction;
- xkbi->setMods = pAction->mods.mask;
- }
- else {
- xkbi->groupChange = XkbSAGroup(&pAction->group);
- if (pAction->group.flags&XkbSA_GroupAbsolute)
- xkbi->groupChange-= xkbi->state.base_group;
- filter->upAction= *pAction;
- XkbSASetGroup(&filter->upAction.group,xkbi->groupChange);
- }
+ if (filter->keycode == 0) { /* initial press */
+ filter->keycode = keycode;
+ filter->active = 1;
+ filter->filterOthers = 1;
+ filter->priv = LATCH_KEY_DOWN;
+ filter->filter = _XkbFilterLatchState;
+ if (pAction->type == XkbSA_LatchMods) {
+ filter->upAction = *pAction;
+ xkbi->setMods = pAction->mods.mask;
+ }
+ else {
+ xkbi->groupChange = XkbSAGroup(&pAction->group);
+ if (pAction->group.flags & XkbSA_GroupAbsolute)
+ xkbi->groupChange -= xkbi->state.base_group;
+ filter->upAction = *pAction;
+ XkbSASetGroup(&filter->upAction.group, xkbi->groupChange);
+ }
}
- else if ( pAction && (filter->priv==LATCH_PENDING) ) {
- if (((1<<pAction->type)&XkbSA_BreakLatch)!=0) {
- filter->active = 0;
- if (filter->upAction.type==XkbSA_LatchMods)
- xkbi->state.latched_mods&= ~filter->upAction.mods.mask;
- else xkbi->state.latched_group-=XkbSAGroup(&filter->upAction.group);
- }
- else if ((pAction->type==filter->upAction.type)&&
- (pAction->mods.flags==filter->upAction.mods.flags)&&
- (pAction->mods.mask==filter->upAction.mods.mask)) {
- if (filter->upAction.mods.flags&XkbSA_LatchToLock) {
- XkbControlsPtr ctrls= xkbi->desc->ctrls;
- if (filter->upAction.type==XkbSA_LatchMods)
- pAction->mods.type= XkbSA_LockMods;
- else pAction->group.type= XkbSA_LockGroup;
- if (XkbAX_NeedFeedback(ctrls,XkbAX_StickyKeysFBMask)&&
- (ctrls->enabled_ctrls&XkbStickyKeysMask)) {
- XkbDDXAccessXBeep(xkbi->device,_BEEP_STICKY_LOCK,
- XkbStickyKeysMask);
- }
- }
- else {
- if (filter->upAction.type==XkbSA_LatchMods)
- pAction->mods.type= XkbSA_SetMods;
- else pAction->group.type= XkbSA_SetGroup;
- }
- if (filter->upAction.type==XkbSA_LatchMods)
- xkbi->state.latched_mods&= ~filter->upAction.mods.mask;
- else xkbi->state.latched_group-=XkbSAGroup(&filter->upAction.group);
- filter->active = 0;
- }
+ else if (pAction && (filter->priv == LATCH_PENDING)) {
+ if (((1 << pAction->type) & XkbSA_BreakLatch) != 0) {
+ filter->active = 0;
+ if (filter->upAction.type == XkbSA_LatchMods)
+ xkbi->state.latched_mods &= ~filter->upAction.mods.mask;
+ else
+ xkbi->state.latched_group -=
+ XkbSAGroup(&filter->upAction.group);
+ }
+ else if ((pAction->type == filter->upAction.type) &&
+ (pAction->mods.flags == filter->upAction.mods.flags) &&
+ (pAction->mods.mask == filter->upAction.mods.mask)) {
+ if (filter->upAction.mods.flags & XkbSA_LatchToLock) {
+ XkbControlsPtr ctrls = xkbi->desc->ctrls;
+
+ if (filter->upAction.type == XkbSA_LatchMods)
+ pAction->mods.type = XkbSA_LockMods;
+ else
+ pAction->group.type = XkbSA_LockGroup;
+ if (XkbAX_NeedFeedback(ctrls, XkbAX_StickyKeysFBMask) &&
+ (ctrls->enabled_ctrls & XkbStickyKeysMask)) {
+ XkbDDXAccessXBeep(xkbi->device, _BEEP_STICKY_LOCK,
+ XkbStickyKeysMask);
+ }
+ }
+ else {
+ if (filter->upAction.type == XkbSA_LatchMods)
+ pAction->mods.type = XkbSA_SetMods;
+ else
+ pAction->group.type = XkbSA_SetGroup;
+ }
+ if (filter->upAction.type == XkbSA_LatchMods)
+ xkbi->state.latched_mods &= ~filter->upAction.mods.mask;
+ else
+ xkbi->state.latched_group -=
+ XkbSAGroup(&filter->upAction.group);
+ filter->active = 0;
+ }
}
- else if (filter->keycode==keycode) { /* release */
- XkbControlsPtr ctrls= xkbi->desc->ctrls;
- int needBeep;
- int beepType= _BEEP_NONE;
-
- needBeep= ((ctrls->enabled_ctrls&XkbStickyKeysMask)&&
- XkbAX_NeedFeedback(ctrls,XkbAX_StickyKeysFBMask));
- if (filter->upAction.type==XkbSA_LatchMods) {
- xkbi->clearMods = filter->upAction.mods.mask;
- if ((filter->upAction.mods.flags&XkbSA_ClearLocks)&&
- (xkbi->clearMods&xkbi->state.locked_mods)==xkbi->clearMods) {
- xkbi->state.locked_mods&= ~xkbi->clearMods;
- filter->priv= NO_LATCH;
- beepType= _BEEP_STICKY_UNLOCK;
- }
- }
- else {
- xkbi->groupChange = -XkbSAGroup(&filter->upAction.group);
- if ((filter->upAction.group.flags&XkbSA_ClearLocks)&&
- (xkbi->state.locked_group)) {
- xkbi->state.locked_group = 0;
- filter->priv = NO_LATCH;
- beepType= _BEEP_STICKY_UNLOCK;
- }
- }
- if (filter->priv==NO_LATCH) {
- filter->active= 0;
- }
- else {
- filter->priv= LATCH_PENDING;
- if (filter->upAction.type==XkbSA_LatchMods) {
- xkbi->state.latched_mods |= filter->upAction.mods.mask;
- needBeep = xkbi->state.latched_mods ? needBeep : 0;
- xkbi->state.latched_mods |= filter->upAction.mods.mask;
- }
- else {
- xkbi->state.latched_group+= XkbSAGroup(&filter->upAction.group);
- }
- if (needBeep && (beepType==_BEEP_NONE))
- beepType= _BEEP_STICKY_LATCH;
- }
- if (needBeep && (beepType!=_BEEP_NONE))
- XkbDDXAccessXBeep(xkbi->device,beepType,XkbStickyKeysMask);
+ else if (filter->keycode == keycode) { /* release */
+ XkbControlsPtr ctrls = xkbi->desc->ctrls;
+ int needBeep;
+ int beepType = _BEEP_NONE;
+
+ needBeep = ((ctrls->enabled_ctrls & XkbStickyKeysMask) &&
+ XkbAX_NeedFeedback(ctrls, XkbAX_StickyKeysFBMask));
+ if (filter->upAction.type == XkbSA_LatchMods) {
+ xkbi->clearMods = filter->upAction.mods.mask;
+ if ((filter->upAction.mods.flags & XkbSA_ClearLocks) &&
+ (xkbi->clearMods & xkbi->state.locked_mods) ==
+ xkbi->clearMods) {
+ xkbi->state.locked_mods &= ~xkbi->clearMods;
+ filter->priv = NO_LATCH;
+ beepType = _BEEP_STICKY_UNLOCK;
+ }
+ }
+ else {
+ xkbi->groupChange = -XkbSAGroup(&filter->upAction.group);
+ if ((filter->upAction.group.flags & XkbSA_ClearLocks) &&
+ (xkbi->state.locked_group)) {
+ xkbi->state.locked_group = 0;
+ filter->priv = NO_LATCH;
+ beepType = _BEEP_STICKY_UNLOCK;
+ }
+ }
+ if (filter->priv == NO_LATCH) {
+ filter->active = 0;
+ }
+ else {
+ filter->priv = LATCH_PENDING;
+ if (filter->upAction.type == XkbSA_LatchMods) {
+ xkbi->state.latched_mods |= filter->upAction.mods.mask;
+ needBeep = xkbi->state.latched_mods ? needBeep : 0;
+ xkbi->state.latched_mods |= filter->upAction.mods.mask;
+ }
+ else {
+ xkbi->state.latched_group +=
+ XkbSAGroup(&filter->upAction.group);
+ }
+ if (needBeep && (beepType == _BEEP_NONE))
+ beepType = _BEEP_STICKY_LATCH;
+ }
+ if (needBeep && (beepType != _BEEP_NONE))
+ XkbDDXAccessXBeep(xkbi->device, beepType, XkbStickyKeysMask);
}
- else if (filter->priv==LATCH_KEY_DOWN) {
- filter->priv= NO_LATCH;
- filter->filterOthers = 0;
+ else if (filter->priv == LATCH_KEY_DOWN) {
+ filter->priv = NO_LATCH;
+ filter->filterOthers = 0;
}
return 1;
}
static int
-_XkbFilterLockState( XkbSrvInfoPtr xkbi,
- XkbFilterPtr filter,
- unsigned keycode,
- XkbAction * pAction)
+_XkbFilterLockState(XkbSrvInfoPtr xkbi,
+ XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)
{
- if (pAction&&(pAction->type==XkbSA_LockGroup)) {
- if (pAction->group.flags&XkbSA_GroupAbsolute)
- xkbi->state.locked_group= XkbSAGroup(&pAction->group);
- else xkbi->state.locked_group+= XkbSAGroup(&pAction->group);
- return 1;
+ if (pAction && (pAction->type == XkbSA_LockGroup)) {
+ if (pAction->group.flags & XkbSA_GroupAbsolute)
+ xkbi->state.locked_group = XkbSAGroup(&pAction->group);
+ else
+ xkbi->state.locked_group += XkbSAGroup(&pAction->group);
+ return 1;
}
- if (filter->keycode==0) { /* initial press */
- filter->keycode = keycode;
- filter->active = 1;
- filter->filterOthers = 0;
- filter->priv = xkbi->state.locked_mods&pAction->mods.mask;
- filter->filter = _XkbFilterLockState;
- filter->upAction = *pAction;
- if (!(filter->upAction.mods.flags&XkbSA_LockNoLock))
- xkbi->state.locked_mods|= pAction->mods.mask;
- xkbi->setMods = pAction->mods.mask;
+ if (filter->keycode == 0) { /* initial press */
+ filter->keycode = keycode;
+ filter->active = 1;
+ filter->filterOthers = 0;
+ filter->priv = xkbi->state.locked_mods & pAction->mods.mask;
+ filter->filter = _XkbFilterLockState;
+ filter->upAction = *pAction;
+ if (!(filter->upAction.mods.flags & XkbSA_LockNoLock))
+ xkbi->state.locked_mods |= pAction->mods.mask;
+ xkbi->setMods = pAction->mods.mask;
}
- else if (filter->keycode==keycode) {
- filter->active = 0;
- xkbi->clearMods = filter->upAction.mods.mask;
- if (!(filter->upAction.mods.flags&XkbSA_LockNoUnlock))
- xkbi->state.locked_mods&= ~filter->priv;
+ else if (filter->keycode == keycode) {
+ filter->active = 0;
+ xkbi->clearMods = filter->upAction.mods.mask;
+ if (!(filter->upAction.mods.flags & XkbSA_LockNoUnlock))
+ xkbi->state.locked_mods &= ~filter->priv;
}
return 1;
}
@@ -364,922 +375,926 @@ _XkbFilterLockState( XkbSrvInfoPtr xkbi,
#define NO_ISO_LOCK 1
static int
-_XkbFilterISOLock( XkbSrvInfoPtr xkbi,
- XkbFilterPtr filter,
- unsigned keycode,
- XkbAction * pAction)
+_XkbFilterISOLock(XkbSrvInfoPtr xkbi,
+ XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)
{
- if (filter->keycode==0) { /* initial press */
- CARD8 flags= pAction->iso.flags;
-
- filter->keycode = keycode;
- filter->active = 1;
- filter->filterOthers = 1;
- filter->priv = ISO_KEY_DOWN;
- filter->upAction = *pAction;
- filter->filter = _XkbFilterISOLock;
- if (flags&XkbSA_ISODfltIsGroup) {
- xkbi->groupChange = XkbSAGroup(&pAction->iso);
- xkbi->setMods = 0;
- }
- else {
- xkbi->setMods = pAction->iso.mask;
- xkbi->groupChange = 0;
- }
- if ((!(flags&XkbSA_ISONoAffectMods))&&(xkbi->state.base_mods)) {
- filter->priv= NO_ISO_LOCK;
- xkbi->state.locked_mods^= xkbi->state.base_mods;
- }
- if ((!(flags&XkbSA_ISONoAffectGroup))&&(xkbi->state.base_group)) {
+ if (filter->keycode == 0) { /* initial press */
+ CARD8 flags = pAction->iso.flags;
+
+ filter->keycode = keycode;
+ filter->active = 1;
+ filter->filterOthers = 1;
+ filter->priv = ISO_KEY_DOWN;
+ filter->upAction = *pAction;
+ filter->filter = _XkbFilterISOLock;
+ if (flags & XkbSA_ISODfltIsGroup) {
+ xkbi->groupChange = XkbSAGroup(&pAction->iso);
+ xkbi->setMods = 0;
+ }
+ else {
+ xkbi->setMods = pAction->iso.mask;
+ xkbi->groupChange = 0;
+ }
+ if ((!(flags & XkbSA_ISONoAffectMods)) && (xkbi->state.base_mods)) {
+ filter->priv = NO_ISO_LOCK;
+ xkbi->state.locked_mods ^= xkbi->state.base_mods;
+ }
+ if ((!(flags & XkbSA_ISONoAffectGroup)) && (xkbi->state.base_group)) {
/* 6/22/93 (ef) -- lock groups if group key is down first */
- }
- if (!(flags&XkbSA_ISONoAffectPtr)) {
+ }
+ if (!(flags & XkbSA_ISONoAffectPtr)) {
/* 6/22/93 (ef) -- lock mouse buttons if they're down */
- }
+ }
}
- else if (filter->keycode==keycode) {
- CARD8 flags= filter->upAction.iso.flags;
-
- if (flags&XkbSA_ISODfltIsGroup) {
- xkbi->groupChange = -XkbSAGroup(&filter->upAction.iso);
- xkbi->clearMods = 0;
- if (filter->priv==ISO_KEY_DOWN)
- xkbi->state.locked_group+= XkbSAGroup(&filter->upAction.iso);
- }
- else {
- xkbi->clearMods= filter->upAction.iso.mask;
- xkbi->groupChange= 0;
- if (filter->priv==ISO_KEY_DOWN)
- xkbi->state.locked_mods^= filter->upAction.iso.mask;
- }
- filter->active = 0;
+ else if (filter->keycode == keycode) {
+ CARD8 flags = filter->upAction.iso.flags;
+
+ if (flags & XkbSA_ISODfltIsGroup) {
+ xkbi->groupChange = -XkbSAGroup(&filter->upAction.iso);
+ xkbi->clearMods = 0;
+ if (filter->priv == ISO_KEY_DOWN)
+ xkbi->state.locked_group += XkbSAGroup(&filter->upAction.iso);
+ }
+ else {
+ xkbi->clearMods = filter->upAction.iso.mask;
+ xkbi->groupChange = 0;
+ if (filter->priv == ISO_KEY_DOWN)
+ xkbi->state.locked_mods ^= filter->upAction.iso.mask;
+ }
+ filter->active = 0;
}
else if (pAction) {
- CARD8 flags= filter->upAction.iso.flags;
-
- switch (pAction->type) {
- case XkbSA_SetMods: case XkbSA_LatchMods:
- if (!(flags&XkbSA_ISONoAffectMods)) {
- pAction->type= XkbSA_LockMods;
- filter->priv= NO_ISO_LOCK;
- }
- break;
- case XkbSA_SetGroup: case XkbSA_LatchGroup:
- if (!(flags&XkbSA_ISONoAffectGroup)) {
- pAction->type= XkbSA_LockGroup;
- filter->priv= NO_ISO_LOCK;
- }
- break;
- case XkbSA_PtrBtn:
- if (!(flags&XkbSA_ISONoAffectPtr)) {
- pAction->type= XkbSA_LockPtrBtn;
- filter->priv= NO_ISO_LOCK;
- }
- break;
- case XkbSA_SetControls:
- if (!(flags&XkbSA_ISONoAffectCtrls)) {
- pAction->type= XkbSA_LockControls;
- filter->priv= NO_ISO_LOCK;
- }
- break;
- }
+ CARD8 flags = filter->upAction.iso.flags;
+
+ switch (pAction->type) {
+ case XkbSA_SetMods:
+ case XkbSA_LatchMods:
+ if (!(flags & XkbSA_ISONoAffectMods)) {
+ pAction->type = XkbSA_LockMods;
+ filter->priv = NO_ISO_LOCK;
+ }
+ break;
+ case XkbSA_SetGroup:
+ case XkbSA_LatchGroup:
+ if (!(flags & XkbSA_ISONoAffectGroup)) {
+ pAction->type = XkbSA_LockGroup;
+ filter->priv = NO_ISO_LOCK;
+ }
+ break;
+ case XkbSA_PtrBtn:
+ if (!(flags & XkbSA_ISONoAffectPtr)) {
+ pAction->type = XkbSA_LockPtrBtn;
+ filter->priv = NO_ISO_LOCK;
+ }
+ break;
+ case XkbSA_SetControls:
+ if (!(flags & XkbSA_ISONoAffectCtrls)) {
+ pAction->type = XkbSA_LockControls;
+ filter->priv = NO_ISO_LOCK;
+ }
+ break;
+ }
}
return 1;
}
-
static CARD32
-_XkbPtrAccelExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+_XkbPtrAccelExpire(OsTimerPtr timer, CARD32 now, pointer arg)
{
-XkbSrvInfoPtr xkbi= (XkbSrvInfoPtr)arg;
-XkbControlsPtr ctrls= xkbi->desc->ctrls;
-int dx,dy;
+ XkbSrvInfoPtr xkbi = (XkbSrvInfoPtr) arg;
+ XkbControlsPtr ctrls = xkbi->desc->ctrls;
+ int dx, dy;
- if (xkbi->mouseKey==0)
- return 0;
+ if (xkbi->mouseKey == 0)
+ return 0;
if (xkbi->mouseKeysAccel) {
- if ((xkbi->mouseKeysCounter)<ctrls->mk_time_to_max) {
- double step;
- xkbi->mouseKeysCounter++;
- step= xkbi->mouseKeysCurveFactor*
- pow((double)xkbi->mouseKeysCounter,xkbi->mouseKeysCurve);
- if (xkbi->mouseKeysDX<0)
- dx= floor( ((double)xkbi->mouseKeysDX)*step );
- else dx= ceil( ((double)xkbi->mouseKeysDX)*step );
- if (xkbi->mouseKeysDY<0)
- dy= floor( ((double)xkbi->mouseKeysDY)*step );
- else dy= ceil( ((double)xkbi->mouseKeysDY)*step );
- }
- else {
- dx= xkbi->mouseKeysDX*ctrls->mk_max_speed;
- dy= xkbi->mouseKeysDY*ctrls->mk_max_speed;
- }
- if (xkbi->mouseKeysFlags&XkbSA_MoveAbsoluteX)
- dx= xkbi->mouseKeysDX;
- if (xkbi->mouseKeysFlags&XkbSA_MoveAbsoluteY)
- dy= xkbi->mouseKeysDY;
+ if ((xkbi->mouseKeysCounter) < ctrls->mk_time_to_max) {
+ double step;
+
+ xkbi->mouseKeysCounter++;
+ step = xkbi->mouseKeysCurveFactor *
+ pow((double) xkbi->mouseKeysCounter, xkbi->mouseKeysCurve);
+ if (xkbi->mouseKeysDX < 0)
+ dx = floor(((double) xkbi->mouseKeysDX) * step);
+ else
+ dx = ceil(((double) xkbi->mouseKeysDX) * step);
+ if (xkbi->mouseKeysDY < 0)
+ dy = floor(((double) xkbi->mouseKeysDY) * step);
+ else
+ dy = ceil(((double) xkbi->mouseKeysDY) * step);
+ }
+ else {
+ dx = xkbi->mouseKeysDX * ctrls->mk_max_speed;
+ dy = xkbi->mouseKeysDY * ctrls->mk_max_speed;
+ }
+ if (xkbi->mouseKeysFlags & XkbSA_MoveAbsoluteX)
+ dx = xkbi->mouseKeysDX;
+ if (xkbi->mouseKeysFlags & XkbSA_MoveAbsoluteY)
+ dy = xkbi->mouseKeysDY;
}
else {
- dx= xkbi->mouseKeysDX;
- dy= xkbi->mouseKeysDY;
+ dx = xkbi->mouseKeysDX;
+ dy = xkbi->mouseKeysDY;
}
- XkbFakePointerMotion(xkbi->device, xkbi->mouseKeysFlags,dx,dy);
+ XkbFakePointerMotion(xkbi->device, xkbi->mouseKeysFlags, dx, dy);
return xkbi->desc->ctrls->mk_interval;
}
static int
-_XkbFilterPointerMove( XkbSrvInfoPtr xkbi,
- XkbFilterPtr filter,
- unsigned keycode,
- XkbAction * pAction)
+_XkbFilterPointerMove(XkbSrvInfoPtr xkbi,
+ XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)
{
-int x,y;
-Bool accel;
-
- if (filter->keycode==0) { /* initial press */
- filter->keycode = keycode;
- filter->active = 1;
- filter->filterOthers = 0;
- filter->priv=0;
- filter->filter = _XkbFilterPointerMove;
- filter->upAction= *pAction;
- xkbi->mouseKeysCounter= 0;
- xkbi->mouseKey= keycode;
- accel= ((pAction->ptr.flags&XkbSA_NoAcceleration)==0);
- x= XkbPtrActionX(&pAction->ptr);
- y= XkbPtrActionY(&pAction->ptr);
- XkbFakePointerMotion(xkbi->device, pAction->ptr.flags,x,y);
- AccessXCancelRepeatKey(xkbi,keycode);
- xkbi->mouseKeysAccel= accel&&
- (xkbi->desc->ctrls->enabled_ctrls&XkbMouseKeysAccelMask);
- xkbi->mouseKeysFlags= pAction->ptr.flags;
- xkbi->mouseKeysDX= XkbPtrActionX(&pAction->ptr);
- xkbi->mouseKeysDY= XkbPtrActionY(&pAction->ptr);
- xkbi->mouseKeyTimer= TimerSet(xkbi->mouseKeyTimer, 0,
- xkbi->desc->ctrls->mk_delay,
- _XkbPtrAccelExpire,(pointer)xkbi);
+ int x, y;
+ Bool accel;
+
+ if (filter->keycode == 0) { /* initial press */
+ filter->keycode = keycode;
+ filter->active = 1;
+ filter->filterOthers = 0;
+ filter->priv = 0;
+ filter->filter = _XkbFilterPointerMove;
+ filter->upAction = *pAction;
+ xkbi->mouseKeysCounter = 0;
+ xkbi->mouseKey = keycode;
+ accel = ((pAction->ptr.flags & XkbSA_NoAcceleration) == 0);
+ x = XkbPtrActionX(&pAction->ptr);
+ y = XkbPtrActionY(&pAction->ptr);
+ XkbFakePointerMotion(xkbi->device, pAction->ptr.flags, x, y);
+ AccessXCancelRepeatKey(xkbi, keycode);
+ xkbi->mouseKeysAccel = accel &&
+ (xkbi->desc->ctrls->enabled_ctrls & XkbMouseKeysAccelMask);
+ xkbi->mouseKeysFlags = pAction->ptr.flags;
+ xkbi->mouseKeysDX = XkbPtrActionX(&pAction->ptr);
+ xkbi->mouseKeysDY = XkbPtrActionY(&pAction->ptr);
+ xkbi->mouseKeyTimer = TimerSet(xkbi->mouseKeyTimer, 0,
+ xkbi->desc->ctrls->mk_delay,
+ _XkbPtrAccelExpire, (pointer) xkbi);
}
- else if (filter->keycode==keycode) {
- filter->active = 0;
- if (xkbi->mouseKey==keycode) {
- xkbi->mouseKey= 0;
- xkbi->mouseKeyTimer= TimerSet(xkbi->mouseKeyTimer, 0, 0,
- NULL, NULL);
- }
+ else if (filter->keycode == keycode) {
+ filter->active = 0;
+ if (xkbi->mouseKey == keycode) {
+ xkbi->mouseKey = 0;
+ xkbi->mouseKeyTimer = TimerSet(xkbi->mouseKeyTimer, 0, 0,
+ NULL, NULL);
+ }
}
return 0;
}
static int
-_XkbFilterPointerBtn( XkbSrvInfoPtr xkbi,
- XkbFilterPtr filter,
- unsigned keycode,
- XkbAction * pAction)
+_XkbFilterPointerBtn(XkbSrvInfoPtr xkbi,
+ XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)
{
- if (filter->keycode==0) { /* initial press */
- int button= pAction->btn.button;
-
- if (button==XkbSA_UseDfltButton)
- button = xkbi->desc->ctrls->mk_dflt_btn;
-
- filter->keycode = keycode;
- filter->active = 1;
- filter->filterOthers = 0;
- filter->priv=0;
- filter->filter = _XkbFilterPointerBtn;
- filter->upAction= *pAction;
- filter->upAction.btn.button= button;
- switch (pAction->type) {
- case XkbSA_LockPtrBtn:
- if (((xkbi->lockedPtrButtons&(1<<button))==0)&&
- ((pAction->btn.flags&XkbSA_LockNoLock)==0)) {
- xkbi->lockedPtrButtons|= (1<<button);
- AccessXCancelRepeatKey(xkbi,keycode);
- XkbFakeDeviceButton(xkbi->device, 1, button);
- filter->upAction.type= XkbSA_NoAction;
- }
- break;
- case XkbSA_PtrBtn:
- {
- register int i,nClicks;
- AccessXCancelRepeatKey(xkbi,keycode);
- if (pAction->btn.count>0) {
- nClicks= pAction->btn.count;
- for (i=0;i<nClicks;i++) {
- XkbFakeDeviceButton(xkbi->device, 1, button);
- XkbFakeDeviceButton(xkbi->device, 0, button);
- }
- filter->upAction.type= XkbSA_NoAction;
- }
- else XkbFakeDeviceButton(xkbi->device, 1, button);
- }
- break;
- case XkbSA_SetPtrDflt:
- {
- XkbControlsPtr ctrls= xkbi->desc->ctrls;
- XkbControlsRec old;
- xkbControlsNotify cn;
-
- old= *ctrls;
- AccessXCancelRepeatKey(xkbi,keycode);
- switch (pAction->dflt.affect) {
- case XkbSA_AffectDfltBtn:
- if (pAction->dflt.flags&XkbSA_DfltBtnAbsolute)
- ctrls->mk_dflt_btn=
- XkbSAPtrDfltValue(&pAction->dflt);
- else {
- ctrls->mk_dflt_btn+=
- XkbSAPtrDfltValue(&pAction->dflt);
- if (ctrls->mk_dflt_btn>5)
- ctrls->mk_dflt_btn= 5;
- else if (ctrls->mk_dflt_btn<1)
- ctrls->mk_dflt_btn= 1;
- }
- break;
- default:
- ErrorF(
- "Attempt to change unknown pointer default (%d) ignored\n",
- pAction->dflt.affect);
- break;
- }
- if (XkbComputeControlsNotify(xkbi->device,
- &old,xkbi->desc->ctrls,
- &cn,FALSE)) {
- cn.keycode = keycode;
- /* XXX: what about DeviceKeyPress? */
- cn.eventType = KeyPress;
- cn.requestMajor = 0;
- cn.requestMinor = 0;
- XkbSendControlsNotify(xkbi->device,&cn);
- }
- }
- break;
- }
+ if (filter->keycode == 0) { /* initial press */
+ int button = pAction->btn.button;
+
+ if (button == XkbSA_UseDfltButton)
+ button = xkbi->desc->ctrls->mk_dflt_btn;
+
+ filter->keycode = keycode;
+ filter->active = 1;
+ filter->filterOthers = 0;
+ filter->priv = 0;
+ filter->filter = _XkbFilterPointerBtn;
+ filter->upAction = *pAction;
+ filter->upAction.btn.button = button;
+ switch (pAction->type) {
+ case XkbSA_LockPtrBtn:
+ if (((xkbi->lockedPtrButtons & (1 << button)) == 0) &&
+ ((pAction->btn.flags & XkbSA_LockNoLock) == 0)) {
+ xkbi->lockedPtrButtons |= (1 << button);
+ AccessXCancelRepeatKey(xkbi, keycode);
+ XkbFakeDeviceButton(xkbi->device, 1, button);
+ filter->upAction.type = XkbSA_NoAction;
+ }
+ break;
+ case XkbSA_PtrBtn:
+ {
+ register int i, nClicks;
+
+ AccessXCancelRepeatKey(xkbi, keycode);
+ if (pAction->btn.count > 0) {
+ nClicks = pAction->btn.count;
+ for (i = 0; i < nClicks; i++) {
+ XkbFakeDeviceButton(xkbi->device, 1, button);
+ XkbFakeDeviceButton(xkbi->device, 0, button);
+ }
+ filter->upAction.type = XkbSA_NoAction;
+ }
+ else
+ XkbFakeDeviceButton(xkbi->device, 1, button);
+ }
+ break;
+ case XkbSA_SetPtrDflt:
+ {
+ XkbControlsPtr ctrls = xkbi->desc->ctrls;
+ XkbControlsRec old;
+ xkbControlsNotify cn;
+
+ old = *ctrls;
+ AccessXCancelRepeatKey(xkbi, keycode);
+ switch (pAction->dflt.affect) {
+ case XkbSA_AffectDfltBtn:
+ if (pAction->dflt.flags & XkbSA_DfltBtnAbsolute)
+ ctrls->mk_dflt_btn = XkbSAPtrDfltValue(&pAction->dflt);
+ else {
+ ctrls->mk_dflt_btn += XkbSAPtrDfltValue(&pAction->dflt);
+ if (ctrls->mk_dflt_btn > 5)
+ ctrls->mk_dflt_btn = 5;
+ else if (ctrls->mk_dflt_btn < 1)
+ ctrls->mk_dflt_btn = 1;
+ }
+ break;
+ default:
+ ErrorF
+ ("Attempt to change unknown pointer default (%d) ignored\n",
+ pAction->dflt.affect);
+ break;
+ }
+ if (XkbComputeControlsNotify(xkbi->device,
+ &old, xkbi->desc->ctrls, &cn, FALSE)) {
+ cn.keycode = keycode;
+ /* XXX: what about DeviceKeyPress? */
+ cn.eventType = KeyPress;
+ cn.requestMajor = 0;
+ cn.requestMinor = 0;
+ XkbSendControlsNotify(xkbi->device, &cn);
+ }
+ }
+ break;
+ }
}
- else if (filter->keycode==keycode) {
- int button= filter->upAction.btn.button;
-
- switch (filter->upAction.type) {
- case XkbSA_LockPtrBtn:
- if (((filter->upAction.btn.flags&XkbSA_LockNoUnlock)!=0)||
- ((xkbi->lockedPtrButtons&(1<<button))==0)) {
- break;
- }
- xkbi->lockedPtrButtons&= ~(1<<button);
-
- if (IsMaster(xkbi->device))
- {
- XkbMergeLockedPtrBtns(xkbi->device);
- /* One SD still has lock set, don't post event */
- if ((xkbi->lockedPtrButtons & (1 << button)) != 0)
- break;
- }
-
- /* fallthrough */
- case XkbSA_PtrBtn:
- XkbFakeDeviceButton(xkbi->device, 0, button);
- break;
- }
- filter->active = 0;
+ else if (filter->keycode == keycode) {
+ int button = filter->upAction.btn.button;
+
+ switch (filter->upAction.type) {
+ case XkbSA_LockPtrBtn:
+ if (((filter->upAction.btn.flags & XkbSA_LockNoUnlock) != 0) ||
+ ((xkbi->lockedPtrButtons & (1 << button)) == 0)) {
+ break;
+ }
+ xkbi->lockedPtrButtons &= ~(1 << button);
+
+ if (IsMaster(xkbi->device)) {
+ XkbMergeLockedPtrBtns(xkbi->device);
+ /* One SD still has lock set, don't post event */
+ if ((xkbi->lockedPtrButtons & (1 << button)) != 0)
+ break;
+ }
+
+ /* fallthrough */
+ case XkbSA_PtrBtn:
+ XkbFakeDeviceButton(xkbi->device, 0, button);
+ break;
+ }
+ filter->active = 0;
}
return 0;
}
static int
-_XkbFilterControls( XkbSrvInfoPtr xkbi,
- XkbFilterPtr filter,
- unsigned keycode,
- XkbAction * pAction)
+_XkbFilterControls(XkbSrvInfoPtr xkbi,
+ XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)
{
-XkbControlsRec old;
-XkbControlsPtr ctrls;
-DeviceIntPtr kbd;
-unsigned int change;
-XkbEventCauseRec cause;
-
- kbd= xkbi->device;
- ctrls= xkbi->desc->ctrls;
- old= *ctrls;
- if (filter->keycode==0) { /* initial press */
- filter->keycode = keycode;
- filter->active = 1;
- filter->filterOthers = 0;
- change= XkbActionCtrls(&pAction->ctrls);
- filter->priv = change;
- filter->filter = _XkbFilterControls;
- filter->upAction = *pAction;
-
- if (pAction->type==XkbSA_LockControls) {
- filter->priv= (ctrls->enabled_ctrls&change);
- change&= ~ctrls->enabled_ctrls;
- }
-
- if (change) {
- xkbControlsNotify cn;
- XkbSrvLedInfoPtr sli;
-
- ctrls->enabled_ctrls|= change;
- if (XkbComputeControlsNotify(kbd,&old,ctrls,&cn,FALSE)) {
- cn.keycode = keycode;
+ XkbControlsRec old;
+ XkbControlsPtr ctrls;
+ DeviceIntPtr kbd;
+ unsigned int change;
+ XkbEventCauseRec cause;
+
+ kbd = xkbi->device;
+ ctrls = xkbi->desc->ctrls;
+ old = *ctrls;
+ if (filter->keycode == 0) { /* initial press */
+ filter->keycode = keycode;
+ filter->active = 1;
+ filter->filterOthers = 0;
+ change = XkbActionCtrls(&pAction->ctrls);
+ filter->priv = change;
+ filter->filter = _XkbFilterControls;
+ filter->upAction = *pAction;
+
+ if (pAction->type == XkbSA_LockControls) {
+ filter->priv = (ctrls->enabled_ctrls & change);
+ change &= ~ctrls->enabled_ctrls;
+ }
+
+ if (change) {
+ xkbControlsNotify cn;
+ XkbSrvLedInfoPtr sli;
+
+ ctrls->enabled_ctrls |= change;
+ if (XkbComputeControlsNotify(kbd, &old, ctrls, &cn, FALSE)) {
+ cn.keycode = keycode;
/* XXX: what about DeviceKeyPress? */
- cn.eventType = KeyPress;
- cn.requestMajor = 0;
- cn.requestMinor = 0;
- XkbSendControlsNotify(kbd,&cn);
- }
-
- XkbSetCauseKey(&cause,keycode,KeyPress);
-
- /* If sticky keys were disabled, clear all locks and latches */
- if ((old.enabled_ctrls&XkbStickyKeysMask)&&
- (!(ctrls->enabled_ctrls&XkbStickyKeysMask))) {
- XkbClearAllLatchesAndLocks(kbd,xkbi,FALSE,&cause);
- }
- sli= XkbFindSrvLedInfo(kbd,XkbDfltXIClass,XkbDfltXIId,0);
- XkbUpdateIndicators(kbd,sli->usesControls,TRUE,NULL,&cause);
- if (XkbAX_NeedFeedback(ctrls,XkbAX_FeatureFBMask))
- XkbDDXAccessXBeep(kbd,_BEEP_FEATURE_ON,change);
- }
+ cn.eventType = KeyPress;
+ cn.requestMajor = 0;
+ cn.requestMinor = 0;
+ XkbSendControlsNotify(kbd, &cn);
+ }
+
+ XkbSetCauseKey(&cause, keycode, KeyPress);
+
+ /* If sticky keys were disabled, clear all locks and latches */
+ if ((old.enabled_ctrls & XkbStickyKeysMask) &&
+ (!(ctrls->enabled_ctrls & XkbStickyKeysMask))) {
+ XkbClearAllLatchesAndLocks(kbd, xkbi, FALSE, &cause);
+ }
+ sli = XkbFindSrvLedInfo(kbd, XkbDfltXIClass, XkbDfltXIId, 0);
+ XkbUpdateIndicators(kbd, sli->usesControls, TRUE, NULL, &cause);
+ if (XkbAX_NeedFeedback(ctrls, XkbAX_FeatureFBMask))
+ XkbDDXAccessXBeep(kbd, _BEEP_FEATURE_ON, change);
+ }
}
- else if (filter->keycode==keycode) {
- change= filter->priv;
- if (change) {
- xkbControlsNotify cn;
- XkbSrvLedInfoPtr sli;
-
- ctrls->enabled_ctrls&= ~change;
- if (XkbComputeControlsNotify(kbd,&old,ctrls,&cn,FALSE)) {
- cn.keycode = keycode;
- cn.eventType = KeyRelease;
- cn.requestMajor = 0;
- cn.requestMinor = 0;
- XkbSendControlsNotify(kbd,&cn);
- }
-
- XkbSetCauseKey(&cause,keycode,KeyRelease);
- /* If sticky keys were disabled, clear all locks and latches */
- if ((old.enabled_ctrls&XkbStickyKeysMask)&&
- (!(ctrls->enabled_ctrls&XkbStickyKeysMask))) {
- XkbClearAllLatchesAndLocks(kbd,xkbi,FALSE,&cause);
- }
- sli= XkbFindSrvLedInfo(kbd,XkbDfltXIClass,XkbDfltXIId,0);
- XkbUpdateIndicators(kbd,sli->usesControls,TRUE,NULL,&cause);
- if (XkbAX_NeedFeedback(ctrls,XkbAX_FeatureFBMask))
- XkbDDXAccessXBeep(kbd,_BEEP_FEATURE_OFF,change);
- }
- filter->keycode= 0;
- filter->active= 0;
+ else if (filter->keycode == keycode) {
+ change = filter->priv;
+ if (change) {
+ xkbControlsNotify cn;
+ XkbSrvLedInfoPtr sli;
+
+ ctrls->enabled_ctrls &= ~change;
+ if (XkbComputeControlsNotify(kbd, &old, ctrls, &cn, FALSE)) {
+ cn.keycode = keycode;
+ cn.eventType = KeyRelease;
+ cn.requestMajor = 0;
+ cn.requestMinor = 0;
+ XkbSendControlsNotify(kbd, &cn);
+ }
+
+ XkbSetCauseKey(&cause, keycode, KeyRelease);
+ /* If sticky keys were disabled, clear all locks and latches */
+ if ((old.enabled_ctrls & XkbStickyKeysMask) &&
+ (!(ctrls->enabled_ctrls & XkbStickyKeysMask))) {
+ XkbClearAllLatchesAndLocks(kbd, xkbi, FALSE, &cause);
+ }
+ sli = XkbFindSrvLedInfo(kbd, XkbDfltXIClass, XkbDfltXIId, 0);
+ XkbUpdateIndicators(kbd, sli->usesControls, TRUE, NULL, &cause);
+ if (XkbAX_NeedFeedback(ctrls, XkbAX_FeatureFBMask))
+ XkbDDXAccessXBeep(kbd, _BEEP_FEATURE_OFF, change);
+ }
+ filter->keycode = 0;
+ filter->active = 0;
}
return 1;
}
static int
-_XkbFilterActionMessage(XkbSrvInfoPtr xkbi,
- XkbFilterPtr filter,
- unsigned keycode,
- XkbAction * pAction)
+_XkbFilterActionMessage(XkbSrvInfoPtr xkbi,
+ XkbFilterPtr filter,
+ unsigned keycode, XkbAction *pAction)
{
-XkbMessageAction * pMsg;
-DeviceIntPtr kbd;
-
- kbd= xkbi->device;
- if (filter->keycode==0) { /* initial press */
- pMsg= &pAction->msg;
- if ((pMsg->flags&XkbSA_MessageOnRelease)||
- ((pMsg->flags&XkbSA_MessageGenKeyEvent)==0)) {
- filter->keycode = keycode;
- filter->active = 1;
- filter->filterOthers = 0;
- filter->priv = 0;
- filter->filter = _XkbFilterActionMessage;
- filter->upAction = *pAction;
- }
- if (pMsg->flags&XkbSA_MessageOnPress) {
- xkbActionMessage msg;
-
- msg.keycode= keycode;
- msg.press= 1;
- msg.keyEventFollows=((pMsg->flags&XkbSA_MessageGenKeyEvent)!=0);
- memcpy((char *)msg.message,
- (char *)pMsg->message,XkbActionMessageLength);
- XkbSendActionMessage(kbd,&msg);
- }
- return ((pAction->msg.flags&XkbSA_MessageGenKeyEvent)!=0);
+ XkbMessageAction *pMsg;
+ DeviceIntPtr kbd;
+
+ kbd = xkbi->device;
+ if (filter->keycode == 0) { /* initial press */
+ pMsg = &pAction->msg;
+ if ((pMsg->flags & XkbSA_MessageOnRelease) ||
+ ((pMsg->flags & XkbSA_MessageGenKeyEvent) == 0)) {
+ filter->keycode = keycode;
+ filter->active = 1;
+ filter->filterOthers = 0;
+ filter->priv = 0;
+ filter->filter = _XkbFilterActionMessage;
+ filter->upAction = *pAction;
+ }
+ if (pMsg->flags & XkbSA_MessageOnPress) {
+ xkbActionMessage msg;
+
+ msg.keycode = keycode;
+ msg.press = 1;
+ msg.keyEventFollows =
+ ((pMsg->flags & XkbSA_MessageGenKeyEvent) != 0);
+ memcpy((char *) msg.message, (char *) pMsg->message,
+ XkbActionMessageLength);
+ XkbSendActionMessage(kbd, &msg);
+ }
+ return ((pAction->msg.flags & XkbSA_MessageGenKeyEvent) != 0);
}
- else if (filter->keycode==keycode) {
- pMsg= &filter->upAction.msg;
- if (pMsg->flags&XkbSA_MessageOnRelease) {
- xkbActionMessage msg;
-
- msg.keycode= keycode;
- msg.press= 0;
- msg.keyEventFollows=((pMsg->flags&XkbSA_MessageGenKeyEvent)!=0);
- memcpy((char *)msg.message,(char *)pMsg->message,
- XkbActionMessageLength);
- XkbSendActionMessage(kbd,&msg);
- }
- filter->keycode= 0;
- filter->active= 0;
- return ((pMsg->flags&XkbSA_MessageGenKeyEvent)!=0);
+ else if (filter->keycode == keycode) {
+ pMsg = &filter->upAction.msg;
+ if (pMsg->flags & XkbSA_MessageOnRelease) {
+ xkbActionMessage msg;
+
+ msg.keycode = keycode;
+ msg.press = 0;
+ msg.keyEventFollows =
+ ((pMsg->flags & XkbSA_MessageGenKeyEvent) != 0);
+ memcpy((char *) msg.message, (char *) pMsg->message,
+ XkbActionMessageLength);
+ XkbSendActionMessage(kbd, &msg);
+ }
+ filter->keycode = 0;
+ filter->active = 0;
+ return ((pMsg->flags & XkbSA_MessageGenKeyEvent) != 0);
}
return 1;
}
static int
-_XkbFilterRedirectKey( XkbSrvInfoPtr xkbi,
- XkbFilterPtr filter,
- unsigned keycode,
- XkbAction * pAction)
+_XkbFilterRedirectKey(XkbSrvInfoPtr xkbi,
+ XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)
{
-DeviceEvent ev;
-int x,y;
-XkbStateRec old;
-unsigned mods,mask;
-xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(xkbi->device);
-ProcessInputProc backupproc;
+ DeviceEvent ev;
+ int x, y;
+ XkbStateRec old;
+ unsigned mods, mask;
+ xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(xkbi->device);
+ ProcessInputProc backupproc;
/* never actually used uninitialised, but gcc isn't smart enough
* to work that out. */
memset(&old, 0, sizeof(old));
memset(&ev, 0, sizeof(ev));
- if ((filter->keycode!=0)&&(filter->keycode!=keycode))
- return 1;
+ if ((filter->keycode != 0) && (filter->keycode != keycode))
+ return 1;
- GetSpritePosition(xkbi->device, &x,&y);
+ GetSpritePosition(xkbi->device, &x, &y);
ev.header = ET_Internal;
ev.length = sizeof(DeviceEvent);
ev.time = GetTimeInMillis();
ev.root_x = x;
ev.root_y = y;
- if (filter->keycode==0) { /* initial press */
- if ((pAction->redirect.new_key<xkbi->desc->min_key_code)||
- (pAction->redirect.new_key>xkbi->desc->max_key_code)) {
- return 1;
- }
- filter->keycode = keycode;
- filter->active = 1;
- filter->filterOthers = 0;
- filter->priv = 0;
- filter->filter = _XkbFilterRedirectKey;
- filter->upAction = *pAction;
+ if (filter->keycode == 0) { /* initial press */
+ if ((pAction->redirect.new_key < xkbi->desc->min_key_code) ||
+ (pAction->redirect.new_key > xkbi->desc->max_key_code)) {
+ return 1;
+ }
+ filter->keycode = keycode;
+ filter->active = 1;
+ filter->filterOthers = 0;
+ filter->priv = 0;
+ filter->filter = _XkbFilterRedirectKey;
+ filter->upAction = *pAction;
ev.type = ET_KeyPress;
ev.detail.key = pAction->redirect.new_key;
- mask= XkbSARedirectVModsMask(&pAction->redirect);
- mods= XkbSARedirectVMods(&pAction->redirect);
- if (mask) XkbVirtualModsToReal(xkbi->desc,mask,&mask);
- if (mods) XkbVirtualModsToReal(xkbi->desc,mods,&mods);
- mask|= pAction->redirect.mods_mask;
- mods|= pAction->redirect.mods;
-
- if ( mask || mods ) {
- old= xkbi->state;
- xkbi->state.base_mods&= ~mask;
- xkbi->state.base_mods|= (mods&mask);
- xkbi->state.latched_mods&= ~mask;
- xkbi->state.latched_mods|= (mods&mask);
- xkbi->state.locked_mods&= ~mask;
- xkbi->state.locked_mods|= (mods&mask);
- XkbComputeDerivedState(xkbi);
- }
-
- UNWRAP_PROCESS_INPUT_PROC(xkbi->device,xkbPrivPtr, backupproc);
- xkbi->device->public.processInputProc((InternalEvent*)&ev, xkbi->device);
- COND_WRAP_PROCESS_INPUT_PROC(xkbi->device, xkbPrivPtr,
- backupproc,xkbUnwrapProc);
-
- if ( mask || mods )
- xkbi->state= old;
+ mask = XkbSARedirectVModsMask(&pAction->redirect);
+ mods = XkbSARedirectVMods(&pAction->redirect);
+ if (mask)
+ XkbVirtualModsToReal(xkbi->desc, mask, &mask);
+ if (mods)
+ XkbVirtualModsToReal(xkbi->desc, mods, &mods);
+ mask |= pAction->redirect.mods_mask;
+ mods |= pAction->redirect.mods;
+
+ if (mask || mods) {
+ old = xkbi->state;
+ xkbi->state.base_mods &= ~mask;
+ xkbi->state.base_mods |= (mods & mask);
+ xkbi->state.latched_mods &= ~mask;
+ xkbi->state.latched_mods |= (mods & mask);
+ xkbi->state.locked_mods &= ~mask;
+ xkbi->state.locked_mods |= (mods & mask);
+ XkbComputeDerivedState(xkbi);
+ }
+
+ UNWRAP_PROCESS_INPUT_PROC(xkbi->device, xkbPrivPtr, backupproc);
+ xkbi->device->public.processInputProc((InternalEvent *) &ev,
+ xkbi->device);
+ COND_WRAP_PROCESS_INPUT_PROC(xkbi->device, xkbPrivPtr, backupproc,
+ xkbUnwrapProc);
+
+ if (mask || mods)
+ xkbi->state = old;
}
- else if (filter->keycode==keycode) {
+ else if (filter->keycode == keycode) {
ev.type = ET_KeyRelease;
ev.detail.key = filter->upAction.redirect.new_key;
- mask= XkbSARedirectVModsMask(&filter->upAction.redirect);
- mods= XkbSARedirectVMods(&filter->upAction.redirect);
- if (mask) XkbVirtualModsToReal(xkbi->desc,mask,&mask);
- if (mods) XkbVirtualModsToReal(xkbi->desc,mods,&mods);
- mask|= filter->upAction.redirect.mods_mask;
- mods|= filter->upAction.redirect.mods;
-
- if ( mask || mods ) {
- old= xkbi->state;
- xkbi->state.base_mods&= ~mask;
- xkbi->state.base_mods|= (mods&mask);
- xkbi->state.latched_mods&= ~mask;
- xkbi->state.latched_mods|= (mods&mask);
- xkbi->state.locked_mods&= ~mask;
- xkbi->state.locked_mods|= (mods&mask);
- XkbComputeDerivedState(xkbi);
- }
-
- UNWRAP_PROCESS_INPUT_PROC(xkbi->device,xkbPrivPtr, backupproc);
- xkbi->device->public.processInputProc((InternalEvent*)&ev, xkbi->device);
- COND_WRAP_PROCESS_INPUT_PROC(xkbi->device, xkbPrivPtr,
- backupproc,xkbUnwrapProc);
-
- if ( mask || mods )
- xkbi->state= old;
-
- filter->keycode= 0;
- filter->active= 0;
+ mask = XkbSARedirectVModsMask(&filter->upAction.redirect);
+ mods = XkbSARedirectVMods(&filter->upAction.redirect);
+ if (mask)
+ XkbVirtualModsToReal(xkbi->desc, mask, &mask);
+ if (mods)
+ XkbVirtualModsToReal(xkbi->desc, mods, &mods);
+ mask |= filter->upAction.redirect.mods_mask;
+ mods |= filter->upAction.redirect.mods;
+
+ if (mask || mods) {
+ old = xkbi->state;
+ xkbi->state.base_mods &= ~mask;
+ xkbi->state.base_mods |= (mods & mask);
+ xkbi->state.latched_mods &= ~mask;
+ xkbi->state.latched_mods |= (mods & mask);
+ xkbi->state.locked_mods &= ~mask;
+ xkbi->state.locked_mods |= (mods & mask);
+ XkbComputeDerivedState(xkbi);
+ }
+
+ UNWRAP_PROCESS_INPUT_PROC(xkbi->device, xkbPrivPtr, backupproc);
+ xkbi->device->public.processInputProc((InternalEvent *) &ev,
+ xkbi->device);
+ COND_WRAP_PROCESS_INPUT_PROC(xkbi->device, xkbPrivPtr, backupproc,
+ xkbUnwrapProc);
+
+ if (mask || mods)
+ xkbi->state = old;
+
+ filter->keycode = 0;
+ filter->active = 0;
}
return 0;
}
static int
-_XkbFilterSwitchScreen( XkbSrvInfoPtr xkbi,
- XkbFilterPtr filter,
- unsigned keycode,
- XkbAction * pAction)
+_XkbFilterSwitchScreen(XkbSrvInfoPtr xkbi,
+ XkbFilterPtr filter,
+ unsigned keycode, XkbAction *pAction)
{
DeviceIntPtr dev = xkbi->device;
+
if (dev == inputInfo.keyboard)
return 0;
- if (filter->keycode==0) { /* initial press */
- filter->keycode = keycode;
- filter->active = 1;
- filter->filterOthers = 0;
- filter->filter = _XkbFilterSwitchScreen;
- AccessXCancelRepeatKey(xkbi, keycode);
- XkbDDXSwitchScreen(dev,keycode,pAction);
- return 0;
+ if (filter->keycode == 0) { /* initial press */
+ filter->keycode = keycode;
+ filter->active = 1;
+ filter->filterOthers = 0;
+ filter->filter = _XkbFilterSwitchScreen;
+ AccessXCancelRepeatKey(xkbi, keycode);
+ XkbDDXSwitchScreen(dev, keycode, pAction);
+ return 0;
}
- else if (filter->keycode==keycode) {
- filter->active= 0;
- return 0;
+ else if (filter->keycode == keycode) {
+ filter->active = 0;
+ return 0;
}
return 1;
}
static int
-_XkbFilterXF86Private( XkbSrvInfoPtr xkbi,
- XkbFilterPtr filter,
- unsigned keycode,
- XkbAction * pAction)
+_XkbFilterXF86Private(XkbSrvInfoPtr xkbi,
+ XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)
{
DeviceIntPtr dev = xkbi->device;
+
if (dev == inputInfo.keyboard)
return 0;
- if (filter->keycode==0) { /* initial press */
- filter->keycode = keycode;
- filter->active = 1;
- filter->filterOthers = 0;
- filter->filter = _XkbFilterXF86Private;
- XkbDDXPrivate(dev,keycode,pAction);
- return 0;
+ if (filter->keycode == 0) { /* initial press */
+ filter->keycode = keycode;
+ filter->active = 1;
+ filter->filterOthers = 0;
+ filter->filter = _XkbFilterXF86Private;
+ XkbDDXPrivate(dev, keycode, pAction);
+ return 0;
}
- else if (filter->keycode==keycode) {
- filter->active= 0;
- return 0;
+ else if (filter->keycode == keycode) {
+ filter->active = 0;
+ return 0;
}
return 1;
}
-
static int
-_XkbFilterDeviceBtn( XkbSrvInfoPtr xkbi,
- XkbFilterPtr filter,
- unsigned keycode,
- XkbAction * pAction)
+_XkbFilterDeviceBtn(XkbSrvInfoPtr xkbi,
+ XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)
{
if (xkbi->device == inputInfo.keyboard)
return 0;
- if (filter->keycode==0) { /* initial press */
- DeviceIntPtr dev;
- int button;
-
- _XkbLookupButtonDevice(&dev, pAction->devbtn.device, serverClient,
- DixUnknownAccess, &button);
- if (!dev || !dev->public.on)
- return 1;
-
- button= pAction->devbtn.button;
- if ((button<1)||(button>dev->button->numButtons))
- return 1;
-
- filter->keycode = keycode;
- filter->active = 1;
- filter->filterOthers = 0;
- filter->priv=0;
- filter->filter = _XkbFilterDeviceBtn;
- filter->upAction= *pAction;
- switch (pAction->type) {
- case XkbSA_LockDeviceBtn:
- if ((pAction->devbtn.flags&XkbSA_LockNoLock)||
- BitIsOn(dev->button->down, button))
- return 0;
- XkbFakeDeviceButton(dev,TRUE,button);
- filter->upAction.type= XkbSA_NoAction;
- break;
- case XkbSA_DeviceBtn:
- if (pAction->devbtn.count>0) {
- int nClicks,i;
- nClicks= pAction->btn.count;
- for (i=0;i<nClicks;i++) {
- XkbFakeDeviceButton(dev,TRUE,button);
- XkbFakeDeviceButton(dev,FALSE,button);
- }
- filter->upAction.type= XkbSA_NoAction;
- }
- else XkbFakeDeviceButton(dev,TRUE,button);
- break;
- }
+ if (filter->keycode == 0) { /* initial press */
+ DeviceIntPtr dev;
+ int button;
+
+ _XkbLookupButtonDevice(&dev, pAction->devbtn.device, serverClient,
+ DixUnknownAccess, &button);
+ if (!dev || !dev->public.on)
+ return 1;
+
+ button = pAction->devbtn.button;
+ if ((button < 1) || (button > dev->button->numButtons))
+ return 1;
+
+ filter->keycode = keycode;
+ filter->active = 1;
+ filter->filterOthers = 0;
+ filter->priv = 0;
+ filter->filter = _XkbFilterDeviceBtn;
+ filter->upAction = *pAction;
+ switch (pAction->type) {
+ case XkbSA_LockDeviceBtn:
+ if ((pAction->devbtn.flags & XkbSA_LockNoLock) ||
+ BitIsOn(dev->button->down, button))
+ return 0;
+ XkbFakeDeviceButton(dev, TRUE, button);
+ filter->upAction.type = XkbSA_NoAction;
+ break;
+ case XkbSA_DeviceBtn:
+ if (pAction->devbtn.count > 0) {
+ int nClicks, i;
+
+ nClicks = pAction->btn.count;
+ for (i = 0; i < nClicks; i++) {
+ XkbFakeDeviceButton(dev, TRUE, button);
+ XkbFakeDeviceButton(dev, FALSE, button);
+ }
+ filter->upAction.type = XkbSA_NoAction;
+ }
+ else
+ XkbFakeDeviceButton(dev, TRUE, button);
+ break;
+ }
}
- else if (filter->keycode==keycode) {
- DeviceIntPtr dev;
- int button;
-
- filter->active= 0;
- _XkbLookupButtonDevice(&dev, filter->upAction.devbtn.device,
- serverClient, DixUnknownAccess, &button);
- if (!dev || !dev->public.on)
- return 1;
-
- button= filter->upAction.btn.button;
- switch (filter->upAction.type) {
- case XkbSA_LockDeviceBtn:
- if ((filter->upAction.devbtn.flags&XkbSA_LockNoUnlock)||
- !BitIsOn(dev->button->down, button))
- return 0;
- XkbFakeDeviceButton(dev,FALSE,button);
- break;
- case XkbSA_DeviceBtn:
- XkbFakeDeviceButton(dev,FALSE,button);
- break;
- }
- filter->active = 0;
+ else if (filter->keycode == keycode) {
+ DeviceIntPtr dev;
+ int button;
+
+ filter->active = 0;
+ _XkbLookupButtonDevice(&dev, filter->upAction.devbtn.device,
+ serverClient, DixUnknownAccess, &button);
+ if (!dev || !dev->public.on)
+ return 1;
+
+ button = filter->upAction.btn.button;
+ switch (filter->upAction.type) {
+ case XkbSA_LockDeviceBtn:
+ if ((filter->upAction.devbtn.flags & XkbSA_LockNoUnlock) ||
+ !BitIsOn(dev->button->down, button))
+ return 0;
+ XkbFakeDeviceButton(dev, FALSE, button);
+ break;
+ case XkbSA_DeviceBtn:
+ XkbFakeDeviceButton(dev, FALSE, button);
+ break;
+ }
+ filter->active = 0;
}
return 0;
}
static XkbFilterPtr
-_XkbNextFreeFilter(
- XkbSrvInfoPtr xkbi
-)
+_XkbNextFreeFilter(XkbSrvInfoPtr xkbi)
{
-register int i;
+ register int i;
- if (xkbi->szFilters==0) {
- xkbi->szFilters = 4;
- xkbi->filters = calloc(xkbi->szFilters, sizeof(XkbFilterRec));
- /* 6/21/93 (ef) -- XXX! deal with allocation failure */
+ if (xkbi->szFilters == 0) {
+ xkbi->szFilters = 4;
+ xkbi->filters = calloc(xkbi->szFilters, sizeof(XkbFilterRec));
+ /* 6/21/93 (ef) -- XXX! deal with allocation failure */
}
- for (i=0;i<xkbi->szFilters;i++) {
- if (!xkbi->filters[i].active) {
- xkbi->filters[i].keycode = 0;
- return &xkbi->filters[i];
- }
+ for (i = 0; i < xkbi->szFilters; i++) {
+ if (!xkbi->filters[i].active) {
+ xkbi->filters[i].keycode = 0;
+ return &xkbi->filters[i];
+ }
}
- xkbi->szFilters*=2;
- xkbi->filters= realloc(xkbi->filters,
+ xkbi->szFilters *= 2;
+ xkbi->filters = realloc(xkbi->filters,
xkbi->szFilters * sizeof(XkbFilterRec));
/* 6/21/93 (ef) -- XXX! deal with allocation failure */
- memset(&xkbi->filters[xkbi->szFilters/2], 0,
- (xkbi->szFilters/2)*sizeof(XkbFilterRec));
- return &xkbi->filters[xkbi->szFilters/2];
+ memset(&xkbi->filters[xkbi->szFilters / 2], 0,
+ (xkbi->szFilters / 2) * sizeof(XkbFilterRec));
+ return &xkbi->filters[xkbi->szFilters / 2];
}
static int
-_XkbApplyFilters(XkbSrvInfoPtr xkbi,unsigned kc,XkbAction *pAction)
+_XkbApplyFilters(XkbSrvInfoPtr xkbi, unsigned kc, XkbAction *pAction)
{
-register int i,send;
-
- send= 1;
- for (i=0;i<xkbi->szFilters;i++) {
- if ((xkbi->filters[i].active)&&(xkbi->filters[i].filter))
- send= ((*xkbi->filters[i].filter)(xkbi,&xkbi->filters[i],kc,pAction)
- && send);
+ register int i, send;
+
+ send = 1;
+ for (i = 0; i < xkbi->szFilters; i++) {
+ if ((xkbi->filters[i].active) && (xkbi->filters[i].filter))
+ send =
+ ((*xkbi->filters[i].filter) (xkbi, &xkbi->filters[i], kc,
+ pAction)
+ && send);
}
return send;
}
void
-XkbHandleActions(DeviceIntPtr dev, DeviceIntPtr kbd, DeviceEvent* event)
+XkbHandleActions(DeviceIntPtr dev, DeviceIntPtr kbd, DeviceEvent *event)
{
-int key,bit,i;
-XkbSrvInfoPtr xkbi;
-KeyClassPtr keyc;
-int changed,sendEvent;
-Bool genStateNotify;
-XkbAction act;
-XkbFilterPtr filter;
-Bool keyEvent;
-Bool pressEvent;
-ProcessInputProc backupproc;
-
-xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(dev);
-
- keyc= kbd->key;
- xkbi= keyc->xkbInfo;
- key= event->detail.key;
+ int key, bit, i;
+ XkbSrvInfoPtr xkbi;
+ KeyClassPtr keyc;
+ int changed, sendEvent;
+ Bool genStateNotify;
+ XkbAction act;
+ XkbFilterPtr filter;
+ Bool keyEvent;
+ Bool pressEvent;
+ ProcessInputProc backupproc;
+
+ xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(dev);
+
+ keyc = kbd->key;
+ xkbi = keyc->xkbInfo;
+ key = event->detail.key;
/* The state may change, so if we're not in the middle of sending a state
* notify, prepare for it */
- if ((xkbi->flags&_XkbStateNotifyInProgress)==0) {
- xkbi->prev_state = xkbi->state;
- xkbi->flags|= _XkbStateNotifyInProgress;
- genStateNotify= TRUE;
+ if ((xkbi->flags & _XkbStateNotifyInProgress) == 0) {
+ xkbi->prev_state = xkbi->state;
+ xkbi->flags |= _XkbStateNotifyInProgress;
+ genStateNotify = TRUE;
}
- else genStateNotify= FALSE;
+ else
+ genStateNotify = FALSE;
xkbi->clearMods = xkbi->setMods = 0;
xkbi->groupChange = 0;
sendEvent = 1;
- keyEvent= ((event->type == ET_KeyPress) || (event->type == ET_KeyRelease));
- pressEvent= ((event->type == ET_KeyPress)|| (event->type == ET_ButtonPress));
+ keyEvent = ((event->type == ET_KeyPress) || (event->type == ET_KeyRelease));
+ pressEvent = ((event->type == ET_KeyPress) ||
+ (event->type == ET_ButtonPress));
if (pressEvent) {
- if (keyEvent)
- act = XkbGetKeyAction(xkbi,&xkbi->state,key);
- else {
- act = XkbGetButtonAction(kbd,dev,key);
- key|= BTN_ACT_FLAG;
- }
- sendEvent = _XkbApplyFilters(xkbi,key,&act);
- if (sendEvent) {
- switch (act.type) {
- case XkbSA_SetMods:
- case XkbSA_SetGroup:
- filter = _XkbNextFreeFilter(xkbi);
- sendEvent = _XkbFilterSetState(xkbi,filter,key,&act);
- break;
- case XkbSA_LatchMods:
- case XkbSA_LatchGroup:
- filter = _XkbNextFreeFilter(xkbi);
- sendEvent=_XkbFilterLatchState(xkbi,filter,key,&act);
- break;
- case XkbSA_LockMods:
- case XkbSA_LockGroup:
- filter = _XkbNextFreeFilter(xkbi);
- sendEvent=_XkbFilterLockState(xkbi,filter,key,&act);
- break;
- case XkbSA_ISOLock:
- filter = _XkbNextFreeFilter(xkbi);
- sendEvent=_XkbFilterISOLock(xkbi,filter,key,&act);
- break;
- case XkbSA_MovePtr:
- filter = _XkbNextFreeFilter(xkbi);
- sendEvent= _XkbFilterPointerMove(xkbi,filter,key,&act);
- break;
- case XkbSA_PtrBtn:
- case XkbSA_LockPtrBtn:
- case XkbSA_SetPtrDflt:
- filter = _XkbNextFreeFilter(xkbi);
- sendEvent= _XkbFilterPointerBtn(xkbi,filter,key,&act);
- break;
- case XkbSA_Terminate:
- sendEvent= XkbDDXTerminateServer(dev,key,&act);
- break;
- case XkbSA_SwitchScreen:
- filter = _XkbNextFreeFilter(xkbi);
- sendEvent=_XkbFilterSwitchScreen(xkbi,filter,key,&act);
- break;
- case XkbSA_SetControls:
- case XkbSA_LockControls:
- filter = _XkbNextFreeFilter(xkbi);
- sendEvent=_XkbFilterControls(xkbi,filter,key,&act);
- break;
- case XkbSA_ActionMessage:
- filter = _XkbNextFreeFilter(xkbi);
- sendEvent=_XkbFilterActionMessage(xkbi,filter,key,&act);
- break;
- case XkbSA_RedirectKey:
- filter = _XkbNextFreeFilter(xkbi);
- sendEvent= _XkbFilterRedirectKey(xkbi,filter,key,&act);
- break;
- case XkbSA_DeviceBtn:
- case XkbSA_LockDeviceBtn:
- filter = _XkbNextFreeFilter(xkbi);
- sendEvent= _XkbFilterDeviceBtn(xkbi,filter,key,&act);
- break;
- case XkbSA_XFree86Private:
- filter = _XkbNextFreeFilter(xkbi);
- sendEvent= _XkbFilterXF86Private(xkbi,filter,key,&act);
- break;
- }
- }
+ if (keyEvent)
+ act = XkbGetKeyAction(xkbi, &xkbi->state, key);
+ else {
+ act = XkbGetButtonAction(kbd, dev, key);
+ key |= BTN_ACT_FLAG;
+ }
+ sendEvent = _XkbApplyFilters(xkbi, key, &act);
+ if (sendEvent) {
+ switch (act.type) {
+ case XkbSA_SetMods:
+ case XkbSA_SetGroup:
+ filter = _XkbNextFreeFilter(xkbi);
+ sendEvent = _XkbFilterSetState(xkbi, filter, key, &act);
+ break;
+ case XkbSA_LatchMods:
+ case XkbSA_LatchGroup:
+ filter = _XkbNextFreeFilter(xkbi);
+ sendEvent = _XkbFilterLatchState(xkbi, filter, key, &act);
+ break;
+ case XkbSA_LockMods:
+ case XkbSA_LockGroup:
+ filter = _XkbNextFreeFilter(xkbi);
+ sendEvent = _XkbFilterLockState(xkbi, filter, key, &act);
+ break;
+ case XkbSA_ISOLock:
+ filter = _XkbNextFreeFilter(xkbi);
+ sendEvent = _XkbFilterISOLock(xkbi, filter, key, &act);
+ break;
+ case XkbSA_MovePtr:
+ filter = _XkbNextFreeFilter(xkbi);
+ sendEvent = _XkbFilterPointerMove(xkbi, filter, key, &act);
+ break;
+ case XkbSA_PtrBtn:
+ case XkbSA_LockPtrBtn:
+ case XkbSA_SetPtrDflt:
+ filter = _XkbNextFreeFilter(xkbi);
+ sendEvent = _XkbFilterPointerBtn(xkbi, filter, key, &act);
+ break;
+ case XkbSA_Terminate:
+ sendEvent = XkbDDXTerminateServer(dev, key, &act);
+ break;
+ case XkbSA_SwitchScreen:
+ filter = _XkbNextFreeFilter(xkbi);
+ sendEvent = _XkbFilterSwitchScreen(xkbi, filter, key, &act);
+ break;
+ case XkbSA_SetControls:
+ case XkbSA_LockControls:
+ filter = _XkbNextFreeFilter(xkbi);
+ sendEvent = _XkbFilterControls(xkbi, filter, key, &act);
+ break;
+ case XkbSA_ActionMessage:
+ filter = _XkbNextFreeFilter(xkbi);
+ sendEvent = _XkbFilterActionMessage(xkbi, filter, key, &act);
+ break;
+ case XkbSA_RedirectKey:
+ filter = _XkbNextFreeFilter(xkbi);
+ sendEvent = _XkbFilterRedirectKey(xkbi, filter, key, &act);
+ break;
+ case XkbSA_DeviceBtn:
+ case XkbSA_LockDeviceBtn:
+ filter = _XkbNextFreeFilter(xkbi);
+ sendEvent = _XkbFilterDeviceBtn(xkbi, filter, key, &act);
+ break;
+ case XkbSA_XFree86Private:
+ filter = _XkbNextFreeFilter(xkbi);
+ sendEvent = _XkbFilterXF86Private(xkbi, filter, key, &act);
+ break;
+ }
+ }
}
else {
- if (!keyEvent)
- key|= BTN_ACT_FLAG;
- sendEvent = _XkbApplyFilters(xkbi,key,NULL);
+ if (!keyEvent)
+ key |= BTN_ACT_FLAG;
+ sendEvent = _XkbApplyFilters(xkbi, key, NULL);
}
- if (xkbi->groupChange!=0)
- xkbi->state.base_group+= xkbi->groupChange;
+ if (xkbi->groupChange != 0)
+ xkbi->state.base_group += xkbi->groupChange;
if (xkbi->setMods) {
- for (i=0,bit=1; xkbi->setMods; i++,bit<<=1 ) {
- if (xkbi->setMods&bit) {
- keyc->modifierKeyCount[i]++;
- xkbi->state.base_mods|= bit;
- xkbi->setMods&= ~bit;
- }
- }
+ for (i = 0, bit = 1; xkbi->setMods; i++, bit <<= 1) {
+ if (xkbi->setMods & bit) {
+ keyc->modifierKeyCount[i]++;
+ xkbi->state.base_mods |= bit;
+ xkbi->setMods &= ~bit;
+ }
+ }
}
if (xkbi->clearMods) {
- for (i=0,bit=1; xkbi->clearMods; i++,bit<<=1 ) {
- if (xkbi->clearMods&bit) {
- keyc->modifierKeyCount[i]--;
- if (keyc->modifierKeyCount[i]<=0) {
- xkbi->state.base_mods&= ~bit;
- keyc->modifierKeyCount[i] = 0;
- }
- xkbi->clearMods&= ~bit;
- }
- }
+ for (i = 0, bit = 1; xkbi->clearMods; i++, bit <<= 1) {
+ if (xkbi->clearMods & bit) {
+ keyc->modifierKeyCount[i]--;
+ if (keyc->modifierKeyCount[i] <= 0) {
+ xkbi->state.base_mods &= ~bit;
+ keyc->modifierKeyCount[i] = 0;
+ }
+ xkbi->clearMods &= ~bit;
+ }
+ }
}
if (sendEvent) {
DeviceIntPtr tmpdev;
- if (keyEvent)
+
+ if (keyEvent)
tmpdev = dev;
else
tmpdev = GetMaster(dev, POINTER_OR_FLOAT);
- UNWRAP_PROCESS_INPUT_PROC(tmpdev,xkbPrivPtr, backupproc);
- dev->public.processInputProc((InternalEvent*)event, tmpdev);
+ UNWRAP_PROCESS_INPUT_PROC(tmpdev, xkbPrivPtr, backupproc);
+ dev->public.processInputProc((InternalEvent *) event, tmpdev);
COND_WRAP_PROCESS_INPUT_PROC(tmpdev, xkbPrivPtr,
- backupproc,xkbUnwrapProc);
+ backupproc, xkbUnwrapProc);
}
else if (keyEvent) {
- FixKeyState(event, dev);
+ FixKeyState(event, dev);
}
XkbComputeDerivedState(xkbi);
- changed = XkbStateChangedFlags(&xkbi->prev_state,&xkbi->state);
+ changed = XkbStateChangedFlags(&xkbi->prev_state, &xkbi->state);
if (genStateNotify) {
- if (changed) {
- xkbStateNotify sn;
- sn.keycode= key;
- sn.eventType= event->type;
- sn.requestMajor = sn.requestMinor = 0;
- sn.changed= changed;
- XkbSendStateNotify(dev,&sn);
- }
- xkbi->flags&= ~_XkbStateNotifyInProgress;
+ if (changed) {
+ xkbStateNotify sn;
+
+ sn.keycode = key;
+ sn.eventType = event->type;
+ sn.requestMajor = sn.requestMinor = 0;
+ sn.changed = changed;
+ XkbSendStateNotify(dev, &sn);
+ }
+ xkbi->flags &= ~_XkbStateNotifyInProgress;
}
- changed= XkbIndicatorsToUpdate(dev,changed,FALSE);
+ changed = XkbIndicatorsToUpdate(dev, changed, FALSE);
if (changed) {
- XkbEventCauseRec cause;
- XkbSetCauseKey(&cause, key, event->type);
- XkbUpdateIndicators(dev,changed,FALSE,NULL,&cause);
+ XkbEventCauseRec cause;
+
+ XkbSetCauseKey(&cause, key, event->type);
+ XkbUpdateIndicators(dev, changed, FALSE, NULL, &cause);
}
return;
}
int
-XkbLatchModifiers(DeviceIntPtr pXDev,CARD8 mask,CARD8 latches)
+XkbLatchModifiers(DeviceIntPtr pXDev, CARD8 mask, CARD8 latches)
{
-XkbSrvInfoPtr xkbi;
-XkbFilterPtr filter;
-XkbAction act;
-unsigned clear;
-
- if ( pXDev && pXDev->key && pXDev->key->xkbInfo ) {
- xkbi = pXDev->key->xkbInfo;
- clear= (mask&(~latches));
- xkbi->state.latched_mods&= ~clear;
- /* Clear any pending latch to locks.
- */
- act.type = XkbSA_NoAction;
- _XkbApplyFilters(xkbi,SYNTHETIC_KEYCODE,&act);
- act.type = XkbSA_LatchMods;
- act.mods.flags = 0;
- act.mods.mask = mask&latches;
- filter = _XkbNextFreeFilter(xkbi);
- _XkbFilterLatchState(xkbi,filter,SYNTHETIC_KEYCODE,&act);
- _XkbFilterLatchState(xkbi,filter,SYNTHETIC_KEYCODE,(XkbAction *)NULL);
- return Success;
+ XkbSrvInfoPtr xkbi;
+ XkbFilterPtr filter;
+ XkbAction act;
+ unsigned clear;
+
+ if (pXDev && pXDev->key && pXDev->key->xkbInfo) {
+ xkbi = pXDev->key->xkbInfo;
+ clear = (mask & (~latches));
+ xkbi->state.latched_mods &= ~clear;
+ /* Clear any pending latch to locks.
+ */
+ act.type = XkbSA_NoAction;
+ _XkbApplyFilters(xkbi, SYNTHETIC_KEYCODE, &act);
+ act.type = XkbSA_LatchMods;
+ act.mods.flags = 0;
+ act.mods.mask = mask & latches;
+ filter = _XkbNextFreeFilter(xkbi);
+ _XkbFilterLatchState(xkbi, filter, SYNTHETIC_KEYCODE, &act);
+ _XkbFilterLatchState(xkbi, filter, SYNTHETIC_KEYCODE,
+ (XkbAction *) NULL);
+ return Success;
}
return BadValue;
}
int
-XkbLatchGroup(DeviceIntPtr pXDev,int group)
+XkbLatchGroup(DeviceIntPtr pXDev, int group)
{
-XkbSrvInfoPtr xkbi;
-XkbFilterPtr filter;
-XkbAction act;
-
- if ( pXDev && pXDev->key && pXDev->key->xkbInfo ) {
- xkbi = pXDev->key->xkbInfo;
- act.type = XkbSA_LatchGroup;
- act.group.flags = 0;
- XkbSASetGroup(&act.group,group);
- filter = _XkbNextFreeFilter(xkbi);
- _XkbFilterLatchState(xkbi,filter,SYNTHETIC_KEYCODE,&act);
- _XkbFilterLatchState(xkbi,filter,SYNTHETIC_KEYCODE,(XkbAction *)NULL);
- return Success;
+ XkbSrvInfoPtr xkbi;
+ XkbFilterPtr filter;
+ XkbAction act;
+
+ if (pXDev && pXDev->key && pXDev->key->xkbInfo) {
+ xkbi = pXDev->key->xkbInfo;
+ act.type = XkbSA_LatchGroup;
+ act.group.flags = 0;
+ XkbSASetGroup(&act.group, group);
+ filter = _XkbNextFreeFilter(xkbi);
+ _XkbFilterLatchState(xkbi, filter, SYNTHETIC_KEYCODE, &act);
+ _XkbFilterLatchState(xkbi, filter, SYNTHETIC_KEYCODE,
+ (XkbAction *) NULL);
+ return Success;
}
return BadValue;
}
@@ -1287,46 +1302,45 @@ XkbAction act;
/***====================================================================***/
void
-XkbClearAllLatchesAndLocks( DeviceIntPtr dev,
- XkbSrvInfoPtr xkbi,
- Bool genEv,
- XkbEventCausePtr cause)
+XkbClearAllLatchesAndLocks(DeviceIntPtr dev,
+ XkbSrvInfoPtr xkbi,
+ Bool genEv, XkbEventCausePtr cause)
{
-XkbStateRec os;
-xkbStateNotify sn;
-
- sn.changed= 0;
- os= xkbi->state;
- if (os.latched_mods) { /* clear all latches */
- XkbLatchModifiers(dev,~0,0);
- sn.changed|= XkbModifierLatchMask;
+ XkbStateRec os;
+ xkbStateNotify sn;
+
+ sn.changed = 0;
+ os = xkbi->state;
+ if (os.latched_mods) { /* clear all latches */
+ XkbLatchModifiers(dev, ~0, 0);
+ sn.changed |= XkbModifierLatchMask;
}
if (os.latched_group) {
- XkbLatchGroup(dev,0);
- sn.changed|= XkbGroupLatchMask;
+ XkbLatchGroup(dev, 0);
+ sn.changed |= XkbGroupLatchMask;
}
if (os.locked_mods) {
- xkbi->state.locked_mods= 0;
- sn.changed|= XkbModifierLockMask;
+ xkbi->state.locked_mods = 0;
+ sn.changed |= XkbModifierLockMask;
}
if (os.locked_group) {
- xkbi->state.locked_group= 0;
- sn.changed|= XkbGroupLockMask;
+ xkbi->state.locked_group = 0;
+ sn.changed |= XkbGroupLockMask;
}
- if ( genEv && sn.changed) {
- CARD32 changed;
-
- XkbComputeDerivedState(xkbi);
- sn.keycode= cause->kc;
- sn.eventType= cause->event;
- sn.requestMajor= cause->mjr;
- sn.requestMinor= cause->mnr;
- sn.changed= XkbStateChangedFlags(&os,&xkbi->state);
- XkbSendStateNotify(dev,&sn);
- changed= XkbIndicatorsToUpdate(dev,sn.changed,FALSE);
- if (changed) {
- XkbUpdateIndicators(dev,changed,TRUE,NULL,cause);
- }
+ if (genEv && sn.changed) {
+ CARD32 changed;
+
+ XkbComputeDerivedState(xkbi);
+ sn.keycode = cause->kc;
+ sn.eventType = cause->event;
+ sn.requestMajor = cause->mjr;
+ sn.requestMinor = cause->mnr;
+ sn.changed = XkbStateChangedFlags(&os, &xkbi->state);
+ XkbSendStateNotify(dev, &sn);
+ changed = XkbIndicatorsToUpdate(dev, sn.changed, FALSE);
+ if (changed) {
+ XkbUpdateIndicators(dev, changed, TRUE, NULL, cause);
+ }
}
return;
}
@@ -1352,31 +1366,33 @@ xkbStateNotify sn;
* First one on drinking island wins!
*/
static void
-InjectPointerKeyEvents(DeviceIntPtr dev, int type, int button, int flags, ValuatorMask *mask)
+InjectPointerKeyEvents(DeviceIntPtr dev, int type, int button, int flags,
+ ValuatorMask *mask)
{
- ScreenPtr pScreen;
- InternalEvent* events;
- int nevents, i;
- DeviceIntPtr ptr, mpointer, lastSlave = NULL;
- Bool saveWait;
+ ScreenPtr pScreen;
+ InternalEvent *events;
+ int nevents, i;
+ DeviceIntPtr ptr, mpointer, lastSlave = NULL;
+ Bool saveWait;
if (IsMaster(dev)) {
mpointer = GetMaster(dev, MASTER_POINTER);
lastSlave = mpointer->lastSlave;
ptr = GetXTestDevice(mpointer);
- } else if (IsFloating(dev))
+ }
+ else if (IsFloating(dev))
ptr = dev;
else
return;
-
events = InitEventList(GetMaximumEventsNum() + 1);
OsBlockSignals();
pScreen = miPointerGetScreen(ptr);
saveWait = miPointerSetWaitForUpdate(pScreen, FALSE);
nevents = GetPointerEvents(events, ptr, type, button, flags, mask);
if (IsMaster(dev) && (lastSlave && lastSlave != ptr))
- UpdateFromMaster(&events[nevents], lastSlave, DEVCHANGE_POINTER_EVENT, &nevents);
+ UpdateFromMaster(&events[nevents], lastSlave, DEVCHANGE_POINTER_EVENT,
+ &nevents);
miPointerSetWaitForUpdate(pScreen, saveWait);
OsReleaseSignals();
@@ -1388,10 +1404,10 @@ InjectPointerKeyEvents(DeviceIntPtr dev, int type, int button, int flags, Valuat
}
static void
-XkbFakePointerMotion(DeviceIntPtr dev, unsigned flags,int x,int y)
+XkbFakePointerMotion(DeviceIntPtr dev, unsigned flags, int x, int y)
{
- ValuatorMask mask;
- int gpe_flags = 0;
+ ValuatorMask mask;
+ int gpe_flags = 0;
/* ignore attached SDs */
if (!IsMaster(dev) && !IsFloating(dev))
@@ -1402,16 +1418,17 @@ XkbFakePointerMotion(DeviceIntPtr dev, unsigned flags,int x,int y)
else
gpe_flags = POINTER_RELATIVE;
- valuator_mask_set_range(&mask, 0, 2, (int[]){x, y});
+ valuator_mask_set_range(&mask, 0, 2, (int[]) {
+ x, y});
InjectPointerKeyEvents(dev, MotionNotify, 0, gpe_flags, &mask);
}
void
-XkbFakeDeviceButton(DeviceIntPtr dev,Bool press,int button)
+XkbFakeDeviceButton(DeviceIntPtr dev, Bool press, int button)
{
- DeviceIntPtr ptr;
- int down;
+ DeviceIntPtr ptr;
+ int down;
/* If dev is a slave device, and the SD is attached, do nothing. If we'd
* post through the attached master pointer we'd get duplicate events.
@@ -1423,8 +1440,10 @@ XkbFakeDeviceButton(DeviceIntPtr dev,Bool press,int button)
if (IsMaster(dev)) {
DeviceIntPtr mpointer = GetMaster(dev, MASTER_POINTER);
+
ptr = GetXTestDevice(mpointer);
- } else if (IsFloating(dev))
+ }
+ else if (IsFloating(dev))
ptr = dev;
else
return;
diff --git a/xkb/xkbDflts.h b/xkb/xkbDflts.h
index 5d8690650..994726c0f 100644
--- a/xkb/xkbDflts.h
+++ b/xkb/xkbDflts.h
@@ -26,444 +26,446 @@
/* types name is "default" */
static Atom lnames_ONE_LEVEL[1];
-static XkbKTMapEntryRec map_TWO_LEVEL[1]= {
- { 1, 1, { ShiftMask, ShiftMask, 0 } }
+static XkbKTMapEntryRec map_TWO_LEVEL[1] = {
+ {1, 1, {ShiftMask, ShiftMask, 0}}
};
+
static Atom lnames_TWO_LEVEL[2];
-static XkbKTMapEntryRec map_ALPHABETIC[2]= {
- { 1, 1, { ShiftMask, ShiftMask, 0 } },
- { 1, 0, { LockMask, LockMask, 0 } }
+static XkbKTMapEntryRec map_ALPHABETIC[2] = {
+ {1, 1, {ShiftMask, ShiftMask, 0}},
+ {1, 0, {LockMask, LockMask, 0}}
};
-static XkbModsRec preserve_ALPHABETIC[2]= {
- { 0, 0, 0 },
- { LockMask, LockMask, 0 }
+
+static XkbModsRec preserve_ALPHABETIC[2] = {
+ {0, 0, 0},
+ {LockMask, LockMask, 0}
};
+
static Atom lnames_ALPHABETIC[2];
-static XkbKTMapEntryRec map_KEYPAD[2]= {
- { 1, 1, { ShiftMask, ShiftMask, 0 } },
- { 0, 1, { 0, 0, vmod_NumLockMask } }
+static XkbKTMapEntryRec map_KEYPAD[2] = {
+ {1, 1, {ShiftMask, ShiftMask, 0}},
+ {0, 1, {0, 0, vmod_NumLockMask}}
};
+
static Atom lnames_KEYPAD[2];
-static XkbKTMapEntryRec map_PC_BREAK[1]= {
- { 1, 1, { ControlMask, ControlMask, 0 } }
+static XkbKTMapEntryRec map_PC_BREAK[1] = {
+ {1, 1, {ControlMask, ControlMask, 0}}
};
+
static Atom lnames_PC_BREAK[2];
-static XkbKTMapEntryRec map_PC_SYSRQ[1]= {
- { 0, 1, { 0, 0, vmod_AltMask } }
+static XkbKTMapEntryRec map_PC_SYSRQ[1] = {
+ {0, 1, {0, 0, vmod_AltMask}}
};
+
static Atom lnames_PC_SYSRQ[2];
-static XkbKTMapEntryRec map_CTRL_ALT[1]= {
- { 0, 1, { ControlMask, ControlMask, vmod_AltMask } }
+static XkbKTMapEntryRec map_CTRL_ALT[1] = {
+ {0, 1, {ControlMask, ControlMask, vmod_AltMask}}
};
+
static Atom lnames_CTRL_ALT[2];
-static XkbKTMapEntryRec map_THREE_LEVEL[3]= {
- { 1, 1, { ShiftMask, ShiftMask, 0 } },
- { 0, 2, { 0, 0, vmod_LevelThreeMask } },
- { 0, 2, { ShiftMask, ShiftMask, vmod_LevelThreeMask } }
+static XkbKTMapEntryRec map_THREE_LEVEL[3] = {
+ {1, 1, {ShiftMask, ShiftMask, 0}},
+ {0, 2, {0, 0, vmod_LevelThreeMask}},
+ {0, 2, {ShiftMask, ShiftMask, vmod_LevelThreeMask}}
};
+
static Atom lnames_THREE_LEVEL[3];
-static XkbKTMapEntryRec map_SHIFT_ALT[1]= {
- { 0, 1, { ShiftMask, ShiftMask, vmod_AltMask } }
+static XkbKTMapEntryRec map_SHIFT_ALT[1] = {
+ {0, 1, {ShiftMask, ShiftMask, vmod_AltMask}}
};
+
static Atom lnames_SHIFT_ALT[2];
-static XkbKeyTypeRec dflt_types[]= {
+static XkbKeyTypeRec dflt_types[] = {
{
- { 0, 0, 0 },
- 1,
- 0, NULL, NULL,
- None, lnames_ONE_LEVEL
- },
+ {0, 0, 0},
+ 1,
+ 0, NULL, NULL,
+ None, lnames_ONE_LEVEL},
{
- { ShiftMask, ShiftMask, 0 },
- 2,
- 1, map_TWO_LEVEL, NULL,
- None, lnames_TWO_LEVEL
- },
+ {ShiftMask, ShiftMask, 0},
+ 2,
+ 1, map_TWO_LEVEL, NULL,
+ None, lnames_TWO_LEVEL},
{
- { ShiftMask|LockMask, ShiftMask|LockMask, 0 },
- 2,
- 2, map_ALPHABETIC, preserve_ALPHABETIC,
- None, lnames_ALPHABETIC
- },
+ {ShiftMask | LockMask, ShiftMask | LockMask, 0},
+ 2,
+ 2, map_ALPHABETIC, preserve_ALPHABETIC,
+ None, lnames_ALPHABETIC},
{
- { ShiftMask, ShiftMask, vmod_NumLockMask },
- 2,
- 2, map_KEYPAD, NULL,
- None, lnames_KEYPAD
- },
+ {ShiftMask, ShiftMask, vmod_NumLockMask},
+ 2,
+ 2, map_KEYPAD, NULL,
+ None, lnames_KEYPAD},
{
- { ControlMask, ControlMask, 0 },
- 2,
- 1, map_PC_BREAK, NULL,
- None, lnames_PC_BREAK
- },
+ {ControlMask, ControlMask, 0},
+ 2,
+ 1, map_PC_BREAK, NULL,
+ None, lnames_PC_BREAK},
{
- { 0, 0, vmod_AltMask },
- 2,
- 1, map_PC_SYSRQ, NULL,
- None, lnames_PC_SYSRQ
- },
+ {0, 0, vmod_AltMask},
+ 2,
+ 1, map_PC_SYSRQ, NULL,
+ None, lnames_PC_SYSRQ},
{
- { ControlMask, ControlMask, vmod_AltMask },
- 2,
- 1, map_CTRL_ALT, NULL,
- None, lnames_CTRL_ALT
- },
+ {ControlMask, ControlMask, vmod_AltMask},
+ 2,
+ 1, map_CTRL_ALT, NULL,
+ None, lnames_CTRL_ALT},
{
- { ShiftMask, ShiftMask, vmod_LevelThreeMask },
- 3,
- 3, map_THREE_LEVEL, NULL,
- None, lnames_THREE_LEVEL
- },
+ {ShiftMask, ShiftMask, vmod_LevelThreeMask},
+ 3,
+ 3, map_THREE_LEVEL, NULL,
+ None, lnames_THREE_LEVEL},
{
- { ShiftMask, ShiftMask, vmod_AltMask },
- 2,
- 1, map_SHIFT_ALT, NULL,
- None, lnames_SHIFT_ALT
- }
+ {ShiftMask, ShiftMask, vmod_AltMask},
+ 2,
+ 1, map_SHIFT_ALT, NULL,
+ None, lnames_SHIFT_ALT}
};
-#define num_dflt_types (sizeof(dflt_types)/sizeof(XkbKeyTypeRec))
+#define num_dflt_types (sizeof(dflt_types)/sizeof(XkbKeyTypeRec))
static void
initTypeNames(DPYTYPE dpy)
{
- dflt_types[0].name= GET_ATOM(dpy,"ONE_LEVEL");
- lnames_ONE_LEVEL[0]= GET_ATOM(dpy,"Any");
- dflt_types[1].name= GET_ATOM(dpy,"TWO_LEVEL");
- lnames_TWO_LEVEL[0]= GET_ATOM(dpy,"Base");
- lnames_TWO_LEVEL[1]= GET_ATOM(dpy,"Shift");
- dflt_types[2].name= GET_ATOM(dpy,"ALPHABETIC");
- lnames_ALPHABETIC[0]= GET_ATOM(dpy,"Base");
- lnames_ALPHABETIC[1]= GET_ATOM(dpy,"Caps");
- dflt_types[3].name= GET_ATOM(dpy,"KEYPAD");
- lnames_KEYPAD[0]= GET_ATOM(dpy,"Base");
- lnames_KEYPAD[1]= GET_ATOM(dpy,"Number");
- dflt_types[4].name= GET_ATOM(dpy,"PC_BREAK");
- lnames_PC_BREAK[0]= GET_ATOM(dpy,"Base");
- lnames_PC_BREAK[1]= GET_ATOM(dpy,"Control");
- dflt_types[5].name= GET_ATOM(dpy,"PC_SYSRQ");
- lnames_PC_SYSRQ[0]= GET_ATOM(dpy,"Base");
- lnames_PC_SYSRQ[1]= GET_ATOM(dpy,"Alt");
- dflt_types[6].name= GET_ATOM(dpy,"CTRL+ALT");
- lnames_CTRL_ALT[0]= GET_ATOM(dpy,"Base");
- lnames_CTRL_ALT[1]= GET_ATOM(dpy,"Ctrl+Alt");
- dflt_types[7].name= GET_ATOM(dpy,"THREE_LEVEL");
- lnames_THREE_LEVEL[0]= GET_ATOM(dpy,"Base");
- lnames_THREE_LEVEL[1]= GET_ATOM(dpy,"Shift");
- lnames_THREE_LEVEL[2]= GET_ATOM(dpy,"Level3");
- dflt_types[8].name= GET_ATOM(dpy,"SHIFT+ALT");
- lnames_SHIFT_ALT[0]= GET_ATOM(dpy,"Base");
- lnames_SHIFT_ALT[1]= GET_ATOM(dpy,"Shift+Alt");
+ dflt_types[0].name = GET_ATOM(dpy, "ONE_LEVEL");
+ lnames_ONE_LEVEL[0] = GET_ATOM(dpy, "Any");
+ dflt_types[1].name = GET_ATOM(dpy, "TWO_LEVEL");
+ lnames_TWO_LEVEL[0] = GET_ATOM(dpy, "Base");
+ lnames_TWO_LEVEL[1] = GET_ATOM(dpy, "Shift");
+ dflt_types[2].name = GET_ATOM(dpy, "ALPHABETIC");
+ lnames_ALPHABETIC[0] = GET_ATOM(dpy, "Base");
+ lnames_ALPHABETIC[1] = GET_ATOM(dpy, "Caps");
+ dflt_types[3].name = GET_ATOM(dpy, "KEYPAD");
+ lnames_KEYPAD[0] = GET_ATOM(dpy, "Base");
+ lnames_KEYPAD[1] = GET_ATOM(dpy, "Number");
+ dflt_types[4].name = GET_ATOM(dpy, "PC_BREAK");
+ lnames_PC_BREAK[0] = GET_ATOM(dpy, "Base");
+ lnames_PC_BREAK[1] = GET_ATOM(dpy, "Control");
+ dflt_types[5].name = GET_ATOM(dpy, "PC_SYSRQ");
+ lnames_PC_SYSRQ[0] = GET_ATOM(dpy, "Base");
+ lnames_PC_SYSRQ[1] = GET_ATOM(dpy, "Alt");
+ dflt_types[6].name = GET_ATOM(dpy, "CTRL+ALT");
+ lnames_CTRL_ALT[0] = GET_ATOM(dpy, "Base");
+ lnames_CTRL_ALT[1] = GET_ATOM(dpy, "Ctrl+Alt");
+ dflt_types[7].name = GET_ATOM(dpy, "THREE_LEVEL");
+ lnames_THREE_LEVEL[0] = GET_ATOM(dpy, "Base");
+ lnames_THREE_LEVEL[1] = GET_ATOM(dpy, "Shift");
+ lnames_THREE_LEVEL[2] = GET_ATOM(dpy, "Level3");
+ dflt_types[8].name = GET_ATOM(dpy, "SHIFT+ALT");
+ lnames_SHIFT_ALT[0] = GET_ATOM(dpy, "Base");
+ lnames_SHIFT_ALT[1] = GET_ATOM(dpy, "Shift+Alt");
}
+
/* compat name is "default" */
-static XkbSymInterpretRec dfltSI[69]= {
- { XK_ISO_Level2_Latch, 0x0000,
- XkbSI_LevelOneOnly|XkbSI_Exactly, ShiftMask,
- 255,
- { XkbSA_LatchMods, { 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Eisu_Shift, 0x0000,
- XkbSI_Exactly, LockMask,
- 255,
- { XkbSA_NoAction, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Eisu_toggle, 0x0000,
- XkbSI_Exactly, LockMask,
- 255,
- { XkbSA_NoAction, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Kana_Shift, 0x0000,
- XkbSI_Exactly, LockMask,
- 255,
- { XkbSA_NoAction, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Kana_Lock, 0x0000,
- XkbSI_Exactly, LockMask,
- 255,
- { XkbSA_NoAction, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Shift_Lock, 0x0000,
- XkbSI_AnyOf, ShiftMask|LockMask,
- 255,
- { XkbSA_LockMods, { 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Num_Lock, 0x0000,
- XkbSI_AnyOf, 0xff,
- 0,
- { XkbSA_LockMods, { 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00 } } },
- { XK_Alt_L, 0x0000,
- XkbSI_AnyOf, 0xff,
- 1,
- { XkbSA_SetMods, { 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Alt_R, 0x0000,
- XkbSI_AnyOf, 0xff,
- 1,
- { XkbSA_SetMods, { 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Scroll_Lock, 0x0000,
- XkbSI_AnyOf, 0xff,
- 4,
- { XkbSA_LockMods, { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_ISO_Lock, 0x0000,
- XkbSI_AnyOf, 0xff,
- 255,
- { XkbSA_ISOLock, { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_ISO_Level3_Shift, 0x0000,
- XkbSI_LevelOneOnly|XkbSI_AnyOf, 0xff,
- 2,
- { XkbSA_SetMods, { 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00 } } },
- { XK_ISO_Level3_Latch, 0x0000,
- XkbSI_LevelOneOnly|XkbSI_AnyOf, 0xff,
- 2,
- { XkbSA_LatchMods, { 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00 } } },
- { XK_Mode_switch, 0x0000,
- XkbSI_LevelOneOnly|XkbSI_AnyOfOrNone, 0xff,
- 3,
- { XkbSA_SetGroup, { 0x05, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_KP_1, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_MovePtr, { 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00 } } },
- { XK_KP_End, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_MovePtr, { 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00 } } },
- { XK_KP_2, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_MovePtr, { 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00 } } },
- { XK_KP_Down, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_MovePtr, { 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00 } } },
- { XK_KP_3, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_MovePtr, { 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00 } } },
- { XK_KP_Next, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_MovePtr, { 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00 } } },
- { XK_KP_4, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_MovePtr, { 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_KP_Left, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_MovePtr, { 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_KP_6, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_MovePtr, { 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_KP_Right, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_MovePtr, { 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_KP_7, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_MovePtr, { 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00 } } },
- { XK_KP_Home, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_MovePtr, { 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00 } } },
- { XK_KP_8, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_MovePtr, { 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 } } },
- { XK_KP_Up, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_MovePtr, { 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 } } },
- { XK_KP_9, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_MovePtr, { 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 } } },
- { XK_KP_Prior, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_MovePtr, { 0x00, 0x00, 0x01, 0xff, 0xff, 0x00, 0x00 } } },
- { XK_KP_5, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_PtrBtn, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_KP_Begin, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_PtrBtn, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_KP_F1, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_SetPtrDflt, { 0x04, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_KP_Divide, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_SetPtrDflt, { 0x04, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_KP_F2, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_SetPtrDflt, { 0x04, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_KP_Multiply, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_SetPtrDflt, { 0x04, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_KP_F3, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_SetPtrDflt, { 0x04, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_KP_Subtract, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_SetPtrDflt, { 0x04, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_KP_Separator, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_PtrBtn, { 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_KP_Add, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_PtrBtn, { 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_KP_0, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_LockPtrBtn, { 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_KP_Insert, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_LockPtrBtn, { 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_KP_Decimal, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_LockPtrBtn, { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_KP_Delete, 0x0001,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_LockPtrBtn, { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Pointer_Button_Dflt, 0x0000,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_PtrBtn, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Pointer_Button1, 0x0000,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_PtrBtn, { 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Pointer_Button2, 0x0000,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_PtrBtn, { 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Pointer_Button3, 0x0000,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_PtrBtn, { 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Pointer_DblClick_Dflt, 0x0000,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_PtrBtn, { 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Pointer_DblClick1, 0x0000,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_PtrBtn, { 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Pointer_DblClick2, 0x0000,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_PtrBtn, { 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Pointer_DblClick3, 0x0000,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_PtrBtn, { 0x00, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Pointer_Drag_Dflt, 0x0000,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_LockPtrBtn, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Pointer_Drag1, 0x0000,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_LockPtrBtn, { 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Pointer_Drag2, 0x0000,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_LockPtrBtn, { 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Pointer_Drag3, 0x0000,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_LockPtrBtn, { 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Pointer_EnableKeys, 0x0000,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_LockControls, { 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00 } } },
- { XK_Pointer_Accelerate, 0x0000,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_LockControls, { 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00 } } },
- { XK_Pointer_DfltBtnNext, 0x0000,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_SetPtrDflt, { 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_Pointer_DfltBtnPrev, 0x0000,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_SetPtrDflt, { 0x00, 0x01, 0xff, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_AccessX_Enable, 0x0000,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_LockControls, { 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00 } } },
- { XK_Terminate_Server, 0x0000,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_Terminate, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_ISO_Group_Latch, 0x0000,
- XkbSI_LevelOneOnly|XkbSI_AnyOfOrNone, 0xff,
- 3,
- { XkbSA_LatchGroup, { 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_ISO_Next_Group, 0x0000,
- XkbSI_LevelOneOnly|XkbSI_AnyOfOrNone, 0xff,
- 3,
- { XkbSA_LockGroup, { 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_ISO_Prev_Group, 0x0000,
- XkbSI_LevelOneOnly|XkbSI_AnyOfOrNone, 0xff,
- 3,
- { XkbSA_LockGroup, { 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_ISO_First_Group, 0x0000,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_LockGroup, { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { XK_ISO_Last_Group, 0x0000,
- XkbSI_AnyOfOrNone, 0xff,
- 255,
- { XkbSA_LockGroup, { 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
- { NoSymbol, 0x0000,
- XkbSI_Exactly, LockMask,
- 255,
- { XkbSA_LockMods, { 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00 } } },
- { NoSymbol, 0x0000,
- XkbSI_AnyOf, 0xff,
- 255,
- { XkbSA_SetMods, { 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } }
+static XkbSymInterpretRec dfltSI[69] = {
+ {XK_ISO_Level2_Latch, 0x0000,
+ XkbSI_LevelOneOnly | XkbSI_Exactly, ShiftMask,
+ 255,
+ {XkbSA_LatchMods, {0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Eisu_Shift, 0x0000,
+ XkbSI_Exactly, LockMask,
+ 255,
+ {XkbSA_NoAction, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Eisu_toggle, 0x0000,
+ XkbSI_Exactly, LockMask,
+ 255,
+ {XkbSA_NoAction, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Kana_Shift, 0x0000,
+ XkbSI_Exactly, LockMask,
+ 255,
+ {XkbSA_NoAction, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Kana_Lock, 0x0000,
+ XkbSI_Exactly, LockMask,
+ 255,
+ {XkbSA_NoAction, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Shift_Lock, 0x0000,
+ XkbSI_AnyOf, ShiftMask | LockMask,
+ 255,
+ {XkbSA_LockMods, {0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Num_Lock, 0x0000,
+ XkbSI_AnyOf, 0xff,
+ 0,
+ {XkbSA_LockMods, {0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00}}},
+ {XK_Alt_L, 0x0000,
+ XkbSI_AnyOf, 0xff,
+ 1,
+ {XkbSA_SetMods, {0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Alt_R, 0x0000,
+ XkbSI_AnyOf, 0xff,
+ 1,
+ {XkbSA_SetMods, {0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Scroll_Lock, 0x0000,
+ XkbSI_AnyOf, 0xff,
+ 4,
+ {XkbSA_LockMods, {0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_ISO_Lock, 0x0000,
+ XkbSI_AnyOf, 0xff,
+ 255,
+ {XkbSA_ISOLock, {0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_ISO_Level3_Shift, 0x0000,
+ XkbSI_LevelOneOnly | XkbSI_AnyOf, 0xff,
+ 2,
+ {XkbSA_SetMods, {0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00}}},
+ {XK_ISO_Level3_Latch, 0x0000,
+ XkbSI_LevelOneOnly | XkbSI_AnyOf, 0xff,
+ 2,
+ {XkbSA_LatchMods, {0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00}}},
+ {XK_Mode_switch, 0x0000,
+ XkbSI_LevelOneOnly | XkbSI_AnyOfOrNone, 0xff,
+ 3,
+ {XkbSA_SetGroup, {0x05, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_KP_1, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_MovePtr, {0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00}}},
+ {XK_KP_End, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_MovePtr, {0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00}}},
+ {XK_KP_2, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_MovePtr, {0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00}}},
+ {XK_KP_Down, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_MovePtr, {0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00}}},
+ {XK_KP_3, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_MovePtr, {0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00}}},
+ {XK_KP_Next, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_MovePtr, {0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00}}},
+ {XK_KP_4, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_MovePtr, {0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_KP_Left, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_MovePtr, {0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_KP_6, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_MovePtr, {0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_KP_Right, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_MovePtr, {0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_KP_7, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_MovePtr, {0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00}}},
+ {XK_KP_Home, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_MovePtr, {0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00}}},
+ {XK_KP_8, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_MovePtr, {0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00}}},
+ {XK_KP_Up, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_MovePtr, {0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00}}},
+ {XK_KP_9, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_MovePtr, {0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00}}},
+ {XK_KP_Prior, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_MovePtr, {0x00, 0x00, 0x01, 0xff, 0xff, 0x00, 0x00}}},
+ {XK_KP_5, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_PtrBtn, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_KP_Begin, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_PtrBtn, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_KP_F1, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_SetPtrDflt, {0x04, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_KP_Divide, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_SetPtrDflt, {0x04, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_KP_F2, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_SetPtrDflt, {0x04, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_KP_Multiply, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_SetPtrDflt, {0x04, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_KP_F3, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_SetPtrDflt, {0x04, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_KP_Subtract, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_SetPtrDflt, {0x04, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_KP_Separator, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_PtrBtn, {0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_KP_Add, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_PtrBtn, {0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_KP_0, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_LockPtrBtn, {0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_KP_Insert, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_LockPtrBtn, {0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_KP_Decimal, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_LockPtrBtn, {0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_KP_Delete, 0x0001,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_LockPtrBtn, {0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Pointer_Button_Dflt, 0x0000,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_PtrBtn, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Pointer_Button1, 0x0000,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_PtrBtn, {0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Pointer_Button2, 0x0000,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_PtrBtn, {0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Pointer_Button3, 0x0000,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_PtrBtn, {0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Pointer_DblClick_Dflt, 0x0000,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_PtrBtn, {0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Pointer_DblClick1, 0x0000,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_PtrBtn, {0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Pointer_DblClick2, 0x0000,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_PtrBtn, {0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Pointer_DblClick3, 0x0000,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_PtrBtn, {0x00, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Pointer_Drag_Dflt, 0x0000,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_LockPtrBtn, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Pointer_Drag1, 0x0000,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_LockPtrBtn, {0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Pointer_Drag2, 0x0000,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_LockPtrBtn, {0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Pointer_Drag3, 0x0000,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_LockPtrBtn, {0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Pointer_EnableKeys, 0x0000,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_LockControls, {0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00}}},
+ {XK_Pointer_Accelerate, 0x0000,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_LockControls, {0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00}}},
+ {XK_Pointer_DfltBtnNext, 0x0000,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_SetPtrDflt, {0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_Pointer_DfltBtnPrev, 0x0000,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_SetPtrDflt, {0x00, 0x01, 0xff, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_AccessX_Enable, 0x0000,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_LockControls, {0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00}}},
+ {XK_Terminate_Server, 0x0000,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_Terminate, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_ISO_Group_Latch, 0x0000,
+ XkbSI_LevelOneOnly | XkbSI_AnyOfOrNone, 0xff,
+ 3,
+ {XkbSA_LatchGroup, {0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_ISO_Next_Group, 0x0000,
+ XkbSI_LevelOneOnly | XkbSI_AnyOfOrNone, 0xff,
+ 3,
+ {XkbSA_LockGroup, {0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_ISO_Prev_Group, 0x0000,
+ XkbSI_LevelOneOnly | XkbSI_AnyOfOrNone, 0xff,
+ 3,
+ {XkbSA_LockGroup, {0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_ISO_First_Group, 0x0000,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_LockGroup, {0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {XK_ISO_Last_Group, 0x0000,
+ XkbSI_AnyOfOrNone, 0xff,
+ 255,
+ {XkbSA_LockGroup, {0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ {NoSymbol, 0x0000,
+ XkbSI_Exactly, LockMask,
+ 255,
+ {XkbSA_LockMods, {0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00}}},
+ {NoSymbol, 0x0000,
+ XkbSI_AnyOf, 0xff,
+ 255,
+ {XkbSA_SetMods, {0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}}
};
+
#define num_dfltSI (sizeof(dfltSI)/sizeof(XkbSymInterpretRec))
-static XkbCompatMapRec compatMap= {
+static XkbCompatMapRec compatMap = {
dfltSI,
- { /* group compatibility */
- { 0, 0, 0 },
- { 0, 0, vmod_AltGrMask },
- { 0, 0, vmod_AltGrMask },
- { 0, 0, vmod_AltGrMask }
- },
+ { /* group compatibility */
+ {0, 0, 0},
+ {0, 0, vmod_AltGrMask},
+ {0, 0, vmod_AltGrMask},
+ {0, 0, vmod_AltGrMask}
+ },
num_dfltSI, num_dfltSI
};
static void
-initIndicatorNames(DPYTYPE dpy,XkbDescPtr xkb)
+initIndicatorNames(DPYTYPE dpy, XkbDescPtr xkb)
{
- xkb->names->indicators[ 0]= GET_ATOM(dpy,"Caps Lock");
- xkb->names->indicators[ 1]= GET_ATOM(dpy,"Num Lock");
- xkb->names->indicators[ 2]= GET_ATOM(dpy,"Shift Lock");
- xkb->names->indicators[ 3]= GET_ATOM(dpy,"Mouse Keys");
- xkb->names->indicators[ 4]= GET_ATOM(dpy,"Scroll Lock");
- xkb->names->indicators[ 5]= GET_ATOM(dpy,"Group 2");
+ xkb->names->indicators[0] = GET_ATOM(dpy, "Caps Lock");
+ xkb->names->indicators[1] = GET_ATOM(dpy, "Num Lock");
+ xkb->names->indicators[2] = GET_ATOM(dpy, "Shift Lock");
+ xkb->names->indicators[3] = GET_ATOM(dpy, "Mouse Keys");
+ xkb->names->indicators[4] = GET_ATOM(dpy, "Scroll Lock");
+ xkb->names->indicators[5] = GET_ATOM(dpy, "Group 2");
}
-#endif /* DEFAULT_H */
+#endif /* DEFAULT_H */
diff --git a/xkb/xkbEvents.c b/xkb/xkbEvents.c
index 347f0f8a4..d49e4c1ba 100644
--- a/xkb/xkbEvents.c
+++ b/xkb/xkbEvents.c
@@ -118,7 +118,7 @@ XkbSendLegacyMapNotify(DeviceIntPtr kbd, CARD16 xkb_event, CARD16 changed,
core_mn.u.mappingNotify.count = num_keys;
else
core_mn.u.mappingNotify.count = clients[i]->maxKC -
- clients[i]->minKC + 1;
+ clients[i]->minKC + 1;
WriteEventsToClient(clients[i], 1, &core_mn);
}
@@ -152,7 +152,7 @@ XkbSendLegacyMapNotify(DeviceIntPtr kbd, CARD16 xkb_event, CARD16 changed,
/***====================================================================***/
void
-XkbSendNewKeyboardNotify(DeviceIntPtr kbd,xkbNewKeyboardNotify *pNKN)
+XkbSendNewKeyboardNotify(DeviceIntPtr kbd, xkbNewKeyboardNotify * pNKN)
{
int i;
Time time = GetTimeInMillis();
@@ -161,7 +161,7 @@ XkbSendNewKeyboardNotify(DeviceIntPtr kbd,xkbNewKeyboardNotify *pNKN)
pNKN->type = XkbEventCode + XkbEventBase;
pNKN->xkbType = XkbNewKeyboardNotify;
- for (i=1; i<currentMaxClients; i++) {
+ for (i = 1; i < currentMaxClients; i++) {
if (!clients[i] || clients[i]->clientState != ClientStateRunning)
continue;
@@ -193,19 +193,19 @@ XkbSendNewKeyboardNotify(DeviceIntPtr kbd,xkbNewKeyboardNotify *pNKN)
/***====================================================================***/
void
-XkbSendStateNotify(DeviceIntPtr kbd,xkbStateNotify *pSN)
+XkbSendStateNotify(DeviceIntPtr kbd, xkbStateNotify * pSN)
{
-XkbSrvInfoPtr xkbi;
-XkbStatePtr state;
-XkbInterestPtr interest;
-Time time;
-register CARD16 changed,bState;
+ XkbSrvInfoPtr xkbi;
+ XkbStatePtr state;
+ XkbInterestPtr interest;
+ Time time;
+ register CARD16 changed, bState;
interest = kbd->xkb_interest;
if (!interest || !kbd->key || !kbd->key->xkbInfo)
- return;
+ return;
xkbi = kbd->key->xkbInfo;
- state= &xkbi->state;
+ state = &xkbi->state;
pSN->type = XkbEventCode + XkbEventBase;
pSN->xkbType = XkbStateNotify;
@@ -226,26 +226,26 @@ register CARD16 changed,bState;
pSN->compatLookupMods = state->compat_lookup_mods;
pSN->ptrBtnState = state->ptr_buttons;
changed = pSN->changed;
- bState= pSN->ptrBtnState;
+ bState = pSN->ptrBtnState;
while (interest) {
- if ((!interest->client->clientGone) &&
- (interest->client->requestVector != InitialVector) &&
- (interest->client->xkbClientFlags&_XkbClientInitialized) &&
- (interest->stateNotifyMask&changed)) {
- pSN->sequenceNumber = interest->client->sequence;
- pSN->time = time;
- pSN->changed = changed;
- pSN->ptrBtnState = bState;
- if ( interest->client->swapped ) {
- swaps(&pSN->sequenceNumber);
- swapl(&pSN->time);
- swaps(&pSN->changed);
- swaps(&pSN->ptrBtnState);
- }
- WriteToClient(interest->client, sizeof(xEvent), (char *)pSN);
- }
- interest= interest->next;
+ if ((!interest->client->clientGone) &&
+ (interest->client->requestVector != InitialVector) &&
+ (interest->client->xkbClientFlags & _XkbClientInitialized) &&
+ (interest->stateNotifyMask & changed)) {
+ pSN->sequenceNumber = interest->client->sequence;
+ pSN->time = time;
+ pSN->changed = changed;
+ pSN->ptrBtnState = bState;
+ if (interest->client->swapped) {
+ swaps(&pSN->sequenceNumber);
+ swapl(&pSN->time);
+ swaps(&pSN->changed);
+ swaps(&pSN->ptrBtnState);
+ }
+ WriteToClient(interest->client, sizeof(xEvent), (char *) pSN);
+ }
+ interest = interest->next;
}
return;
}
@@ -257,7 +257,7 @@ register CARD16 changed,bState;
* have explicitly selected for them. Core and Xi events are handled by
* XkbSendLegacyMapNotify. */
void
-XkbSendMapNotify(DeviceIntPtr kbd, xkbMapNotify *pMN)
+XkbSendMapNotify(DeviceIntPtr kbd, xkbMapNotify * pMN)
{
int i;
CARD32 time = GetTimeInMillis();
@@ -295,595 +295,599 @@ XkbSendMapNotify(DeviceIntPtr kbd, xkbMapNotify *pMN)
}
int
-XkbComputeControlsNotify( DeviceIntPtr kbd,
- XkbControlsPtr old,
- XkbControlsPtr new,
- xkbControlsNotify * pCN,
- Bool forceCtrlProc)
+XkbComputeControlsNotify(DeviceIntPtr kbd,
+ XkbControlsPtr old,
+ XkbControlsPtr new,
+ xkbControlsNotify * pCN, Bool forceCtrlProc)
{
-int i;
-CARD32 changedControls;
+ int i;
+ CARD32 changedControls;
- changedControls= 0;
+ changedControls = 0;
if (!kbd || !kbd->kbdfeed)
return 0;
-
- if (old->enabled_ctrls!=new->enabled_ctrls)
- changedControls|= XkbControlsEnabledMask;
- if ((old->repeat_delay!=new->repeat_delay)||
- (old->repeat_interval!=new->repeat_interval))
- changedControls|= XkbRepeatKeysMask;
+
+ if (old->enabled_ctrls != new->enabled_ctrls)
+ changedControls |= XkbControlsEnabledMask;
+ if ((old->repeat_delay != new->repeat_delay) ||
+ (old->repeat_interval != new->repeat_interval))
+ changedControls |= XkbRepeatKeysMask;
for (i = 0; i < XkbPerKeyBitArraySize; i++)
- if (old->per_key_repeat[i] != new->per_key_repeat[i])
- changedControls|= XkbPerKeyRepeatMask;
- if (old->slow_keys_delay!=new->slow_keys_delay)
- changedControls|= XkbSlowKeysMask;
- if (old->debounce_delay!=new->debounce_delay)
- changedControls|= XkbBounceKeysMask;
- if ((old->mk_delay!=new->mk_delay)||
- (old->mk_interval!=new->mk_interval)||
- (old->mk_dflt_btn!=new->mk_dflt_btn))
- changedControls|= XkbMouseKeysMask;
- if ((old->mk_time_to_max!=new->mk_time_to_max)||
- (old->mk_curve!=new->mk_curve)||
- (old->mk_max_speed!=new->mk_max_speed))
- changedControls|= XkbMouseKeysAccelMask;
- if (old->ax_options!=new->ax_options)
- changedControls|= XkbAccessXKeysMask;
- if ((old->ax_options^new->ax_options) & XkbAX_SKOptionsMask)
- changedControls|= XkbStickyKeysMask;
- if ((old->ax_options^new->ax_options) & XkbAX_FBOptionsMask)
- changedControls|= XkbAccessXFeedbackMask;
- if ((old->ax_timeout!=new->ax_timeout)||
- (old->axt_ctrls_mask!=new->axt_ctrls_mask)||
- (old->axt_ctrls_values!=new->axt_ctrls_values)||
- (old->axt_opts_mask!=new->axt_opts_mask)||
- (old->axt_opts_values!= new->axt_opts_values)) {
- changedControls|= XkbAccessXTimeoutMask;
+ if (old->per_key_repeat[i] != new->per_key_repeat[i])
+ changedControls |= XkbPerKeyRepeatMask;
+ if (old->slow_keys_delay != new->slow_keys_delay)
+ changedControls |= XkbSlowKeysMask;
+ if (old->debounce_delay != new->debounce_delay)
+ changedControls |= XkbBounceKeysMask;
+ if ((old->mk_delay != new->mk_delay) ||
+ (old->mk_interval != new->mk_interval) ||
+ (old->mk_dflt_btn != new->mk_dflt_btn))
+ changedControls |= XkbMouseKeysMask;
+ if ((old->mk_time_to_max != new->mk_time_to_max) ||
+ (old->mk_curve != new->mk_curve) ||
+ (old->mk_max_speed != new->mk_max_speed))
+ changedControls |= XkbMouseKeysAccelMask;
+ if (old->ax_options != new->ax_options)
+ changedControls |= XkbAccessXKeysMask;
+ if ((old->ax_options ^ new->ax_options) & XkbAX_SKOptionsMask)
+ changedControls |= XkbStickyKeysMask;
+ if ((old->ax_options ^ new->ax_options) & XkbAX_FBOptionsMask)
+ changedControls |= XkbAccessXFeedbackMask;
+ if ((old->ax_timeout != new->ax_timeout) ||
+ (old->axt_ctrls_mask != new->axt_ctrls_mask) ||
+ (old->axt_ctrls_values != new->axt_ctrls_values) ||
+ (old->axt_opts_mask != new->axt_opts_mask) ||
+ (old->axt_opts_values != new->axt_opts_values)) {
+ changedControls |= XkbAccessXTimeoutMask;
}
- if ((old->internal.mask!=new->internal.mask)||
- (old->internal.real_mods!=new->internal.real_mods)||
- (old->internal.vmods!=new->internal.vmods))
- changedControls|= XkbInternalModsMask;
- if ((old->ignore_lock.mask!=new->ignore_lock.mask)||
- (old->ignore_lock.real_mods!=new->ignore_lock.real_mods)||
- (old->ignore_lock.vmods!=new->ignore_lock.vmods))
- changedControls|= XkbIgnoreLockModsMask;
-
- if (new->enabled_ctrls&XkbRepeatKeysMask)
- kbd->kbdfeed->ctrl.autoRepeat=TRUE;
- else kbd->kbdfeed->ctrl.autoRepeat=FALSE;
+ if ((old->internal.mask != new->internal.mask) ||
+ (old->internal.real_mods != new->internal.real_mods) ||
+ (old->internal.vmods != new->internal.vmods))
+ changedControls |= XkbInternalModsMask;
+ if ((old->ignore_lock.mask != new->ignore_lock.mask) ||
+ (old->ignore_lock.real_mods != new->ignore_lock.real_mods) ||
+ (old->ignore_lock.vmods != new->ignore_lock.vmods))
+ changedControls |= XkbIgnoreLockModsMask;
+
+ if (new->enabled_ctrls & XkbRepeatKeysMask)
+ kbd->kbdfeed->ctrl.autoRepeat = TRUE;
+ else
+ kbd->kbdfeed->ctrl.autoRepeat = FALSE;
if (kbd->kbdfeed && kbd->kbdfeed->CtrlProc &&
- (changedControls || forceCtrlProc))
- (*kbd->kbdfeed->CtrlProc)(kbd, &kbd->kbdfeed->ctrl);
+ (changedControls || forceCtrlProc))
+ (*kbd->kbdfeed->CtrlProc) (kbd, &kbd->kbdfeed->ctrl);
- if ((!changedControls)&&(old->num_groups==new->num_groups))
- return 0;
+ if ((!changedControls) && (old->num_groups == new->num_groups))
+ return 0;
if (!kbd->xkb_interest)
- return 0;
+ return 0;
pCN->changedControls = changedControls;
pCN->enabledControls = new->enabled_ctrls;
- pCN->enabledControlChanges = (new->enabled_ctrls^old->enabled_ctrls);
+ pCN->enabledControlChanges = (new->enabled_ctrls ^ old->enabled_ctrls);
pCN->numGroups = new->num_groups;
return 1;
}
void
-XkbSendControlsNotify(DeviceIntPtr kbd,xkbControlsNotify *pCN)
+XkbSendControlsNotify(DeviceIntPtr kbd, xkbControlsNotify * pCN)
{
-int initialized;
-CARD32 changedControls, enabledControls, enabledChanges = 0;
-XkbSrvInfoPtr xkbi;
-XkbInterestPtr interest;
-Time time = 0;
+ int initialized;
+ CARD32 changedControls, enabledControls, enabledChanges = 0;
+ XkbSrvInfoPtr xkbi;
+ XkbInterestPtr interest;
+ Time time = 0;
interest = kbd->xkb_interest;
if (!interest || !kbd->key || !kbd->key->xkbInfo)
- return;
+ return;
xkbi = kbd->key->xkbInfo;
-
+
initialized = 0;
enabledControls = xkbi->desc->ctrls->enabled_ctrls;
changedControls = pCN->changedControls;
- pCN->numGroups= xkbi->desc->ctrls->num_groups;
+ pCN->numGroups = xkbi->desc->ctrls->num_groups;
while (interest) {
- if ((!interest->client->clientGone) &&
- (interest->client->requestVector != InitialVector) &&
- (interest->client->xkbClientFlags&_XkbClientInitialized) &&
- (interest->ctrlsNotifyMask&changedControls)) {
- if (!initialized) {
- pCN->type = XkbEventCode + XkbEventBase;
- pCN->xkbType = XkbControlsNotify;
- pCN->deviceID = kbd->id;
- pCN->time = time = GetTimeInMillis();
- enabledChanges = pCN->enabledControlChanges;
- initialized= 1;
- }
- pCN->changedControls = changedControls;
- pCN->enabledControls = enabledControls;
- pCN->enabledControlChanges = enabledChanges;
- pCN->sequenceNumber = interest->client->sequence;
- pCN->time = time;
- if ( interest->client->swapped ) {
- swaps(&pCN->sequenceNumber);
- swapl(&pCN->changedControls);
- swapl(&pCN->enabledControls);
- swapl(&pCN->enabledControlChanges);
- swapl(&pCN->time);
- }
- WriteToClient(interest->client, sizeof(xEvent), (char *)pCN);
- }
- interest= interest->next;
+ if ((!interest->client->clientGone) &&
+ (interest->client->requestVector != InitialVector) &&
+ (interest->client->xkbClientFlags & _XkbClientInitialized) &&
+ (interest->ctrlsNotifyMask & changedControls)) {
+ if (!initialized) {
+ pCN->type = XkbEventCode + XkbEventBase;
+ pCN->xkbType = XkbControlsNotify;
+ pCN->deviceID = kbd->id;
+ pCN->time = time = GetTimeInMillis();
+ enabledChanges = pCN->enabledControlChanges;
+ initialized = 1;
+ }
+ pCN->changedControls = changedControls;
+ pCN->enabledControls = enabledControls;
+ pCN->enabledControlChanges = enabledChanges;
+ pCN->sequenceNumber = interest->client->sequence;
+ pCN->time = time;
+ if (interest->client->swapped) {
+ swaps(&pCN->sequenceNumber);
+ swapl(&pCN->changedControls);
+ swapl(&pCN->enabledControls);
+ swapl(&pCN->enabledControlChanges);
+ swapl(&pCN->time);
+ }
+ WriteToClient(interest->client, sizeof(xEvent), (char *) pCN);
+ }
+ interest = interest->next;
}
return;
}
static void
-XkbSendIndicatorNotify(DeviceIntPtr kbd,int xkbType,xkbIndicatorNotify *pEv)
+XkbSendIndicatorNotify(DeviceIntPtr kbd, int xkbType, xkbIndicatorNotify * pEv)
{
-int initialized;
-XkbInterestPtr interest;
-Time time = 0;
-CARD32 state,changed;
+ int initialized;
+ XkbInterestPtr interest;
+ Time time = 0;
+ CARD32 state, changed;
interest = kbd->xkb_interest;
if (!interest)
- return;
-
+ return;
+
initialized = 0;
state = pEv->state;
changed = pEv->changed;
while (interest) {
- if ((!interest->client->clientGone) &&
- (interest->client->requestVector != InitialVector) &&
- (interest->client->xkbClientFlags&_XkbClientInitialized) &&
- (((xkbType==XkbIndicatorStateNotify)&&
- (interest->iStateNotifyMask&changed))||
- ((xkbType==XkbIndicatorMapNotify)&&
- (interest->iMapNotifyMask&changed)))) {
- if (!initialized) {
- pEv->type = XkbEventCode + XkbEventBase;
- pEv->xkbType = xkbType;
- pEv->deviceID = kbd->id;
- pEv->time = time = GetTimeInMillis();
- initialized= 1;
- }
- pEv->sequenceNumber = interest->client->sequence;
- pEv->time = time;
- pEv->changed = changed;
- pEv->state = state;
- if ( interest->client->swapped ) {
- swaps(&pEv->sequenceNumber);
- swapl(&pEv->time);
- swapl(&pEv->changed);
- swapl(&pEv->state);
- }
- WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
- }
- interest= interest->next;
+ if ((!interest->client->clientGone) &&
+ (interest->client->requestVector != InitialVector) &&
+ (interest->client->xkbClientFlags & _XkbClientInitialized) &&
+ (((xkbType == XkbIndicatorStateNotify) &&
+ (interest->iStateNotifyMask & changed)) ||
+ ((xkbType == XkbIndicatorMapNotify) &&
+ (interest->iMapNotifyMask & changed)))) {
+ if (!initialized) {
+ pEv->type = XkbEventCode + XkbEventBase;
+ pEv->xkbType = xkbType;
+ pEv->deviceID = kbd->id;
+ pEv->time = time = GetTimeInMillis();
+ initialized = 1;
+ }
+ pEv->sequenceNumber = interest->client->sequence;
+ pEv->time = time;
+ pEv->changed = changed;
+ pEv->state = state;
+ if (interest->client->swapped) {
+ swaps(&pEv->sequenceNumber);
+ swapl(&pEv->time);
+ swapl(&pEv->changed);
+ swapl(&pEv->state);
+ }
+ WriteToClient(interest->client, sizeof(xEvent), (char *) pEv);
+ }
+ interest = interest->next;
}
return;
}
-
void
-XkbHandleBell( BOOL force,
- BOOL eventOnly,
- DeviceIntPtr kbd,
- CARD8 percent,
- pointer pCtrl,
- CARD8 class,
- Atom name,
- WindowPtr pWin,
- ClientPtr pClient)
+XkbHandleBell(BOOL force,
+ BOOL eventOnly,
+ DeviceIntPtr kbd,
+ CARD8 percent,
+ pointer pCtrl,
+ CARD8 class, Atom name, WindowPtr pWin, ClientPtr pClient)
{
-xkbBellNotify bn;
-int initialized;
-XkbSrvInfoPtr xkbi;
-XkbInterestPtr interest;
-CARD8 id;
-CARD16 pitch,duration;
-Time time = 0;
-XID winID = 0;
+ xkbBellNotify bn;
+ int initialized;
+ XkbSrvInfoPtr xkbi;
+ XkbInterestPtr interest;
+ CARD8 id;
+ CARD16 pitch, duration;
+ Time time = 0;
+ XID winID = 0;
if (!kbd->key || !kbd->key->xkbInfo)
return;
xkbi = kbd->key->xkbInfo;
- if ((force||(xkbi->desc->ctrls->enabled_ctrls&XkbAudibleBellMask))&&
- (!eventOnly)) {
+ if ((force || (xkbi->desc->ctrls->enabled_ctrls & XkbAudibleBellMask)) &&
+ (!eventOnly)) {
if (kbd->kbdfeed->BellProc)
- (*kbd->kbdfeed->BellProc)(percent,kbd,(pointer)pCtrl,class);
+ (*kbd->kbdfeed->BellProc) (percent, kbd, (pointer) pCtrl, class);
}
interest = kbd->xkb_interest;
- if ((!interest)||(force))
- return;
-
- if ((class==0)||(class==KbdFeedbackClass)) {
- KeybdCtrl *pKeyCtrl= (KeybdCtrl *)pCtrl;
- id= pKeyCtrl->id;
- pitch= pKeyCtrl->bell_pitch;
- duration= pKeyCtrl->bell_duration;
+ if ((!interest) || (force))
+ return;
+
+ if ((class == 0) || (class == KbdFeedbackClass)) {
+ KeybdCtrl *pKeyCtrl = (KeybdCtrl *) pCtrl;
+
+ id = pKeyCtrl->id;
+ pitch = pKeyCtrl->bell_pitch;
+ duration = pKeyCtrl->bell_duration;
}
- else if (class==BellFeedbackClass) {
- BellCtrl *pBellCtrl= (BellCtrl *)pCtrl;
- id= pBellCtrl->id;
- pitch= pBellCtrl->pitch;
- duration= pBellCtrl->duration;
+ else if (class == BellFeedbackClass) {
+ BellCtrl *pBellCtrl = (BellCtrl *) pCtrl;
+
+ id = pBellCtrl->id;
+ pitch = pBellCtrl->pitch;
+ duration = pBellCtrl->duration;
}
- else return;
-
+ else
+ return;
+
initialized = 0;
while (interest) {
- if ((!interest->client->clientGone) &&
- (interest->client->requestVector != InitialVector) &&
- (interest->client->xkbClientFlags&_XkbClientInitialized) &&
- (interest->bellNotifyMask)) {
- if (!initialized) {
- time = GetTimeInMillis();
- bn.type = XkbEventCode + XkbEventBase;
- bn.xkbType = XkbBellNotify;
- bn.deviceID = kbd->id;
- bn.bellClass = class;
- bn.bellID = id;
- bn.percent= percent;
- bn.eventOnly = (eventOnly!=0);
- winID= (pWin?pWin->drawable.id:None);
- initialized= 1;
- }
- bn.sequenceNumber = interest->client->sequence;
- bn.time = time;
- bn.pitch = pitch;
- bn.duration = duration;
- bn.name = name;
- bn.window= winID;
- if ( interest->client->swapped ) {
- swaps(&bn.sequenceNumber);
- swapl(&bn.time);
- swaps(&bn.pitch);
- swaps(&bn.duration);
- swapl(&bn.name);
- swapl(&bn.window);
- }
- WriteToClient(interest->client, sizeof(xEvent), (char *)&bn);
- }
- interest= interest->next;
+ if ((!interest->client->clientGone) &&
+ (interest->client->requestVector != InitialVector) &&
+ (interest->client->xkbClientFlags & _XkbClientInitialized) &&
+ (interest->bellNotifyMask)) {
+ if (!initialized) {
+ time = GetTimeInMillis();
+ bn.type = XkbEventCode + XkbEventBase;
+ bn.xkbType = XkbBellNotify;
+ bn.deviceID = kbd->id;
+ bn.bellClass = class;
+ bn.bellID = id;
+ bn.percent = percent;
+ bn.eventOnly = (eventOnly != 0);
+ winID = (pWin ? pWin->drawable.id : None);
+ initialized = 1;
+ }
+ bn.sequenceNumber = interest->client->sequence;
+ bn.time = time;
+ bn.pitch = pitch;
+ bn.duration = duration;
+ bn.name = name;
+ bn.window = winID;
+ if (interest->client->swapped) {
+ swaps(&bn.sequenceNumber);
+ swapl(&bn.time);
+ swaps(&bn.pitch);
+ swaps(&bn.duration);
+ swapl(&bn.name);
+ swapl(&bn.window);
+ }
+ WriteToClient(interest->client, sizeof(xEvent), (char *) &bn);
+ }
+ interest = interest->next;
}
return;
}
void
-XkbSendAccessXNotify(DeviceIntPtr kbd,xkbAccessXNotify *pEv)
+XkbSendAccessXNotify(DeviceIntPtr kbd, xkbAccessXNotify * pEv)
{
-int initialized;
-XkbInterestPtr interest;
-Time time = 0;
-CARD16 sk_delay,db_delay;
+ int initialized;
+ XkbInterestPtr interest;
+ Time time = 0;
+ CARD16 sk_delay, db_delay;
interest = kbd->xkb_interest;
if (!interest)
- return;
-
+ return;
+
initialized = 0;
- sk_delay= pEv->slowKeysDelay;
- db_delay= pEv->debounceDelay;
+ sk_delay = pEv->slowKeysDelay;
+ db_delay = pEv->debounceDelay;
while (interest) {
- if ((!interest->client->clientGone) &&
- (interest->client->requestVector != InitialVector) &&
- (interest->client->xkbClientFlags&_XkbClientInitialized) &&
- (interest->accessXNotifyMask&(1<<pEv->detail))) {
- if (!initialized) {
- pEv->type = XkbEventCode + XkbEventBase;
- pEv->xkbType = XkbAccessXNotify;
- pEv->deviceID = kbd->id;
- pEv->time = time = GetTimeInMillis();
- initialized= 1;
- }
- pEv->sequenceNumber = interest->client->sequence;
- pEv->time = time;
- pEv->slowKeysDelay = sk_delay;
- pEv->debounceDelay = db_delay;
- if ( interest->client->swapped ) {
- swaps(&pEv->sequenceNumber);
- swapl(&pEv->time);
- swaps(&pEv->slowKeysDelay);
- swaps(&pEv->debounceDelay);
- }
- WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
- }
- interest= interest->next;
+ if ((!interest->client->clientGone) &&
+ (interest->client->requestVector != InitialVector) &&
+ (interest->client->xkbClientFlags & _XkbClientInitialized) &&
+ (interest->accessXNotifyMask & (1 << pEv->detail))) {
+ if (!initialized) {
+ pEv->type = XkbEventCode + XkbEventBase;
+ pEv->xkbType = XkbAccessXNotify;
+ pEv->deviceID = kbd->id;
+ pEv->time = time = GetTimeInMillis();
+ initialized = 1;
+ }
+ pEv->sequenceNumber = interest->client->sequence;
+ pEv->time = time;
+ pEv->slowKeysDelay = sk_delay;
+ pEv->debounceDelay = db_delay;
+ if (interest->client->swapped) {
+ swaps(&pEv->sequenceNumber);
+ swapl(&pEv->time);
+ swaps(&pEv->slowKeysDelay);
+ swaps(&pEv->debounceDelay);
+ }
+ WriteToClient(interest->client, sizeof(xEvent), (char *) pEv);
+ }
+ interest = interest->next;
}
return;
}
void
-XkbSendNamesNotify(DeviceIntPtr kbd,xkbNamesNotify *pEv)
+XkbSendNamesNotify(DeviceIntPtr kbd, xkbNamesNotify * pEv)
{
-int initialized;
-XkbInterestPtr interest;
-Time time = 0;
-CARD16 changed,changedVirtualMods;
-CARD32 changedIndicators;
+ int initialized;
+ XkbInterestPtr interest;
+ Time time = 0;
+ CARD16 changed, changedVirtualMods;
+ CARD32 changedIndicators;
interest = kbd->xkb_interest;
if (!interest)
- return;
-
+ return;
+
initialized = 0;
- changed= pEv->changed;
- changedIndicators= pEv->changedIndicators;
- changedVirtualMods= pEv->changedVirtualMods;
+ changed = pEv->changed;
+ changedIndicators = pEv->changedIndicators;
+ changedVirtualMods = pEv->changedVirtualMods;
while (interest) {
- if ((!interest->client->clientGone) &&
- (interest->client->requestVector != InitialVector) &&
- (interest->client->xkbClientFlags&_XkbClientInitialized) &&
- (interest->namesNotifyMask&pEv->changed)) {
- if (!initialized) {
- pEv->type = XkbEventCode + XkbEventBase;
- pEv->xkbType = XkbNamesNotify;
- pEv->deviceID = kbd->id;
- pEv->time = time = GetTimeInMillis();
- initialized= 1;
- }
- pEv->sequenceNumber = interest->client->sequence;
- pEv->time = time;
- pEv->changed = changed;
- pEv->changedIndicators = changedIndicators;
- pEv->changedVirtualMods= changedVirtualMods;
- if ( interest->client->swapped ) {
- swaps(&pEv->sequenceNumber);
- swapl(&pEv->time);
- swaps(&pEv->changed);
- swapl(&pEv->changedIndicators);
- swaps(&pEv->changedVirtualMods);
- }
- WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
- }
- interest= interest->next;
+ if ((!interest->client->clientGone) &&
+ (interest->client->requestVector != InitialVector) &&
+ (interest->client->xkbClientFlags & _XkbClientInitialized) &&
+ (interest->namesNotifyMask & pEv->changed)) {
+ if (!initialized) {
+ pEv->type = XkbEventCode + XkbEventBase;
+ pEv->xkbType = XkbNamesNotify;
+ pEv->deviceID = kbd->id;
+ pEv->time = time = GetTimeInMillis();
+ initialized = 1;
+ }
+ pEv->sequenceNumber = interest->client->sequence;
+ pEv->time = time;
+ pEv->changed = changed;
+ pEv->changedIndicators = changedIndicators;
+ pEv->changedVirtualMods = changedVirtualMods;
+ if (interest->client->swapped) {
+ swaps(&pEv->sequenceNumber);
+ swapl(&pEv->time);
+ swaps(&pEv->changed);
+ swapl(&pEv->changedIndicators);
+ swaps(&pEv->changedVirtualMods);
+ }
+ WriteToClient(interest->client, sizeof(xEvent), (char *) pEv);
+ }
+ interest = interest->next;
}
return;
}
void
-XkbSendCompatMapNotify(DeviceIntPtr kbd,xkbCompatMapNotify *pEv)
+XkbSendCompatMapNotify(DeviceIntPtr kbd, xkbCompatMapNotify * pEv)
{
-int initialized;
-XkbInterestPtr interest;
-Time time = 0;
-CARD16 firstSI = 0, nSI = 0, nTotalSI = 0;
+ int initialized;
+ XkbInterestPtr interest;
+ Time time = 0;
+ CARD16 firstSI = 0, nSI = 0, nTotalSI = 0;
interest = kbd->xkb_interest;
if (!interest)
- return;
-
+ return;
+
initialized = 0;
while (interest) {
- if ((!interest->client->clientGone) &&
- (interest->client->requestVector != InitialVector) &&
- (interest->client->xkbClientFlags&_XkbClientInitialized) &&
- (interest->compatNotifyMask)) {
- if (!initialized) {
- pEv->type = XkbEventCode + XkbEventBase;
- pEv->xkbType = XkbCompatMapNotify;
- pEv->deviceID = kbd->id;
- pEv->time = time = GetTimeInMillis();
- firstSI= pEv->firstSI;
- nSI= pEv->nSI;
- nTotalSI= pEv->nTotalSI;
- initialized= 1;
- }
- pEv->sequenceNumber = interest->client->sequence;
- pEv->time = time;
- pEv->firstSI = firstSI;
- pEv->nSI = nSI;
- pEv->nTotalSI = nTotalSI;
- if ( interest->client->swapped ) {
- swaps(&pEv->sequenceNumber);
- swapl(&pEv->time);
- swaps(&pEv->firstSI);
- swaps(&pEv->nSI);
- swaps(&pEv->nTotalSI);
- }
- WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
- }
- interest= interest->next;
+ if ((!interest->client->clientGone) &&
+ (interest->client->requestVector != InitialVector) &&
+ (interest->client->xkbClientFlags & _XkbClientInitialized) &&
+ (interest->compatNotifyMask)) {
+ if (!initialized) {
+ pEv->type = XkbEventCode + XkbEventBase;
+ pEv->xkbType = XkbCompatMapNotify;
+ pEv->deviceID = kbd->id;
+ pEv->time = time = GetTimeInMillis();
+ firstSI = pEv->firstSI;
+ nSI = pEv->nSI;
+ nTotalSI = pEv->nTotalSI;
+ initialized = 1;
+ }
+ pEv->sequenceNumber = interest->client->sequence;
+ pEv->time = time;
+ pEv->firstSI = firstSI;
+ pEv->nSI = nSI;
+ pEv->nTotalSI = nTotalSI;
+ if (interest->client->swapped) {
+ swaps(&pEv->sequenceNumber);
+ swapl(&pEv->time);
+ swaps(&pEv->firstSI);
+ swaps(&pEv->nSI);
+ swaps(&pEv->nTotalSI);
+ }
+ WriteToClient(interest->client, sizeof(xEvent), (char *) pEv);
+ }
+ interest = interest->next;
}
return;
}
void
-XkbSendActionMessage(DeviceIntPtr kbd,xkbActionMessage *pEv)
+XkbSendActionMessage(DeviceIntPtr kbd, xkbActionMessage * pEv)
{
-int initialized;
-XkbSrvInfoPtr xkbi;
-XkbInterestPtr interest;
-Time time = 0;
+ int initialized;
+ XkbSrvInfoPtr xkbi;
+ XkbInterestPtr interest;
+ Time time = 0;
interest = kbd->xkb_interest;
if (!interest || !kbd->key || !kbd->key->xkbInfo)
- return;
-
+ return;
+
xkbi = kbd->key->xkbInfo;
initialized = 0;
- pEv->mods= xkbi->state.mods;
- pEv->group= xkbi->state.group;
+ pEv->mods = xkbi->state.mods;
+ pEv->group = xkbi->state.group;
while (interest) {
- if ((!interest->client->clientGone) &&
- (interest->client->requestVector != InitialVector) &&
- (interest->client->xkbClientFlags&_XkbClientInitialized) &&
- (interest->actionMessageMask)) {
- if (!initialized) {
- pEv->type = XkbEventCode + XkbEventBase;
- pEv->xkbType = XkbActionMessage;
- pEv->deviceID = kbd->id;
- pEv->sequenceNumber = interest->client->sequence;
- pEv->time = time = GetTimeInMillis();
- initialized= 1;
- }
- pEv->sequenceNumber = interest->client->sequence;
- pEv->time = time;
- if ( interest->client->swapped ) {
- swaps(&pEv->sequenceNumber);
- swapl(&pEv->time);
- }
- WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
- }
- interest= interest->next;
+ if ((!interest->client->clientGone) &&
+ (interest->client->requestVector != InitialVector) &&
+ (interest->client->xkbClientFlags & _XkbClientInitialized) &&
+ (interest->actionMessageMask)) {
+ if (!initialized) {
+ pEv->type = XkbEventCode + XkbEventBase;
+ pEv->xkbType = XkbActionMessage;
+ pEv->deviceID = kbd->id;
+ pEv->sequenceNumber = interest->client->sequence;
+ pEv->time = time = GetTimeInMillis();
+ initialized = 1;
+ }
+ pEv->sequenceNumber = interest->client->sequence;
+ pEv->time = time;
+ if (interest->client->swapped) {
+ swaps(&pEv->sequenceNumber);
+ swapl(&pEv->time);
+ }
+ WriteToClient(interest->client, sizeof(xEvent), (char *) pEv);
+ }
+ interest = interest->next;
}
return;
}
void
-XkbSendExtensionDeviceNotify( DeviceIntPtr dev,
- ClientPtr client,
- xkbExtensionDeviceNotify * pEv)
+XkbSendExtensionDeviceNotify(DeviceIntPtr dev,
+ ClientPtr client, xkbExtensionDeviceNotify * pEv)
{
-int initialized;
-XkbInterestPtr interest;
-Time time = 0;
-CARD32 defined, state;
-CARD16 reason;
+ int initialized;
+ XkbInterestPtr interest;
+ Time time = 0;
+ CARD32 defined, state;
+ CARD16 reason;
interest = dev->xkb_interest;
if (!interest)
- return;
-
+ return;
+
initialized = 0;
- reason= pEv->reason;
- defined= pEv->ledsDefined;
- state= pEv->ledState;
+ reason = pEv->reason;
+ defined = pEv->ledsDefined;
+ state = pEv->ledState;
while (interest) {
- if ((!interest->client->clientGone) &&
- (interest->client->requestVector != InitialVector) &&
- (interest->client->xkbClientFlags&_XkbClientInitialized) &&
- (interest->extDevNotifyMask&reason)) {
- if (!initialized) {
- pEv->type = XkbEventCode + XkbEventBase;
- pEv->xkbType = XkbExtensionDeviceNotify;
- pEv->deviceID = dev->id;
- pEv->sequenceNumber = interest->client->sequence;
- pEv->time = time = GetTimeInMillis();
- initialized= 1;
- }
- else {
- pEv->sequenceNumber = interest->client->sequence;
- pEv->time = time;
- pEv->ledsDefined= defined;
- pEv->ledState= state;
- pEv->reason= reason;
- pEv->supported= XkbXI_AllFeaturesMask;
- }
- if ( interest->client->swapped ) {
- swaps(&pEv->sequenceNumber);
- swapl(&pEv->time);
- swapl(&pEv->ledsDefined);
- swapl(&pEv->ledState);
- swaps(&pEv->reason);
- swaps(&pEv->supported);
- }
- WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
- }
- interest= interest->next;
+ if ((!interest->client->clientGone) &&
+ (interest->client->requestVector != InitialVector) &&
+ (interest->client->xkbClientFlags & _XkbClientInitialized) &&
+ (interest->extDevNotifyMask & reason)) {
+ if (!initialized) {
+ pEv->type = XkbEventCode + XkbEventBase;
+ pEv->xkbType = XkbExtensionDeviceNotify;
+ pEv->deviceID = dev->id;
+ pEv->sequenceNumber = interest->client->sequence;
+ pEv->time = time = GetTimeInMillis();
+ initialized = 1;
+ }
+ else {
+ pEv->sequenceNumber = interest->client->sequence;
+ pEv->time = time;
+ pEv->ledsDefined = defined;
+ pEv->ledState = state;
+ pEv->reason = reason;
+ pEv->supported = XkbXI_AllFeaturesMask;
+ }
+ if (interest->client->swapped) {
+ swaps(&pEv->sequenceNumber);
+ swapl(&pEv->time);
+ swapl(&pEv->ledsDefined);
+ swapl(&pEv->ledState);
+ swaps(&pEv->reason);
+ swaps(&pEv->supported);
+ }
+ WriteToClient(interest->client, sizeof(xEvent), (char *) pEv);
+ }
+ interest = interest->next;
}
return;
}
void
-XkbSendNotification( DeviceIntPtr kbd,
- XkbChangesPtr pChanges,
- XkbEventCausePtr cause)
+XkbSendNotification(DeviceIntPtr kbd,
+ XkbChangesPtr pChanges, XkbEventCausePtr cause)
{
-XkbSrvLedInfoPtr sli;
+ XkbSrvLedInfoPtr sli;
- sli= NULL;
+ sli = NULL;
if (pChanges->state_changes) {
- xkbStateNotify sn;
- sn.changed= pChanges->state_changes;
- sn.keycode= cause->kc;
- sn.eventType= cause->event;
- sn.requestMajor= cause->mjr;
- sn.requestMinor= cause->mnr;
- XkbSendStateNotify(kbd,&sn);
+ xkbStateNotify sn;
+
+ sn.changed = pChanges->state_changes;
+ sn.keycode = cause->kc;
+ sn.eventType = cause->event;
+ sn.requestMajor = cause->mjr;
+ sn.requestMinor = cause->mnr;
+ XkbSendStateNotify(kbd, &sn);
}
if (pChanges->map.changed) {
- xkbMapNotify mn;
- memset(&mn, 0, sizeof(xkbMapNotify));
- mn.changed= pChanges->map.changed;
- mn.firstType= pChanges->map.first_type;
- mn.nTypes= pChanges->map.num_types;
- mn.firstKeySym= pChanges->map.first_key_sym;
- mn.nKeySyms= pChanges->map.num_key_syms;
- mn.firstKeyAct= pChanges->map.first_key_act;
- mn.nKeyActs= pChanges->map.num_key_acts;
- mn.firstKeyBehavior= pChanges->map.first_key_behavior;
- mn.nKeyBehaviors= pChanges->map.num_key_behaviors;
- mn.virtualMods= pChanges->map.vmods;
- mn.firstKeyExplicit= pChanges->map.first_key_explicit;
- mn.nKeyExplicit= pChanges->map.num_key_explicit;
- mn.firstModMapKey= pChanges->map.first_modmap_key;
- mn.nModMapKeys= pChanges->map.num_modmap_keys;
- mn.firstVModMapKey= pChanges->map.first_vmodmap_key;
- mn.nVModMapKeys= pChanges->map.num_vmodmap_keys;
- XkbSendMapNotify(kbd,&mn);
+ xkbMapNotify mn;
+
+ memset(&mn, 0, sizeof(xkbMapNotify));
+ mn.changed = pChanges->map.changed;
+ mn.firstType = pChanges->map.first_type;
+ mn.nTypes = pChanges->map.num_types;
+ mn.firstKeySym = pChanges->map.first_key_sym;
+ mn.nKeySyms = pChanges->map.num_key_syms;
+ mn.firstKeyAct = pChanges->map.first_key_act;
+ mn.nKeyActs = pChanges->map.num_key_acts;
+ mn.firstKeyBehavior = pChanges->map.first_key_behavior;
+ mn.nKeyBehaviors = pChanges->map.num_key_behaviors;
+ mn.virtualMods = pChanges->map.vmods;
+ mn.firstKeyExplicit = pChanges->map.first_key_explicit;
+ mn.nKeyExplicit = pChanges->map.num_key_explicit;
+ mn.firstModMapKey = pChanges->map.first_modmap_key;
+ mn.nModMapKeys = pChanges->map.num_modmap_keys;
+ mn.firstVModMapKey = pChanges->map.first_vmodmap_key;
+ mn.nVModMapKeys = pChanges->map.num_vmodmap_keys;
+ XkbSendMapNotify(kbd, &mn);
}
- if ((pChanges->ctrls.changed_ctrls)||
- (pChanges->ctrls.enabled_ctrls_changes)) {
- xkbControlsNotify cn;
- memset(&cn, 0, sizeof(xkbControlsNotify));
- cn.changedControls= pChanges->ctrls.changed_ctrls;
- cn.enabledControlChanges= pChanges->ctrls.enabled_ctrls_changes;
- cn.keycode= cause->kc;
- cn.eventType= cause->event;
- cn.requestMajor= cause->mjr;
- cn.requestMinor= cause->mnr;
- XkbSendControlsNotify(kbd,&cn);
+ if ((pChanges->ctrls.changed_ctrls) ||
+ (pChanges->ctrls.enabled_ctrls_changes)) {
+ xkbControlsNotify cn;
+
+ memset(&cn, 0, sizeof(xkbControlsNotify));
+ cn.changedControls = pChanges->ctrls.changed_ctrls;
+ cn.enabledControlChanges = pChanges->ctrls.enabled_ctrls_changes;
+ cn.keycode = cause->kc;
+ cn.eventType = cause->event;
+ cn.requestMajor = cause->mjr;
+ cn.requestMinor = cause->mnr;
+ XkbSendControlsNotify(kbd, &cn);
}
if (pChanges->indicators.map_changes) {
- xkbIndicatorNotify in;
- if (sli==NULL)
- sli= XkbFindSrvLedInfo(kbd,XkbDfltXIClass,XkbDfltXIId,0);
- memset(&in, 0, sizeof(xkbIndicatorNotify));
- in.state= sli->effectiveState;
- in.changed= pChanges->indicators.map_changes;
- XkbSendIndicatorNotify(kbd,XkbIndicatorMapNotify,&in);
+ xkbIndicatorNotify in;
+
+ if (sli == NULL)
+ sli = XkbFindSrvLedInfo(kbd, XkbDfltXIClass, XkbDfltXIId, 0);
+ memset(&in, 0, sizeof(xkbIndicatorNotify));
+ in.state = sli->effectiveState;
+ in.changed = pChanges->indicators.map_changes;
+ XkbSendIndicatorNotify(kbd, XkbIndicatorMapNotify, &in);
}
if (pChanges->indicators.state_changes) {
- xkbIndicatorNotify in;
- if (sli==NULL)
- sli= XkbFindSrvLedInfo(kbd,XkbDfltXIClass,XkbDfltXIId,0);
- memset(&in, 0, sizeof(xkbIndicatorNotify));
- in.state= sli->effectiveState;
- in.changed= pChanges->indicators.state_changes;
- XkbSendIndicatorNotify(kbd,XkbIndicatorStateNotify,&in);
+ xkbIndicatorNotify in;
+
+ if (sli == NULL)
+ sli = XkbFindSrvLedInfo(kbd, XkbDfltXIClass, XkbDfltXIId, 0);
+ memset(&in, 0, sizeof(xkbIndicatorNotify));
+ in.state = sli->effectiveState;
+ in.changed = pChanges->indicators.state_changes;
+ XkbSendIndicatorNotify(kbd, XkbIndicatorStateNotify, &in);
}
if (pChanges->names.changed) {
- xkbNamesNotify nn;
- memset(&nn, 0, sizeof(xkbNamesNotify));
- nn.changed= pChanges->names.changed;
- nn.firstType= pChanges->names.first_type;
- nn.nTypes= pChanges->names.num_types;
- nn.firstLevelName= pChanges->names.first_lvl;
- nn.nLevelNames= pChanges->names.num_lvls;
- nn.nRadioGroups= pChanges->names.num_rg;
- nn.changedVirtualMods= pChanges->names.changed_vmods;
- nn.changedIndicators= pChanges->names.changed_indicators;
- XkbSendNamesNotify(kbd,&nn);
+ xkbNamesNotify nn;
+
+ memset(&nn, 0, sizeof(xkbNamesNotify));
+ nn.changed = pChanges->names.changed;
+ nn.firstType = pChanges->names.first_type;
+ nn.nTypes = pChanges->names.num_types;
+ nn.firstLevelName = pChanges->names.first_lvl;
+ nn.nLevelNames = pChanges->names.num_lvls;
+ nn.nRadioGroups = pChanges->names.num_rg;
+ nn.changedVirtualMods = pChanges->names.changed_vmods;
+ nn.changedIndicators = pChanges->names.changed_indicators;
+ XkbSendNamesNotify(kbd, &nn);
}
- if ((pChanges->compat.changed_groups)||(pChanges->compat.num_si>0)) {
- xkbCompatMapNotify cmn;
- memset(&cmn, 0, sizeof(xkbCompatMapNotify));
- cmn.changedGroups= pChanges->compat.changed_groups;
- cmn.firstSI= pChanges->compat.first_si;
- cmn.nSI= pChanges->compat.num_si;
- cmn.nTotalSI= kbd->key->xkbInfo->desc->compat->num_si;
- XkbSendCompatMapNotify(kbd,&cmn);
+ if ((pChanges->compat.changed_groups) || (pChanges->compat.num_si > 0)) {
+ xkbCompatMapNotify cmn;
+
+ memset(&cmn, 0, sizeof(xkbCompatMapNotify));
+ cmn.changedGroups = pChanges->compat.changed_groups;
+ cmn.firstSI = pChanges->compat.first_si;
+ cmn.nSI = pChanges->compat.num_si;
+ cmn.nTotalSI = kbd->key->xkbInfo->desc->compat->num_si;
+ XkbSendCompatMapNotify(kbd, &cmn);
}
return;
}
@@ -891,7 +895,7 @@ XkbSrvLedInfoPtr sli;
/***====================================================================***/
void
-XkbFilterEvents(ClientPtr client,int nEvents,xEvent *xE)
+XkbFilterEvents(ClientPtr client, int nEvents, xEvent *xE)
{
DeviceIntPtr dev = NULL;
XkbSrvInfoPtr xkbi;
@@ -909,76 +913,78 @@ XkbFilterEvents(ClientPtr client,int nEvents,xEvent *xE)
xkbi = dev->key->xkbInfo;
if (client->xkbClientFlags & _XkbClientInitialized) {
- if ((xkbDebugFlags&0x10)&&
+ if ((xkbDebugFlags & 0x10) &&
(type == KeyPress || type == KeyRelease ||
type == DeviceKeyPress || type == DeviceKeyRelease))
- DebugF("[xkb] XkbFilterWriteEvents (XKB client): state 0x%04x\n",
+ DebugF("[xkb] XkbFilterWriteEvents (XKB client): state 0x%04x\n",
xE[0].u.keyButtonPointer.state);
- if (dev->deviceGrab.grab != NullGrab && dev->deviceGrab.fromPassiveGrab &&
- (type == KeyPress || type == KeyRelease ||
- type == DeviceKeyPress || type == DeviceKeyRelease)) {
- unsigned int state, flags;
-
- flags = client->xkbClientFlags;
- state = xkbi->state.compat_grab_mods;
- if (flags & XkbPCF_GrabsUseXKBStateMask) {
- int group;
- if (flags & XkbPCF_LookupStateWhenGrabbed) {
- group = xkbi->state.group;
- state = xkbi->state.lookup_mods;
- }
- else {
- state = xkbi->state.grab_mods;
- group = xkbi->state.base_group + xkbi->state.latched_group;
- if (group < 0 || group >= xkbi->desc->ctrls->num_groups)
- group = XkbAdjustGroup(group, xkbi->desc->ctrls);
- }
- state = XkbBuildCoreState(state, group);
- }
- else if (flags & XkbPCF_LookupStateWhenGrabbed) {
- state = xkbi->state.compat_lookup_mods;
+ if (dev->deviceGrab.grab != NullGrab && dev->deviceGrab.fromPassiveGrab
+ && (type == KeyPress || type == KeyRelease || type == DeviceKeyPress
+ || type == DeviceKeyRelease)) {
+ unsigned int state, flags;
+
+ flags = client->xkbClientFlags;
+ state = xkbi->state.compat_grab_mods;
+ if (flags & XkbPCF_GrabsUseXKBStateMask) {
+ int group;
+
+ if (flags & XkbPCF_LookupStateWhenGrabbed) {
+ group = xkbi->state.group;
+ state = xkbi->state.lookup_mods;
+ }
+ else {
+ state = xkbi->state.grab_mods;
+ group = xkbi->state.base_group + xkbi->state.latched_group;
+ if (group < 0 || group >= xkbi->desc->ctrls->num_groups)
+ group = XkbAdjustGroup(group, xkbi->desc->ctrls);
+ }
+ state = XkbBuildCoreState(state, group);
+ }
+ else if (flags & XkbPCF_LookupStateWhenGrabbed) {
+ state = xkbi->state.compat_lookup_mods;
}
- xE[0].u.keyButtonPointer.state = state;
- }
+ xE[0].u.keyButtonPointer.state = state;
+ }
}
else {
if ((xkbDebugFlags & 0x4) &&
- (xE[0].u.u.type == KeyPress || xE[0].u.u.type==KeyRelease ||
+ (xE[0].u.u.type == KeyPress || xE[0].u.u.type == KeyRelease ||
xE[0].u.u.type == DeviceKeyPress ||
xE[0].u.u.type == DeviceKeyRelease)) {
- DebugF("[xkb] XKbFilterWriteEvents (non-XKB):\n");
- DebugF("[xkb] event= 0x%04x\n",xE[0].u.keyButtonPointer.state);
- DebugF("[xkb] lookup= 0x%02x, grab= 0x%02x\n",
+ DebugF("[xkb] XKbFilterWriteEvents (non-XKB):\n");
+ DebugF("[xkb] event= 0x%04x\n", xE[0].u.keyButtonPointer.state);
+ DebugF("[xkb] lookup= 0x%02x, grab= 0x%02x\n",
xkbi->state.lookup_mods, xkbi->state.grab_mods);
- DebugF("[xkb] compat lookup= 0x%02x, grab= 0x%02x\n",
- xkbi->state.compat_lookup_mods, xkbi->state.compat_grab_mods);
- }
- if (type >= KeyPress && type <= MotionNotify) {
- CARD16 old, new;
-
- old = xE[0].u.keyButtonPointer.state & ~0x1f00;
- new = xE[0].u.keyButtonPointer.state & 0x1F00;
-
- if (old == XkbStateFieldFromRec(&xkbi->state))
- new |= xkbi->state.compat_lookup_mods;
- else
+ DebugF("[xkb] compat lookup= 0x%02x, grab= 0x%02x\n",
+ xkbi->state.compat_lookup_mods,
+ xkbi->state.compat_grab_mods);
+ }
+ if (type >= KeyPress && type <= MotionNotify) {
+ CARD16 old, new;
+
+ old = xE[0].u.keyButtonPointer.state & ~0x1f00;
+ new = xE[0].u.keyButtonPointer.state & 0x1F00;
+
+ if (old == XkbStateFieldFromRec(&xkbi->state))
+ new |= xkbi->state.compat_lookup_mods;
+ else
new |= xkbi->state.compat_grab_mods;
- xE[0].u.keyButtonPointer.state = new;
- }
- else if (type == EnterNotify || type == LeaveNotify) {
- xE[0].u.enterLeave.state &= 0x1F00;
- xE[0].u.enterLeave.state |= xkbi->state.compat_grab_mods;
- }
+ xE[0].u.keyButtonPointer.state = new;
+ }
+ else if (type == EnterNotify || type == LeaveNotify) {
+ xE[0].u.enterLeave.state &= 0x1F00;
+ xE[0].u.enterLeave.state |= xkbi->state.compat_grab_mods;
+ }
else if (type >= DeviceKeyPress && type <= DeviceMotionNotify) {
CARD16 old, new;
- deviceKeyButtonPointer *kbp = (deviceKeyButtonPointer*) &xE[0];
+ deviceKeyButtonPointer *kbp = (deviceKeyButtonPointer *) &xE[0];
old = kbp->state & ~0x1F00;
new = kbp->state & 0x1F00;
- if (old == XkbStateFieldFromRec(&xkbi->state))
- new |= xkbi->state.compat_lookup_mods;
- else
+ if (old == XkbStateFieldFromRec(&xkbi->state))
+ new |= xkbi->state.compat_lookup_mods;
+ else
new |= xkbi->state.compat_grab_mods;
kbp->state = new;
}
@@ -988,92 +994,93 @@ XkbFilterEvents(ClientPtr client,int nEvents,xEvent *xE)
/***====================================================================***/
XkbInterestPtr
-XkbFindClientResource(DevicePtr inDev,ClientPtr client)
+XkbFindClientResource(DevicePtr inDev, ClientPtr client)
{
-DeviceIntPtr dev = (DeviceIntPtr)inDev;
-XkbInterestPtr interest;
-
- if ( dev->xkb_interest ) {
- interest = dev->xkb_interest;
- while (interest){
- if (interest->client==client) {
- return interest;
- }
- interest = interest->next;
- }
+ DeviceIntPtr dev = (DeviceIntPtr) inDev;
+ XkbInterestPtr interest;
+
+ if (dev->xkb_interest) {
+ interest = dev->xkb_interest;
+ while (interest) {
+ if (interest->client == client) {
+ return interest;
+ }
+ interest = interest->next;
+ }
}
return NULL;
}
XkbInterestPtr
-XkbAddClientResource(DevicePtr inDev,ClientPtr client,XID id)
+XkbAddClientResource(DevicePtr inDev, ClientPtr client, XID id)
{
-DeviceIntPtr dev = (DeviceIntPtr)inDev;
-XkbInterestPtr interest;
+ DeviceIntPtr dev = (DeviceIntPtr) inDev;
+ XkbInterestPtr interest;
interest = dev->xkb_interest;
while (interest) {
- if (interest->client==client)
- return ((interest->resource==id)?interest:NULL);
- interest = interest->next;
+ if (interest->client == client)
+ return ((interest->resource == id) ? interest : NULL);
+ interest = interest->next;
}
interest = calloc(1, sizeof(XkbInterestRec));
if (interest) {
- interest->dev = dev;
- interest->client = client;
- interest->resource = id;
- interest->next = dev->xkb_interest;
- dev->xkb_interest= interest;
- return interest;
+ interest->dev = dev;
+ interest->client = client;
+ interest->resource = id;
+ interest->next = dev->xkb_interest;
+ dev->xkb_interest = interest;
+ return interest;
}
return NULL;
}
int
-XkbRemoveResourceClient(DevicePtr inDev,XID id)
+XkbRemoveResourceClient(DevicePtr inDev, XID id)
{
-XkbSrvInfoPtr xkbi;
-DeviceIntPtr dev = (DeviceIntPtr)inDev;
-XkbInterestPtr interest;
-Bool found;
-unsigned long autoCtrls,autoValues;
-ClientPtr client = NULL;
+ XkbSrvInfoPtr xkbi;
+ DeviceIntPtr dev = (DeviceIntPtr) inDev;
+ XkbInterestPtr interest;
+ Bool found;
+ unsigned long autoCtrls, autoValues;
+ ClientPtr client = NULL;
- found= FALSE;
+ found = FALSE;
if (!dev->key || !dev->key->xkbInfo)
return found;
- autoCtrls= autoValues= 0;
- if ( dev->xkb_interest ) {
- interest = dev->xkb_interest;
- if (interest && (interest->resource==id)){
- dev->xkb_interest = interest->next;
- autoCtrls= interest->autoCtrls;
- autoValues= interest->autoCtrlValues;
- client= interest->client;
- free(interest);
- found= TRUE;
- }
- while ((!found)&&(interest->next)) {
- if (interest->next->resource==id) {
- XkbInterestPtr victim = interest->next;
- interest->next = victim->next;
- autoCtrls= victim->autoCtrls;
- autoValues= victim->autoCtrlValues;
- client= victim->client;
- free(victim);
- found= TRUE;
- }
- interest = interest->next;
- }
+ autoCtrls = autoValues = 0;
+ if (dev->xkb_interest) {
+ interest = dev->xkb_interest;
+ if (interest && (interest->resource == id)) {
+ dev->xkb_interest = interest->next;
+ autoCtrls = interest->autoCtrls;
+ autoValues = interest->autoCtrlValues;
+ client = interest->client;
+ free(interest);
+ found = TRUE;
+ }
+ while ((!found) && (interest->next)) {
+ if (interest->next->resource == id) {
+ XkbInterestPtr victim = interest->next;
+
+ interest->next = victim->next;
+ autoCtrls = victim->autoCtrls;
+ autoValues = victim->autoCtrlValues;
+ client = victim->client;
+ free(victim);
+ found = TRUE;
+ }
+ interest = interest->next;
+ }
}
- if (found && autoCtrls && dev->key && dev->key->xkbInfo ) {
- XkbEventCauseRec cause;
+ if (found && autoCtrls && dev->key && dev->key->xkbInfo) {
+ XkbEventCauseRec cause;
- xkbi= dev->key->xkbInfo;
- XkbSetCauseXkbReq(&cause,X_kbPerClientFlags,client);
- XkbEnableDisableControls(xkbi,autoCtrls,autoValues,NULL,&cause);
+ xkbi = dev->key->xkbInfo;
+ XkbSetCauseXkbReq(&cause, X_kbPerClientFlags, client);
+ XkbEnableDisableControls(xkbi, autoCtrls, autoValues, NULL, &cause);
}
return found;
}
diff --git a/xkb/xkbInit.c b/xkb/xkbInit.c
index f578f1679..4e8e267da 100644
--- a/xkb/xkbInit.c
+++ b/xkb/xkbInit.c
@@ -75,38 +75,37 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#endif
#define MAX_TOC 16
-typedef struct _SrvXkmInfo {
- DeviceIntPtr dev;
- FILE * file;
- XkbDescPtr xkb;
+typedef struct _SrvXkmInfo {
+ DeviceIntPtr dev;
+ FILE *file;
+ XkbDescPtr xkb;
} SrvXkmInfo;
-
/***====================================================================***/
#ifndef XKB_DFLT_RULES_PROP
#define XKB_DFLT_RULES_PROP TRUE
#endif
-const char * XkbBaseDirectory= XKB_BASE_DIRECTORY;
-const char * XkbBinDirectory= XKB_BIN_DIRECTORY;
-static int XkbWantAccessX= 0;
+const char *XkbBaseDirectory = XKB_BASE_DIRECTORY;
+const char *XkbBinDirectory = XKB_BIN_DIRECTORY;
+static int XkbWantAccessX = 0;
-static char * XkbRulesDflt= NULL;
-static char * XkbModelDflt= NULL;
-static char * XkbLayoutDflt= NULL;
-static char * XkbVariantDflt= NULL;
-static char * XkbOptionsDflt= NULL;
+static char *XkbRulesDflt = NULL;
+static char *XkbModelDflt = NULL;
+static char *XkbLayoutDflt = NULL;
+static char *XkbVariantDflt = NULL;
+static char *XkbOptionsDflt = NULL;
-static char * XkbRulesUsed= NULL;
-static char * XkbModelUsed= NULL;
-static char * XkbLayoutUsed= NULL;
-static char * XkbVariantUsed= NULL;
-static char * XkbOptionsUsed= NULL;
+static char *XkbRulesUsed = NULL;
+static char *XkbModelUsed = NULL;
+static char *XkbLayoutUsed = NULL;
+static char *XkbVariantUsed = NULL;
+static char *XkbOptionsUsed = NULL;
-static XkbDescPtr xkb_cached_map = NULL;
+static XkbDescPtr xkb_cached_map = NULL;
-static Bool XkbWantRulesProp= XKB_DFLT_RULES_PROP;
+static Bool XkbWantRulesProp = XKB_DFLT_RULES_PROP;
/***====================================================================***/
@@ -115,17 +114,17 @@ static Bool XkbWantRulesProp= XKB_DFLT_RULES_PROP;
* Caller must free the data in rmlvo.
*/
void
-XkbGetRulesDflts(XkbRMLVOSet *rmlvo)
+XkbGetRulesDflts(XkbRMLVOSet * rmlvo)
{
- rmlvo->rules = strdup(XkbRulesDflt ? XkbRulesDflt : XKB_DFLT_RULES);
- rmlvo->model = strdup(XkbModelDflt ? XkbModelDflt : XKB_DFLT_MODEL);
- rmlvo->layout = strdup(XkbLayoutDflt ? XkbLayoutDflt : XKB_DFLT_LAYOUT);
- rmlvo->variant= strdup(XkbVariantDflt ? XkbVariantDflt : XKB_DFLT_VARIANT);
- rmlvo->options= strdup(XkbOptionsDflt ? XkbOptionsDflt : XKB_DFLT_OPTIONS);
+ rmlvo->rules = strdup(XkbRulesDflt ? XkbRulesDflt : XKB_DFLT_RULES);
+ rmlvo->model = strdup(XkbModelDflt ? XkbModelDflt : XKB_DFLT_MODEL);
+ rmlvo->layout = strdup(XkbLayoutDflt ? XkbLayoutDflt : XKB_DFLT_LAYOUT);
+ rmlvo->variant = strdup(XkbVariantDflt ? XkbVariantDflt : XKB_DFLT_VARIANT);
+ rmlvo->options = strdup(XkbOptionsDflt ? XkbOptionsDflt : XKB_DFLT_OPTIONS);
}
void
-XkbFreeRMLVOSet(XkbRMLVOSet *rmlvo, Bool freeRMLVO)
+XkbFreeRMLVOSet(XkbRMLVOSet * rmlvo, Bool freeRMLVO)
{
if (!rmlvo)
return;
@@ -145,107 +144,108 @@ XkbFreeRMLVOSet(XkbRMLVOSet *rmlvo, Bool freeRMLVO)
static Bool
XkbWriteRulesProp(ClientPtr client, pointer closure)
{
-int len,out;
-Atom name;
-char * pval;
-
- len= (XkbRulesUsed?strlen(XkbRulesUsed):0);
- len+= (XkbModelUsed?strlen(XkbModelUsed):0);
- len+= (XkbLayoutUsed?strlen(XkbLayoutUsed):0);
- len+= (XkbVariantUsed?strlen(XkbVariantUsed):0);
- len+= (XkbOptionsUsed?strlen(XkbOptionsUsed):0);
- if (len<1)
- return TRUE;
-
- len+= 5; /* trailing NULs */
-
- name= MakeAtom(_XKB_RF_NAMES_PROP_ATOM,strlen(_XKB_RF_NAMES_PROP_ATOM),1);
- if (name==None) {
- ErrorF("[xkb] Atom error: %s not created\n",_XKB_RF_NAMES_PROP_ATOM);
- return TRUE;
- }
- pval= (char*) malloc(len);
+ int len, out;
+ Atom name;
+ char *pval;
+
+ len = (XkbRulesUsed ? strlen(XkbRulesUsed) : 0);
+ len += (XkbModelUsed ? strlen(XkbModelUsed) : 0);
+ len += (XkbLayoutUsed ? strlen(XkbLayoutUsed) : 0);
+ len += (XkbVariantUsed ? strlen(XkbVariantUsed) : 0);
+ len += (XkbOptionsUsed ? strlen(XkbOptionsUsed) : 0);
+ if (len < 1)
+ return TRUE;
+
+ len += 5; /* trailing NULs */
+
+ name =
+ MakeAtom(_XKB_RF_NAMES_PROP_ATOM, strlen(_XKB_RF_NAMES_PROP_ATOM), 1);
+ if (name == None) {
+ ErrorF("[xkb] Atom error: %s not created\n", _XKB_RF_NAMES_PROP_ATOM);
+ return TRUE;
+ }
+ pval = (char *) malloc(len);
if (!pval) {
- ErrorF("[xkb] Allocation error: %s proprerty not created\n",
- _XKB_RF_NAMES_PROP_ATOM);
- return TRUE;
+ ErrorF("[xkb] Allocation error: %s proprerty not created\n",
+ _XKB_RF_NAMES_PROP_ATOM);
+ return TRUE;
}
- out= 0;
+ out = 0;
if (XkbRulesUsed) {
- strcpy(&pval[out],XkbRulesUsed);
- out+= strlen(XkbRulesUsed);
+ strcpy(&pval[out], XkbRulesUsed);
+ out += strlen(XkbRulesUsed);
}
- pval[out++]= '\0';
+ pval[out++] = '\0';
if (XkbModelUsed) {
- strcpy(&pval[out],XkbModelUsed);
- out+= strlen(XkbModelUsed);
- }
- pval[out++]= '\0';
+ strcpy(&pval[out], XkbModelUsed);
+ out += strlen(XkbModelUsed);
+ }
+ pval[out++] = '\0';
if (XkbLayoutUsed) {
- strcpy(&pval[out],XkbLayoutUsed);
- out+= strlen(XkbLayoutUsed);
+ strcpy(&pval[out], XkbLayoutUsed);
+ out += strlen(XkbLayoutUsed);
}
- pval[out++]= '\0';
+ pval[out++] = '\0';
if (XkbVariantUsed) {
- strcpy(&pval[out],XkbVariantUsed);
- out+= strlen(XkbVariantUsed);
+ strcpy(&pval[out], XkbVariantUsed);
+ out += strlen(XkbVariantUsed);
}
- pval[out++]= '\0';
+ pval[out++] = '\0';
if (XkbOptionsUsed) {
- strcpy(&pval[out],XkbOptionsUsed);
- out+= strlen(XkbOptionsUsed);
+ strcpy(&pval[out], XkbOptionsUsed);
+ out += strlen(XkbOptionsUsed);
}
- pval[out++]= '\0';
- if (out!=len) {
- ErrorF("[xkb] Internal Error! bad size (%d!=%d) for _XKB_RULES_NAMES\n",
- out,len);
+ pval[out++] = '\0';
+ if (out != len) {
+ ErrorF("[xkb] Internal Error! bad size (%d!=%d) for _XKB_RULES_NAMES\n",
+ out, len);
}
- dixChangeWindowProperty(serverClient, screenInfo.screens[0]->root, name, XA_STRING, 8,
- PropModeReplace, len, pval, TRUE);
+ dixChangeWindowProperty(serverClient, screenInfo.screens[0]->root, name,
+ XA_STRING, 8, PropModeReplace, len, pval, TRUE);
free(pval);
return TRUE;
}
static void
-XkbSetRulesUsed(XkbRMLVOSet *rmlvo)
+XkbSetRulesUsed(XkbRMLVOSet * rmlvo)
{
free(XkbRulesUsed);
- XkbRulesUsed= (rmlvo->rules?Xstrdup(rmlvo->rules):NULL);
+ XkbRulesUsed = (rmlvo->rules ? Xstrdup(rmlvo->rules) : NULL);
free(XkbModelUsed);
- XkbModelUsed= (rmlvo->model?Xstrdup(rmlvo->model):NULL);
+ XkbModelUsed = (rmlvo->model ? Xstrdup(rmlvo->model) : NULL);
free(XkbLayoutUsed);
- XkbLayoutUsed= (rmlvo->layout?Xstrdup(rmlvo->layout):NULL);
+ XkbLayoutUsed = (rmlvo->layout ? Xstrdup(rmlvo->layout) : NULL);
free(XkbVariantUsed);
- XkbVariantUsed= (rmlvo->variant?Xstrdup(rmlvo->variant):NULL);
+ XkbVariantUsed = (rmlvo->variant ? Xstrdup(rmlvo->variant) : NULL);
free(XkbOptionsUsed);
- XkbOptionsUsed= (rmlvo->options?Xstrdup(rmlvo->options):NULL);
+ XkbOptionsUsed = (rmlvo->options ? Xstrdup(rmlvo->options) : NULL);
if (XkbWantRulesProp)
- QueueWorkProc(XkbWriteRulesProp,NULL,NULL);
+ QueueWorkProc(XkbWriteRulesProp, NULL, NULL);
return;
}
void
-XkbSetRulesDflts(XkbRMLVOSet *rmlvo)
+XkbSetRulesDflts(XkbRMLVOSet * rmlvo)
{
if (rmlvo->rules) {
free(XkbRulesDflt);
- XkbRulesDflt= Xstrdup(rmlvo->rules);
+ XkbRulesDflt = Xstrdup(rmlvo->rules);
}
if (rmlvo->model) {
- free(XkbModelDflt);
- XkbModelDflt= Xstrdup(rmlvo->model);
+ free(XkbModelDflt);
+ XkbModelDflt = Xstrdup(rmlvo->model);
}
if (rmlvo->layout) {
- free(XkbLayoutDflt);
- XkbLayoutDflt= Xstrdup(rmlvo->layout);
+ free(XkbLayoutDflt);
+ XkbLayoutDflt = Xstrdup(rmlvo->layout);
}
if (rmlvo->variant) {
- free(XkbVariantDflt);
- XkbVariantDflt= Xstrdup(rmlvo->variant);
+ free(XkbVariantDflt);
+ XkbVariantDflt = Xstrdup(rmlvo->variant);
}
if (rmlvo->options) {
- free(XkbOptionsDflt);
- XkbOptionsDflt= Xstrdup(rmlvo->options);
+ free(XkbOptionsDflt);
+ XkbOptionsDflt = Xstrdup(rmlvo->options);
}
return;
}
@@ -271,7 +271,7 @@ XkbDeleteRulesDflts(void)
#define DIFFERS(a, b) (strcmp((a) ? (a) : "", (b) ? (b) : "") != 0)
static Bool
-XkbCompareUsedRMLVO(XkbRMLVOSet *rmlvo)
+XkbCompareUsedRMLVO(XkbRMLVOSet * rmlvo)
{
if (DIFFERS(rmlvo->rules, XkbRulesUsed) ||
DIFFERS(rmlvo->model, XkbModelUsed) ||
@@ -295,13 +295,12 @@ XkbInitKeyTypes(XkbDescPtr xkb)
return TRUE;
initTypeNames(NULL);
- if (XkbAllocClientMap(xkb,XkbKeyTypesMask,num_dflt_types)!=Success)
- return FALSE;
- if (XkbCopyKeyTypes(dflt_types,xkb->map->types,num_dflt_types)!=
- Success) {
- return FALSE;
+ if (XkbAllocClientMap(xkb, XkbKeyTypesMask, num_dflt_types) != Success)
+ return FALSE;
+ if (XkbCopyKeyTypes(dflt_types, xkb->map->types, num_dflt_types) != Success) {
+ return FALSE;
}
- xkb->map->size_types= xkb->map->num_types= num_dflt_types;
+ xkb->map->size_types = xkb->map->num_types = num_dflt_types;
return TRUE;
}
@@ -313,31 +312,32 @@ XkbInitRadioGroups(XkbSrvInfoPtr xkbi)
return;
}
-
static Status
XkbInitCompatStructs(XkbDescPtr xkb)
{
-register int i;
-XkbCompatMapPtr compat;
+ register int i;
+ XkbCompatMapPtr compat;
if (xkb->defined & XkmCompatMapMask)
return TRUE;
- if (XkbAllocCompatMap(xkb,XkbAllCompatMask,num_dfltSI)!=Success)
- return BadAlloc;
+ if (XkbAllocCompatMap(xkb, XkbAllCompatMask, num_dfltSI) != Success)
+ return BadAlloc;
compat = xkb->compat;
if (compat->sym_interpret) {
- compat->num_si = num_dfltSI;
- memcpy((char *)compat->sym_interpret,(char *)dfltSI,sizeof(dfltSI));
- }
- for (i=0;i<XkbNumKbdGroups;i++) {
- compat->groups[i]= compatMap.groups[i];
- if (compat->groups[i].vmods!=0) {
- unsigned mask;
- mask= XkbMaskForVMask(xkb,compat->groups[i].vmods);
- compat->groups[i].mask= compat->groups[i].real_mods|mask;
- }
- else compat->groups[i].mask= compat->groups[i].real_mods;
+ compat->num_si = num_dfltSI;
+ memcpy((char *) compat->sym_interpret, (char *) dfltSI, sizeof(dfltSI));
+ }
+ for (i = 0; i < XkbNumKbdGroups; i++) {
+ compat->groups[i] = compatMap.groups[i];
+ if (compat->groups[i].vmods != 0) {
+ unsigned mask;
+
+ mask = XkbMaskForVMask(xkb, compat->groups[i].vmods);
+ compat->groups[i].mask = compat->groups[i].real_mods | mask;
+ }
+ else
+ compat->groups[i].mask = compat->groups[i].real_mods;
}
return Success;
}
@@ -355,49 +355,56 @@ XkbInitSemantics(XkbDescPtr xkb)
static Status
XkbInitNames(XkbSrvInfoPtr xkbi)
{
-XkbDescPtr xkb;
-XkbNamesPtr names;
-Status rtrn;
-Atom unknown;
-
- xkb= xkbi->desc;
- if ((rtrn=XkbAllocNames(xkb,XkbAllNamesMask,0,0))!=Success)
- return rtrn;
- unknown= CREATE_ATOM("unknown");
+ XkbDescPtr xkb;
+ XkbNamesPtr names;
+ Status rtrn;
+ Atom unknown;
+
+ xkb = xkbi->desc;
+ if ((rtrn = XkbAllocNames(xkb, XkbAllNamesMask, 0, 0)) != Success)
+ return rtrn;
+ unknown = CREATE_ATOM("unknown");
names = xkb->names;
- if (names->keycodes==None) names->keycodes= unknown;
- if (names->geometry==None) names->geometry= unknown;
- if (names->phys_symbols==None) names->phys_symbols= unknown;
- if (names->symbols==None) names->symbols= unknown;
- if (names->types==None) names->types= unknown;
- if (names->compat==None) names->compat= unknown;
+ if (names->keycodes == None)
+ names->keycodes = unknown;
+ if (names->geometry == None)
+ names->geometry = unknown;
+ if (names->phys_symbols == None)
+ names->phys_symbols = unknown;
+ if (names->symbols == None)
+ names->symbols = unknown;
+ if (names->types == None)
+ names->types = unknown;
+ if (names->compat == None)
+ names->compat = unknown;
if (!(xkb->defined & XkmVirtualModsMask)) {
- if (names->vmods[vmod_NumLock]==None)
- names->vmods[vmod_NumLock]= CREATE_ATOM("NumLock");
- if (names->vmods[vmod_Alt]==None)
- names->vmods[vmod_Alt]= CREATE_ATOM("Alt");
- if (names->vmods[vmod_AltGr]==None)
- names->vmods[vmod_AltGr]= CREATE_ATOM("ModeSwitch");
+ if (names->vmods[vmod_NumLock] == None)
+ names->vmods[vmod_NumLock] = CREATE_ATOM("NumLock");
+ if (names->vmods[vmod_Alt] == None)
+ names->vmods[vmod_Alt] = CREATE_ATOM("Alt");
+ if (names->vmods[vmod_AltGr] == None)
+ names->vmods[vmod_AltGr] = CREATE_ATOM("ModeSwitch");
}
if (!(xkb->defined & XkmIndicatorsMask) ||
!(xkb->defined & XkmGeometryMask)) {
- initIndicatorNames(NULL,xkb);
- if (names->indicators[LED_CAPS-1]==None)
- names->indicators[LED_CAPS-1] = CREATE_ATOM("Caps Lock");
- if (names->indicators[LED_NUM-1]==None)
- names->indicators[LED_NUM-1] = CREATE_ATOM("Num Lock");
- if (names->indicators[LED_SCROLL-1]==None)
- names->indicators[LED_SCROLL-1] = CREATE_ATOM("Scroll Lock");
+ initIndicatorNames(NULL, xkb);
+ if (names->indicators[LED_CAPS - 1] == None)
+ names->indicators[LED_CAPS - 1] = CREATE_ATOM("Caps Lock");
+ if (names->indicators[LED_NUM - 1] == None)
+ names->indicators[LED_NUM - 1] = CREATE_ATOM("Num Lock");
+ if (names->indicators[LED_SCROLL - 1] == None)
+ names->indicators[LED_SCROLL - 1] = CREATE_ATOM("Scroll Lock");
#ifdef LED_COMPOSE
- if (names->indicators[LED_COMPOSE-1]==None)
- names->indicators[LED_COMPOSE-1] = CREATE_ATOM("Compose");
+ if (names->indicators[LED_COMPOSE - 1] == None)
+ names->indicators[LED_COMPOSE - 1] = CREATE_ATOM("Compose");
#endif
}
- if (xkb->geom!=NULL)
- names->geometry= xkb->geom->name;
- else names->geometry= unknown;
+ if (xkb->geom != NULL)
+ names->geometry = xkb->geom->name;
+ else
+ names->geometry = unknown;
return Success;
}
@@ -405,75 +412,74 @@ Atom unknown;
static Status
XkbInitIndicatorMap(XkbSrvInfoPtr xkbi)
{
-XkbDescPtr xkb;
-XkbIndicatorPtr map;
-XkbSrvLedInfoPtr sli;
+ XkbDescPtr xkb;
+ XkbIndicatorPtr map;
+ XkbSrvLedInfoPtr sli;
- xkb= xkbi->desc;
- if (XkbAllocIndicatorMaps(xkb)!=Success)
- return BadAlloc;
+ xkb = xkbi->desc;
+ if (XkbAllocIndicatorMaps(xkb) != Success)
+ return BadAlloc;
if (!(xkb->defined & XkmIndicatorsMask)) {
- map= xkb->indicators;
+ map = xkb->indicators;
map->phys_indicators = PHYS_LEDS;
- map->maps[LED_CAPS-1].flags= XkbIM_NoExplicit;
- map->maps[LED_CAPS-1].which_mods= XkbIM_UseLocked;
- map->maps[LED_CAPS-1].mods.mask= LockMask;
- map->maps[LED_CAPS-1].mods.real_mods= LockMask;
+ map->maps[LED_CAPS - 1].flags = XkbIM_NoExplicit;
+ map->maps[LED_CAPS - 1].which_mods = XkbIM_UseLocked;
+ map->maps[LED_CAPS - 1].mods.mask = LockMask;
+ map->maps[LED_CAPS - 1].mods.real_mods = LockMask;
- map->maps[LED_NUM-1].flags= XkbIM_NoExplicit;
- map->maps[LED_NUM-1].which_mods= XkbIM_UseLocked;
- map->maps[LED_NUM-1].mods.mask= 0;
- map->maps[LED_NUM-1].mods.real_mods= 0;
- map->maps[LED_NUM-1].mods.vmods= vmod_NumLockMask;
+ map->maps[LED_NUM - 1].flags = XkbIM_NoExplicit;
+ map->maps[LED_NUM - 1].which_mods = XkbIM_UseLocked;
+ map->maps[LED_NUM - 1].mods.mask = 0;
+ map->maps[LED_NUM - 1].mods.real_mods = 0;
+ map->maps[LED_NUM - 1].mods.vmods = vmod_NumLockMask;
- map->maps[LED_SCROLL-1].flags= XkbIM_NoExplicit;
- map->maps[LED_SCROLL-1].which_mods= XkbIM_UseLocked;
- map->maps[LED_SCROLL-1].mods.mask= Mod3Mask;
- map->maps[LED_SCROLL-1].mods.real_mods= Mod3Mask;
+ map->maps[LED_SCROLL - 1].flags = XkbIM_NoExplicit;
+ map->maps[LED_SCROLL - 1].which_mods = XkbIM_UseLocked;
+ map->maps[LED_SCROLL - 1].mods.mask = Mod3Mask;
+ map->maps[LED_SCROLL - 1].mods.real_mods = Mod3Mask;
}
- sli= XkbFindSrvLedInfo(xkbi->device,XkbDfltXIClass,XkbDfltXIId,0);
+ sli = XkbFindSrvLedInfo(xkbi->device, XkbDfltXIClass, XkbDfltXIId, 0);
if (sli)
- XkbCheckIndicatorMaps(xkbi->device,sli,XkbAllIndicatorsMask);
+ XkbCheckIndicatorMaps(xkbi->device, sli, XkbAllIndicatorsMask);
return Success;
}
static Status
-XkbInitControls(DeviceIntPtr pXDev,XkbSrvInfoPtr xkbi)
+XkbInitControls(DeviceIntPtr pXDev, XkbSrvInfoPtr xkbi)
{
-XkbDescPtr xkb;
-XkbControlsPtr ctrls;
+ XkbDescPtr xkb;
+ XkbControlsPtr ctrls;
- xkb= xkbi->desc;
+ xkb = xkbi->desc;
/* 12/31/94 (ef) -- XXX! Should check if controls loaded from file */
- if (XkbAllocControls(xkb,XkbAllControlsMask)!=Success)
- FatalError("Couldn't allocate keyboard controls\n");
- ctrls= xkb->ctrls;
+ if (XkbAllocControls(xkb, XkbAllControlsMask) != Success)
+ FatalError("Couldn't allocate keyboard controls\n");
+ ctrls = xkb->ctrls;
if (!(xkb->defined & XkmSymbolsMask))
ctrls->num_groups = 1;
- ctrls->groups_wrap = XkbSetGroupInfo(1,XkbWrapIntoRange,0);
+ ctrls->groups_wrap = XkbSetGroupInfo(1, XkbWrapIntoRange, 0);
ctrls->internal.mask = 0;
ctrls->internal.real_mods = 0;
ctrls->internal.vmods = 0;
ctrls->ignore_lock.mask = 0;
ctrls->ignore_lock.real_mods = 0;
ctrls->ignore_lock.vmods = 0;
- ctrls->enabled_ctrls = XkbAccessXTimeoutMask|XkbRepeatKeysMask|
- XkbMouseKeysAccelMask|XkbAudibleBellMask|
- XkbIgnoreGroupLockMask;
+ ctrls->enabled_ctrls = XkbAccessXTimeoutMask | XkbRepeatKeysMask |
+ XkbMouseKeysAccelMask | XkbAudibleBellMask | XkbIgnoreGroupLockMask;
if (XkbWantAccessX)
- ctrls->enabled_ctrls|= XkbAccessXKeysMask;
+ ctrls->enabled_ctrls |= XkbAccessXKeysMask;
AccessXInit(pXDev);
return Success;
}
_X_EXPORT Bool
-InitKeyboardDeviceStruct(DeviceIntPtr dev, XkbRMLVOSet *rmlvo,
+InitKeyboardDeviceStruct(DeviceIntPtr dev, XkbRMLVOSet * rmlvo,
BellProcPtr bell_func, KbdCtrlProcPtr ctrl_func)
{
- int i;
+ int i;
unsigned int check;
XkbSrvInfoPtr xkbi;
XkbDescPtr xkb;
@@ -483,15 +489,13 @@ InitKeyboardDeviceStruct(DeviceIntPtr dev, XkbRMLVOSet *rmlvo,
XkbRMLVOSet rmlvo_dflts = { NULL };
if (dev->key || dev->kbdfeed)
- return FALSE;
+ return FALSE;
- if (!rmlvo)
- {
+ if (!rmlvo) {
rmlvo = &rmlvo_dflts;
XkbGetRulesDflts(rmlvo);
}
-
memset(&changes, 0, sizeof(changes));
XkbSetCauseUnknown(&cause);
@@ -585,11 +589,11 @@ InitKeyboardDeviceStruct(DeviceIntPtr dev, XkbRMLVOSet *rmlvo,
sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
if (sli)
- XkbCheckIndicatorMaps(dev, sli, XkbAllIndicatorsMask);
+ XkbCheckIndicatorMaps(dev, sli, XkbAllIndicatorsMask);
else
DebugF("XKB: No indicator feedback in XkbFinishInit!\n");
- dev->kbdfeed->CtrlProc(dev,&dev->kbdfeed->ctrl);
+ dev->kbdfeed->CtrlProc(dev, &dev->kbdfeed->ctrl);
XkbSetRulesDflts(rmlvo);
XkbSetRulesUsed(rmlvo);
@@ -597,63 +601,62 @@ InitKeyboardDeviceStruct(DeviceIntPtr dev, XkbRMLVOSet *rmlvo,
return TRUE;
-unwind_desc:
+ unwind_desc:
XkbFreeKeyboard(xkb, 0, TRUE);
-unwind_info:
+ unwind_info:
free(xkbi);
dev->key->xkbInfo = NULL;
-unwind_kbdfeed:
+ unwind_kbdfeed:
free(dev->kbdfeed);
dev->kbdfeed = NULL;
-unwind_key:
+ unwind_key:
free(dev->key);
dev->key = NULL;
return FALSE;
}
-
/***====================================================================***/
- /*
- * Be very careful about what does and doesn't get freed by this
- * function. To reduce fragmentation, XkbInitDevice allocates a
- * single huge block per device and divides it up into most of the
- * fixed-size structures for the device. Don't free anything that
- * is part of this larger block.
- */
+ /*
+ * Be very careful about what does and doesn't get freed by this
+ * function. To reduce fragmentation, XkbInitDevice allocates a
+ * single huge block per device and divides it up into most of the
+ * fixed-size structures for the device. Don't free anything that
+ * is part of this larger block.
+ */
void
XkbFreeInfo(XkbSrvInfoPtr xkbi)
{
free(xkbi->radioGroups);
xkbi->radioGroups = NULL;
if (xkbi->mouseKeyTimer) {
- TimerFree(xkbi->mouseKeyTimer);
- xkbi->mouseKeyTimer= NULL;
+ TimerFree(xkbi->mouseKeyTimer);
+ xkbi->mouseKeyTimer = NULL;
}
if (xkbi->slowKeysTimer) {
- TimerFree(xkbi->slowKeysTimer);
- xkbi->slowKeysTimer= NULL;
+ TimerFree(xkbi->slowKeysTimer);
+ xkbi->slowKeysTimer = NULL;
}
if (xkbi->bounceKeysTimer) {
- TimerFree(xkbi->bounceKeysTimer);
- xkbi->bounceKeysTimer= NULL;
+ TimerFree(xkbi->bounceKeysTimer);
+ xkbi->bounceKeysTimer = NULL;
}
if (xkbi->repeatKeyTimer) {
- TimerFree(xkbi->repeatKeyTimer);
- xkbi->repeatKeyTimer= NULL;
+ TimerFree(xkbi->repeatKeyTimer);
+ xkbi->repeatKeyTimer = NULL;
}
if (xkbi->krgTimer) {
- TimerFree(xkbi->krgTimer);
- xkbi->krgTimer= NULL;
+ TimerFree(xkbi->krgTimer);
+ xkbi->krgTimer = NULL;
}
- xkbi->beepType= _BEEP_NONE;
+ xkbi->beepType = _BEEP_NONE;
if (xkbi->beepTimer) {
- TimerFree(xkbi->beepTimer);
- xkbi->beepTimer= NULL;
+ TimerFree(xkbi->beepTimer);
+ xkbi->beepTimer = NULL;
}
if (xkbi->desc) {
- XkbFreeKeyboard(xkbi->desc,XkbAllComponentsMask,TRUE);
- xkbi->desc= NULL;
+ XkbFreeKeyboard(xkbi->desc, XkbAllComponentsMask, TRUE);
+ xkbi->desc = NULL;
}
free(xkbi);
return;
@@ -661,88 +664,92 @@ XkbFreeInfo(XkbSrvInfoPtr xkbi)
/***====================================================================***/
-extern int XkbDfltRepeatDelay;
-extern int XkbDfltRepeatInterval;
+extern int XkbDfltRepeatDelay;
+extern int XkbDfltRepeatInterval;
-extern unsigned short XkbDfltAccessXTimeout;
-extern unsigned int XkbDfltAccessXTimeoutMask;
-extern unsigned int XkbDfltAccessXFeedback;
-extern unsigned char XkbDfltAccessXOptions;
+extern unsigned short XkbDfltAccessXTimeout;
+extern unsigned int XkbDfltAccessXTimeoutMask;
+extern unsigned int XkbDfltAccessXFeedback;
+extern unsigned char XkbDfltAccessXOptions;
int
-XkbProcessArguments(int argc,char *argv[],int i)
+XkbProcessArguments(int argc, char *argv[], int i)
{
if (strncmp(argv[i], "-xkbdir", 7) == 0) {
- if(++i < argc) {
+ if (++i < argc) {
#if !defined(WIN32) && !defined(__CYGWIN__)
- if (getuid() != geteuid()) {
- LogMessage(X_WARNING, "-xkbdir is not available for setuid X servers\n");
- return -1;
- } else
+ if (getuid() != geteuid()) {
+ LogMessage(X_WARNING,
+ "-xkbdir is not available for setuid X servers\n");
+ return -1;
+ }
+ else
#endif
- {
- if (strlen(argv[i]) < PATH_MAX) {
- XkbBaseDirectory= argv[i];
- return 2;
- } else {
- LogMessage(X_ERROR, "-xkbdir pathname too long\n");
- return -1;
- }
- }
- }
- else {
- return -1;
- }
- }
- else if ((strncmp(argv[i],"-accessx",8)==0)||
- (strncmp(argv[i],"+accessx",8)==0)) {
- int j=1;
- if (argv[i][0]=='-')
- XkbWantAccessX= 0;
- else {
- XkbWantAccessX= 1;
-
- if ( ((i+1)<argc) && (isdigit(argv[i+1][0])) ) {
- XkbDfltAccessXTimeout = atoi(argv[++i]);
- j++;
-
- if ( ((i+1)<argc) && (isdigit(argv[i+1][0])) ) {
- /*
- * presumption that the reasonably useful range of
- * values fits in 0..MAXINT since SunOS 4 doesn't
- * have strtoul.
- */
- XkbDfltAccessXTimeoutMask=(unsigned int)
- strtol(argv[++i],NULL,16);
- j++;
- }
- if ( ((i+1)<argc) && (isdigit(argv[i+1][0])) ) {
- if (argv[++i][0] == '1' )
- XkbDfltAccessXFeedback=XkbAccessXFeedbackMask;
- else
- XkbDfltAccessXFeedback=0;
- j++;
- }
- if ( ((i+1)<argc) && (isdigit(argv[i+1][0])) ) {
- XkbDfltAccessXOptions=(unsigned char)
- strtol(argv[++i],NULL,16);
- j++;
- }
- }
- }
- return j;
- }
- if ((strcmp(argv[i], "-ardelay") == 0) ||
- (strcmp (argv[i], "-ar1") == 0)) { /* -ardelay int */
- if (++i >= argc) UseMsg ();
- XkbDfltRepeatDelay = (long)atoi(argv[i]);
- return 2;
- }
- if ((strcmp(argv[i], "-arinterval") == 0) ||
- (strcmp (argv[i], "-ar2") == 0)) { /* -arinterval int */
- if (++i >= argc) UseMsg ();
- XkbDfltRepeatInterval = (long)atoi(argv[i]);
- return 2;
+ {
+ if (strlen(argv[i]) < PATH_MAX) {
+ XkbBaseDirectory = argv[i];
+ return 2;
+ }
+ else {
+ LogMessage(X_ERROR, "-xkbdir pathname too long\n");
+ return -1;
+ }
+ }
+ }
+ else {
+ return -1;
+ }
+ }
+ else if ((strncmp(argv[i], "-accessx", 8) == 0) ||
+ (strncmp(argv[i], "+accessx", 8) == 0)) {
+ int j = 1;
+
+ if (argv[i][0] == '-')
+ XkbWantAccessX = 0;
+ else {
+ XkbWantAccessX = 1;
+
+ if (((i + 1) < argc) && (isdigit(argv[i + 1][0]))) {
+ XkbDfltAccessXTimeout = atoi(argv[++i]);
+ j++;
+
+ if (((i + 1) < argc) && (isdigit(argv[i + 1][0]))) {
+ /*
+ * presumption that the reasonably useful range of
+ * values fits in 0..MAXINT since SunOS 4 doesn't
+ * have strtoul.
+ */
+ XkbDfltAccessXTimeoutMask = (unsigned int)
+ strtol(argv[++i], NULL, 16);
+ j++;
+ }
+ if (((i + 1) < argc) && (isdigit(argv[i + 1][0]))) {
+ if (argv[++i][0] == '1')
+ XkbDfltAccessXFeedback = XkbAccessXFeedbackMask;
+ else
+ XkbDfltAccessXFeedback = 0;
+ j++;
+ }
+ if (((i + 1) < argc) && (isdigit(argv[i + 1][0]))) {
+ XkbDfltAccessXOptions = (unsigned char)
+ strtol(argv[++i], NULL, 16);
+ j++;
+ }
+ }
+ }
+ return j;
+ }
+ if ((strcmp(argv[i], "-ardelay") == 0) || (strcmp(argv[i], "-ar1") == 0)) { /* -ardelay int */
+ if (++i >= argc)
+ UseMsg();
+ XkbDfltRepeatDelay = (long) atoi(argv[i]);
+ return 2;
+ }
+ if ((strcmp(argv[i], "-arinterval") == 0) || (strcmp(argv[i], "-ar2") == 0)) { /* -arinterval int */
+ if (++i >= argc)
+ UseMsg();
+ XkbDfltRepeatInterval = (long) atoi(argv[i]);
+ return 2;
}
return 0;
}
@@ -750,7 +757,8 @@ XkbProcessArguments(int argc,char *argv[],int i)
void
XkbUseMsg(void)
{
- ErrorF("[+-]accessx [ timeout [ timeout_mask [ feedback [ options_mask] ] ] ]\n");
+ ErrorF
+ ("[+-]accessx [ timeout [ timeout_mask [ feedback [ options_mask] ] ] ]\n");
ErrorF(" enable/disable accessx key sequences\n");
ErrorF("-ardelay set XKB autorepeat delay\n");
ErrorF("-arinterval set XKB autorepeat interval\n");
diff --git a/xkb/xkbLEDs.c b/xkb/xkbLEDs.c
index 24fcd3b48..e1e22d178 100644
--- a/xkb/xkbLEDs.c
+++ b/xkb/xkbLEDs.c
@@ -42,347 +42,358 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
/***====================================================================***/
- /*
- * unsigned
- * XkbIndicatorsToUpdate(dev,changed,check_devs_rtrn)
- *
- * Given a keyboard and a set of state components that have changed,
- * this function returns the indicators on the default keyboard
- * feedback that might be affected. It also reports whether or not
- * any extension devices might be affected in check_devs_rtrn.
- */
+ /*
+ * unsigned
+ * XkbIndicatorsToUpdate(dev,changed,check_devs_rtrn)
+ *
+ * Given a keyboard and a set of state components that have changed,
+ * this function returns the indicators on the default keyboard
+ * feedback that might be affected. It also reports whether or not
+ * any extension devices might be affected in check_devs_rtrn.
+ */
unsigned
-XkbIndicatorsToUpdate( DeviceIntPtr dev,
- unsigned long state_changes,
- Bool enable_changes)
+XkbIndicatorsToUpdate(DeviceIntPtr dev,
+ unsigned long state_changes, Bool enable_changes)
{
-register unsigned update= 0;
-XkbSrvLedInfoPtr sli;
+ register unsigned update = 0;
+ XkbSrvLedInfoPtr sli;
- sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
+ sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
if (!sli)
return update;
- if (state_changes&(XkbModifierStateMask|XkbGroupStateMask))
- update|= sli->usesEffective;
- if (state_changes&(XkbModifierBaseMask|XkbGroupBaseMask))
- update|= sli->usesBase;
- if (state_changes&(XkbModifierLatchMask|XkbGroupLatchMask))
- update|= sli->usesLatched;
- if (state_changes&(XkbModifierLockMask|XkbGroupLockMask))
- update|= sli->usesLocked;
- if (state_changes&XkbCompatStateMask)
- update|= sli->usesCompat;
+ if (state_changes & (XkbModifierStateMask | XkbGroupStateMask))
+ update |= sli->usesEffective;
+ if (state_changes & (XkbModifierBaseMask | XkbGroupBaseMask))
+ update |= sli->usesBase;
+ if (state_changes & (XkbModifierLatchMask | XkbGroupLatchMask))
+ update |= sli->usesLatched;
+ if (state_changes & (XkbModifierLockMask | XkbGroupLockMask))
+ update |= sli->usesLocked;
+ if (state_changes & XkbCompatStateMask)
+ update |= sli->usesCompat;
if (enable_changes)
- update|= sli->usesControls;
+ update |= sli->usesControls;
return update;
}
/***====================================================================***/
- /*
- * Bool
- *XkbApplyLEDChangeToKeyboard(xkbi,map,on,change)
- *
- * Some indicators "drive" the keyboard when their state is explicitly
- * changed, as described in section 9.2.1 of the XKB protocol spec.
- * This function updates the state and controls for the keyboard
- * specified by 'xkbi' to reflect any changes that are required
- * when the indicator described by 'map' is turned on or off. The
- * extent of the changes is reported in change, which must be defined.
- */
+ /*
+ * Bool
+ *XkbApplyLEDChangeToKeyboard(xkbi,map,on,change)
+ *
+ * Some indicators "drive" the keyboard when their state is explicitly
+ * changed, as described in section 9.2.1 of the XKB protocol spec.
+ * This function updates the state and controls for the keyboard
+ * specified by 'xkbi' to reflect any changes that are required
+ * when the indicator described by 'map' is turned on or off. The
+ * extent of the changes is reported in change, which must be defined.
+ */
static Bool
-XkbApplyLEDChangeToKeyboard( XkbSrvInfoPtr xkbi,
- XkbIndicatorMapPtr map,
- Bool on,
- XkbChangesPtr change)
+XkbApplyLEDChangeToKeyboard(XkbSrvInfoPtr xkbi,
+ XkbIndicatorMapPtr map,
+ Bool on, XkbChangesPtr change)
{
-Bool ctrlChange,stateChange;
-XkbStatePtr state;
+ Bool ctrlChange, stateChange;
+ XkbStatePtr state;
- if ((map->flags&XkbIM_NoExplicit)||((map->flags&XkbIM_LEDDrivesKB)==0))
- return FALSE;
- ctrlChange= stateChange= FALSE;
+ if ((map->flags & XkbIM_NoExplicit) ||
+ ((map->flags & XkbIM_LEDDrivesKB) == 0))
+ return FALSE;
+ ctrlChange = stateChange = FALSE;
if (map->ctrls) {
- XkbControlsPtr ctrls= xkbi->desc->ctrls;
- unsigned old;
-
- old= ctrls->enabled_ctrls;
- if (on) ctrls->enabled_ctrls|= map->ctrls;
- else ctrls->enabled_ctrls&= ~map->ctrls;
- if (old!=ctrls->enabled_ctrls) {
- change->ctrls.changed_ctrls= XkbControlsEnabledMask;
- change->ctrls.enabled_ctrls_changes= old^ctrls->enabled_ctrls;
- ctrlChange= TRUE;
- }
- }
- state= &xkbi->state;
- if ((map->groups)&&((map->which_groups&(~XkbIM_UseBase))!=0)) {
- register int i;
- register unsigned bit,match;
-
- if (on) match= (map->groups)&XkbAllGroupsMask;
- else match= (~map->groups)&XkbAllGroupsMask;
- if (map->which_groups&(XkbIM_UseLocked|XkbIM_UseEffective)) {
- for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
- if (bit&match)
- break;
- }
- if (map->which_groups&XkbIM_UseLatched)
- XkbLatchGroup(xkbi->device,0); /* unlatch group */
- state->locked_group= i;
- stateChange= TRUE;
- }
- else if (map->which_groups&(XkbIM_UseLatched|XkbIM_UseEffective)) {
- for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
- if (bit&match)
- break;
- }
- state->locked_group= 0;
- XkbLatchGroup(xkbi->device,i);
- stateChange= TRUE;
- }
- }
- if ((map->mods.mask)&&((map->which_mods&(~XkbIM_UseBase))!=0)) {
- if (map->which_mods&(XkbIM_UseLocked|XkbIM_UseEffective)) {
- register unsigned long old;
- old= state->locked_mods;
- if (on) state->locked_mods|= map->mods.mask;
- else state->locked_mods&= ~map->mods.mask;
- if (state->locked_mods!=old)
- stateChange= TRUE;
- }
- if (map->which_mods&(XkbIM_UseLatched|XkbIM_UseEffective)) {
- register unsigned long newmods;
- newmods= state->latched_mods;
- if (on) newmods|= map->mods.mask;
- else newmods&= ~map->mods.mask;
- if (newmods!=state->locked_mods) {
- newmods&= map->mods.mask;
- XkbLatchModifiers(xkbi->device,map->mods.mask,newmods);
- stateChange= TRUE;
- }
- }
+ XkbControlsPtr ctrls = xkbi->desc->ctrls;
+ unsigned old;
+
+ old = ctrls->enabled_ctrls;
+ if (on)
+ ctrls->enabled_ctrls |= map->ctrls;
+ else
+ ctrls->enabled_ctrls &= ~map->ctrls;
+ if (old != ctrls->enabled_ctrls) {
+ change->ctrls.changed_ctrls = XkbControlsEnabledMask;
+ change->ctrls.enabled_ctrls_changes = old ^ ctrls->enabled_ctrls;
+ ctrlChange = TRUE;
+ }
+ }
+ state = &xkbi->state;
+ if ((map->groups) && ((map->which_groups & (~XkbIM_UseBase)) != 0)) {
+ register int i;
+ register unsigned bit, match;
+
+ if (on)
+ match = (map->groups) & XkbAllGroupsMask;
+ else
+ match = (~map->groups) & XkbAllGroupsMask;
+ if (map->which_groups & (XkbIM_UseLocked | XkbIM_UseEffective)) {
+ for (i = 0, bit = 1; i < XkbNumKbdGroups; i++, bit <<= 1) {
+ if (bit & match)
+ break;
+ }
+ if (map->which_groups & XkbIM_UseLatched)
+ XkbLatchGroup(xkbi->device, 0); /* unlatch group */
+ state->locked_group = i;
+ stateChange = TRUE;
+ }
+ else if (map->which_groups & (XkbIM_UseLatched | XkbIM_UseEffective)) {
+ for (i = 0, bit = 1; i < XkbNumKbdGroups; i++, bit <<= 1) {
+ if (bit & match)
+ break;
+ }
+ state->locked_group = 0;
+ XkbLatchGroup(xkbi->device, i);
+ stateChange = TRUE;
+ }
+ }
+ if ((map->mods.mask) && ((map->which_mods & (~XkbIM_UseBase)) != 0)) {
+ if (map->which_mods & (XkbIM_UseLocked | XkbIM_UseEffective)) {
+ register unsigned long old;
+
+ old = state->locked_mods;
+ if (on)
+ state->locked_mods |= map->mods.mask;
+ else
+ state->locked_mods &= ~map->mods.mask;
+ if (state->locked_mods != old)
+ stateChange = TRUE;
+ }
+ if (map->which_mods & (XkbIM_UseLatched | XkbIM_UseEffective)) {
+ register unsigned long newmods;
+
+ newmods = state->latched_mods;
+ if (on)
+ newmods |= map->mods.mask;
+ else
+ newmods &= ~map->mods.mask;
+ if (newmods != state->locked_mods) {
+ newmods &= map->mods.mask;
+ XkbLatchModifiers(xkbi->device, map->mods.mask, newmods);
+ stateChange = TRUE;
+ }
+ }
}
return stateChange || ctrlChange;
}
-
- /*
- * Bool
- * ComputeAutoState(map,state,ctrls)
- *
- * This function reports the effect of applying the specified
- * indicator map given the specified state and controls, as
- * described in section 9.2 of the XKB protocol specification.
- */
+
+ /*
+ * Bool
+ * ComputeAutoState(map,state,ctrls)
+ *
+ * This function reports the effect of applying the specified
+ * indicator map given the specified state and controls, as
+ * described in section 9.2 of the XKB protocol specification.
+ */
static Bool
-ComputeAutoState( XkbIndicatorMapPtr map,
- XkbStatePtr state,
- XkbControlsPtr ctrls)
+ComputeAutoState(XkbIndicatorMapPtr map,
+ XkbStatePtr state, XkbControlsPtr ctrls)
{
-Bool on;
-CARD8 mods,group;
-
- on= FALSE;
- mods= group= 0;
- if (map->which_mods&XkbIM_UseAnyMods) {
- if (map->which_mods&XkbIM_UseBase)
- mods|= state->base_mods;
- if (map->which_mods&XkbIM_UseLatched)
- mods|= state->latched_mods;
- if (map->which_mods&XkbIM_UseLocked)
- mods|= state->locked_mods;
- if (map->which_mods&XkbIM_UseEffective)
- mods|= state->mods;
- if (map->which_mods&XkbIM_UseCompat)
- mods|= state->compat_state;
- on = ((map->mods.mask&mods)!=0);
- on = on||((mods==0)&&(map->mods.mask==0)&&(map->mods.vmods==0));
- }
- if (map->which_groups&XkbIM_UseAnyGroup) {
- if (map->which_groups&XkbIM_UseBase)
- group|= (1L << state->base_group);
- if (map->which_groups&XkbIM_UseLatched)
- group|= (1L << state->latched_group);
- if (map->which_groups&XkbIM_UseLocked)
- group|= (1L << state->locked_group);
- if (map->which_groups&XkbIM_UseEffective)
- group|= (1L << state->group);
- on = on||(((map->groups&group)!=0)||(map->groups==0));
+ Bool on;
+ CARD8 mods, group;
+
+ on = FALSE;
+ mods = group = 0;
+ if (map->which_mods & XkbIM_UseAnyMods) {
+ if (map->which_mods & XkbIM_UseBase)
+ mods |= state->base_mods;
+ if (map->which_mods & XkbIM_UseLatched)
+ mods |= state->latched_mods;
+ if (map->which_mods & XkbIM_UseLocked)
+ mods |= state->locked_mods;
+ if (map->which_mods & XkbIM_UseEffective)
+ mods |= state->mods;
+ if (map->which_mods & XkbIM_UseCompat)
+ mods |= state->compat_state;
+ on = ((map->mods.mask & mods) != 0);
+ on = on || ((mods == 0) && (map->mods.mask == 0) &&
+ (map->mods.vmods == 0));
+ }
+ if (map->which_groups & XkbIM_UseAnyGroup) {
+ if (map->which_groups & XkbIM_UseBase)
+ group |= (1L << state->base_group);
+ if (map->which_groups & XkbIM_UseLatched)
+ group |= (1L << state->latched_group);
+ if (map->which_groups & XkbIM_UseLocked)
+ group |= (1L << state->locked_group);
+ if (map->which_groups & XkbIM_UseEffective)
+ group |= (1L << state->group);
+ on = on || (((map->groups & group) != 0) || (map->groups == 0));
}
if (map->ctrls)
- on = on||(ctrls->enabled_ctrls&map->ctrls);
+ on = on || (ctrls->enabled_ctrls & map->ctrls);
return on;
}
-
static void
-XkbUpdateLedAutoState( DeviceIntPtr dev,
- XkbSrvLedInfoPtr sli,
- unsigned maps_to_check,
- xkbExtensionDeviceNotify * ed,
- XkbChangesPtr changes,
- XkbEventCausePtr cause)
+XkbUpdateLedAutoState(DeviceIntPtr dev,
+ XkbSrvLedInfoPtr sli,
+ unsigned maps_to_check,
+ xkbExtensionDeviceNotify * ed,
+ XkbChangesPtr changes, XkbEventCausePtr cause)
{
-DeviceIntPtr kbd;
-XkbStatePtr state;
-XkbControlsPtr ctrls;
-XkbChangesRec my_changes;
-xkbExtensionDeviceNotify my_ed;
-register unsigned i,bit,affected;
-register XkbIndicatorMapPtr map;
-unsigned oldState;
-
- if ((maps_to_check==0)||(sli->maps==NULL)||(sli->mapsPresent==0))
- return;
+ DeviceIntPtr kbd;
+ XkbStatePtr state;
+ XkbControlsPtr ctrls;
+ XkbChangesRec my_changes;
+ xkbExtensionDeviceNotify my_ed;
+ register unsigned i, bit, affected;
+ register XkbIndicatorMapPtr map;
+ unsigned oldState;
+
+ if ((maps_to_check == 0) || (sli->maps == NULL) || (sli->mapsPresent == 0))
+ return;
if (dev->key && dev->key->xkbInfo)
- kbd= dev;
- else kbd= inputInfo.keyboard;
-
- state= &kbd->key->xkbInfo->state;
- ctrls= kbd->key->xkbInfo->desc->ctrls;
- affected= maps_to_check;
- oldState= sli->effectiveState;
- sli->autoState&= ~affected;
- for (i=0,bit=1;(i<XkbNumIndicators)&&(affected);i++,bit<<=1) {
- if ((affected&bit)==0)
- continue;
- affected&= ~bit;
- map= &sli->maps[i];
- if((!(map->flags&XkbIM_NoAutomatic))&&ComputeAutoState(map,state,ctrls))
- sli->autoState|= bit;
- }
- sli->effectiveState= (sli->autoState|sli->explicitState);
- affected= sli->effectiveState^oldState;
- if (affected==0)
- return;
-
- if (ed==NULL) {
- ed= &my_ed;
- memset((char *)ed, 0, sizeof(xkbExtensionDeviceNotify));
- }
- else if ((ed->reason&XkbXI_IndicatorsMask)&&
- ((ed->ledClass!=sli->class)||(ed->ledID!=sli->id))) {
- XkbFlushLedEvents(dev,kbd,sli,ed,changes,cause);
- }
-
- if ((kbd==dev)&&(sli->flags&XkbSLI_IsDefault)) {
- if (changes==NULL) {
- changes= &my_changes;
- memset((char *)changes, 0, sizeof(XkbChangesRec));
- }
- changes->indicators.state_changes|= affected;
- }
-
- ed->reason|= XkbXI_IndicatorStateMask;
- ed->ledClass= sli->class;
- ed->ledID= sli->id;
- ed->ledsDefined= sli->namesPresent|sli->mapsPresent;
- ed->ledState= sli->effectiveState;
- ed->unsupported= 0;
- ed->supported= XkbXI_AllFeaturesMask;
-
- if (changes!=&my_changes) changes= NULL;
- if (ed!=&my_ed) ed= NULL;
+ kbd = dev;
+ else
+ kbd = inputInfo.keyboard;
+
+ state = &kbd->key->xkbInfo->state;
+ ctrls = kbd->key->xkbInfo->desc->ctrls;
+ affected = maps_to_check;
+ oldState = sli->effectiveState;
+ sli->autoState &= ~affected;
+ for (i = 0, bit = 1; (i < XkbNumIndicators) && (affected); i++, bit <<= 1) {
+ if ((affected & bit) == 0)
+ continue;
+ affected &= ~bit;
+ map = &sli->maps[i];
+ if ((!(map->flags & XkbIM_NoAutomatic)) &&
+ ComputeAutoState(map, state, ctrls))
+ sli->autoState |= bit;
+ }
+ sli->effectiveState = (sli->autoState | sli->explicitState);
+ affected = sli->effectiveState ^ oldState;
+ if (affected == 0)
+ return;
+
+ if (ed == NULL) {
+ ed = &my_ed;
+ memset((char *) ed, 0, sizeof(xkbExtensionDeviceNotify));
+ }
+ else if ((ed->reason & XkbXI_IndicatorsMask) &&
+ ((ed->ledClass != sli->class) || (ed->ledID != sli->id))) {
+ XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause);
+ }
+
+ if ((kbd == dev) && (sli->flags & XkbSLI_IsDefault)) {
+ if (changes == NULL) {
+ changes = &my_changes;
+ memset((char *) changes, 0, sizeof(XkbChangesRec));
+ }
+ changes->indicators.state_changes |= affected;
+ }
+
+ ed->reason |= XkbXI_IndicatorStateMask;
+ ed->ledClass = sli->class;
+ ed->ledID = sli->id;
+ ed->ledsDefined = sli->namesPresent | sli->mapsPresent;
+ ed->ledState = sli->effectiveState;
+ ed->unsupported = 0;
+ ed->supported = XkbXI_AllFeaturesMask;
+
+ if (changes != &my_changes)
+ changes = NULL;
+ if (ed != &my_ed)
+ ed = NULL;
if (changes || ed)
- XkbFlushLedEvents(dev,kbd,sli,ed,changes,cause);
+ XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause);
return;
}
static void
-XkbUpdateAllDeviceIndicators(XkbChangesPtr changes,XkbEventCausePtr cause)
+XkbUpdateAllDeviceIndicators(XkbChangesPtr changes, XkbEventCausePtr cause)
{
-DeviceIntPtr edev;
-XkbSrvLedInfoPtr sli;
-
- for (edev=inputInfo.devices;edev!=NULL;edev=edev->next) {
- if (edev->kbdfeed) {
- KbdFeedbackPtr kf;
- for (kf=edev->kbdfeed;kf!=NULL;kf=kf->next) {
- if ((kf->xkb_sli==NULL)||(kf->xkb_sli->maps==NULL))
- continue;
- sli= kf->xkb_sli;
- XkbUpdateLedAutoState(edev,sli,sli->mapsPresent,NULL,
- changes,cause);
-
- }
- }
- if (edev->leds) {
- LedFeedbackPtr lf;
- for (lf=edev->leds;lf!=NULL;lf=lf->next) {
- if ((lf->xkb_sli==NULL)||(lf->xkb_sli->maps==NULL))
- continue;
- sli= lf->xkb_sli;
- XkbUpdateLedAutoState(edev,sli,sli->mapsPresent,NULL,
- changes,cause);
-
- }
- }
+ DeviceIntPtr edev;
+ XkbSrvLedInfoPtr sli;
+
+ for (edev = inputInfo.devices; edev != NULL; edev = edev->next) {
+ if (edev->kbdfeed) {
+ KbdFeedbackPtr kf;
+
+ for (kf = edev->kbdfeed; kf != NULL; kf = kf->next) {
+ if ((kf->xkb_sli == NULL) || (kf->xkb_sli->maps == NULL))
+ continue;
+ sli = kf->xkb_sli;
+ XkbUpdateLedAutoState(edev, sli, sli->mapsPresent, NULL,
+ changes, cause);
+
+ }
+ }
+ if (edev->leds) {
+ LedFeedbackPtr lf;
+
+ for (lf = edev->leds; lf != NULL; lf = lf->next) {
+ if ((lf->xkb_sli == NULL) || (lf->xkb_sli->maps == NULL))
+ continue;
+ sli = lf->xkb_sli;
+ XkbUpdateLedAutoState(edev, sli, sli->mapsPresent, NULL,
+ changes, cause);
+
+ }
+ }
}
return;
}
-
/***====================================================================***/
- /*
- * void
- * XkbSetIndicators(dev,affect,values,cause)
- *
- * Attempts to change the indicators specified in 'affect' to the
- * states specified in 'values' for the default keyboard feedback
- * on the keyboard specified by 'dev.' Attempts to change indicator
- * state might be ignored or have no affect, depending on the XKB
- * indicator map for any affected indicators, as described in section
- * 9.2 of the XKB protocol specification.
- *
- * If 'changes' is non-NULL, this function notes any changes to the
- * keyboard state, controls, or indicator state that result from this
- * attempted change. If 'changes' is NULL, this function generates
- * XKB events to report any such changes to interested clients.
- *
- * If 'cause' is non-NULL, it specifies the reason for the change,
- * as reported in some XKB events. If it is NULL, this function
- * assumes that the change is the result of a core protocol
- * ChangeKeyboardMapping request.
- */
+ /*
+ * void
+ * XkbSetIndicators(dev,affect,values,cause)
+ *
+ * Attempts to change the indicators specified in 'affect' to the
+ * states specified in 'values' for the default keyboard feedback
+ * on the keyboard specified by 'dev.' Attempts to change indicator
+ * state might be ignored or have no affect, depending on the XKB
+ * indicator map for any affected indicators, as described in section
+ * 9.2 of the XKB protocol specification.
+ *
+ * If 'changes' is non-NULL, this function notes any changes to the
+ * keyboard state, controls, or indicator state that result from this
+ * attempted change. If 'changes' is NULL, this function generates
+ * XKB events to report any such changes to interested clients.
+ *
+ * If 'cause' is non-NULL, it specifies the reason for the change,
+ * as reported in some XKB events. If it is NULL, this function
+ * assumes that the change is the result of a core protocol
+ * ChangeKeyboardMapping request.
+ */
void
-XkbSetIndicators( DeviceIntPtr dev,
- CARD32 affect,
- CARD32 values,
- XkbEventCausePtr cause)
+XkbSetIndicators(DeviceIntPtr dev,
+ CARD32 affect, CARD32 values, XkbEventCausePtr cause)
{
-XkbSrvLedInfoPtr sli;
-XkbChangesRec changes;
-xkbExtensionDeviceNotify ed;
-unsigned side_affected;
-
- memset((char *)&changes, 0, sizeof(XkbChangesRec));
- memset((char *)&ed, 0, sizeof(xkbExtensionDeviceNotify));
- sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
- sli->explicitState&= ~affect;
- sli->explicitState|= (affect&values);
- XkbApplyLedStateChanges(dev,sli,affect,&ed,&changes,cause);
-
- side_affected= 0;
- if (changes.state_changes!=0)
- side_affected|= XkbIndicatorsToUpdate(dev,changes.state_changes,FALSE);
+ XkbSrvLedInfoPtr sli;
+ XkbChangesRec changes;
+ xkbExtensionDeviceNotify ed;
+ unsigned side_affected;
+
+ memset((char *) &changes, 0, sizeof(XkbChangesRec));
+ memset((char *) &ed, 0, sizeof(xkbExtensionDeviceNotify));
+ sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
+ sli->explicitState &= ~affect;
+ sli->explicitState |= (affect & values);
+ XkbApplyLedStateChanges(dev, sli, affect, &ed, &changes, cause);
+
+ side_affected = 0;
+ if (changes.state_changes != 0)
+ side_affected |=
+ XkbIndicatorsToUpdate(dev, changes.state_changes, FALSE);
if (changes.ctrls.enabled_ctrls_changes)
- side_affected|= sli->usesControls;
+ side_affected |= sli->usesControls;
if (side_affected) {
- XkbUpdateLedAutoState(dev,sli,side_affected,&ed,&changes,cause);
- affect|= side_affected;
+ XkbUpdateLedAutoState(dev, sli, side_affected, &ed, &changes, cause);
+ affect |= side_affected;
}
if (changes.state_changes || changes.ctrls.enabled_ctrls_changes)
- XkbUpdateAllDeviceIndicators(NULL,cause);
+ XkbUpdateAllDeviceIndicators(NULL, cause);
- XkbFlushLedEvents(dev,dev,sli,&ed,&changes,cause);
+ XkbFlushLedEvents(dev, dev, sli, &ed, &changes, cause);
return;
}
@@ -390,36 +401,35 @@ unsigned side_affected;
/***====================================================================***/
- /*
- * void
- * XkbUpdateIndicators(dev,update,check_edevs,changes,cause)
- *
- * Applies the indicator maps for any indicators specified in
- * 'update' from the default keyboard feedback on the device
- * specified by 'dev.'
- *
- * If 'changes' is NULL, this function generates and XKB events
- * required to report the necessary changes, otherwise it simply
- * notes the indicators with changed state.
- *
- * If 'check_edevs' is TRUE, this function also checks the indicator
- * maps for any open extension devices that have them, and updates
- * the state of any extension device indicators as necessary.
- */
+ /*
+ * void
+ * XkbUpdateIndicators(dev,update,check_edevs,changes,cause)
+ *
+ * Applies the indicator maps for any indicators specified in
+ * 'update' from the default keyboard feedback on the device
+ * specified by 'dev.'
+ *
+ * If 'changes' is NULL, this function generates and XKB events
+ * required to report the necessary changes, otherwise it simply
+ * notes the indicators with changed state.
+ *
+ * If 'check_edevs' is TRUE, this function also checks the indicator
+ * maps for any open extension devices that have them, and updates
+ * the state of any extension device indicators as necessary.
+ */
void
-XkbUpdateIndicators( DeviceIntPtr dev,
- register CARD32 update,
- Bool check_edevs,
- XkbChangesPtr changes,
- XkbEventCausePtr cause)
+XkbUpdateIndicators(DeviceIntPtr dev,
+ register CARD32 update,
+ Bool check_edevs,
+ XkbChangesPtr changes, XkbEventCausePtr cause)
{
-XkbSrvLedInfoPtr sli;
+ XkbSrvLedInfoPtr sli;
- sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
- XkbUpdateLedAutoState(dev,sli,update,NULL,changes,cause);
+ sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
+ XkbUpdateLedAutoState(dev, sli, update, NULL, changes, cause);
if (check_edevs)
- XkbUpdateAllDeviceIndicators(changes,cause);
+ XkbUpdateAllDeviceIndicators(changes, cause);
return;
}
@@ -427,192 +437,196 @@ XkbSrvLedInfoPtr sli;
/***====================================================================***/
- /*
- * void
- * XkbCheckIndicatorMaps(dev,sli,which)
- *
- * Updates the 'indicator accelerators' for the indicators specified
- * by 'which' in the feedback specified by 'sli.' The indicator
- * accelerators are internal to the server and are used to simplify
- * and speed up the process of figuring out which indicators might
- * be affected by a particular change in keyboard state or controls.
- */
+ /*
+ * void
+ * XkbCheckIndicatorMaps(dev,sli,which)
+ *
+ * Updates the 'indicator accelerators' for the indicators specified
+ * by 'which' in the feedback specified by 'sli.' The indicator
+ * accelerators are internal to the server and are used to simplify
+ * and speed up the process of figuring out which indicators might
+ * be affected by a particular change in keyboard state or controls.
+ */
void
-XkbCheckIndicatorMaps(DeviceIntPtr dev,XkbSrvLedInfoPtr sli,unsigned which)
+XkbCheckIndicatorMaps(DeviceIntPtr dev, XkbSrvLedInfoPtr sli, unsigned which)
{
-register unsigned i,bit;
-XkbIndicatorMapPtr map;
-XkbDescPtr xkb;
+ register unsigned i, bit;
+ XkbIndicatorMapPtr map;
+ XkbDescPtr xkb;
- if ((sli->flags&XkbSLI_HasOwnState)==0)
+ if ((sli->flags & XkbSLI_HasOwnState) == 0)
return;
- sli->usesBase&= ~which;
- sli->usesLatched&= ~which;
- sli->usesLocked&= ~which;
- sli->usesEffective&= ~which;
- sli->usesCompat&= ~which;
- sli->usesControls&= ~which;
- sli->mapsPresent&= ~which;
-
- xkb= dev->key->xkbInfo->desc;
- for (i=0,bit=1,map=sli->maps;i<XkbNumIndicators;i++,bit<<=1,map++) {
- if (which&bit) {
- CARD8 what;
-
- if (!map || !XkbIM_InUse(map))
- continue;
- sli->mapsPresent|= bit;
-
- what= (map->which_mods|map->which_groups);
- if (what&XkbIM_UseBase)
- sli->usesBase|= bit;
- if (what&XkbIM_UseLatched)
- sli->usesLatched|= bit;
- if (what&XkbIM_UseLocked)
- sli->usesLocked|= bit;
- if (what&XkbIM_UseEffective)
- sli->usesEffective|= bit;
- if (what&XkbIM_UseCompat)
- sli->usesCompat|= bit;
- if (map->ctrls)
- sli->usesControls|= bit;
-
- map->mods.mask= map->mods.real_mods;
- if (map->mods.vmods!=0) {
- map->mods.mask|= XkbMaskForVMask(xkb,map->mods.vmods);
- }
- }
- }
- sli->usedComponents= 0;
+ sli->usesBase &= ~which;
+ sli->usesLatched &= ~which;
+ sli->usesLocked &= ~which;
+ sli->usesEffective &= ~which;
+ sli->usesCompat &= ~which;
+ sli->usesControls &= ~which;
+ sli->mapsPresent &= ~which;
+
+ xkb = dev->key->xkbInfo->desc;
+ for (i = 0, bit = 1, map = sli->maps; i < XkbNumIndicators;
+ i++, bit <<= 1, map++) {
+ if (which & bit) {
+ CARD8 what;
+
+ if (!map || !XkbIM_InUse(map))
+ continue;
+ sli->mapsPresent |= bit;
+
+ what = (map->which_mods | map->which_groups);
+ if (what & XkbIM_UseBase)
+ sli->usesBase |= bit;
+ if (what & XkbIM_UseLatched)
+ sli->usesLatched |= bit;
+ if (what & XkbIM_UseLocked)
+ sli->usesLocked |= bit;
+ if (what & XkbIM_UseEffective)
+ sli->usesEffective |= bit;
+ if (what & XkbIM_UseCompat)
+ sli->usesCompat |= bit;
+ if (map->ctrls)
+ sli->usesControls |= bit;
+
+ map->mods.mask = map->mods.real_mods;
+ if (map->mods.vmods != 0) {
+ map->mods.mask |= XkbMaskForVMask(xkb, map->mods.vmods);
+ }
+ }
+ }
+ sli->usedComponents = 0;
if (sli->usesBase)
- sli->usedComponents|= XkbModifierBaseMask|XkbGroupBaseMask;
+ sli->usedComponents |= XkbModifierBaseMask | XkbGroupBaseMask;
if (sli->usesLatched)
- sli->usedComponents|= XkbModifierLatchMask|XkbGroupLatchMask;
+ sli->usedComponents |= XkbModifierLatchMask | XkbGroupLatchMask;
if (sli->usesLocked)
- sli->usedComponents|= XkbModifierLockMask|XkbGroupLockMask;
+ sli->usedComponents |= XkbModifierLockMask | XkbGroupLockMask;
if (sli->usesEffective)
- sli->usedComponents|= XkbModifierStateMask|XkbGroupStateMask;
+ sli->usedComponents |= XkbModifierStateMask | XkbGroupStateMask;
if (sli->usesCompat)
- sli->usedComponents|= XkbCompatStateMask;
+ sli->usedComponents |= XkbCompatStateMask;
return;
}
/***====================================================================***/
- /*
- * XkbSrvLedInfoPtr
- * XkbAllocSrvLedInfo(dev,kf,lf,needed_parts)
- *
- * Allocates an XkbSrvLedInfoPtr for the feedback specified by either
- * 'kf' or 'lf' on the keyboard specified by 'dev.'
- *
- * If 'needed_parts' is non-zero, this function makes sure that any
- * of the parts speicified therein are allocated.
- */
+ /*
+ * XkbSrvLedInfoPtr
+ * XkbAllocSrvLedInfo(dev,kf,lf,needed_parts)
+ *
+ * Allocates an XkbSrvLedInfoPtr for the feedback specified by either
+ * 'kf' or 'lf' on the keyboard specified by 'dev.'
+ *
+ * If 'needed_parts' is non-zero, this function makes sure that any
+ * of the parts speicified therein are allocated.
+ */
XkbSrvLedInfoPtr
-XkbAllocSrvLedInfo( DeviceIntPtr dev,
- KbdFeedbackPtr kf,
- LedFeedbackPtr lf,
- unsigned needed_parts)
+XkbAllocSrvLedInfo(DeviceIntPtr dev,
+ KbdFeedbackPtr kf, LedFeedbackPtr lf, unsigned needed_parts)
{
-XkbSrvLedInfoPtr sli;
-Bool checkAccel;
-Bool checkNames;
-
- sli= NULL;
- checkAccel= checkNames= FALSE;
- if ((kf!=NULL)&&(kf->xkb_sli==NULL)) {
- kf->xkb_sli= sli= calloc(1, sizeof(XkbSrvLedInfoRec));
- if (sli==NULL)
- return NULL; /* ALLOCATION ERROR */
- if (dev->key && dev->key->xkbInfo)
- sli->flags= XkbSLI_HasOwnState;
- else sli->flags= 0;
- sli->class= KbdFeedbackClass;
- sli->id= kf->ctrl.id;
- sli->fb.kf= kf;
-
- sli->autoState= 0;
- sli->explicitState= kf->ctrl.leds;
- sli->effectiveState= kf->ctrl.leds;
-
- if ((kf==dev->kbdfeed) && (dev->key) && (dev->key->xkbInfo)) {
- XkbDescPtr xkb;
- xkb= dev->key->xkbInfo->desc;
- sli->flags|= XkbSLI_IsDefault;
- sli->physIndicators= xkb->indicators->phys_indicators;
- sli->names= xkb->names->indicators;
- sli->maps= xkb->indicators->maps;
- checkNames= checkAccel= TRUE;
- }
- else {
- sli->physIndicators= XkbAllIndicatorsMask;
- sli->names= NULL;
- sli->maps= NULL;
- }
- }
- else if ((kf!=NULL)&&((kf->xkb_sli->flags&XkbSLI_IsDefault)!=0)) {
- XkbDescPtr xkb;
- xkb= dev->key->xkbInfo->desc;
- sli= kf->xkb_sli;
- sli->physIndicators= xkb->indicators->phys_indicators;
- if (xkb->names->indicators!=sli->names) {
- checkNames= TRUE;
- sli->names= xkb->names->indicators;
- }
- if (xkb->indicators->maps!=sli->maps) {
- checkAccel= TRUE;
- sli->maps= xkb->indicators->maps;
- }
- }
- else if ((lf!=NULL)&&(lf->xkb_sli==NULL)) {
- lf->xkb_sli= sli= calloc(1, sizeof(XkbSrvLedInfoRec));
- if (sli==NULL)
- return NULL; /* ALLOCATION ERROR */
- if (dev->key && dev->key->xkbInfo)
- sli->flags= XkbSLI_HasOwnState;
- else sli->flags= 0;
- sli->class= LedFeedbackClass;
- sli->id= lf->ctrl.id;
- sli->fb.lf= lf;
-
- sli->physIndicators= lf->ctrl.led_mask;
- sli->autoState= 0;
- sli->explicitState= lf->ctrl.led_values;
- sli->effectiveState= lf->ctrl.led_values;
- sli->maps= NULL;
- sli->names= NULL;
+ XkbSrvLedInfoPtr sli;
+ Bool checkAccel;
+ Bool checkNames;
+
+ sli = NULL;
+ checkAccel = checkNames = FALSE;
+ if ((kf != NULL) && (kf->xkb_sli == NULL)) {
+ kf->xkb_sli = sli = calloc(1, sizeof(XkbSrvLedInfoRec));
+ if (sli == NULL)
+ return NULL; /* ALLOCATION ERROR */
+ if (dev->key && dev->key->xkbInfo)
+ sli->flags = XkbSLI_HasOwnState;
+ else
+ sli->flags = 0;
+ sli->class = KbdFeedbackClass;
+ sli->id = kf->ctrl.id;
+ sli->fb.kf = kf;
+
+ sli->autoState = 0;
+ sli->explicitState = kf->ctrl.leds;
+ sli->effectiveState = kf->ctrl.leds;
+
+ if ((kf == dev->kbdfeed) && (dev->key) && (dev->key->xkbInfo)) {
+ XkbDescPtr xkb;
+
+ xkb = dev->key->xkbInfo->desc;
+ sli->flags |= XkbSLI_IsDefault;
+ sli->physIndicators = xkb->indicators->phys_indicators;
+ sli->names = xkb->names->indicators;
+ sli->maps = xkb->indicators->maps;
+ checkNames = checkAccel = TRUE;
+ }
+ else {
+ sli->physIndicators = XkbAllIndicatorsMask;
+ sli->names = NULL;
+ sli->maps = NULL;
+ }
+ }
+ else if ((kf != NULL) && ((kf->xkb_sli->flags & XkbSLI_IsDefault) != 0)) {
+ XkbDescPtr xkb;
+
+ xkb = dev->key->xkbInfo->desc;
+ sli = kf->xkb_sli;
+ sli->physIndicators = xkb->indicators->phys_indicators;
+ if (xkb->names->indicators != sli->names) {
+ checkNames = TRUE;
+ sli->names = xkb->names->indicators;
+ }
+ if (xkb->indicators->maps != sli->maps) {
+ checkAccel = TRUE;
+ sli->maps = xkb->indicators->maps;
+ }
+ }
+ else if ((lf != NULL) && (lf->xkb_sli == NULL)) {
+ lf->xkb_sli = sli = calloc(1, sizeof(XkbSrvLedInfoRec));
+ if (sli == NULL)
+ return NULL; /* ALLOCATION ERROR */
+ if (dev->key && dev->key->xkbInfo)
+ sli->flags = XkbSLI_HasOwnState;
+ else
+ sli->flags = 0;
+ sli->class = LedFeedbackClass;
+ sli->id = lf->ctrl.id;
+ sli->fb.lf = lf;
+
+ sli->physIndicators = lf->ctrl.led_mask;
+ sli->autoState = 0;
+ sli->explicitState = lf->ctrl.led_values;
+ sli->effectiveState = lf->ctrl.led_values;
+ sli->maps = NULL;
+ sli->names = NULL;
}
else
- return NULL;
- if ((sli->names==NULL)&&(needed_parts&XkbXI_IndicatorNamesMask))
- sli->names= calloc(XkbNumIndicators, sizeof(Atom));
- if ((sli->maps==NULL)&&(needed_parts&XkbXI_IndicatorMapsMask))
- sli->maps= calloc(XkbNumIndicators, sizeof(XkbIndicatorMapRec));
+ return NULL;
+ if ((sli->names == NULL) && (needed_parts & XkbXI_IndicatorNamesMask))
+ sli->names = calloc(XkbNumIndicators, sizeof(Atom));
+ if ((sli->maps == NULL) && (needed_parts & XkbXI_IndicatorMapsMask))
+ sli->maps = calloc(XkbNumIndicators, sizeof(XkbIndicatorMapRec));
if (checkNames) {
- register unsigned i,bit;
- sli->namesPresent= 0;
- for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
- if (sli->names[i]!=None)
- sli->namesPresent|= bit;
- }
+ register unsigned i, bit;
+
+ sli->namesPresent = 0;
+ for (i = 0, bit = 1; i < XkbNumIndicators; i++, bit <<= 1) {
+ if (sli->names[i] != None)
+ sli->namesPresent |= bit;
+ }
}
if (checkAccel)
- XkbCheckIndicatorMaps(dev,sli,XkbAllIndicatorsMask);
+ XkbCheckIndicatorMaps(dev, sli, XkbAllIndicatorsMask);
return sli;
}
void
XkbFreeSrvLedInfo(XkbSrvLedInfoPtr sli)
{
- if ((sli->flags&XkbSLI_IsDefault)==0) {
- free(sli->maps);
- free(sli->names);
+ if ((sli->flags & XkbSLI_IsDefault) == 0) {
+ free(sli->maps);
+ free(sli->names);
}
- sli->maps= NULL;
- sli->names= NULL;
+ sli->maps = NULL;
+ sli->names = NULL;
free(sli);
return;
}
@@ -626,100 +640,103 @@ XkbFreeSrvLedInfo(XkbSrvLedInfoPtr sli)
* XkbFreeSrvLedInfo.
*/
XkbSrvLedInfoPtr
-XkbCopySrvLedInfo( DeviceIntPtr from,
- XkbSrvLedInfoPtr src,
- KbdFeedbackPtr kf,
- LedFeedbackPtr lf)
+XkbCopySrvLedInfo(DeviceIntPtr from,
+ XkbSrvLedInfoPtr src, KbdFeedbackPtr kf, LedFeedbackPtr lf)
{
XkbSrvLedInfoPtr sli_new = NULL;
if (!src)
- goto finish;
+ goto finish;
- sli_new = calloc(1, sizeof( XkbSrvLedInfoRec));
+ sli_new = calloc(1, sizeof(XkbSrvLedInfoRec));
if (!sli_new)
- goto finish;
+ goto finish;
memcpy(sli_new, src, sizeof(XkbSrvLedInfoRec));
if (sli_new->class == KbdFeedbackClass)
- sli_new->fb.kf = kf;
+ sli_new->fb.kf = kf;
else
- sli_new->fb.lf = lf;
+ sli_new->fb.lf = lf;
if (!(sli_new->flags & XkbSLI_IsDefault)) {
- sli_new->names= calloc(XkbNumIndicators, sizeof(Atom));
- sli_new->maps= calloc(XkbNumIndicators, sizeof(XkbIndicatorMapRec));
- } /* else sli_new->names/maps is pointing to
- dev->key->xkbInfo->desc->names->indicators;
- dev->key->xkbInfo->desc->names->indicators; */
+ sli_new->names = calloc(XkbNumIndicators, sizeof(Atom));
+ sli_new->maps = calloc(XkbNumIndicators, sizeof(XkbIndicatorMapRec));
+ } /* else sli_new->names/maps is pointing to
+ dev->key->xkbInfo->desc->names->indicators;
+ dev->key->xkbInfo->desc->names->indicators; */
-finish:
+ finish:
return sli_new;
}
/***====================================================================***/
- /*
- * XkbSrvLedInfoPtr
- * XkbFindSrvLedInfo(dev,class,id,needed_parts)
- *
- * Finds the XkbSrvLedInfoPtr for the specified 'class' and 'id'
- * on the device specified by 'dev.' If the class and id specify
- * a valid device feedback, this function returns the existing
- * feedback or allocates a new one.
- *
- */
+ /*
+ * XkbSrvLedInfoPtr
+ * XkbFindSrvLedInfo(dev,class,id,needed_parts)
+ *
+ * Finds the XkbSrvLedInfoPtr for the specified 'class' and 'id'
+ * on the device specified by 'dev.' If the class and id specify
+ * a valid device feedback, this function returns the existing
+ * feedback or allocates a new one.
+ *
+ */
XkbSrvLedInfoPtr
-XkbFindSrvLedInfo( DeviceIntPtr dev,
- unsigned class,
- unsigned id,
- unsigned needed_parts)
+XkbFindSrvLedInfo(DeviceIntPtr dev,
+ unsigned class, unsigned id, unsigned needed_parts)
{
-XkbSrvLedInfoPtr sli;
+ XkbSrvLedInfoPtr sli;
/* optimization to check for most common case */
- if (((class==XkbDfltXIClass)&&(id==XkbDfltXIId))&&(dev->kbdfeed)) {
- if (dev->kbdfeed->xkb_sli==NULL) {
- dev->kbdfeed->xkb_sli=
- XkbAllocSrvLedInfo(dev,dev->kbdfeed,NULL,needed_parts);
- }
- return dev->kbdfeed->xkb_sli;
- }
-
- sli= NULL;
- if (class==XkbDfltXIClass) {
- if (dev->kbdfeed) class= KbdFeedbackClass;
- else if (dev->leds) class= LedFeedbackClass;
- else return NULL;
- }
- if (class==KbdFeedbackClass) {
- KbdFeedbackPtr kf;
- for (kf=dev->kbdfeed;kf!=NULL;kf=kf->next) {
- if ((id==XkbDfltXIId)||(id==kf->ctrl.id)) {
- if (kf->xkb_sli==NULL)
- kf->xkb_sli= XkbAllocSrvLedInfo(dev,kf,NULL,needed_parts);
- sli= kf->xkb_sli;
- break;
- }
- }
- }
- else if (class==LedFeedbackClass) {
- LedFeedbackPtr lf;
- for (lf=dev->leds;lf!=NULL;lf=lf->next) {
- if ((id==XkbDfltXIId)||(id==lf->ctrl.id)) {
- if (lf->xkb_sli==NULL)
- lf->xkb_sli= XkbAllocSrvLedInfo(dev,NULL,lf,needed_parts);
- sli= lf->xkb_sli;
- break;
- }
- }
+ if (((class == XkbDfltXIClass) && (id == XkbDfltXIId)) && (dev->kbdfeed)) {
+ if (dev->kbdfeed->xkb_sli == NULL) {
+ dev->kbdfeed->xkb_sli =
+ XkbAllocSrvLedInfo(dev, dev->kbdfeed, NULL, needed_parts);
+ }
+ return dev->kbdfeed->xkb_sli;
+ }
+
+ sli = NULL;
+ if (class == XkbDfltXIClass) {
+ if (dev->kbdfeed)
+ class = KbdFeedbackClass;
+ else if (dev->leds)
+ class = LedFeedbackClass;
+ else
+ return NULL;
+ }
+ if (class == KbdFeedbackClass) {
+ KbdFeedbackPtr kf;
+
+ for (kf = dev->kbdfeed; kf != NULL; kf = kf->next) {
+ if ((id == XkbDfltXIId) || (id == kf->ctrl.id)) {
+ if (kf->xkb_sli == NULL)
+ kf->xkb_sli =
+ XkbAllocSrvLedInfo(dev, kf, NULL, needed_parts);
+ sli = kf->xkb_sli;
+ break;
+ }
+ }
+ }
+ else if (class == LedFeedbackClass) {
+ LedFeedbackPtr lf;
+
+ for (lf = dev->leds; lf != NULL; lf = lf->next) {
+ if ((id == XkbDfltXIId) || (id == lf->ctrl.id)) {
+ if (lf->xkb_sli == NULL)
+ lf->xkb_sli =
+ XkbAllocSrvLedInfo(dev, NULL, lf, needed_parts);
+ sli = lf->xkb_sli;
+ break;
+ }
+ }
}
if (sli) {
- if ((sli->names==NULL)&&(needed_parts&XkbXI_IndicatorNamesMask))
- sli->names= calloc(XkbNumIndicators, sizeof(Atom));
- if ((sli->maps==NULL)&&(needed_parts&XkbXI_IndicatorMapsMask))
- sli->maps= calloc(XkbNumIndicators, sizeof(XkbIndicatorMapRec));
+ if ((sli->names == NULL) && (needed_parts & XkbXI_IndicatorNamesMask))
+ sli->names = calloc(XkbNumIndicators, sizeof(Atom));
+ if ((sli->maps == NULL) && (needed_parts & XkbXI_IndicatorMapsMask))
+ sli->maps = calloc(XkbNumIndicators, sizeof(XkbIndicatorMapRec));
}
return sli;
}
@@ -727,34 +744,34 @@ XkbSrvLedInfoPtr sli;
/***====================================================================***/
void
-XkbFlushLedEvents( DeviceIntPtr dev,
- DeviceIntPtr kbd,
- XkbSrvLedInfoPtr sli,
- xkbExtensionDeviceNotify * ed,
- XkbChangesPtr changes,
- XkbEventCausePtr cause)
+XkbFlushLedEvents(DeviceIntPtr dev,
+ DeviceIntPtr kbd,
+ XkbSrvLedInfoPtr sli,
+ xkbExtensionDeviceNotify * ed,
+ XkbChangesPtr changes, XkbEventCausePtr cause)
{
if (changes) {
- if (changes->indicators.state_changes)
- XkbDDXUpdateDeviceIndicators(dev,sli,sli->effectiveState);
- XkbSendNotification(kbd,changes,cause);
- memset((char *)changes, 0, sizeof(XkbChangesRec));
-
- if (XkbAX_NeedFeedback(kbd->key->xkbInfo->desc->ctrls, XkbAX_IndicatorFBMask)) {
- if (sli->effectiveState)
- /* it appears that the which parameter is not used */
- XkbDDXAccessXBeep(dev, _BEEP_LED_ON, XkbAccessXFeedbackMask);
- else
- XkbDDXAccessXBeep(dev, _BEEP_LED_OFF, XkbAccessXFeedbackMask);
- }
+ if (changes->indicators.state_changes)
+ XkbDDXUpdateDeviceIndicators(dev, sli, sli->effectiveState);
+ XkbSendNotification(kbd, changes, cause);
+ memset((char *) changes, 0, sizeof(XkbChangesRec));
+
+ if (XkbAX_NeedFeedback
+ (kbd->key->xkbInfo->desc->ctrls, XkbAX_IndicatorFBMask)) {
+ if (sli->effectiveState)
+ /* it appears that the which parameter is not used */
+ XkbDDXAccessXBeep(dev, _BEEP_LED_ON, XkbAccessXFeedbackMask);
+ else
+ XkbDDXAccessXBeep(dev, _BEEP_LED_OFF, XkbAccessXFeedbackMask);
+ }
}
if (ed) {
- if (ed->reason) {
- if ((dev!=kbd)&&(ed->reason&XkbXI_IndicatorStateMask))
- XkbDDXUpdateDeviceIndicators(dev,sli,sli->effectiveState);
- XkbSendExtensionDeviceNotify(dev,cause->client,ed);
- }
- memset((char *)ed, 0, sizeof(XkbExtensionDeviceNotify));
+ if (ed->reason) {
+ if ((dev != kbd) && (ed->reason & XkbXI_IndicatorStateMask))
+ XkbDDXUpdateDeviceIndicators(dev, sli, sli->effectiveState);
+ XkbSendExtensionDeviceNotify(dev, cause->client, ed);
+ }
+ memset((char *) ed, 0, sizeof(XkbExtensionDeviceNotify));
}
return;
}
@@ -762,219 +779,227 @@ XkbFlushLedEvents( DeviceIntPtr dev,
/***====================================================================***/
void
-XkbApplyLedNameChanges( DeviceIntPtr dev,
- XkbSrvLedInfoPtr sli,
- unsigned changed_names,
- xkbExtensionDeviceNotify * ed,
- XkbChangesPtr changes,
- XkbEventCausePtr cause)
+XkbApplyLedNameChanges(DeviceIntPtr dev,
+ XkbSrvLedInfoPtr sli,
+ unsigned changed_names,
+ xkbExtensionDeviceNotify * ed,
+ XkbChangesPtr changes, XkbEventCausePtr cause)
{
-DeviceIntPtr kbd;
-XkbChangesRec my_changes;
-xkbExtensionDeviceNotify my_ed;
+ DeviceIntPtr kbd;
+ XkbChangesRec my_changes;
+ xkbExtensionDeviceNotify my_ed;
- if (changed_names==0)
- return;
+ if (changed_names == 0)
+ return;
if (dev->key && dev->key->xkbInfo)
- kbd= dev;
- else kbd= inputInfo.keyboard;
-
- if (ed==NULL) {
- ed= &my_ed;
- memset((char *)ed, 0, sizeof(xkbExtensionDeviceNotify));
- }
- else if ((ed->reason&XkbXI_IndicatorsMask)&&
- ((ed->ledClass!=sli->class)||(ed->ledID!=sli->id))) {
- XkbFlushLedEvents(dev,kbd,sli,ed,changes,cause);
- }
-
- if ((kbd==dev)&&(sli->flags&XkbSLI_IsDefault)) {
- if (changes==NULL) {
- changes= &my_changes;
- memset((char *)changes, 0, sizeof(XkbChangesRec));
- }
- changes->names.changed|= XkbIndicatorNamesMask;
- changes->names.changed_indicators|= changed_names;
- }
-
- ed->reason|= XkbXI_IndicatorNamesMask;
- ed->ledClass= sli->class;
- ed->ledID= sli->id;
- ed->ledsDefined= sli->namesPresent|sli->mapsPresent;
- ed->ledState= sli->effectiveState;
- ed->unsupported= 0;
- ed->supported= XkbXI_AllFeaturesMask;
-
- if (changes!=&my_changes) changes= NULL;
- if (ed!=&my_ed) ed= NULL;
+ kbd = dev;
+ else
+ kbd = inputInfo.keyboard;
+
+ if (ed == NULL) {
+ ed = &my_ed;
+ memset((char *) ed, 0, sizeof(xkbExtensionDeviceNotify));
+ }
+ else if ((ed->reason & XkbXI_IndicatorsMask) &&
+ ((ed->ledClass != sli->class) || (ed->ledID != sli->id))) {
+ XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause);
+ }
+
+ if ((kbd == dev) && (sli->flags & XkbSLI_IsDefault)) {
+ if (changes == NULL) {
+ changes = &my_changes;
+ memset((char *) changes, 0, sizeof(XkbChangesRec));
+ }
+ changes->names.changed |= XkbIndicatorNamesMask;
+ changes->names.changed_indicators |= changed_names;
+ }
+
+ ed->reason |= XkbXI_IndicatorNamesMask;
+ ed->ledClass = sli->class;
+ ed->ledID = sli->id;
+ ed->ledsDefined = sli->namesPresent | sli->mapsPresent;
+ ed->ledState = sli->effectiveState;
+ ed->unsupported = 0;
+ ed->supported = XkbXI_AllFeaturesMask;
+
+ if (changes != &my_changes)
+ changes = NULL;
+ if (ed != &my_ed)
+ ed = NULL;
if (changes || ed)
- XkbFlushLedEvents(dev,kbd,sli,ed,changes,cause);
+ XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause);
return;
}
+
/***====================================================================***/
- /*
- * void
- * XkbApplyLedMapChanges(dev,sli,changed_maps,changes,cause)
- *
- * Handles all of the secondary effects of the changes to the
- * feedback specified by 'sli' on the device specified by 'dev.'
- *
- * If 'changed_maps' specifies any indicators, this function generates
- * XkbExtensionDeviceNotify events and possibly IndicatorMapNotify
- * events to report the changes, and recalculates the effective
- * state of each indicator with a changed map. If any indicators
- * change state, the server generates XkbExtensionDeviceNotify and
- * XkbIndicatorStateNotify events as appropriate.
- *
- * If 'changes' is non-NULL, this function updates it to reflect
- * any changes to the keyboard state or controls or to the 'core'
- * indicator names, maps, or state. If 'changes' is NULL, this
- * function generates XKB events as needed to report the changes.
- * If 'dev' is not a keyboard device, any changes are reported
- * for the core keyboard.
- *
- * The 'cause' specifies the reason for the event (key event or
- * request) for the change, as reported in some XKB events.
- */
+ /*
+ * void
+ * XkbApplyLedMapChanges(dev,sli,changed_maps,changes,cause)
+ *
+ * Handles all of the secondary effects of the changes to the
+ * feedback specified by 'sli' on the device specified by 'dev.'
+ *
+ * If 'changed_maps' specifies any indicators, this function generates
+ * XkbExtensionDeviceNotify events and possibly IndicatorMapNotify
+ * events to report the changes, and recalculates the effective
+ * state of each indicator with a changed map. If any indicators
+ * change state, the server generates XkbExtensionDeviceNotify and
+ * XkbIndicatorStateNotify events as appropriate.
+ *
+ * If 'changes' is non-NULL, this function updates it to reflect
+ * any changes to the keyboard state or controls or to the 'core'
+ * indicator names, maps, or state. If 'changes' is NULL, this
+ * function generates XKB events as needed to report the changes.
+ * If 'dev' is not a keyboard device, any changes are reported
+ * for the core keyboard.
+ *
+ * The 'cause' specifies the reason for the event (key event or
+ * request) for the change, as reported in some XKB events.
+ */
void
-XkbApplyLedMapChanges( DeviceIntPtr dev,
- XkbSrvLedInfoPtr sli,
- unsigned changed_maps,
- xkbExtensionDeviceNotify * ed,
- XkbChangesPtr changes,
- XkbEventCausePtr cause)
+XkbApplyLedMapChanges(DeviceIntPtr dev,
+ XkbSrvLedInfoPtr sli,
+ unsigned changed_maps,
+ xkbExtensionDeviceNotify * ed,
+ XkbChangesPtr changes, XkbEventCausePtr cause)
{
-DeviceIntPtr kbd;
-XkbChangesRec my_changes;
-xkbExtensionDeviceNotify my_ed;
+ DeviceIntPtr kbd;
+ XkbChangesRec my_changes;
+ xkbExtensionDeviceNotify my_ed;
- if (changed_maps==0)
- return;
+ if (changed_maps == 0)
+ return;
if (dev->key && dev->key->xkbInfo)
- kbd= dev;
- else kbd= inputInfo.keyboard;
+ kbd = dev;
+ else
+ kbd = inputInfo.keyboard;
- if (ed==NULL) {
- ed= &my_ed;
- memset((char *)ed, 0, sizeof(xkbExtensionDeviceNotify));
+ if (ed == NULL) {
+ ed = &my_ed;
+ memset((char *) ed, 0, sizeof(xkbExtensionDeviceNotify));
}
- else if ((ed->reason&XkbXI_IndicatorsMask)&&
- ((ed->ledClass!=sli->class)||(ed->ledID!=sli->id))) {
- XkbFlushLedEvents(dev,kbd,sli,ed,changes,cause);
+ else if ((ed->reason & XkbXI_IndicatorsMask) &&
+ ((ed->ledClass != sli->class) || (ed->ledID != sli->id))) {
+ XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause);
}
- if ((kbd==dev)&&(sli->flags&XkbSLI_IsDefault)) {
- if (changes==NULL) {
- changes= &my_changes;
- memset((char *)changes, 0, sizeof(XkbChangesRec));
- }
- changes->indicators.map_changes|= changed_maps;
+ if ((kbd == dev) && (sli->flags & XkbSLI_IsDefault)) {
+ if (changes == NULL) {
+ changes = &my_changes;
+ memset((char *) changes, 0, sizeof(XkbChangesRec));
+ }
+ changes->indicators.map_changes |= changed_maps;
}
- XkbCheckIndicatorMaps(dev,sli,changed_maps);
+ XkbCheckIndicatorMaps(dev, sli, changed_maps);
- ed->reason|= XkbXI_IndicatorMapsMask;
- ed->ledClass= sli->class;
- ed->ledID= sli->id;
- ed->ledsDefined= sli->namesPresent|sli->mapsPresent;
- ed->ledState= sli->effectiveState;
- ed->unsupported= 0;
- ed->supported= XkbXI_AllFeaturesMask;
+ ed->reason |= XkbXI_IndicatorMapsMask;
+ ed->ledClass = sli->class;
+ ed->ledID = sli->id;
+ ed->ledsDefined = sli->namesPresent | sli->mapsPresent;
+ ed->ledState = sli->effectiveState;
+ ed->unsupported = 0;
+ ed->supported = XkbXI_AllFeaturesMask;
- XkbUpdateLedAutoState(dev,sli,changed_maps,ed,changes,cause);
+ XkbUpdateLedAutoState(dev, sli, changed_maps, ed, changes, cause);
- if (changes!=&my_changes) changes= NULL;
- if (ed!=&my_ed) ed= NULL;
+ if (changes != &my_changes)
+ changes = NULL;
+ if (ed != &my_ed)
+ ed = NULL;
if (changes || ed)
- XkbFlushLedEvents(dev,kbd,sli,ed,changes,cause);
+ XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause);
return;
}
/***====================================================================***/
void
-XkbApplyLedStateChanges(DeviceIntPtr dev,
- XkbSrvLedInfoPtr sli,
- unsigned changed_leds,
- xkbExtensionDeviceNotify * ed,
- XkbChangesPtr changes,
- XkbEventCausePtr cause)
+XkbApplyLedStateChanges(DeviceIntPtr dev,
+ XkbSrvLedInfoPtr sli,
+ unsigned changed_leds,
+ xkbExtensionDeviceNotify * ed,
+ XkbChangesPtr changes, XkbEventCausePtr cause)
{
-XkbSrvInfoPtr xkbi;
-DeviceIntPtr kbd;
-XkbChangesRec my_changes;
-xkbExtensionDeviceNotify my_ed;
-register unsigned i,bit,affected;
-XkbIndicatorMapPtr map;
-unsigned oldState;
-Bool kb_changed;
-
- if (changed_leds==0)
- return;
+ XkbSrvInfoPtr xkbi;
+ DeviceIntPtr kbd;
+ XkbChangesRec my_changes;
+ xkbExtensionDeviceNotify my_ed;
+ register unsigned i, bit, affected;
+ XkbIndicatorMapPtr map;
+ unsigned oldState;
+ Bool kb_changed;
+
+ if (changed_leds == 0)
+ return;
if (dev->key && dev->key->xkbInfo)
- kbd= dev;
- else kbd= inputInfo.keyboard;
- xkbi= kbd->key->xkbInfo;
-
- if (changes==NULL) {
- changes= &my_changes;
- memset((char *)changes, 0, sizeof(XkbChangesRec));
- }
-
- kb_changed= FALSE;
- affected= changed_leds;
- oldState= sli->effectiveState;
- for (i=0,bit=1;(i<XkbNumIndicators)&&(affected);i++,bit<<=1) {
- if ((affected&bit)==0)
- continue;
- affected&= ~bit;
- map= &sli->maps[i];
- if (map->flags&XkbIM_NoExplicit) {
- sli->explicitState&= ~bit;
- continue;
- }
- if (map->flags&XkbIM_LEDDrivesKB) {
- Bool on= ((sli->explicitState&bit)!=0);
- if (XkbApplyLEDChangeToKeyboard(xkbi,map,on,changes))
- kb_changed= TRUE;
- }
- }
- sli->effectiveState= (sli->autoState|sli->explicitState);
- affected= sli->effectiveState^oldState;
-
- if (ed==NULL) {
- ed= &my_ed;
- memset((char *)ed, 0, sizeof(xkbExtensionDeviceNotify));
- }
- else if (affected&&(ed->reason&XkbXI_IndicatorsMask)&&
- ((ed->ledClass!=sli->class)||(ed->ledID!=sli->id))) {
- XkbFlushLedEvents(dev,kbd,sli,ed,changes,cause);
- }
-
- if ((kbd==dev)&&(sli->flags&XkbSLI_IsDefault))
- changes->indicators.state_changes|= affected;
+ kbd = dev;
+ else
+ kbd = inputInfo.keyboard;
+ xkbi = kbd->key->xkbInfo;
+
+ if (changes == NULL) {
+ changes = &my_changes;
+ memset((char *) changes, 0, sizeof(XkbChangesRec));
+ }
+
+ kb_changed = FALSE;
+ affected = changed_leds;
+ oldState = sli->effectiveState;
+ for (i = 0, bit = 1; (i < XkbNumIndicators) && (affected); i++, bit <<= 1) {
+ if ((affected & bit) == 0)
+ continue;
+ affected &= ~bit;
+ map = &sli->maps[i];
+ if (map->flags & XkbIM_NoExplicit) {
+ sli->explicitState &= ~bit;
+ continue;
+ }
+ if (map->flags & XkbIM_LEDDrivesKB) {
+ Bool on = ((sli->explicitState & bit) != 0);
+
+ if (XkbApplyLEDChangeToKeyboard(xkbi, map, on, changes))
+ kb_changed = TRUE;
+ }
+ }
+ sli->effectiveState = (sli->autoState | sli->explicitState);
+ affected = sli->effectiveState ^ oldState;
+
+ if (ed == NULL) {
+ ed = &my_ed;
+ memset((char *) ed, 0, sizeof(xkbExtensionDeviceNotify));
+ }
+ else if (affected && (ed->reason & XkbXI_IndicatorsMask) &&
+ ((ed->ledClass != sli->class) || (ed->ledID != sli->id))) {
+ XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause);
+ }
+
+ if ((kbd == dev) && (sli->flags & XkbSLI_IsDefault))
+ changes->indicators.state_changes |= affected;
if (affected) {
- ed->reason|= XkbXI_IndicatorStateMask;
- ed->ledClass= sli->class;
- ed->ledID= sli->id;
- ed->ledsDefined= sli->namesPresent|sli->mapsPresent;
- ed->ledState= sli->effectiveState;
- ed->unsupported= 0;
- ed->supported= XkbXI_AllFeaturesMask;
+ ed->reason |= XkbXI_IndicatorStateMask;
+ ed->ledClass = sli->class;
+ ed->ledID = sli->id;
+ ed->ledsDefined = sli->namesPresent | sli->mapsPresent;
+ ed->ledState = sli->effectiveState;
+ ed->unsupported = 0;
+ ed->supported = XkbXI_AllFeaturesMask;
}
if (kb_changed) {
- XkbComputeDerivedState(kbd->key->xkbInfo);
- XkbUpdateLedAutoState(dev,sli,sli->mapsPresent,ed,changes,cause);
+ XkbComputeDerivedState(kbd->key->xkbInfo);
+ XkbUpdateLedAutoState(dev, sli, sli->mapsPresent, ed, changes, cause);
}
- if (changes!=&my_changes) changes= NULL;
- if (ed!=&my_ed) ed= NULL;
+ if (changes != &my_changes)
+ changes = NULL;
+ if (ed != &my_ed)
+ ed = NULL;
if (changes || ed)
- XkbFlushLedEvents(dev,kbd,sli,ed,changes,cause);
+ XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause);
if (kb_changed)
- XkbUpdateAllDeviceIndicators(NULL,cause);
+ XkbUpdateAllDeviceIndicators(NULL, cause);
return;
}
diff --git a/xkb/xkbPrKeyEv.c b/xkb/xkbPrKeyEv.c
index 630f17c23..32411838d 100644
--- a/xkb/xkbPrKeyEv.c
+++ b/xkb/xkbPrKeyEv.c
@@ -46,20 +46,21 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
void
XkbProcessKeyboardEvent(DeviceEvent *event, DeviceIntPtr keybd)
{
-KeyClassPtr keyc = keybd->key;
-XkbSrvInfoPtr xkbi;
-int key;
-XkbBehavior behavior;
-unsigned ndx;
+ KeyClassPtr keyc = keybd->key;
+ XkbSrvInfoPtr xkbi;
+ int key;
+ XkbBehavior behavior;
+ unsigned ndx;
xkbi = keyc->xkbInfo;
key = event->detail.key;
if (xkbDebugFlags & 0x8)
- DebugF("[xkb] XkbPKE: Key %d %s\n",key,(event->type == ET_KeyPress?"down":"up"));
+ DebugF("[xkb] XkbPKE: Key %d %s\n", key,
+ (event->type == ET_KeyPress ? "down" : "up"));
- if (xkbi->repeatKey == key && event->type== ET_KeyRelease &&
+ if (xkbi->repeatKey == key && event->type == ET_KeyRelease &&
!(xkbi->desc->ctrls->enabled_ctrls & XkbRepeatKeysMask))
- AccessXCancelRepeatKey(xkbi, key);
+ AccessXCancelRepeatKey(xkbi, key);
behavior = xkbi->desc->server->behaviors[key];
/* The "permanent" flag indicates a hard-wired behavior that occurs */
@@ -68,73 +69,79 @@ unsigned ndx;
/* key is hardwired */
if (!(behavior.type & XkbKB_Permanent)) {
- switch (behavior.type) {
- case XkbKB_Default:
- /* Neither of these should happen in practice, but ignore them
- anyway. */
- if (event->type == ET_KeyPress && !event->key_repeat &&
- key_is_down(keybd, key, KEY_PROCESSED))
+ switch (behavior.type) {
+ case XkbKB_Default:
+ /* Neither of these should happen in practice, but ignore them
+ anyway. */
+ if (event->type == ET_KeyPress && !event->key_repeat &&
+ key_is_down(keybd, key, KEY_PROCESSED))
+ return;
+ else if (event->type == ET_KeyRelease &&
+ !key_is_down(keybd, key, KEY_PROCESSED))
+ return;
+ break;
+ case XkbKB_Lock:
+ if (event->type == ET_KeyRelease)
+ return;
+ else if (key_is_down(keybd, key, KEY_PROCESSED))
+ event->type = ET_KeyRelease;
+ break;
+ case XkbKB_RadioGroup:
+ ndx = (behavior.data & (~XkbKB_RGAllowNone));
+ if (ndx < xkbi->nRadioGroups) {
+ XkbRadioGroupPtr rg;
+
+ if (event->type == ET_KeyRelease)
return;
- else if (event->type == ET_KeyRelease &&
- !key_is_down(keybd, key, KEY_PROCESSED))
+
+ rg = &xkbi->radioGroups[ndx];
+ if (rg->currentDown == event->detail.key) {
+ if (behavior.data & XkbKB_RGAllowNone) {
+ event->type = ET_KeyRelease;
+ XkbHandleActions(keybd, keybd, event);
+ rg->currentDown = 0;
+ }
return;
- break;
- case XkbKB_Lock:
- if (event->type == ET_KeyRelease)
- return;
- else if (key_is_down(keybd, key, KEY_PROCESSED))
+ }
+ if (rg->currentDown != 0) {
+ int key = event->detail.key;
+
event->type = ET_KeyRelease;
- break;
- case XkbKB_RadioGroup:
- ndx= (behavior.data&(~XkbKB_RGAllowNone));
- if ( ndx<xkbi->nRadioGroups ) {
- XkbRadioGroupPtr rg;
-
- if (event->type == ET_KeyRelease)
- return;
-
- rg = &xkbi->radioGroups[ndx];
- if ( rg->currentDown == event->detail.key) {
- if (behavior.data&XkbKB_RGAllowNone) {
- event->type = ET_KeyRelease;
- XkbHandleActions(keybd, keybd, event);
- rg->currentDown= 0;
- }
- return;
- }
- if ( rg->currentDown!=0 ) {
- int key = event->detail.key;
- event->type = ET_KeyRelease;
- event->detail.key = rg->currentDown;
- XkbHandleActions(keybd, keybd, event);
- event->type = ET_KeyPress;
- event->detail.key = key;
- }
- rg->currentDown= key;
- }
- else ErrorF("[xkb] InternalError! Illegal radio group %d\n",ndx);
- break;
- case XkbKB_Overlay1: case XkbKB_Overlay2:
- {
- unsigned which;
- if (behavior.type==XkbKB_Overlay1) which= XkbOverlay1Mask;
- else which= XkbOverlay2Mask;
- if ( (xkbi->desc->ctrls->enabled_ctrls&which)==0 )
- break;
- if ((behavior.data>=xkbi->desc->min_key_code)&&
- (behavior.data<=xkbi->desc->max_key_code)) {
- event->detail.key = behavior.data;
- /* 9/11/94 (ef) -- XXX! need to match release with */
- /* press even if the state of the */
- /* corresponding overlay control */
- /* changes while the key is down */
- }
- }
- break;
- default:
- ErrorF("[xkb] unknown key behavior 0x%04x\n",behavior.type);
- break;
- }
+ event->detail.key = rg->currentDown;
+ XkbHandleActions(keybd, keybd, event);
+ event->type = ET_KeyPress;
+ event->detail.key = key;
+ }
+ rg->currentDown = key;
+ }
+ else
+ ErrorF("[xkb] InternalError! Illegal radio group %d\n", ndx);
+ break;
+ case XkbKB_Overlay1:
+ case XkbKB_Overlay2:
+ {
+ unsigned which;
+
+ if (behavior.type == XkbKB_Overlay1)
+ which = XkbOverlay1Mask;
+ else
+ which = XkbOverlay2Mask;
+ if ((xkbi->desc->ctrls->enabled_ctrls & which) == 0)
+ break;
+ if ((behavior.data >= xkbi->desc->min_key_code) &&
+ (behavior.data <= xkbi->desc->max_key_code)) {
+ event->detail.key = behavior.data;
+ /* 9/11/94 (ef) -- XXX! need to match release with */
+ /* press even if the state of the */
+ /* corresponding overlay control */
+ /* changes while the key is down */
+ }
+ }
+ break;
+ default:
+ ErrorF("[xkb] unknown key behavior 0x%04x\n", behavior.type);
+ break;
+ }
}
XkbHandleActions(keybd, keybd, event);
return;
diff --git a/xkb/xkbSwap.c b/xkb/xkbSwap.c
index fcae918a9..076da340b 100644
--- a/xkb/xkbSwap.c
+++ b/xkb/xkbSwap.c
@@ -38,9 +38,9 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "extnsionst.h"
#include "xkb.h"
- /*
- * REQUEST SWAPPING
- */
+ /*
+ * REQUEST SWAPPING
+ */
static int
SProcXkbUseExtension(ClientPtr client)
{
@@ -66,66 +66,67 @@ SProcXkbSelectEvents(ClientPtr client)
swaps(&stuff->selectAll);
swaps(&stuff->affectMap);
swaps(&stuff->map);
- if ((stuff->affectWhich&(~XkbMapNotifyMask))!=0) {
- union {
- BOOL *b;
- CARD8 *c8;
- CARD16 *c16;
- CARD32 *c32;
- } from;
- register unsigned bit,ndx,maskLeft,dataLeft,size;
-
- from.c8= (CARD8 *)&stuff[1];
- dataLeft= (stuff->length*4)-SIZEOF(xkbSelectEventsReq);
- maskLeft= (stuff->affectWhich&(~XkbMapNotifyMask));
- for (ndx=0,bit=1; (maskLeft!=0); ndx++, bit<<=1) {
- if (((bit&maskLeft)==0)||(ndx==XkbMapNotify))
- continue;
- maskLeft&= ~bit;
- if ((stuff->selectAll&bit)||(stuff->clear&bit))
- continue;
- switch (ndx) {
- case XkbNewKeyboardNotify:
- case XkbStateNotify:
- case XkbNamesNotify:
- case XkbAccessXNotify:
- case XkbExtensionDeviceNotify:
- size= 2;
- break;
- case XkbControlsNotify:
- case XkbIndicatorStateNotify:
- case XkbIndicatorMapNotify:
- size= 4;
- break;
- case XkbBellNotify:
- case XkbActionMessage:
- case XkbCompatMapNotify:
- size= 1;
- break;
- default:
- client->errorValue = _XkbErrCode2(0x1,bit);
- return BadValue;
- }
- if (dataLeft<(size*2))
- return BadLength;
- if (size==2) {
- swaps(&from.c16[0]);
- swaps(&from.c16[1]);
- }
- else if (size==4) {
- swapl(&from.c32[0]);
- swapl(&from.c32[1]);
- }
- else {
- size= 2;
- }
- from.c8+= (size*2);
- dataLeft-= (size*2);
- }
- if (dataLeft>2) {
- ErrorF("[xkb] Extra data (%d bytes) after SelectEvents\n",dataLeft);
- return BadLength;
- }
+ if ((stuff->affectWhich & (~XkbMapNotifyMask)) != 0) {
+ union {
+ BOOL *b;
+ CARD8 *c8;
+ CARD16 *c16;
+ CARD32 *c32;
+ } from;
+ register unsigned bit, ndx, maskLeft, dataLeft, size;
+
+ from.c8 = (CARD8 *) &stuff[1];
+ dataLeft = (stuff->length * 4) - SIZEOF(xkbSelectEventsReq);
+ maskLeft = (stuff->affectWhich & (~XkbMapNotifyMask));
+ for (ndx = 0, bit = 1; (maskLeft != 0); ndx++, bit <<= 1) {
+ if (((bit & maskLeft) == 0) || (ndx == XkbMapNotify))
+ continue;
+ maskLeft &= ~bit;
+ if ((stuff->selectAll & bit) || (stuff->clear & bit))
+ continue;
+ switch (ndx) {
+ case XkbNewKeyboardNotify:
+ case XkbStateNotify:
+ case XkbNamesNotify:
+ case XkbAccessXNotify:
+ case XkbExtensionDeviceNotify:
+ size = 2;
+ break;
+ case XkbControlsNotify:
+ case XkbIndicatorStateNotify:
+ case XkbIndicatorMapNotify:
+ size = 4;
+ break;
+ case XkbBellNotify:
+ case XkbActionMessage:
+ case XkbCompatMapNotify:
+ size = 1;
+ break;
+ default:
+ client->errorValue = _XkbErrCode2(0x1, bit);
+ return BadValue;
+ }
+ if (dataLeft < (size * 2))
+ return BadLength;
+ if (size == 2) {
+ swaps(&from.c16[0]);
+ swaps(&from.c16[1]);
+ }
+ else if (size == 4) {
+ swapl(&from.c32[0]);
+ swapl(&from.c32[1]);
+ }
+ else {
+ size = 2;
+ }
+ from.c8 += (size * 2);
+ dataLeft -= (size * 2);
+ }
+ if (dataLeft > 2) {
+ ErrorF("[xkb] Extra data (%d bytes) after SelectEvents\n",
+ dataLeft);
+ return BadLength;
+ }
}
return ProcXkbSelectEvents(client);
}
@@ -244,7 +245,6 @@ SProcXkbSetMap(ClientPtr client)
return ProcXkbSetMap(client);
}
-
static int
SProcXkbGetCompatMap(ClientPtr client)
{
@@ -336,7 +336,6 @@ SProcXkbSetNamedIndicator(ClientPtr client)
return ProcXkbSetNamedIndicator(client);
}
-
static int
SProcXkbGetNames(ClientPtr client)
{
@@ -478,64 +477,63 @@ SProcXkbSetDebuggingFlags(ClientPtr client)
}
int
-SProcXkbDispatch (ClientPtr client)
+SProcXkbDispatch(ClientPtr client)
{
REQUEST(xReq);
- switch (stuff->data)
- {
+ switch (stuff->data) {
case X_kbUseExtension:
- return SProcXkbUseExtension(client);
+ return SProcXkbUseExtension(client);
case X_kbSelectEvents:
- return SProcXkbSelectEvents(client);
+ return SProcXkbSelectEvents(client);
case X_kbBell:
- return SProcXkbBell(client);
+ return SProcXkbBell(client);
case X_kbGetState:
- return SProcXkbGetState(client);
+ return SProcXkbGetState(client);
case X_kbLatchLockState:
- return SProcXkbLatchLockState(client);
+ return SProcXkbLatchLockState(client);
case X_kbGetControls:
- return SProcXkbGetControls(client);
+ return SProcXkbGetControls(client);
case X_kbSetControls:
- return SProcXkbSetControls(client);
+ return SProcXkbSetControls(client);
case X_kbGetMap:
- return SProcXkbGetMap(client);
+ return SProcXkbGetMap(client);
case X_kbSetMap:
- return SProcXkbSetMap(client);
+ return SProcXkbSetMap(client);
case X_kbGetCompatMap:
- return SProcXkbGetCompatMap(client);
+ return SProcXkbGetCompatMap(client);
case X_kbSetCompatMap:
- return SProcXkbSetCompatMap(client);
+ return SProcXkbSetCompatMap(client);
case X_kbGetIndicatorState:
- return SProcXkbGetIndicatorState(client);
+ return SProcXkbGetIndicatorState(client);
case X_kbGetIndicatorMap:
- return SProcXkbGetIndicatorMap(client);
+ return SProcXkbGetIndicatorMap(client);
case X_kbSetIndicatorMap:
- return SProcXkbSetIndicatorMap(client);
+ return SProcXkbSetIndicatorMap(client);
case X_kbGetNamedIndicator:
- return SProcXkbGetNamedIndicator(client);
+ return SProcXkbGetNamedIndicator(client);
case X_kbSetNamedIndicator:
- return SProcXkbSetNamedIndicator(client);
+ return SProcXkbSetNamedIndicator(client);
case X_kbGetNames:
- return SProcXkbGetNames(client);
+ return SProcXkbGetNames(client);
case X_kbSetNames:
- return SProcXkbSetNames(client);
+ return SProcXkbSetNames(client);
case X_kbGetGeometry:
- return SProcXkbGetGeometry(client);
+ return SProcXkbGetGeometry(client);
case X_kbSetGeometry:
- return SProcXkbSetGeometry(client);
+ return SProcXkbSetGeometry(client);
case X_kbPerClientFlags:
- return SProcXkbPerClientFlags(client);
+ return SProcXkbPerClientFlags(client);
case X_kbListComponents:
- return SProcXkbListComponents(client);
+ return SProcXkbListComponents(client);
case X_kbGetKbdByName:
- return SProcXkbGetKbdByName(client);
+ return SProcXkbGetKbdByName(client);
case X_kbGetDeviceInfo:
- return SProcXkbGetDeviceInfo(client);
+ return SProcXkbGetDeviceInfo(client);
case X_kbSetDeviceInfo:
- return SProcXkbSetDeviceInfo(client);
+ return SProcXkbSetDeviceInfo(client);
case X_kbSetDebuggingFlags:
- return SProcXkbSetDebuggingFlags(client);
+ return SProcXkbSetDebuggingFlags(client);
default:
- return BadRequest;
+ return BadRequest;
}
}
diff --git a/xkb/xkbUtils.c b/xkb/xkbUtils.c
index cc9aaa75a..c23cd7784 100644
--- a/xkb/xkbUtils.c
+++ b/xkb/xkbUtils.c
@@ -73,7 +73,7 @@ DEALINGS IN THE SOFTWARE.
int
_XkbLookupAnyDevice(DeviceIntPtr *pDev, int id, ClientPtr client,
- Mask access_mode, int *xkb_err)
+ Mask access_mode, int *xkb_err)
{
int rc = XkbKeyboardErrorCode;
@@ -84,14 +84,14 @@ _XkbLookupAnyDevice(DeviceIntPtr *pDev, int id, ClientPtr client,
rc = dixLookupDevice(pDev, id, client, access_mode);
if (rc != Success)
- *xkb_err = XkbErr_BadDevice;
+ *xkb_err = XkbErr_BadDevice;
return rc;
}
int
_XkbLookupKeyboard(DeviceIntPtr *pDev, int id, ClientPtr client,
- Mask access_mode, int *xkb_err)
+ Mask access_mode, int *xkb_err)
{
DeviceIntPtr dev;
int rc;
@@ -101,40 +101,40 @@ _XkbLookupKeyboard(DeviceIntPtr *pDev, int id, ClientPtr client,
rc = _XkbLookupAnyDevice(pDev, id, client, access_mode, xkb_err);
if (rc != Success)
- return rc;
+ return rc;
dev = *pDev;
if (!dev->key || !dev->key->xkbInfo) {
- *pDev = NULL;
- *xkb_err= XkbErr_BadClass;
- return XkbKeyboardErrorCode;
+ *pDev = NULL;
+ *xkb_err = XkbErr_BadClass;
+ return XkbKeyboardErrorCode;
}
return Success;
}
int
_XkbLookupBellDevice(DeviceIntPtr *pDev, int id, ClientPtr client,
- Mask access_mode, int *xkb_err)
+ Mask access_mode, int *xkb_err)
{
DeviceIntPtr dev;
int rc;
rc = _XkbLookupAnyDevice(pDev, id, client, access_mode, xkb_err);
if (rc != Success)
- return rc;
+ return rc;
dev = *pDev;
if (!dev->kbdfeed && !dev->bell) {
- *pDev = NULL;
- *xkb_err= XkbErr_BadClass;
- return XkbKeyboardErrorCode;
+ *pDev = NULL;
+ *xkb_err = XkbErr_BadClass;
+ return XkbKeyboardErrorCode;
}
return Success;
}
int
_XkbLookupLedDevice(DeviceIntPtr *pDev, int id, ClientPtr client,
- Mask access_mode, int *xkb_err)
+ Mask access_mode, int *xkb_err)
{
DeviceIntPtr dev;
int rc;
@@ -144,68 +144,70 @@ _XkbLookupLedDevice(DeviceIntPtr *pDev, int id, ClientPtr client,
rc = _XkbLookupAnyDevice(pDev, id, client, access_mode, xkb_err);
if (rc != Success)
- return rc;
+ return rc;
dev = *pDev;
if (!dev->kbdfeed && !dev->leds) {
- *pDev = NULL;
- *xkb_err= XkbErr_BadClass;
- return XkbKeyboardErrorCode;
+ *pDev = NULL;
+ *xkb_err = XkbErr_BadClass;
+ return XkbKeyboardErrorCode;
}
return Success;
}
int
_XkbLookupButtonDevice(DeviceIntPtr *pDev, int id, ClientPtr client,
- Mask access_mode, int *xkb_err)
+ Mask access_mode, int *xkb_err)
{
DeviceIntPtr dev;
int rc;
rc = _XkbLookupAnyDevice(pDev, id, client, access_mode, xkb_err);
if (rc != Success)
- return rc;
+ return rc;
dev = *pDev;
if (!dev->button) {
- *pDev = NULL;
- *xkb_err= XkbErr_BadClass;
- return XkbKeyboardErrorCode;
+ *pDev = NULL;
+ *xkb_err = XkbErr_BadClass;
+ return XkbKeyboardErrorCode;
}
return Success;
}
void
-XkbSetActionKeyMods(XkbDescPtr xkb,XkbAction *act,unsigned mods)
+XkbSetActionKeyMods(XkbDescPtr xkb, XkbAction *act, unsigned mods)
{
-register unsigned tmp;
+ register unsigned tmp;
switch (act->type) {
- case XkbSA_SetMods: case XkbSA_LatchMods: case XkbSA_LockMods:
- if (act->mods.flags&XkbSA_UseModMapMods)
- act->mods.real_mods= act->mods.mask= mods;
- if ((tmp= XkbModActionVMods(&act->mods))!=0)
- act->mods.mask|= XkbMaskForVMask(xkb,tmp);
- break;
- case XkbSA_ISOLock:
- if (act->iso.flags&XkbSA_UseModMapMods)
- act->iso.real_mods= act->iso.mask= mods;
- if ((tmp= XkbModActionVMods(&act->iso))!=0)
- act->iso.mask|= XkbMaskForVMask(xkb,tmp);
- break;
+ case XkbSA_SetMods:
+ case XkbSA_LatchMods:
+ case XkbSA_LockMods:
+ if (act->mods.flags & XkbSA_UseModMapMods)
+ act->mods.real_mods = act->mods.mask = mods;
+ if ((tmp = XkbModActionVMods(&act->mods)) != 0)
+ act->mods.mask |= XkbMaskForVMask(xkb, tmp);
+ break;
+ case XkbSA_ISOLock:
+ if (act->iso.flags & XkbSA_UseModMapMods)
+ act->iso.real_mods = act->iso.mask = mods;
+ if ((tmp = XkbModActionVMods(&act->iso)) != 0)
+ act->iso.mask |= XkbMaskForVMask(xkb, tmp);
+ break;
}
return;
}
unsigned
-XkbMaskForVMask(XkbDescPtr xkb,unsigned vmask)
+XkbMaskForVMask(XkbDescPtr xkb, unsigned vmask)
{
-register int i,bit;
-register unsigned mask;
-
- for (mask=i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
- if (vmask&bit)
- mask|= xkb->server->vmods[i];
+ register int i, bit;
+ register unsigned mask;
+
+ for (mask = i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+ if (vmask & bit)
+ mask |= xkb->server->vmods[i];
}
return mask;
}
@@ -213,147 +215,144 @@ register unsigned mask;
/***====================================================================***/
void
-XkbUpdateKeyTypesFromCore( DeviceIntPtr pXDev,
- KeySymsPtr pCore,
- KeyCode first,
- CARD8 num,
- XkbChangesPtr changes)
+XkbUpdateKeyTypesFromCore(DeviceIntPtr pXDev,
+ KeySymsPtr pCore,
+ KeyCode first, CARD8 num, XkbChangesPtr changes)
{
-XkbDescPtr xkb;
-unsigned key,nG,explicit;
-int types[XkbNumKbdGroups];
-KeySym tsyms[XkbMaxSymsPerKey],*syms;
-XkbMapChangesPtr mc;
-
- xkb= pXDev->key->xkbInfo->desc;
- if (first+num-1>xkb->max_key_code) {
- /* 1/12/95 (ef) -- XXX! should allow XKB structures to grow */
- num= xkb->max_key_code-first+1;
+ XkbDescPtr xkb;
+ unsigned key, nG, explicit;
+ int types[XkbNumKbdGroups];
+ KeySym tsyms[XkbMaxSymsPerKey], *syms;
+ XkbMapChangesPtr mc;
+
+ xkb = pXDev->key->xkbInfo->desc;
+ if (first + num - 1 > xkb->max_key_code) {
+ /* 1/12/95 (ef) -- XXX! should allow XKB structures to grow */
+ num = xkb->max_key_code - first + 1;
}
- mc= (changes?(&changes->map):NULL);
-
- syms= &pCore->map[(first - pCore->minKeyCode) * pCore->mapWidth];
- for (key=first; key<(first+num); key++,syms+= pCore->mapWidth) {
- explicit= xkb->server->explicit[key]&XkbExplicitKeyTypesMask;
- types[XkbGroup1Index]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup1Index);
- types[XkbGroup2Index]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup2Index);
- types[XkbGroup3Index]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup3Index);
- types[XkbGroup4Index]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup4Index);
- nG= XkbKeyTypesForCoreSymbols(xkb,pCore->mapWidth,syms,explicit,types,
- tsyms);
- XkbChangeTypesOfKey(xkb,key,nG,XkbAllGroupsMask,types,mc);
- memcpy((char *)XkbKeySymsPtr(xkb,key),(char *)tsyms,
- XkbKeyNumSyms(xkb,key)*sizeof(KeySym));
+ mc = (changes ? (&changes->map) : NULL);
+
+ syms = &pCore->map[(first - pCore->minKeyCode) * pCore->mapWidth];
+ for (key = first; key < (first + num); key++, syms += pCore->mapWidth) {
+ explicit = xkb->server->explicit[key] & XkbExplicitKeyTypesMask;
+ types[XkbGroup1Index] = XkbKeyKeyTypeIndex(xkb, key, XkbGroup1Index);
+ types[XkbGroup2Index] = XkbKeyKeyTypeIndex(xkb, key, XkbGroup2Index);
+ types[XkbGroup3Index] = XkbKeyKeyTypeIndex(xkb, key, XkbGroup3Index);
+ types[XkbGroup4Index] = XkbKeyKeyTypeIndex(xkb, key, XkbGroup4Index);
+ nG = XkbKeyTypesForCoreSymbols(xkb, pCore->mapWidth, syms, explicit,
+ types, tsyms);
+ XkbChangeTypesOfKey(xkb, key, nG, XkbAllGroupsMask, types, mc);
+ memcpy((char *) XkbKeySymsPtr(xkb, key), (char *) tsyms,
+ XkbKeyNumSyms(xkb, key) * sizeof(KeySym));
}
- if (changes->map.changed&XkbKeySymsMask) {
- CARD8 oldLast,newLast;
- oldLast = changes->map.first_key_sym+changes->map.num_key_syms-1;
- newLast = first+num-1;
-
- if (first<changes->map.first_key_sym)
- changes->map.first_key_sym = first;
- if (oldLast>newLast)
- newLast= oldLast;
- changes->map.num_key_syms = newLast-changes->map.first_key_sym+1;
+ if (changes->map.changed & XkbKeySymsMask) {
+ CARD8 oldLast, newLast;
+
+ oldLast = changes->map.first_key_sym + changes->map.num_key_syms - 1;
+ newLast = first + num - 1;
+
+ if (first < changes->map.first_key_sym)
+ changes->map.first_key_sym = first;
+ if (oldLast > newLast)
+ newLast = oldLast;
+ changes->map.num_key_syms = newLast - changes->map.first_key_sym + 1;
}
else {
- changes->map.changed|= XkbKeySymsMask;
- changes->map.first_key_sym = first;
- changes->map.num_key_syms = num;
+ changes->map.changed |= XkbKeySymsMask;
+ changes->map.first_key_sym = first;
+ changes->map.num_key_syms = num;
}
return;
}
void
-XkbUpdateDescActions( XkbDescPtr xkb,
- KeyCode first,
- CARD8 num,
- XkbChangesPtr changes)
+XkbUpdateDescActions(XkbDescPtr xkb,
+ KeyCode first, CARD8 num, XkbChangesPtr changes)
{
-register unsigned key;
+ register unsigned key;
- for (key=first;key<(first+num);key++) {
- XkbApplyCompatMapToKey(xkb,key,changes);
+ for (key = first; key < (first + num); key++) {
+ XkbApplyCompatMapToKey(xkb, key, changes);
}
- if (changes->map.changed&(XkbVirtualModMapMask|XkbModifierMapMask)) {
- unsigned char newVMods[XkbNumVirtualMods];
- register unsigned bit,i;
- unsigned present;
+ if (changes->map.changed & (XkbVirtualModMapMask | XkbModifierMapMask)) {
+ unsigned char newVMods[XkbNumVirtualMods];
+ register unsigned bit, i;
+ unsigned present;
memset(newVMods, 0, XkbNumVirtualMods);
- present= 0;
- for (key=xkb->min_key_code;key<=xkb->max_key_code;key++) {
- if (xkb->server->vmodmap[key]==0)
+ present = 0;
+ for (key = xkb->min_key_code; key <= xkb->max_key_code; key++) {
+ if (xkb->server->vmodmap[key] == 0)
continue;
- for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
- if (bit&xkb->server->vmodmap[key]) {
- present|= bit;
- newVMods[i]|= xkb->map->modmap[key];
+ for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+ if (bit & xkb->server->vmodmap[key]) {
+ present |= bit;
+ newVMods[i] |= xkb->map->modmap[key];
}
}
}
- for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
- if ((bit&present)&&(newVMods[i]!=xkb->server->vmods[i])) {
- changes->map.changed|= XkbVirtualModsMask;
- changes->map.vmods|= bit;
- xkb->server->vmods[i]= newVMods[i];
+ for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+ if ((bit & present) && (newVMods[i] != xkb->server->vmods[i])) {
+ changes->map.changed |= XkbVirtualModsMask;
+ changes->map.vmods |= bit;
+ xkb->server->vmods[i] = newVMods[i];
}
}
}
- if (changes->map.changed&XkbVirtualModsMask)
- XkbApplyVirtualModChanges(xkb,changes->map.vmods,changes);
-
- if (changes->map.changed&XkbKeyActionsMask) {
- CARD8 oldLast,newLast;
- oldLast= changes->map.first_key_act+changes->map.num_key_acts-1;
- newLast = first+num-1;
-
- if (first<changes->map.first_key_act)
- changes->map.first_key_act = first;
- if (newLast>oldLast)
- newLast= oldLast;
- changes->map.num_key_acts= newLast-changes->map.first_key_act+1;
+ if (changes->map.changed & XkbVirtualModsMask)
+ XkbApplyVirtualModChanges(xkb, changes->map.vmods, changes);
+
+ if (changes->map.changed & XkbKeyActionsMask) {
+ CARD8 oldLast, newLast;
+
+ oldLast = changes->map.first_key_act + changes->map.num_key_acts - 1;
+ newLast = first + num - 1;
+
+ if (first < changes->map.first_key_act)
+ changes->map.first_key_act = first;
+ if (newLast > oldLast)
+ newLast = oldLast;
+ changes->map.num_key_acts = newLast - changes->map.first_key_act + 1;
}
else {
- changes->map.changed|= XkbKeyActionsMask;
- changes->map.first_key_act = first;
- changes->map.num_key_acts = num;
+ changes->map.changed |= XkbKeyActionsMask;
+ changes->map.first_key_act = first;
+ changes->map.num_key_acts = num;
}
return;
}
void
-XkbUpdateActions( DeviceIntPtr pXDev,
- KeyCode first,
- CARD8 num,
- XkbChangesPtr changes,
- unsigned * needChecksRtrn,
- XkbEventCausePtr cause)
+XkbUpdateActions(DeviceIntPtr pXDev,
+ KeyCode first,
+ CARD8 num,
+ XkbChangesPtr changes,
+ unsigned *needChecksRtrn, XkbEventCausePtr cause)
{
-XkbSrvInfoPtr xkbi;
-XkbDescPtr xkb;
-CARD8 * repeat;
+ XkbSrvInfoPtr xkbi;
+ XkbDescPtr xkb;
+ CARD8 *repeat;
if (needChecksRtrn)
- *needChecksRtrn= 0;
- xkbi= pXDev->key->xkbInfo;
- xkb= xkbi->desc;
- repeat= xkb->ctrls->per_key_repeat;
+ *needChecksRtrn = 0;
+ xkbi = pXDev->key->xkbInfo;
+ xkb = xkbi->desc;
+ repeat = xkb->ctrls->per_key_repeat;
/* before letting XKB do any changes, copy the current core values */
if (pXDev->kbdfeed)
- memcpy(repeat,pXDev->kbdfeed->ctrl.autoRepeats,XkbPerKeyBitArraySize);
+ memcpy(repeat, pXDev->kbdfeed->ctrl.autoRepeats, XkbPerKeyBitArraySize);
- XkbUpdateDescActions(xkb,first,num,changes);
+ XkbUpdateDescActions(xkb, first, num, changes);
- if ((pXDev->kbdfeed)&&
- (changes->ctrls.changed_ctrls&XkbPerKeyRepeatMask)) {
- /* now copy the modified changes back to core */
- memcpy(pXDev->kbdfeed->ctrl.autoRepeats,repeat, XkbPerKeyBitArraySize);
- if (pXDev->kbdfeed->CtrlProc)
- (*pXDev->kbdfeed->CtrlProc)(pXDev, &pXDev->kbdfeed->ctrl);
+ if ((pXDev->kbdfeed) &&
+ (changes->ctrls.changed_ctrls & XkbPerKeyRepeatMask)) {
+ /* now copy the modified changes back to core */
+ memcpy(pXDev->kbdfeed->ctrl.autoRepeats, repeat, XkbPerKeyBitArraySize);
+ if (pXDev->kbdfeed->CtrlProc)
+ (*pXDev->kbdfeed->CtrlProc) (pXDev, &pXDev->kbdfeed->ctrl);
}
return;
}
@@ -361,53 +360,57 @@ CARD8 * repeat;
KeySymsPtr
XkbGetCoreMap(DeviceIntPtr keybd)
{
-register int key,tmp;
-int maxSymsPerKey, maxGroup1Width;
-XkbDescPtr xkb;
-KeySymsPtr syms;
-int maxNumberOfGroups;
+ register int key, tmp;
+ int maxSymsPerKey, maxGroup1Width;
+ XkbDescPtr xkb;
+ KeySymsPtr syms;
+ int maxNumberOfGroups;
if (!keybd || !keybd->key || !keybd->key->xkbInfo)
- return NULL;
+ return NULL;
- xkb= keybd->key->xkbInfo->desc;
- maxSymsPerKey= maxGroup1Width= 0;
+ xkb = keybd->key->xkbInfo->desc;
+ maxSymsPerKey = maxGroup1Width = 0;
maxNumberOfGroups = 0;
/* determine sizes */
- for (key=xkb->min_key_code;key<=xkb->max_key_code;key++) {
- if (XkbKeycodeInRange(xkb,key)) {
- int nGroups;
- int w;
- nGroups= XkbKeyNumGroups(xkb,key);
- tmp= 0;
- if (nGroups>0) {
- if ((w=XkbKeyGroupWidth(xkb,key,XkbGroup1Index))<=2)
- tmp+= 2;
- else tmp+= w + 2;
+ for (key = xkb->min_key_code; key <= xkb->max_key_code; key++) {
+ if (XkbKeycodeInRange(xkb, key)) {
+ int nGroups;
+ int w;
+
+ nGroups = XkbKeyNumGroups(xkb, key);
+ tmp = 0;
+ if (nGroups > 0) {
+ if ((w = XkbKeyGroupWidth(xkb, key, XkbGroup1Index)) <= 2)
+ tmp += 2;
+ else
+ tmp += w + 2;
/* remember highest G1 width */
if (w > maxGroup1Width)
maxGroup1Width = w;
- }
- if (nGroups>1) {
+ }
+ if (nGroups > 1) {
if (tmp <= 2) {
- if ((w=XkbKeyGroupWidth(xkb,key,XkbGroup2Index))<2)
- tmp+= 2;
- else tmp+= w;
- } else {
- if ((w=XkbKeyGroupWidth(xkb,key,XkbGroup2Index))>2)
- tmp+= w - 2;
+ if ((w = XkbKeyGroupWidth(xkb, key, XkbGroup2Index)) < 2)
+ tmp += 2;
+ else
+ tmp += w;
+ }
+ else {
+ if ((w = XkbKeyGroupWidth(xkb, key, XkbGroup2Index)) > 2)
+ tmp += w - 2;
}
- }
- if (nGroups>2)
- tmp+= XkbKeyGroupWidth(xkb,key,XkbGroup3Index);
- if (nGroups>3)
- tmp+= XkbKeyGroupWidth(xkb,key,XkbGroup4Index);
- if (tmp>maxSymsPerKey)
- maxSymsPerKey= tmp;
+ }
+ if (nGroups > 2)
+ tmp += XkbKeyGroupWidth(xkb, key, XkbGroup3Index);
+ if (nGroups > 3)
+ tmp += XkbKeyGroupWidth(xkb, key, XkbGroup4Index);
+ if (tmp > maxSymsPerKey)
+ maxSymsPerKey = tmp;
if (nGroups > maxNumberOfGroups)
- maxNumberOfGroups = nGroups;
- }
+ maxNumberOfGroups = nGroups;
+ }
}
if (maxSymsPerKey <= 0)
@@ -436,104 +439,110 @@ int maxNumberOfGroups;
return NULL;
}
- for (key=xkb->min_key_code;key<=xkb->max_key_code;key++) {
- KeySym *pCore,*pXKB;
- unsigned nGroups,groupWidth,n,nOut;
-
- nGroups= XkbKeyNumGroups(xkb,key);
- n= (key-xkb->min_key_code)*syms->mapWidth;
- pCore= &syms->map[n];
- pXKB= XkbKeySymsPtr(xkb,key);
- nOut= 2;
- if (nGroups>0) {
- groupWidth= XkbKeyGroupWidth(xkb,key,XkbGroup1Index);
- if (groupWidth>0) pCore[0]= pXKB[0];
- if (groupWidth>1) pCore[1]= pXKB[1];
- for (n=2;n<groupWidth;n++)
- pCore[2+n]= pXKB[n];
- if (groupWidth>2)
- nOut= groupWidth;
- }
-
- /* See XKB Protocol Sec, Section 12.4.
+ for (key = xkb->min_key_code; key <= xkb->max_key_code; key++) {
+ KeySym *pCore, *pXKB;
+ unsigned nGroups, groupWidth, n, nOut;
+
+ nGroups = XkbKeyNumGroups(xkb, key);
+ n = (key - xkb->min_key_code) * syms->mapWidth;
+ pCore = &syms->map[n];
+ pXKB = XkbKeySymsPtr(xkb, key);
+ nOut = 2;
+ if (nGroups > 0) {
+ groupWidth = XkbKeyGroupWidth(xkb, key, XkbGroup1Index);
+ if (groupWidth > 0)
+ pCore[0] = pXKB[0];
+ if (groupWidth > 1)
+ pCore[1] = pXKB[1];
+ for (n = 2; n < groupWidth; n++)
+ pCore[2 + n] = pXKB[n];
+ if (groupWidth > 2)
+ nOut = groupWidth;
+ }
+
+ /* See XKB Protocol Sec, Section 12.4.
A 1-group key with ABCDE on a 2 group keyboard must be
- duplicated across all groups as ABABCDECDE.
- */
- if (nGroups == 1)
- {
- int idx, j;
-
- groupWidth = XkbKeyGroupWidth(xkb, key, XkbGroup1Index);
-
- /* AB..CDE... -> ABABCDE... */
- if (groupWidth > 0 && syms->mapWidth >= 3)
- pCore[2] = pCore[0];
- if (groupWidth > 1 && syms->mapWidth >= 4)
- pCore[3] = pCore[1];
-
- /* ABABCDE... -> ABABCDECDE */
- idx = 2 + groupWidth;
- while (groupWidth > 2 && idx < syms->mapWidth &&
- idx < groupWidth * 2)
- {
- pCore[idx] = pCore[idx - groupWidth + 2];
- idx++;
- }
- idx = 2 * groupWidth;
- if (idx < 4)
- idx = 4;
- /* 3 or more groups: ABABCDECDEABCDEABCDE */
- for (j = 3; j <= maxNumberOfGroups; j++)
- for (n = 0; n < groupWidth && idx < maxSymsPerKey; n++)
- pCore[idx++] = pXKB[n];
- }
-
- pXKB+= XkbKeyGroupsWidth(xkb,key);
- nOut+= 2;
- if (nGroups>1) {
- groupWidth= XkbKeyGroupWidth(xkb,key,XkbGroup2Index);
- if (groupWidth>0) pCore[2]= pXKB[0];
- if (groupWidth>1) pCore[3]= pXKB[1];
- for (n=2;n<groupWidth;n++) {
- pCore[nOut+(n-2)]= pXKB[n];
- }
- if (groupWidth>2)
- nOut+= (groupWidth-2);
- }
- pXKB+= XkbKeyGroupsWidth(xkb,key);
- for (n=XkbGroup3Index;n<nGroups;n++) {
- register int s;
- groupWidth= XkbKeyGroupWidth(xkb,key,n);
- for (s=0;s<groupWidth;s++) {
- pCore[nOut++]= pXKB[s];
- }
- pXKB+= XkbKeyGroupsWidth(xkb,key);
- }
+ duplicated across all groups as ABABCDECDE.
+ */
+ if (nGroups == 1) {
+ int idx, j;
+
+ groupWidth = XkbKeyGroupWidth(xkb, key, XkbGroup1Index);
+
+ /* AB..CDE... -> ABABCDE... */
+ if (groupWidth > 0 && syms->mapWidth >= 3)
+ pCore[2] = pCore[0];
+ if (groupWidth > 1 && syms->mapWidth >= 4)
+ pCore[3] = pCore[1];
+
+ /* ABABCDE... -> ABABCDECDE */
+ idx = 2 + groupWidth;
+ while (groupWidth > 2 && idx < syms->mapWidth &&
+ idx < groupWidth * 2) {
+ pCore[idx] = pCore[idx - groupWidth + 2];
+ idx++;
+ }
+ idx = 2 * groupWidth;
+ if (idx < 4)
+ idx = 4;
+ /* 3 or more groups: ABABCDECDEABCDEABCDE */
+ for (j = 3; j <= maxNumberOfGroups; j++)
+ for (n = 0; n < groupWidth && idx < maxSymsPerKey; n++)
+ pCore[idx++] = pXKB[n];
+ }
+
+ pXKB += XkbKeyGroupsWidth(xkb, key);
+ nOut += 2;
+ if (nGroups > 1) {
+ groupWidth = XkbKeyGroupWidth(xkb, key, XkbGroup2Index);
+ if (groupWidth > 0)
+ pCore[2] = pXKB[0];
+ if (groupWidth > 1)
+ pCore[3] = pXKB[1];
+ for (n = 2; n < groupWidth; n++) {
+ pCore[nOut + (n - 2)] = pXKB[n];
+ }
+ if (groupWidth > 2)
+ nOut += (groupWidth - 2);
+ }
+ pXKB += XkbKeyGroupsWidth(xkb, key);
+ for (n = XkbGroup3Index; n < nGroups; n++) {
+ register int s;
+
+ groupWidth = XkbKeyGroupWidth(xkb, key, n);
+ for (s = 0; s < groupWidth; s++) {
+ pCore[nOut++] = pXKB[s];
+ }
+ pXKB += XkbKeyGroupsWidth(xkb, key);
+ }
}
return syms;
}
void
-XkbSetRepeatKeys(DeviceIntPtr pXDev,int key,int onoff)
+XkbSetRepeatKeys(DeviceIntPtr pXDev, int key, int onoff)
{
if (pXDev && pXDev->key && pXDev->key->xkbInfo) {
- xkbControlsNotify cn;
- XkbControlsPtr ctrls = pXDev->key->xkbInfo->desc->ctrls;
- XkbControlsRec old;
- old = *ctrls;
-
- if (key== -1) { /* global autorepeat setting changed */
- if (onoff) ctrls->enabled_ctrls |= XkbRepeatKeysMask;
- else ctrls->enabled_ctrls &= ~XkbRepeatKeysMask;
- }
- else if (pXDev->kbdfeed) {
- ctrls->per_key_repeat[key/8] =
- pXDev->kbdfeed->ctrl.autoRepeats[key/8];
- }
-
- if (XkbComputeControlsNotify(pXDev,&old,ctrls,&cn,TRUE))
- XkbSendControlsNotify(pXDev,&cn);
+ xkbControlsNotify cn;
+ XkbControlsPtr ctrls = pXDev->key->xkbInfo->desc->ctrls;
+ XkbControlsRec old;
+
+ old = *ctrls;
+
+ if (key == -1) { /* global autorepeat setting changed */
+ if (onoff)
+ ctrls->enabled_ctrls |= XkbRepeatKeysMask;
+ else
+ ctrls->enabled_ctrls &= ~XkbRepeatKeysMask;
+ }
+ else if (pXDev->kbdfeed) {
+ ctrls->per_key_repeat[key / 8] =
+ pXDev->kbdfeed->ctrl.autoRepeats[key / 8];
+ }
+
+ if (XkbComputeControlsNotify(pXDev, &old, ctrls, &cn, TRUE))
+ XkbSendControlsNotify(pXDev, &cn);
}
return;
}
@@ -566,7 +575,7 @@ XkbApplyMappingChange(DeviceIntPtr kbd, KeySymsPtr map, KeyCode first_key,
/* A keymap change can imply a modmap change, se we prefer the
* former. */
if (!cause.mjr)
- XkbSetCauseCoreReq(&cause,X_SetModifierMapping,client);
+ XkbSetCauseCoreReq(&cause, X_SetModifierMapping, client);
check = 0;
num_keys = xkb->max_key_code - xkb->min_key_code + 1;
@@ -585,102 +594,110 @@ XkbApplyMappingChange(DeviceIntPtr kbd, KeySymsPtr map, KeyCode first_key,
}
void
-XkbDisableComputedAutoRepeats(DeviceIntPtr dev,unsigned key)
+XkbDisableComputedAutoRepeats(DeviceIntPtr dev, unsigned key)
{
-XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
-xkbMapNotify mn;
+ XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
+ xkbMapNotify mn;
- xkbi->desc->server->explicit[key]|= XkbExplicitAutoRepeatMask;
+ xkbi->desc->server->explicit[key] |= XkbExplicitAutoRepeatMask;
memset(&mn, 0, sizeof(mn));
- mn.changed= XkbExplicitComponentsMask;
- mn.firstKeyExplicit= key;
- mn.nKeyExplicit= 1;
- XkbSendMapNotify(dev,&mn);
+ mn.changed = XkbExplicitComponentsMask;
+ mn.firstKeyExplicit = key;
+ mn.nKeyExplicit = 1;
+ XkbSendMapNotify(dev, &mn);
return;
}
unsigned
-XkbStateChangedFlags(XkbStatePtr old,XkbStatePtr new)
+XkbStateChangedFlags(XkbStatePtr old, XkbStatePtr new)
{
-int changed;
-
- changed=(old->group!=new->group?XkbGroupStateMask:0);
- changed|=(old->base_group!=new->base_group?XkbGroupBaseMask:0);
- changed|=(old->latched_group!=new->latched_group?XkbGroupLatchMask:0);
- changed|=(old->locked_group!=new->locked_group?XkbGroupLockMask:0);
- changed|=(old->mods!=new->mods?XkbModifierStateMask:0);
- changed|=(old->base_mods!=new->base_mods?XkbModifierBaseMask:0);
- changed|=(old->latched_mods!=new->latched_mods?XkbModifierLatchMask:0);
- changed|=(old->locked_mods!=new->locked_mods?XkbModifierLockMask:0);
- changed|=(old->compat_state!=new->compat_state?XkbCompatStateMask:0);
- changed|=(old->grab_mods!=new->grab_mods?XkbGrabModsMask:0);
- if (old->compat_grab_mods!=new->compat_grab_mods)
- changed|= XkbCompatGrabModsMask;
- changed|=(old->lookup_mods!=new->lookup_mods?XkbLookupModsMask:0);
- if (old->compat_lookup_mods!=new->compat_lookup_mods)
- changed|= XkbCompatLookupModsMask;
- changed|=(old->ptr_buttons!=new->ptr_buttons?XkbPointerButtonMask:0);
+ int changed;
+
+ changed = (old->group != new->group ? XkbGroupStateMask : 0);
+ changed |= (old->base_group != new->base_group ? XkbGroupBaseMask : 0);
+ changed |=
+ (old->latched_group != new->latched_group ? XkbGroupLatchMask : 0);
+ changed |= (old->locked_group != new->locked_group ? XkbGroupLockMask : 0);
+ changed |= (old->mods != new->mods ? XkbModifierStateMask : 0);
+ changed |= (old->base_mods != new->base_mods ? XkbModifierBaseMask : 0);
+ changed |=
+ (old->latched_mods != new->latched_mods ? XkbModifierLatchMask : 0);
+ changed |= (old->locked_mods != new->locked_mods ? XkbModifierLockMask : 0);
+ changed |=
+ (old->compat_state != new->compat_state ? XkbCompatStateMask : 0);
+ changed |= (old->grab_mods != new->grab_mods ? XkbGrabModsMask : 0);
+ if (old->compat_grab_mods != new->compat_grab_mods)
+ changed |= XkbCompatGrabModsMask;
+ changed |= (old->lookup_mods != new->lookup_mods ? XkbLookupModsMask : 0);
+ if (old->compat_lookup_mods != new->compat_lookup_mods)
+ changed |= XkbCompatLookupModsMask;
+ changed |=
+ (old->ptr_buttons != new->ptr_buttons ? XkbPointerButtonMask : 0);
return changed;
}
static void
XkbComputeCompatState(XkbSrvInfoPtr xkbi)
{
-CARD16 grp_mask;
-XkbStatePtr state= &xkbi->state;
-XkbCompatMapPtr map;
+ CARD16 grp_mask;
+ XkbStatePtr state = &xkbi->state;
+ XkbCompatMapPtr map;
if (!state || !xkbi->desc || !xkbi->desc->ctrls || !xkbi->desc->compat)
return;
- map= xkbi->desc->compat;
- grp_mask= map->groups[state->group].mask;
- state->compat_state = state->mods|grp_mask;
- state->compat_lookup_mods= state->lookup_mods|grp_mask;
+ map = xkbi->desc->compat;
+ grp_mask = map->groups[state->group].mask;
+ state->compat_state = state->mods | grp_mask;
+ state->compat_lookup_mods = state->lookup_mods | grp_mask;
- if (xkbi->desc->ctrls->enabled_ctrls&XkbIgnoreGroupLockMask)
- grp_mask= map->groups[state->base_group].mask;
- state->compat_grab_mods= state->grab_mods|grp_mask;
+ if (xkbi->desc->ctrls->enabled_ctrls & XkbIgnoreGroupLockMask)
+ grp_mask = map->groups[state->base_group].mask;
+ state->compat_grab_mods = state->grab_mods | grp_mask;
return;
}
unsigned
-XkbAdjustGroup(int group,XkbControlsPtr ctrls)
+XkbAdjustGroup(int group, XkbControlsPtr ctrls)
{
-unsigned act;
-
- act= XkbOutOfRangeGroupAction(ctrls->groups_wrap);
- if (group<0) {
- while ( group < 0 ) {
- if (act==XkbClampIntoRange) {
- group= XkbGroup1Index;
- }
- else if (act==XkbRedirectIntoRange) {
- int newGroup;
- newGroup= XkbOutOfRangeGroupNumber(ctrls->groups_wrap);
- if (newGroup>=ctrls->num_groups)
- group= XkbGroup1Index;
- else group= newGroup;
- }
- else {
- group+= ctrls->num_groups;
- }
- }
+ unsigned act;
+
+ act = XkbOutOfRangeGroupAction(ctrls->groups_wrap);
+ if (group < 0) {
+ while (group < 0) {
+ if (act == XkbClampIntoRange) {
+ group = XkbGroup1Index;
+ }
+ else if (act == XkbRedirectIntoRange) {
+ int newGroup;
+
+ newGroup = XkbOutOfRangeGroupNumber(ctrls->groups_wrap);
+ if (newGroup >= ctrls->num_groups)
+ group = XkbGroup1Index;
+ else
+ group = newGroup;
+ }
+ else {
+ group += ctrls->num_groups;
+ }
+ }
}
- else if (group>=ctrls->num_groups) {
- if (act==XkbClampIntoRange) {
- group= ctrls->num_groups-1;
- }
- else if (act==XkbRedirectIntoRange) {
- int newGroup;
- newGroup= XkbOutOfRangeGroupNumber(ctrls->groups_wrap);
- if (newGroup>=ctrls->num_groups)
- group= XkbGroup1Index;
- else group= newGroup;
- }
- else {
- group%= ctrls->num_groups;
- }
+ else if (group >= ctrls->num_groups) {
+ if (act == XkbClampIntoRange) {
+ group = ctrls->num_groups - 1;
+ }
+ else if (act == XkbRedirectIntoRange) {
+ int newGroup;
+
+ newGroup = XkbOutOfRangeGroupNumber(ctrls->groups_wrap);
+ if (newGroup >= ctrls->num_groups)
+ group = XkbGroup1Index;
+ else
+ group = newGroup;
+ }
+ else {
+ group %= ctrls->num_groups;
+ }
}
return group;
}
@@ -688,28 +705,28 @@ unsigned act;
void
XkbComputeDerivedState(XkbSrvInfoPtr xkbi)
{
-XkbStatePtr state= &xkbi->state;
-XkbControlsPtr ctrls= xkbi->desc->ctrls;
-unsigned char grp;
+ XkbStatePtr state = &xkbi->state;
+ XkbControlsPtr ctrls = xkbi->desc->ctrls;
+ unsigned char grp;
if (!state || !ctrls)
return;
- state->mods= (state->base_mods|state->latched_mods|state->locked_mods);
- state->lookup_mods= state->mods&(~ctrls->internal.mask);
- state->grab_mods= state->lookup_mods&(~ctrls->ignore_lock.mask);
- state->grab_mods|=
- ((state->base_mods|state->latched_mods)&ctrls->ignore_lock.mask);
-
+ state->mods = (state->base_mods | state->latched_mods | state->locked_mods);
+ state->lookup_mods = state->mods & (~ctrls->internal.mask);
+ state->grab_mods = state->lookup_mods & (~ctrls->ignore_lock.mask);
+ state->grab_mods |=
+ ((state->base_mods | state->latched_mods) & ctrls->ignore_lock.mask);
- grp= state->locked_group;
- if (grp>=ctrls->num_groups)
- state->locked_group= XkbAdjustGroup(XkbCharToInt(grp),ctrls);
+ grp = state->locked_group;
+ if (grp >= ctrls->num_groups)
+ state->locked_group = XkbAdjustGroup(XkbCharToInt(grp), ctrls);
- grp= state->locked_group+state->base_group+state->latched_group;
- if (grp>=ctrls->num_groups)
- state->group= XkbAdjustGroup(XkbCharToInt(grp),ctrls);
- else state->group= grp;
+ grp = state->locked_group + state->base_group + state->latched_group;
+ if (grp >= ctrls->num_groups)
+ state->group = XkbAdjustGroup(XkbCharToInt(grp), ctrls);
+ else
+ state->group = grp;
XkbComputeCompatState(xkbi);
return;
}
@@ -717,67 +734,68 @@ unsigned char grp;
/***====================================================================***/
void
-XkbCheckSecondaryEffects( XkbSrvInfoPtr xkbi,
- unsigned which,
- XkbChangesPtr changes,
- XkbEventCausePtr cause)
+XkbCheckSecondaryEffects(XkbSrvInfoPtr xkbi,
+ unsigned which,
+ XkbChangesPtr changes, XkbEventCausePtr cause)
{
- if (which&XkbStateNotifyMask) {
- XkbStateRec old;
- old= xkbi->state;
- changes->state_changes|= XkbStateChangedFlags(&old,&xkbi->state);
- XkbComputeDerivedState(xkbi);
+ if (which & XkbStateNotifyMask) {
+ XkbStateRec old;
+
+ old = xkbi->state;
+ changes->state_changes |= XkbStateChangedFlags(&old, &xkbi->state);
+ XkbComputeDerivedState(xkbi);
}
- if (which&XkbIndicatorStateNotifyMask)
- XkbUpdateIndicators(xkbi->device,XkbAllIndicatorsMask,TRUE,changes,
- cause);
+ if (which & XkbIndicatorStateNotifyMask)
+ XkbUpdateIndicators(xkbi->device, XkbAllIndicatorsMask, TRUE, changes,
+ cause);
return;
}
/***====================================================================***/
Bool
-XkbEnableDisableControls( XkbSrvInfoPtr xkbi,
- unsigned long change,
- unsigned long newValues,
- XkbChangesPtr changes,
- XkbEventCausePtr cause)
+XkbEnableDisableControls(XkbSrvInfoPtr xkbi,
+ unsigned long change,
+ unsigned long newValues,
+ XkbChangesPtr changes, XkbEventCausePtr cause)
{
-XkbControlsPtr ctrls;
-unsigned old;
-XkbSrvLedInfoPtr sli;
-
- ctrls= xkbi->desc->ctrls;
- old= ctrls->enabled_ctrls;
- ctrls->enabled_ctrls&= ~change;
- ctrls->enabled_ctrls|= (change&newValues);
- if (old==ctrls->enabled_ctrls)
- return FALSE;
- if (cause!=NULL) {
- xkbControlsNotify cn;
- cn.numGroups= ctrls->num_groups;
- cn.changedControls= XkbControlsEnabledMask;
- cn.enabledControls= ctrls->enabled_ctrls;
- cn.enabledControlChanges= (ctrls->enabled_ctrls^old);
- cn.keycode= cause->kc;
- cn.eventType= cause->event;
- cn.requestMajor= cause->mjr;
- cn.requestMinor= cause->mnr;
- XkbSendControlsNotify(xkbi->device,&cn);
+ XkbControlsPtr ctrls;
+ unsigned old;
+ XkbSrvLedInfoPtr sli;
+
+ ctrls = xkbi->desc->ctrls;
+ old = ctrls->enabled_ctrls;
+ ctrls->enabled_ctrls &= ~change;
+ ctrls->enabled_ctrls |= (change & newValues);
+ if (old == ctrls->enabled_ctrls)
+ return FALSE;
+ if (cause != NULL) {
+ xkbControlsNotify cn;
+
+ cn.numGroups = ctrls->num_groups;
+ cn.changedControls = XkbControlsEnabledMask;
+ cn.enabledControls = ctrls->enabled_ctrls;
+ cn.enabledControlChanges = (ctrls->enabled_ctrls ^ old);
+ cn.keycode = cause->kc;
+ cn.eventType = cause->event;
+ cn.requestMajor = cause->mjr;
+ cn.requestMinor = cause->mnr;
+ XkbSendControlsNotify(xkbi->device, &cn);
}
else {
- /* Yes, this really should be an XOR. If ctrls->enabled_ctrls_changes*/
- /* is non-zero, the controls in question changed already in "this" */
- /* request and this change merely undoes the previous one. By the */
- /* same token, we have to figure out whether or not ControlsEnabled */
- /* should be set or not in the changes structure */
- changes->ctrls.enabled_ctrls_changes^= (ctrls->enabled_ctrls^old);
- if (changes->ctrls.enabled_ctrls_changes)
- changes->ctrls.changed_ctrls|= XkbControlsEnabledMask;
- else changes->ctrls.changed_ctrls&= ~XkbControlsEnabledMask;
+ /* Yes, this really should be an XOR. If ctrls->enabled_ctrls_changes */
+ /* is non-zero, the controls in question changed already in "this" */
+ /* request and this change merely undoes the previous one. By the */
+ /* same token, we have to figure out whether or not ControlsEnabled */
+ /* should be set or not in the changes structure */
+ changes->ctrls.enabled_ctrls_changes ^= (ctrls->enabled_ctrls ^ old);
+ if (changes->ctrls.enabled_ctrls_changes)
+ changes->ctrls.changed_ctrls |= XkbControlsEnabledMask;
+ else
+ changes->ctrls.changed_ctrls &= ~XkbControlsEnabledMask;
}
- sli= XkbFindSrvLedInfo(xkbi->device,XkbDfltXIClass,XkbDfltXIId,0);
- XkbUpdateIndicators(xkbi->device,sli->usesControls,TRUE,changes,cause);
+ sli = XkbFindSrvLedInfo(xkbi->device, XkbDfltXIClass, XkbDfltXIId, 0);
+ XkbUpdateIndicators(xkbi->device, sli->usesControls, TRUE, changes, cause);
return TRUE;
}
@@ -786,120 +804,120 @@ XkbSrvLedInfoPtr sli;
#define MAX_TOC 16
XkbGeometryPtr
-XkbLookupNamedGeometry(DeviceIntPtr dev,Atom name,Bool *shouldFree)
+XkbLookupNamedGeometry(DeviceIntPtr dev, Atom name, Bool *shouldFree)
{
-XkbSrvInfoPtr xkbi= dev->key->xkbInfo;
-XkbDescPtr xkb= xkbi->desc;
-
- *shouldFree= 0;
- if (name==None) {
- if (xkb->geom!=NULL)
- return xkb->geom;
- name= xkb->names->geometry;
+ XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
+ XkbDescPtr xkb = xkbi->desc;
+
+ *shouldFree = 0;
+ if (name == None) {
+ if (xkb->geom != NULL)
+ return xkb->geom;
+ name = xkb->names->geometry;
}
- if ((xkb->geom!=NULL)&&(xkb->geom->name==name))
- return xkb->geom;
- *shouldFree= 1;
+ if ((xkb->geom != NULL) && (xkb->geom->name == name))
+ return xkb->geom;
+ *shouldFree = 1;
return NULL;
}
void
-XkbConvertCase(register KeySym sym, KeySym *lower, KeySym *upper)
+XkbConvertCase(register KeySym sym, KeySym * lower, KeySym * upper)
{
*lower = sym;
*upper = sym;
- switch(sym >> 8) {
- case 0: /* Latin 1 */
- if ((sym >= XK_A) && (sym <= XK_Z))
- *lower += (XK_a - XK_A);
- else if ((sym >= XK_a) && (sym <= XK_z))
- *upper -= (XK_a - XK_A);
- else if ((sym >= XK_Agrave) && (sym <= XK_Odiaeresis))
- *lower += (XK_agrave - XK_Agrave);
- else if ((sym >= XK_agrave) && (sym <= XK_odiaeresis))
- *upper -= (XK_agrave - XK_Agrave);
- else if ((sym >= XK_Ooblique) && (sym <= XK_Thorn))
- *lower += (XK_oslash - XK_Ooblique);
- else if ((sym >= XK_oslash) && (sym <= XK_thorn))
- *upper -= (XK_oslash - XK_Ooblique);
- break;
- case 1: /* Latin 2 */
- /* Assume the KeySym is a legal value (ignore discontinuities) */
- if (sym == XK_Aogonek)
- *lower = XK_aogonek;
- else if (sym >= XK_Lstroke && sym <= XK_Sacute)
- *lower += (XK_lstroke - XK_Lstroke);
- else if (sym >= XK_Scaron && sym <= XK_Zacute)
- *lower += (XK_scaron - XK_Scaron);
- else if (sym >= XK_Zcaron && sym <= XK_Zabovedot)
- *lower += (XK_zcaron - XK_Zcaron);
- else if (sym == XK_aogonek)
- *upper = XK_Aogonek;
- else if (sym >= XK_lstroke && sym <= XK_sacute)
- *upper -= (XK_lstroke - XK_Lstroke);
- else if (sym >= XK_scaron && sym <= XK_zacute)
- *upper -= (XK_scaron - XK_Scaron);
- else if (sym >= XK_zcaron && sym <= XK_zabovedot)
- *upper -= (XK_zcaron - XK_Zcaron);
- else if (sym >= XK_Racute && sym <= XK_Tcedilla)
- *lower += (XK_racute - XK_Racute);
- else if (sym >= XK_racute && sym <= XK_tcedilla)
- *upper -= (XK_racute - XK_Racute);
- break;
- case 2: /* Latin 3 */
- /* Assume the KeySym is a legal value (ignore discontinuities) */
- if (sym >= XK_Hstroke && sym <= XK_Hcircumflex)
- *lower += (XK_hstroke - XK_Hstroke);
- else if (sym >= XK_Gbreve && sym <= XK_Jcircumflex)
- *lower += (XK_gbreve - XK_Gbreve);
- else if (sym >= XK_hstroke && sym <= XK_hcircumflex)
- *upper -= (XK_hstroke - XK_Hstroke);
- else if (sym >= XK_gbreve && sym <= XK_jcircumflex)
- *upper -= (XK_gbreve - XK_Gbreve);
- else if (sym >= XK_Cabovedot && sym <= XK_Scircumflex)
- *lower += (XK_cabovedot - XK_Cabovedot);
- else if (sym >= XK_cabovedot && sym <= XK_scircumflex)
- *upper -= (XK_cabovedot - XK_Cabovedot);
- break;
- case 3: /* Latin 4 */
- /* Assume the KeySym is a legal value (ignore discontinuities) */
- if (sym >= XK_Rcedilla && sym <= XK_Tslash)
- *lower += (XK_rcedilla - XK_Rcedilla);
- else if (sym >= XK_rcedilla && sym <= XK_tslash)
- *upper -= (XK_rcedilla - XK_Rcedilla);
- else if (sym == XK_ENG)
- *lower = XK_eng;
- else if (sym == XK_eng)
- *upper = XK_ENG;
- else if (sym >= XK_Amacron && sym <= XK_Umacron)
- *lower += (XK_amacron - XK_Amacron);
- else if (sym >= XK_amacron && sym <= XK_umacron)
- *upper -= (XK_amacron - XK_Amacron);
- break;
- case 6: /* Cyrillic */
- /* Assume the KeySym is a legal value (ignore discontinuities) */
- if (sym >= XK_Serbian_DJE && sym <= XK_Serbian_DZE)
- *lower -= (XK_Serbian_DJE - XK_Serbian_dje);
- else if (sym >= XK_Serbian_dje && sym <= XK_Serbian_dze)
- *upper += (XK_Serbian_DJE - XK_Serbian_dje);
- else if (sym >= XK_Cyrillic_YU && sym <= XK_Cyrillic_HARDSIGN)
- *lower -= (XK_Cyrillic_YU - XK_Cyrillic_yu);
- else if (sym >= XK_Cyrillic_yu && sym <= XK_Cyrillic_hardsign)
- *upper += (XK_Cyrillic_YU - XK_Cyrillic_yu);
+ switch (sym >> 8) {
+ case 0: /* Latin 1 */
+ if ((sym >= XK_A) && (sym <= XK_Z))
+ *lower += (XK_a - XK_A);
+ else if ((sym >= XK_a) && (sym <= XK_z))
+ *upper -= (XK_a - XK_A);
+ else if ((sym >= XK_Agrave) && (sym <= XK_Odiaeresis))
+ *lower += (XK_agrave - XK_Agrave);
+ else if ((sym >= XK_agrave) && (sym <= XK_odiaeresis))
+ *upper -= (XK_agrave - XK_Agrave);
+ else if ((sym >= XK_Ooblique) && (sym <= XK_Thorn))
+ *lower += (XK_oslash - XK_Ooblique);
+ else if ((sym >= XK_oslash) && (sym <= XK_thorn))
+ *upper -= (XK_oslash - XK_Ooblique);
+ break;
+ case 1: /* Latin 2 */
+ /* Assume the KeySym is a legal value (ignore discontinuities) */
+ if (sym == XK_Aogonek)
+ *lower = XK_aogonek;
+ else if (sym >= XK_Lstroke && sym <= XK_Sacute)
+ *lower += (XK_lstroke - XK_Lstroke);
+ else if (sym >= XK_Scaron && sym <= XK_Zacute)
+ *lower += (XK_scaron - XK_Scaron);
+ else if (sym >= XK_Zcaron && sym <= XK_Zabovedot)
+ *lower += (XK_zcaron - XK_Zcaron);
+ else if (sym == XK_aogonek)
+ *upper = XK_Aogonek;
+ else if (sym >= XK_lstroke && sym <= XK_sacute)
+ *upper -= (XK_lstroke - XK_Lstroke);
+ else if (sym >= XK_scaron && sym <= XK_zacute)
+ *upper -= (XK_scaron - XK_Scaron);
+ else if (sym >= XK_zcaron && sym <= XK_zabovedot)
+ *upper -= (XK_zcaron - XK_Zcaron);
+ else if (sym >= XK_Racute && sym <= XK_Tcedilla)
+ *lower += (XK_racute - XK_Racute);
+ else if (sym >= XK_racute && sym <= XK_tcedilla)
+ *upper -= (XK_racute - XK_Racute);
+ break;
+ case 2: /* Latin 3 */
+ /* Assume the KeySym is a legal value (ignore discontinuities) */
+ if (sym >= XK_Hstroke && sym <= XK_Hcircumflex)
+ *lower += (XK_hstroke - XK_Hstroke);
+ else if (sym >= XK_Gbreve && sym <= XK_Jcircumflex)
+ *lower += (XK_gbreve - XK_Gbreve);
+ else if (sym >= XK_hstroke && sym <= XK_hcircumflex)
+ *upper -= (XK_hstroke - XK_Hstroke);
+ else if (sym >= XK_gbreve && sym <= XK_jcircumflex)
+ *upper -= (XK_gbreve - XK_Gbreve);
+ else if (sym >= XK_Cabovedot && sym <= XK_Scircumflex)
+ *lower += (XK_cabovedot - XK_Cabovedot);
+ else if (sym >= XK_cabovedot && sym <= XK_scircumflex)
+ *upper -= (XK_cabovedot - XK_Cabovedot);
+ break;
+ case 3: /* Latin 4 */
+ /* Assume the KeySym is a legal value (ignore discontinuities) */
+ if (sym >= XK_Rcedilla && sym <= XK_Tslash)
+ *lower += (XK_rcedilla - XK_Rcedilla);
+ else if (sym >= XK_rcedilla && sym <= XK_tslash)
+ *upper -= (XK_rcedilla - XK_Rcedilla);
+ else if (sym == XK_ENG)
+ *lower = XK_eng;
+ else if (sym == XK_eng)
+ *upper = XK_ENG;
+ else if (sym >= XK_Amacron && sym <= XK_Umacron)
+ *lower += (XK_amacron - XK_Amacron);
+ else if (sym >= XK_amacron && sym <= XK_umacron)
+ *upper -= (XK_amacron - XK_Amacron);
break;
- case 7: /* Greek */
- /* Assume the KeySym is a legal value (ignore discontinuities) */
- if (sym >= XK_Greek_ALPHAaccent && sym <= XK_Greek_OMEGAaccent)
- *lower += (XK_Greek_alphaaccent - XK_Greek_ALPHAaccent);
- else if (sym >= XK_Greek_alphaaccent && sym <= XK_Greek_omegaaccent &&
- sym != XK_Greek_iotaaccentdieresis &&
- sym != XK_Greek_upsilonaccentdieresis)
- *upper -= (XK_Greek_alphaaccent - XK_Greek_ALPHAaccent);
- else if (sym >= XK_Greek_ALPHA && sym <= XK_Greek_OMEGA)
- *lower += (XK_Greek_alpha - XK_Greek_ALPHA);
- else if (sym >= XK_Greek_alpha && sym <= XK_Greek_omega &&
- sym != XK_Greek_finalsmallsigma)
- *upper -= (XK_Greek_alpha - XK_Greek_ALPHA);
+ case 6: /* Cyrillic */
+ /* Assume the KeySym is a legal value (ignore discontinuities) */
+ if (sym >= XK_Serbian_DJE && sym <= XK_Serbian_DZE)
+ *lower -= (XK_Serbian_DJE - XK_Serbian_dje);
+ else if (sym >= XK_Serbian_dje && sym <= XK_Serbian_dze)
+ *upper += (XK_Serbian_DJE - XK_Serbian_dje);
+ else if (sym >= XK_Cyrillic_YU && sym <= XK_Cyrillic_HARDSIGN)
+ *lower -= (XK_Cyrillic_YU - XK_Cyrillic_yu);
+ else if (sym >= XK_Cyrillic_yu && sym <= XK_Cyrillic_hardsign)
+ *upper += (XK_Cyrillic_YU - XK_Cyrillic_yu);
+ break;
+ case 7: /* Greek */
+ /* Assume the KeySym is a legal value (ignore discontinuities) */
+ if (sym >= XK_Greek_ALPHAaccent && sym <= XK_Greek_OMEGAaccent)
+ *lower += (XK_Greek_alphaaccent - XK_Greek_ALPHAaccent);
+ else if (sym >= XK_Greek_alphaaccent && sym <= XK_Greek_omegaaccent &&
+ sym != XK_Greek_iotaaccentdieresis &&
+ sym != XK_Greek_upsilonaccentdieresis)
+ *upper -= (XK_Greek_alphaaccent - XK_Greek_ALPHAaccent);
+ else if (sym >= XK_Greek_ALPHA && sym <= XK_Greek_OMEGA)
+ *lower += (XK_Greek_alpha - XK_Greek_ALPHA);
+ else if (sym >= XK_Greek_alpha && sym <= XK_Greek_omega &&
+ sym != XK_Greek_finalsmallsigma)
+ *upper -= (XK_Greek_alpha - XK_Greek_ALPHA);
break;
}
}
@@ -960,13 +978,13 @@ _XkbCopyClientMap(XkbDescPtr src, XkbDescPtr dst)
!dst->map->types || !dst->map->size_types) {
if (dst->map->types && dst->map->size_types) {
tmp = realloc(dst->map->types,
- src->map->num_types * sizeof(XkbKeyTypeRec));
+ src->map->num_types * sizeof(XkbKeyTypeRec));
if (!tmp)
return FALSE;
dst->map->types = tmp;
memset(dst->map->types + dst->map->num_types, 0,
- (src->map->num_types - dst->map->num_types) *
- sizeof(XkbKeyTypeRec));
+ (src->map->num_types - dst->map->num_types) *
+ sizeof(XkbKeyTypeRec));
}
else {
tmp = calloc(src->map->num_types, sizeof(XkbKeyTypeRec));
@@ -997,7 +1015,7 @@ _XkbCopyClientMap(XkbDescPtr src, XkbDescPtr dst)
dtype->num_levels && dtype->level_names &&
i < dst->map->num_types) {
tmp = realloc(dtype->level_names,
- stype->num_levels * sizeof(Atom));
+ stype->num_levels * sizeof(Atom));
if (!tmp)
continue;
dtype->level_names = tmp;
@@ -1030,8 +1048,8 @@ _XkbCopyClientMap(XkbDescPtr src, XkbDescPtr dst)
dtype->map_count && dtype->map &&
i < dst->map->num_types) {
tmp = realloc(dtype->map,
- stype->map_count *
- sizeof(XkbKTMapEntryRec));
+ stype->map_count *
+ sizeof(XkbKTMapEntryRec));
if (!tmp)
return FALSE;
dtype->map = tmp;
@@ -1039,7 +1057,7 @@ _XkbCopyClientMap(XkbDescPtr src, XkbDescPtr dst)
else if (!dtype->map_count || !dtype->map ||
i >= dst->map->num_types) {
tmp = malloc(stype->map_count *
- sizeof(XkbKTMapEntryRec));
+ sizeof(XkbKTMapEntryRec));
if (!tmp)
return FALSE;
dtype->map = tmp;
@@ -1059,16 +1077,15 @@ _XkbCopyClientMap(XkbDescPtr src, XkbDescPtr dst)
dtype->map_count && dtype->preserve &&
i < dst->map->num_types) {
tmp = realloc(dtype->preserve,
- stype->map_count *
- sizeof(XkbModsRec));
+ stype->map_count *
+ sizeof(XkbModsRec));
if (!tmp)
return FALSE;
dtype->preserve = tmp;
}
else if (!dtype->preserve || !dtype->map_count ||
i >= dst->map->num_types) {
- tmp = malloc(stype->map_count *
- sizeof(XkbModsRec));
+ tmp = malloc(stype->map_count * sizeof(XkbModsRec));
if (!tmp)
return FALSE;
dtype->preserve = tmp;
@@ -1182,8 +1199,8 @@ _XkbCopyServerMap(XkbDescPtr src, XkbDescPtr dst)
free(dst->server->acts);
dst->server->acts = NULL;
}
- dst->server->size_acts = src->server->size_acts;
- dst->server->num_acts = src->server->num_acts;
+ dst->server->size_acts = src->server->size_acts;
+ dst->server->num_acts = src->server->num_acts;
if (src->server->key_acts) {
if (src->max_key_code != dst->max_key_code) {
@@ -1402,8 +1419,8 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
* the source, run through and free all the excess ones
* first. */
if (src->geom->num_properties < dst->geom->sz_properties) {
- for (i = src->geom->num_properties, dprop = dst->geom->properties + i;
- i < dst->geom->num_properties;
+ for (i = src->geom->num_properties, dprop =
+ dst->geom->properties + i; i < dst->geom->num_properties;
i++, dprop++) {
free(dprop->name);
free(dprop->value);
@@ -1411,18 +1428,19 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
}
/* Reallocate and clear all new items if the buffer grows. */
- if (!XkbGeomRealloc((void **)&dst->geom->properties, dst->geom->sz_properties, src->geom->num_properties,
- sizeof(XkbPropertyRec), XKB_GEOM_CLEAR_EXCESS))
+ if (!XkbGeomRealloc
+ ((void **) &dst->geom->properties, dst->geom->sz_properties,
+ src->geom->num_properties, sizeof(XkbPropertyRec),
+ XKB_GEOM_CLEAR_EXCESS))
return FALSE;
/* We don't set num_properties as we need it to try and avoid
* too much reallocing. */
dst->geom->sz_properties = src->geom->num_properties;
for (i = 0,
- sprop = src->geom->properties,
- dprop = dst->geom->properties;
- i < src->geom->num_properties;
- i++, sprop++, dprop++) {
+ sprop = src->geom->properties,
+ dprop = dst->geom->properties;
+ i < src->geom->num_properties; i++, sprop++, dprop++) {
if (i < dst->geom->num_properties) {
if (strlen(sprop->name) != strlen(dprop->name)) {
tmp = realloc(dprop->name, strlen(sprop->name) + 1);
@@ -1451,8 +1469,7 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
else {
if (dst->geom->sz_properties) {
for (i = 0, dprop = dst->geom->properties;
- i < dst->geom->num_properties;
- i++, dprop++) {
+ i < dst->geom->num_properties; i++, dprop++) {
free(dprop->name);
free(dprop->value);
}
@@ -1468,23 +1485,23 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
if (src->geom->num_colors) {
if (src->geom->num_colors < dst->geom->sz_colors) {
for (i = src->geom->num_colors, dcolor = dst->geom->colors + i;
- i < dst->geom->num_colors;
- i++, dcolor++) {
+ i < dst->geom->num_colors; i++, dcolor++) {
free(dcolor->spec);
}
}
/* Reallocate and clear all new items if the buffer grows. */
- if (!XkbGeomRealloc((void **)&dst->geom->colors, dst->geom->sz_colors, src->geom->num_colors,
- sizeof(XkbColorRec), XKB_GEOM_CLEAR_EXCESS))
+ if (!XkbGeomRealloc
+ ((void **) &dst->geom->colors, dst->geom->sz_colors,
+ src->geom->num_colors, sizeof(XkbColorRec),
+ XKB_GEOM_CLEAR_EXCESS))
return FALSE;
dst->geom->sz_colors = src->geom->num_colors;
for (i = 0,
- scolor = src->geom->colors,
- dcolor = dst->geom->colors;
- i < src->geom->num_colors;
- i++, scolor++, dcolor++) {
+ scolor = src->geom->colors,
+ dcolor = dst->geom->colors;
+ i < src->geom->num_colors; i++, scolor++, dcolor++) {
if (i < dst->geom->num_colors) {
if (strlen(scolor->spec) != strlen(dcolor->spec)) {
tmp = realloc(dcolor->spec, strlen(scolor->spec) + 1);
@@ -1505,8 +1522,7 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
else {
if (dst->geom->sz_colors) {
for (i = 0, dcolor = dst->geom->colors;
- i < dst->geom->num_colors;
- i++, dcolor++) {
+ i < dst->geom->num_colors; i++, dcolor++) {
free(dcolor->spec);
}
free(dst->geom->colors);
@@ -1521,11 +1537,9 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
/* shapes break down into outlines, which break down into points. */
if (dst->geom->num_shapes) {
for (i = 0, dshape = dst->geom->shapes;
- i < dst->geom->num_shapes;
- i++, dshape++) {
+ i < dst->geom->num_shapes; i++, dshape++) {
for (j = 0, doutline = dshape->outlines;
- j < dshape->num_outlines;
- j++, doutline++) {
+ j < dshape->num_outlines; j++, doutline++) {
if (doutline->sz_points)
free(doutline->points);
}
@@ -1542,27 +1556,28 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
if (src->geom->num_shapes) {
/* Reallocate and clear all items. */
- if (!XkbGeomRealloc((void **)&dst->geom->shapes, dst->geom->sz_shapes, src->geom->num_shapes,
- sizeof(XkbShapeRec), XKB_GEOM_CLEAR_ALL))
+ if (!XkbGeomRealloc
+ ((void **) &dst->geom->shapes, dst->geom->sz_shapes,
+ src->geom->num_shapes, sizeof(XkbShapeRec),
+ XKB_GEOM_CLEAR_ALL))
return FALSE;
for (i = 0, sshape = src->geom->shapes, dshape = dst->geom->shapes;
- i < src->geom->num_shapes;
- i++, sshape++, dshape++) {
+ i < src->geom->num_shapes; i++, sshape++, dshape++) {
if (sshape->num_outlines) {
tmp = calloc(sshape->num_outlines, sizeof(XkbOutlineRec));
if (!tmp)
return FALSE;
dshape->outlines = tmp;
-
+
for (j = 0,
- soutline = sshape->outlines,
- doutline = dshape->outlines;
+ soutline = sshape->outlines,
+ doutline = dshape->outlines;
j < sshape->num_outlines;
j++, soutline++, doutline++) {
if (soutline->num_points) {
tmp = malloc(soutline->num_points *
- sizeof(XkbPointRec));
+ sizeof(XkbPointRec));
if (!tmp)
return FALSE;
doutline->points = tmp;
@@ -1587,13 +1602,14 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
if (sshape->approx && sshape->num_outlines > 0) {
const ptrdiff_t approx_idx =
- sshape->approx - sshape->outlines;
+ sshape->approx - sshape->outlines;
if (approx_idx < dshape->num_outlines) {
- dshape->approx = dshape->outlines + approx_idx;
- } else {
- LogMessage(X_WARNING, "XKB: approx outline "
- "index is out of range\n");
+ dshape->approx = dshape->outlines + approx_idx;
+ }
+ else {
+ LogMessage(X_WARNING, "XKB: approx outline "
+ "index is out of range\n");
}
}
@@ -1601,13 +1617,14 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
if (sshape->primary && sshape->num_outlines > 0) {
const ptrdiff_t primary_idx =
- sshape->primary - sshape->outlines;
+ sshape->primary - sshape->outlines;
if (primary_idx < dshape->num_outlines) {
- dshape->primary = dshape->outlines + primary_idx;
- } else {
- LogMessage(X_WARNING, "XKB: primary outline "
- "index is out of range\n");
+ dshape->primary = dshape->outlines + primary_idx;
+ }
+ else {
+ LogMessage(X_WARNING, "XKB: primary outline "
+ "index is out of range\n");
}
}
}
@@ -1629,11 +1646,9 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
* down into keys. */
if (dst->geom->num_sections) {
for (i = 0, dsection = dst->geom->sections;
- i < dst->geom->num_sections;
- i++, dsection++) {
+ i < dst->geom->num_sections; i++, dsection++) {
for (j = 0, drow = dsection->rows;
- j < dsection->num_rows;
- j++, drow++) {
+ j < dsection->num_rows; j++, drow++) {
if (drow->num_keys)
free(drow->keys);
}
@@ -1643,17 +1658,16 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
/* cut and waste from geom/doodad below. */
for (j = 0, ddoodad = dsection->doodads;
- j < dsection->num_doodads;
- j++, ddoodad++) {
+ j < dsection->num_doodads; j++, ddoodad++) {
if (ddoodad->any.type == XkbTextDoodad) {
free(ddoodad->text.text);
ddoodad->text.text = NULL;
free(ddoodad->text.font);
ddoodad->text.font = NULL;
- }
- else if (ddoodad->any.type == XkbLogoDoodad) {
- free(ddoodad->logo.logo_name);
- ddoodad->logo.logo_name = NULL;
+ }
+ else if (ddoodad->any.type == XkbLogoDoodad) {
+ free(ddoodad->logo.logo_name);
+ ddoodad->logo.logo_name = NULL;
}
}
@@ -1665,17 +1679,18 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
if (src->geom->num_sections) {
/* Reallocate and clear all items. */
- if (!XkbGeomRealloc((void **)&dst->geom->sections, dst->geom->sz_sections, src->geom->num_sections,
- sizeof(XkbSectionRec), XKB_GEOM_CLEAR_ALL))
+ if (!XkbGeomRealloc
+ ((void **) &dst->geom->sections, dst->geom->sz_sections,
+ src->geom->num_sections, sizeof(XkbSectionRec),
+ XKB_GEOM_CLEAR_ALL))
return FALSE;
dst->geom->num_sections = src->geom->num_sections;
dst->geom->sz_sections = src->geom->num_sections;
for (i = 0,
- ssection = src->geom->sections,
- dsection = dst->geom->sections;
- i < src->geom->num_sections;
- i++, ssection++, dsection++) {
+ ssection = src->geom->sections,
+ dsection = dst->geom->sections;
+ i < src->geom->num_sections; i++, ssection++, dsection++) {
*dsection = *ssection;
if (ssection->num_rows) {
tmp = calloc(ssection->num_rows, sizeof(XkbRowRec));
@@ -1687,8 +1702,7 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
dsection->sz_rows = ssection->num_rows;
for (j = 0, srow = ssection->rows, drow = dsection->rows;
- j < ssection->num_rows;
- j++, srow++, drow++) {
+ j < ssection->num_rows; j++, srow++, drow++) {
if (srow->num_keys) {
tmp = malloc(srow->num_keys * sizeof(XkbKeyRec));
if (!tmp)
@@ -1717,23 +1731,20 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
dsection->sz_doodads = ssection->num_doodads;
for (k = 0,
- sdoodad = ssection->doodads,
- ddoodad = dsection->doodads;
- k < ssection->num_doodads;
- k++, sdoodad++, ddoodad++) {
- memcpy(ddoodad , sdoodad, sizeof(XkbDoodadRec));
+ sdoodad = ssection->doodads,
+ ddoodad = dsection->doodads;
+ k < ssection->num_doodads; k++, sdoodad++, ddoodad++) {
+ memcpy(ddoodad, sdoodad, sizeof(XkbDoodadRec));
if (sdoodad->any.type == XkbTextDoodad) {
if (sdoodad->text.text)
- ddoodad->text.text =
- strdup(sdoodad->text.text);
+ ddoodad->text.text = strdup(sdoodad->text.text);
if (sdoodad->text.font)
- ddoodad->text.font =
- strdup(sdoodad->text.font);
+ ddoodad->text.font = strdup(sdoodad->text.font);
}
else if (sdoodad->any.type == XkbLogoDoodad) {
if (sdoodad->logo.logo_name)
ddoodad->logo.logo_name =
- strdup(sdoodad->logo.logo_name);
+ strdup(sdoodad->logo.logo_name);
}
}
dsection->overlays = NULL;
@@ -1754,19 +1765,18 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
/* doodads */
if (dst->geom->num_doodads) {
for (i = src->geom->num_doodads,
- ddoodad = dst->geom->doodads +
- src->geom->num_doodads;
- i < dst->geom->num_doodads;
- i++, ddoodad++) {
- if (ddoodad->any.type == XkbTextDoodad) {
- free(ddoodad->text.text);
- ddoodad->text.text = NULL;
- free(ddoodad->text.font);
- ddoodad->text.font = NULL;
- }
- else if (ddoodad->any.type == XkbLogoDoodad) {
- free(ddoodad->logo.logo_name);
- ddoodad->logo.logo_name = NULL;
+ ddoodad = dst->geom->doodads +
+ src->geom->num_doodads;
+ i < dst->geom->num_doodads; i++, ddoodad++) {
+ if (ddoodad->any.type == XkbTextDoodad) {
+ free(ddoodad->text.text);
+ ddoodad->text.text = NULL;
+ free(ddoodad->text.font);
+ ddoodad->text.font = NULL;
+ }
+ else if (ddoodad->any.type == XkbLogoDoodad) {
+ free(ddoodad->logo.logo_name);
+ ddoodad->logo.logo_name = NULL;
}
}
dst->geom->num_doodads = 0;
@@ -1774,18 +1784,19 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
if (src->geom->num_doodads) {
/* Reallocate and clear all items. */
- if (!XkbGeomRealloc((void **)&dst->geom->doodads, dst->geom->sz_doodads, src->geom->num_doodads,
- sizeof(XkbDoodadRec), XKB_GEOM_CLEAR_ALL))
+ if (!XkbGeomRealloc
+ ((void **) &dst->geom->doodads, dst->geom->sz_doodads,
+ src->geom->num_doodads, sizeof(XkbDoodadRec),
+ XKB_GEOM_CLEAR_ALL))
return FALSE;
dst->geom->sz_doodads = src->geom->num_doodads;
for (i = 0,
- sdoodad = src->geom->doodads,
- ddoodad = dst->geom->doodads;
- i < src->geom->num_doodads;
- i++, sdoodad++, ddoodad++) {
- memcpy(ddoodad , sdoodad, sizeof(XkbDoodadRec));
+ sdoodad = src->geom->doodads,
+ ddoodad = dst->geom->doodads;
+ i < src->geom->num_doodads; i++, sdoodad++, ddoodad++) {
+ memcpy(ddoodad, sdoodad, sizeof(XkbDoodadRec));
if (sdoodad->any.type == XkbTextDoodad) {
if (sdoodad->text.text)
ddoodad->text.text = strdup(sdoodad->text.text);
@@ -1795,7 +1806,7 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
else if (sdoodad->any.type == XkbLogoDoodad) {
if (sdoodad->logo.logo_name)
ddoodad->logo.logo_name =
- strdup(sdoodad->logo.logo_name);
+ strdup(sdoodad->logo.logo_name);
}
}
@@ -1816,8 +1827,10 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
/* Reallocate but don't clear any items. There is no need
* to clear anything because data is immediately copied
* over the whole memory area with memcpy. */
- if (!XkbGeomRealloc((void **)&dst->geom->key_aliases, dst->geom->sz_key_aliases, src->geom->num_key_aliases,
- 2 * XkbKeyNameLength, XKB_GEOM_CLEAR_NONE))
+ if (!XkbGeomRealloc
+ ((void **) &dst->geom->key_aliases, dst->geom->sz_key_aliases,
+ src->geom->num_key_aliases, 2 * XkbKeyNameLength,
+ XKB_GEOM_CLEAR_NONE))
return FALSE;
dst->geom->sz_key_aliases = src->geom->num_key_aliases;
@@ -1833,7 +1846,7 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
dst->geom->num_key_aliases = 0;
dst->geom->sz_key_aliases = 0;
}
-
+
/* font */
if (src->geom->label_font) {
if (!dst->geom->label_font) {
@@ -1843,9 +1856,9 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
dst->geom->label_font = tmp;
}
else if (strlen(src->geom->label_font) !=
- strlen(dst->geom->label_font)) {
+ strlen(dst->geom->label_font)) {
tmp = realloc(dst->geom->label_font,
- strlen(src->geom->label_font) + 1);
+ strlen(src->geom->label_font) + 1);
if (!tmp)
return FALSE;
dst->geom->label_font = tmp;
@@ -1868,8 +1881,7 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
dst->geom->width_mm = src->geom->width_mm;
dst->geom->height_mm = src->geom->height_mm;
}
- else
- {
+ else {
if (dst->geom) {
/* I LOVE THE DIFFERENT CALL SIGNATURE. REALLY, I DO. */
XkbFreeGeometry(dst->geom, XkbGeomAllMask, TRUE);
@@ -1993,11 +2005,11 @@ XkbCopyDeviceKeymap(DeviceIntPtr dst, DeviceIntPtr src)
nkn.oldMinKeyCode = dst->key->xkbInfo->desc->min_key_code;
nkn.oldMaxKeyCode = dst->key->xkbInfo->desc->max_key_code;
nkn.deviceID = dst->id;
- nkn.oldDeviceID = dst->id; /* maybe src->id? */
+ nkn.oldDeviceID = dst->id; /* maybe src->id? */
nkn.minKeyCode = src->key->xkbInfo->desc->min_key_code;
nkn.maxKeyCode = src->key->xkbInfo->desc->max_key_code;
nkn.requestMajor = XkbReqCode;
- nkn.requestMinor = X_kbSetMap; /* Near enough's good enough. */
+ nkn.requestMinor = X_kbSetMap; /* Near enough's good enough. */
nkn.changed = XkbNKN_KeycodesMask;
if (src->key->xkbInfo->desc->geom)
nkn.changed |= XkbNKN_GeometryMask;
@@ -2021,26 +2033,28 @@ XkbGetEffectiveGroup(XkbSrvInfoPtr xkbi, XkbStatePtr xkbState, CARD8 keycode)
if (effectiveGroup == XkbGroup1Index)
return effectiveGroup;
- if (XkbKeyNumGroups(xkb,keycode) > 1U) {
- if (effectiveGroup >= XkbKeyNumGroups(xkb,keycode)) {
- unsigned int gi = XkbKeyGroupInfo(xkb,keycode);
+ if (XkbKeyNumGroups(xkb, keycode) > 1U) {
+ if (effectiveGroup >= XkbKeyNumGroups(xkb, keycode)) {
+ unsigned int gi = XkbKeyGroupInfo(xkb, keycode);
+
switch (XkbOutOfRangeGroupAction(gi)) {
- default:
- case XkbWrapIntoRange:
- effectiveGroup %= XkbKeyNumGroups(xkb, keycode);
- break;
- case XkbClampIntoRange:
- effectiveGroup = XkbKeyNumGroups(xkb, keycode) - 1;
- break;
- case XkbRedirectIntoRange:
- effectiveGroup = XkbOutOfRangeGroupInfo(gi);
- if (effectiveGroup >= XkbKeyNumGroups(xkb, keycode))
- effectiveGroup = 0;
- break;
+ default:
+ case XkbWrapIntoRange:
+ effectiveGroup %= XkbKeyNumGroups(xkb, keycode);
+ break;
+ case XkbClampIntoRange:
+ effectiveGroup = XkbKeyNumGroups(xkb, keycode) - 1;
+ break;
+ case XkbRedirectIntoRange:
+ effectiveGroup = XkbOutOfRangeGroupInfo(gi);
+ if (effectiveGroup >= XkbKeyNumGroups(xkb, keycode))
+ effectiveGroup = 0;
+ break;
}
}
}
- else effectiveGroup = XkbGroup1Index;
+ else
+ effectiveGroup = XkbGroup1Index;
return effectiveGroup;
}
diff --git a/xkb/xkbfmisc.c b/xkb/xkbfmisc.c
index 782b823bb..d96ee4b52 100644
--- a/xkb/xkbfmisc.c
+++ b/xkb/xkbfmisc.c
@@ -51,94 +51,92 @@
unsigned
_XkbKSCheckCase(KeySym ks)
{
-unsigned set,rtrn;
+ unsigned set, rtrn;
- set= (ks & (~0xff)) >> 8;
- rtrn= 0;
+ set = (ks & (~0xff)) >> 8;
+ rtrn = 0;
switch (set) {
- case 0: /* latin 1 */
- if (((ks>=XK_A)&&(ks<=XK_Z))||
- ((ks>=XK_Agrave)&&(ks<=XK_THORN)&&(ks!=XK_multiply))) {
- rtrn|= _XkbKSUpper;
- }
- if (((ks>=XK_a)&&(ks<=XK_z))||
- ((ks>=XK_ssharp)&&(ks<=XK_ydiaeresis)&&(ks!=XK_division))) {
- rtrn|= _XkbKSLower;
- }
- break;
- case 1: /* latin 2 */
- if (((ks>=XK_Aogonek)&&(ks<=XK_Zabovedot)&&(ks!=XK_breve))||
- ((ks>=XK_Racute)&&(ks<=XK_Tcedilla))) {
- rtrn|= _XkbKSUpper;
- }
- if (((ks>=XK_aogonek)&&(ks<=XK_zabovedot)&&(ks!=XK_ogonek)&&(ks!=XK_caron)&&(ks!=XK_doubleacute))||
- ((ks>=XK_racute)&&(ks<=XK_tcedilla))) {
- rtrn|= _XkbKSLower;
- }
- break;
- case 2: /* latin 3 */
- if (((ks>=XK_Hstroke)&&(ks<=XK_Jcircumflex))||
- ((ks>=XK_Cabovedot)&&(ks<=XK_Scircumflex))) {
- rtrn|= _XkbKSUpper;
- }
- if (((ks>=XK_hstroke)&&(ks<=XK_jcircumflex))||
- ((ks>=XK_cabovedot)&&(ks<=XK_scircumflex))) {
- rtrn|= _XkbKSLower;
- }
- break;
- case 3: /* latin 4 */
- if (((ks>=XK_Rcedilla)&&(ks<=XK_Tslash))||
- (ks==XK_ENG)||
- ((ks>=XK_Amacron)&&(ks<=XK_Umacron))) {
- rtrn|= _XkbKSUpper;
- }
- if ((ks==XK_kra)||
- ((ks>=XK_rcedilla)&&(ks<=XK_tslash))||
- (ks==XK_eng)||
- ((ks>=XK_amacron)&&(ks<=XK_umacron))) {
- rtrn|= _XkbKSLower;
- }
- break;
- case 18: /* latin 8 */
- if ((ks==XK_Wcircumflex)||
- (ks==XK_Ycircumflex)||
- (ks==XK_Babovedot)||
- (ks==XK_Dabovedot)||
- (ks==XK_Fabovedot)||
- (ks==XK_Mabovedot)||
- (ks==XK_Pabovedot)||
- (ks==XK_Sabovedot)||
- (ks==XK_Tabovedot)||
- (ks==XK_Wgrave)||
- (ks==XK_Wacute)||
- (ks==XK_Wdiaeresis)||
- (ks==XK_Ygrave)) {
- rtrn|= _XkbKSUpper;
- }
- if ((ks==XK_wcircumflex)||
- (ks==XK_ycircumflex)||
- (ks==XK_babovedot)||
- (ks==XK_dabovedot)||
- (ks==XK_fabovedot)||
- (ks==XK_mabovedot)||
- (ks==XK_pabovedot)||
- (ks==XK_sabovedot)||
- (ks==XK_tabovedot)||
- (ks==XK_wgrave)||
- (ks==XK_wacute)||
- (ks==XK_wdiaeresis)||
- (ks==XK_ygrave)) {
- rtrn|= _XkbKSLower;
- }
- break;
- case 19: /* latin 9 */
- if ((ks==XK_OE)||(ks==XK_Ydiaeresis)) {
- rtrn|= _XkbKSUpper;
- }
- if (ks==XK_oe) {
- rtrn|= _XkbKSLower;
- }
- break;
+ case 0: /* latin 1 */
+ if (((ks >= XK_A) && (ks <= XK_Z)) ||
+ ((ks >= XK_Agrave) && (ks <= XK_THORN) && (ks != XK_multiply))) {
+ rtrn |= _XkbKSUpper;
+ }
+ if (((ks >= XK_a) && (ks <= XK_z)) ||
+ ((ks >= XK_ssharp) && (ks <= XK_ydiaeresis) &&
+ (ks != XK_division))) {
+ rtrn |= _XkbKSLower;
+ }
+ break;
+ case 1: /* latin 2 */
+ if (((ks >= XK_Aogonek) && (ks <= XK_Zabovedot) && (ks != XK_breve)) ||
+ ((ks >= XK_Racute) && (ks <= XK_Tcedilla))) {
+ rtrn |= _XkbKSUpper;
+ }
+ if (((ks >= XK_aogonek) && (ks <= XK_zabovedot) && (ks != XK_ogonek) &&
+ (ks != XK_caron) && (ks != XK_doubleacute)) || ((ks >= XK_racute)
+ && (ks <=
+ XK_tcedilla)))
+ {
+ rtrn |= _XkbKSLower;
+ }
+ break;
+ case 2: /* latin 3 */
+ if (((ks >= XK_Hstroke) && (ks <= XK_Jcircumflex)) ||
+ ((ks >= XK_Cabovedot) && (ks <= XK_Scircumflex))) {
+ rtrn |= _XkbKSUpper;
+ }
+ if (((ks >= XK_hstroke) && (ks <= XK_jcircumflex)) ||
+ ((ks >= XK_cabovedot) && (ks <= XK_scircumflex))) {
+ rtrn |= _XkbKSLower;
+ }
+ break;
+ case 3: /* latin 4 */
+ if (((ks >= XK_Rcedilla) && (ks <= XK_Tslash)) ||
+ (ks == XK_ENG) || ((ks >= XK_Amacron) && (ks <= XK_Umacron))) {
+ rtrn |= _XkbKSUpper;
+ }
+ if ((ks == XK_kra) ||
+ ((ks >= XK_rcedilla) && (ks <= XK_tslash)) ||
+ (ks == XK_eng) || ((ks >= XK_amacron) && (ks <= XK_umacron))) {
+ rtrn |= _XkbKSLower;
+ }
+ break;
+ case 18: /* latin 8 */
+ if ((ks == XK_Wcircumflex) ||
+ (ks == XK_Ycircumflex) ||
+ (ks == XK_Babovedot) ||
+ (ks == XK_Dabovedot) ||
+ (ks == XK_Fabovedot) ||
+ (ks == XK_Mabovedot) ||
+ (ks == XK_Pabovedot) ||
+ (ks == XK_Sabovedot) ||
+ (ks == XK_Tabovedot) ||
+ (ks == XK_Wgrave) ||
+ (ks == XK_Wacute) || (ks == XK_Wdiaeresis) || (ks == XK_Ygrave)) {
+ rtrn |= _XkbKSUpper;
+ }
+ if ((ks == XK_wcircumflex) ||
+ (ks == XK_ycircumflex) ||
+ (ks == XK_babovedot) ||
+ (ks == XK_dabovedot) ||
+ (ks == XK_fabovedot) ||
+ (ks == XK_mabovedot) ||
+ (ks == XK_pabovedot) ||
+ (ks == XK_sabovedot) ||
+ (ks == XK_tabovedot) ||
+ (ks == XK_wgrave) ||
+ (ks == XK_wacute) || (ks == XK_wdiaeresis) || (ks == XK_ygrave)) {
+ rtrn |= _XkbKSLower;
+ }
+ break;
+ case 19: /* latin 9 */
+ if ((ks == XK_OE) || (ks == XK_Ydiaeresis)) {
+ rtrn |= _XkbKSUpper;
+ }
+ if (ks == XK_oe) {
+ rtrn |= _XkbKSLower;
+ }
+ break;
}
return rtrn;
}
@@ -146,9 +144,9 @@ unsigned set,rtrn;
/***===================================================================***/
static Bool
-XkbWriteSectionFromName(FILE *file,const char *sectionName,const char *name)
+XkbWriteSectionFromName(FILE * file, const char *sectionName, const char *name)
{
- fprintf(file," xkb_%-20s { include \"%s\" };\n",sectionName,name);
+ fprintf(file, " xkb_%-20s { include \"%s\" };\n", sectionName, name);
return TRUE;
}
@@ -157,43 +155,43 @@ XkbWriteSectionFromName(FILE *file,const char *sectionName,const char *name)
/* ARGSUSED */
static void
-_AddIncl( FILE * file,
- XkbDescPtr xkb,
- Bool topLevel,
- Bool showImplicit,
- int index,
- void * priv)
+_AddIncl(FILE * file,
+ XkbDescPtr xkb,
+ Bool topLevel, Bool showImplicit, int index, void *priv)
{
- if ((priv)&&(strcmp((char *)priv,"%")!=0))
- fprintf(file," include \"%s\"\n",(char *)priv);
+ if ((priv) && (strcmp((char *) priv, "%") != 0))
+ fprintf(file, " include \"%s\"\n", (char *) priv);
return;
}
Bool
-XkbWriteXKBKeymapForNames( FILE * file,
- XkbComponentNamesPtr names,
- XkbDescPtr xkb,
- unsigned want,
- unsigned need)
+XkbWriteXKBKeymapForNames(FILE * file,
+ XkbComponentNamesPtr names,
+ XkbDescPtr xkb, unsigned want, unsigned need)
{
-const char * tmp;
-unsigned complete;
-XkbNamesPtr old_names;
-int multi_section;
-unsigned wantNames,wantConfig,wantDflts;
-
- complete= 0;
- if (COMPLETE(names->keycodes)) complete|= XkmKeyNamesMask;
- if (COMPLETE(names->types)) complete|= XkmTypesMask;
- if (COMPLETE(names->compat)) complete|= XkmCompatMapMask;
- if (COMPLETE(names->symbols)) complete|= XkmSymbolsMask;
- if (COMPLETE(names->geometry)) complete|= XkmGeometryMask;
- want|= (complete|need);
- if (want&XkmSymbolsMask)
- want|= XkmKeyNamesMask|XkmTypesMask;
-
- if (want==0)
- return FALSE;
+ const char *tmp;
+ unsigned complete;
+ XkbNamesPtr old_names;
+ int multi_section;
+ unsigned wantNames, wantConfig, wantDflts;
+
+ complete = 0;
+ if (COMPLETE(names->keycodes))
+ complete |= XkmKeyNamesMask;
+ if (COMPLETE(names->types))
+ complete |= XkmTypesMask;
+ if (COMPLETE(names->compat))
+ complete |= XkmCompatMapMask;
+ if (COMPLETE(names->symbols))
+ complete |= XkmSymbolsMask;
+ if (COMPLETE(names->geometry))
+ complete |= XkmGeometryMask;
+ want |= (complete | need);
+ if (want & XkmSymbolsMask)
+ want |= XkmKeyNamesMask | XkmTypesMask;
+
+ if (want == 0)
+ return FALSE;
if (xkb) {
old_names = xkb->names;
@@ -214,207 +212,224 @@ unsigned wantNames,wantConfig,wantDflts;
xkb->defined |= XkmGeometryMask;
}
else {
- old_names= NULL;
+ old_names = NULL;
}
- wantConfig= want&(~complete);
- if (xkb!=NULL) {
- if (wantConfig&XkmTypesMask) {
- if ((!xkb->map) || (xkb->map->num_types<XkbNumRequiredTypes))
- wantConfig&= ~XkmTypesMask;
- }
- if (wantConfig&XkmCompatMapMask) {
- if ((!xkb->compat) || (xkb->compat->num_si<1))
- wantConfig&= ~XkmCompatMapMask;
- }
- if (wantConfig&XkmSymbolsMask) {
- if ((!xkb->map) || (!xkb->map->key_sym_map))
- wantConfig&= ~XkmSymbolsMask;
- }
- if (wantConfig&XkmIndicatorsMask) {
- if (!xkb->indicators)
- wantConfig&= ~XkmIndicatorsMask;
- }
- if (wantConfig&XkmKeyNamesMask) {
- if ((!xkb->names)||(!xkb->names->keys))
- wantConfig&= ~XkmKeyNamesMask;
- }
- if ((wantConfig&XkmGeometryMask)&&(!xkb->geom))
- wantConfig&= ~XkmGeometryMask;
+ wantConfig = want & (~complete);
+ if (xkb != NULL) {
+ if (wantConfig & XkmTypesMask) {
+ if ((!xkb->map) || (xkb->map->num_types < XkbNumRequiredTypes))
+ wantConfig &= ~XkmTypesMask;
+ }
+ if (wantConfig & XkmCompatMapMask) {
+ if ((!xkb->compat) || (xkb->compat->num_si < 1))
+ wantConfig &= ~XkmCompatMapMask;
+ }
+ if (wantConfig & XkmSymbolsMask) {
+ if ((!xkb->map) || (!xkb->map->key_sym_map))
+ wantConfig &= ~XkmSymbolsMask;
+ }
+ if (wantConfig & XkmIndicatorsMask) {
+ if (!xkb->indicators)
+ wantConfig &= ~XkmIndicatorsMask;
+ }
+ if (wantConfig & XkmKeyNamesMask) {
+ if ((!xkb->names) || (!xkb->names->keys))
+ wantConfig &= ~XkmKeyNamesMask;
+ }
+ if ((wantConfig & XkmGeometryMask) && (!xkb->geom))
+ wantConfig &= ~XkmGeometryMask;
}
else {
- wantConfig= 0;
+ wantConfig = 0;
}
- complete|= wantConfig;
-
- wantDflts= 0;
- wantNames= want&(~complete);
- if ((xkb!=NULL) && (old_names!=NULL)) {
- if (wantNames&XkmTypesMask) {
- if (old_names->types!=None) {
- tmp= NameForAtom(old_names->types);
- names->types= Xstrdup(tmp);
- }
- else {
- wantDflts|= XkmTypesMask;
- }
- complete|= XkmTypesMask;
- }
- if (wantNames&XkmCompatMapMask) {
- if (old_names->compat!=None) {
- tmp= NameForAtom(old_names->compat);
- names->compat= Xstrdup(tmp);
- }
- else wantDflts|= XkmCompatMapMask;
- complete|= XkmCompatMapMask;
- }
- if (wantNames&XkmSymbolsMask) {
- if (old_names->symbols==None)
- return FALSE;
- tmp= NameForAtom(old_names->symbols);
- names->symbols= Xstrdup(tmp);
- complete|= XkmSymbolsMask;
- }
- if (wantNames&XkmKeyNamesMask) {
- if (old_names->keycodes!=None) {
- tmp= NameForAtom(old_names->keycodes);
- names->keycodes= Xstrdup(tmp);
- }
- else wantDflts|= XkmKeyNamesMask;
- complete|= XkmKeyNamesMask;
- }
- if (wantNames&XkmGeometryMask) {
- if (old_names->geometry==None)
- return FALSE;
- tmp= NameForAtom(old_names->geometry);
- names->geometry= Xstrdup(tmp);
- complete|= XkmGeometryMask;
- wantNames&= ~XkmGeometryMask;
- }
+ complete |= wantConfig;
+
+ wantDflts = 0;
+ wantNames = want & (~complete);
+ if ((xkb != NULL) && (old_names != NULL)) {
+ if (wantNames & XkmTypesMask) {
+ if (old_names->types != None) {
+ tmp = NameForAtom(old_names->types);
+ names->types = Xstrdup(tmp);
+ }
+ else {
+ wantDflts |= XkmTypesMask;
+ }
+ complete |= XkmTypesMask;
+ }
+ if (wantNames & XkmCompatMapMask) {
+ if (old_names->compat != None) {
+ tmp = NameForAtom(old_names->compat);
+ names->compat = Xstrdup(tmp);
+ }
+ else
+ wantDflts |= XkmCompatMapMask;
+ complete |= XkmCompatMapMask;
+ }
+ if (wantNames & XkmSymbolsMask) {
+ if (old_names->symbols == None)
+ return FALSE;
+ tmp = NameForAtom(old_names->symbols);
+ names->symbols = Xstrdup(tmp);
+ complete |= XkmSymbolsMask;
+ }
+ if (wantNames & XkmKeyNamesMask) {
+ if (old_names->keycodes != None) {
+ tmp = NameForAtom(old_names->keycodes);
+ names->keycodes = Xstrdup(tmp);
+ }
+ else
+ wantDflts |= XkmKeyNamesMask;
+ complete |= XkmKeyNamesMask;
+ }
+ if (wantNames & XkmGeometryMask) {
+ if (old_names->geometry == None)
+ return FALSE;
+ tmp = NameForAtom(old_names->geometry);
+ names->geometry = Xstrdup(tmp);
+ complete |= XkmGeometryMask;
+ wantNames &= ~XkmGeometryMask;
+ }
}
- if (complete&XkmCompatMapMask)
- complete|= XkmIndicatorsMask|XkmVirtualModsMask;
- else if (complete&(XkmSymbolsMask|XkmTypesMask))
- complete|= XkmVirtualModsMask;
+ if (complete & XkmCompatMapMask)
+ complete |= XkmIndicatorsMask | XkmVirtualModsMask;
+ else if (complete & (XkmSymbolsMask | XkmTypesMask))
+ complete |= XkmVirtualModsMask;
if (need & (~complete))
- return FALSE;
- if ((complete&XkmSymbolsMask)&&((XkmKeyNamesMask|XkmTypesMask)&(~complete)))
- return FALSE;
-
- multi_section= 1;
- if (((complete&XkmKeymapRequired)==XkmKeymapRequired)&&
- ((complete&(~XkmKeymapLegal))==0)) {
- fprintf(file,"xkb_keymap \"default\" {\n");
+ return FALSE;
+ if ((complete & XkmSymbolsMask) &&
+ ((XkmKeyNamesMask | XkmTypesMask) & (~complete)))
+ return FALSE;
+
+ multi_section = 1;
+ if (((complete & XkmKeymapRequired) == XkmKeymapRequired) &&
+ ((complete & (~XkmKeymapLegal)) == 0)) {
+ fprintf(file, "xkb_keymap \"default\" {\n");
}
- else if (((complete&XkmSemanticsRequired)==XkmSemanticsRequired)&&
- ((complete&(~XkmSemanticsLegal))==0)) {
- fprintf(file,"xkb_semantics \"default\" {\n");
+ else if (((complete & XkmSemanticsRequired) == XkmSemanticsRequired) &&
+ ((complete & (~XkmSemanticsLegal)) == 0)) {
+ fprintf(file, "xkb_semantics \"default\" {\n");
}
- else if (((complete&XkmLayoutRequired)==XkmLayoutRequired)&&
- ((complete&(~XkmLayoutLegal))==0)) {
- fprintf(file,"xkb_layout \"default\" {\n");
+ else if (((complete & XkmLayoutRequired) == XkmLayoutRequired) &&
+ ((complete & (~XkmLayoutLegal)) == 0)) {
+ fprintf(file, "xkb_layout \"default\" {\n");
}
- else if (XkmSingleSection(complete&(~XkmVirtualModsMask))) {
- multi_section= 0;
+ else if (XkmSingleSection(complete & (~XkmVirtualModsMask))) {
+ multi_section = 0;
}
else {
- return FALSE;
+ return FALSE;
}
- wantNames= complete&(~(wantConfig|wantDflts));
- if (wantConfig&XkmKeyNamesMask)
- XkbWriteXKBKeycodes(file,xkb,FALSE,FALSE,_AddIncl,names->keycodes);
- else if (wantDflts&XkmKeyNamesMask)
- fprintf(stderr,"Default symbols not implemented yet!\n");
- else if (wantNames&XkmKeyNamesMask)
- XkbWriteSectionFromName(file,"keycodes",names->keycodes);
-
- if (wantConfig&XkmTypesMask)
- XkbWriteXKBKeyTypes(file,xkb,FALSE,FALSE,_AddIncl,names->types);
- else if (wantDflts&XkmTypesMask)
- fprintf(stderr,"Default types not implemented yet!\n");
- else if (wantNames&XkmTypesMask)
- XkbWriteSectionFromName(file,"types",names->types);
-
- if (wantConfig&XkmCompatMapMask)
- XkbWriteXKBCompatMap(file,xkb,FALSE,FALSE,_AddIncl,names->compat);
- else if (wantDflts&XkmCompatMapMask)
- fprintf(stderr,"Default interps not implemented yet!\n");
- else if (wantNames&XkmCompatMapMask)
- XkbWriteSectionFromName(file,"compatibility",names->compat);
-
- if (wantConfig&XkmSymbolsMask)
- XkbWriteXKBSymbols(file,xkb,FALSE,FALSE,_AddIncl,names->symbols);
- else if (wantNames&XkmSymbolsMask)
- XkbWriteSectionFromName(file,"symbols",names->symbols);
-
- if (wantConfig&XkmGeometryMask)
- XkbWriteXKBGeometry(file,xkb,FALSE,FALSE,_AddIncl,names->geometry);
- else if (wantNames&XkmGeometryMask)
- XkbWriteSectionFromName(file,"geometry",names->geometry);
+ wantNames = complete & (~(wantConfig | wantDflts));
+ if (wantConfig & XkmKeyNamesMask)
+ XkbWriteXKBKeycodes(file, xkb, FALSE, FALSE, _AddIncl, names->keycodes);
+ else if (wantDflts & XkmKeyNamesMask)
+ fprintf(stderr, "Default symbols not implemented yet!\n");
+ else if (wantNames & XkmKeyNamesMask)
+ XkbWriteSectionFromName(file, "keycodes", names->keycodes);
+
+ if (wantConfig & XkmTypesMask)
+ XkbWriteXKBKeyTypes(file, xkb, FALSE, FALSE, _AddIncl, names->types);
+ else if (wantDflts & XkmTypesMask)
+ fprintf(stderr, "Default types not implemented yet!\n");
+ else if (wantNames & XkmTypesMask)
+ XkbWriteSectionFromName(file, "types", names->types);
+
+ if (wantConfig & XkmCompatMapMask)
+ XkbWriteXKBCompatMap(file, xkb, FALSE, FALSE, _AddIncl, names->compat);
+ else if (wantDflts & XkmCompatMapMask)
+ fprintf(stderr, "Default interps not implemented yet!\n");
+ else if (wantNames & XkmCompatMapMask)
+ XkbWriteSectionFromName(file, "compatibility", names->compat);
+
+ if (wantConfig & XkmSymbolsMask)
+ XkbWriteXKBSymbols(file, xkb, FALSE, FALSE, _AddIncl, names->symbols);
+ else if (wantNames & XkmSymbolsMask)
+ XkbWriteSectionFromName(file, "symbols", names->symbols);
+
+ if (wantConfig & XkmGeometryMask)
+ XkbWriteXKBGeometry(file, xkb, FALSE, FALSE, _AddIncl, names->geometry);
+ else if (wantNames & XkmGeometryMask)
+ XkbWriteSectionFromName(file, "geometry", names->geometry);
if (multi_section)
- fprintf(file,"};\n");
+ fprintf(file, "};\n");
return TRUE;
}
/***====================================================================***/
int
-XkbFindKeycodeByName(XkbDescPtr xkb,char *name,Bool use_aliases)
+XkbFindKeycodeByName(XkbDescPtr xkb, char *name, Bool use_aliases)
{
-register int i;
+ register int i;
- if ((!xkb)||(!xkb->names)||(!xkb->names->keys))
- return 0;
- for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
- if (strncmp(xkb->names->keys[i].name,name,XkbKeyNameLength)==0)
- return i;
+ if ((!xkb) || (!xkb->names) || (!xkb->names->keys))
+ return 0;
+ for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+ if (strncmp(xkb->names->keys[i].name, name, XkbKeyNameLength) == 0)
+ return i;
}
if (!use_aliases)
- return 0;
+ return 0;
if (xkb->geom && xkb->geom->key_aliases) {
- XkbKeyAliasPtr a;
- a= xkb->geom->key_aliases;
- for (i=0;i<xkb->geom->num_key_aliases;i++,a++) {
- if (strncmp(name,a->alias,XkbKeyNameLength)==0)
- return XkbFindKeycodeByName(xkb,a->real,FALSE);
- }
+ XkbKeyAliasPtr a;
+
+ a = xkb->geom->key_aliases;
+ for (i = 0; i < xkb->geom->num_key_aliases; i++, a++) {
+ if (strncmp(name, a->alias, XkbKeyNameLength) == 0)
+ return XkbFindKeycodeByName(xkb, a->real, FALSE);
+ }
}
if (xkb->names && xkb->names->key_aliases) {
- XkbKeyAliasPtr a;
- a= xkb->names->key_aliases;
- for (i=0;i<xkb->names->num_key_aliases;i++,a++) {
- if (strncmp(name,a->alias,XkbKeyNameLength)==0)
- return XkbFindKeycodeByName(xkb,a->real,FALSE);
- }
+ XkbKeyAliasPtr a;
+
+ a = xkb->names->key_aliases;
+ for (i = 0; i < xkb->names->num_key_aliases; i++, a++) {
+ if (strncmp(name, a->alias, XkbKeyNameLength) == 0)
+ return XkbFindKeycodeByName(xkb, a->real, FALSE);
+ }
}
return 0;
}
-
unsigned
-XkbConvertGetByNameComponents(Bool toXkm,unsigned orig)
+XkbConvertGetByNameComponents(Bool toXkm, unsigned orig)
{
-unsigned rtrn;
+ unsigned rtrn;
- rtrn= 0;
+ rtrn = 0;
if (toXkm) {
- if (orig&XkbGBN_TypesMask) rtrn|= XkmTypesMask;
- if (orig&XkbGBN_CompatMapMask) rtrn|= XkmCompatMapMask;
- if (orig&XkbGBN_SymbolsMask) rtrn|= XkmSymbolsMask;
- if (orig&XkbGBN_IndicatorMapMask) rtrn|= XkmIndicatorsMask;
- if (orig&XkbGBN_KeyNamesMask) rtrn|= XkmKeyNamesMask;
- if (orig&XkbGBN_GeometryMask) rtrn|= XkmGeometryMask;
+ if (orig & XkbGBN_TypesMask)
+ rtrn |= XkmTypesMask;
+ if (orig & XkbGBN_CompatMapMask)
+ rtrn |= XkmCompatMapMask;
+ if (orig & XkbGBN_SymbolsMask)
+ rtrn |= XkmSymbolsMask;
+ if (orig & XkbGBN_IndicatorMapMask)
+ rtrn |= XkmIndicatorsMask;
+ if (orig & XkbGBN_KeyNamesMask)
+ rtrn |= XkmKeyNamesMask;
+ if (orig & XkbGBN_GeometryMask)
+ rtrn |= XkmGeometryMask;
}
else {
- if (orig&XkmTypesMask) rtrn|= XkbGBN_TypesMask;
- if (orig&XkmCompatMapMask) rtrn|= XkbGBN_CompatMapMask;
- if (orig&XkmSymbolsMask) rtrn|= XkbGBN_SymbolsMask;
- if (orig&XkmIndicatorsMask) rtrn|= XkbGBN_IndicatorMapMask;
- if (orig&XkmKeyNamesMask) rtrn|= XkbGBN_KeyNamesMask;
- if (orig&XkmGeometryMask) rtrn|= XkbGBN_GeometryMask;
- if (orig!=0) rtrn|= XkbGBN_OtherNamesMask;
+ if (orig & XkmTypesMask)
+ rtrn |= XkbGBN_TypesMask;
+ if (orig & XkmCompatMapMask)
+ rtrn |= XkbGBN_CompatMapMask;
+ if (orig & XkmSymbolsMask)
+ rtrn |= XkbGBN_SymbolsMask;
+ if (orig & XkmIndicatorsMask)
+ rtrn |= XkbGBN_IndicatorMapMask;
+ if (orig & XkmKeyNamesMask)
+ rtrn |= XkbGBN_KeyNamesMask;
+ if (orig & XkmGeometryMask)
+ rtrn |= XkbGBN_GeometryMask;
+ if (orig != 0)
+ rtrn |= XkbGBN_OtherNamesMask;
}
return rtrn;
}
@@ -424,30 +439,31 @@ unsigned rtrn;
#define UNMATCHABLE(c) (((c)=='(')||((c)==')')||((c)=='/'))
Bool
-XkbNameMatchesPattern(char *name,char *ptrn)
+XkbNameMatchesPattern(char *name, char *ptrn)
{
- while (ptrn[0]!='\0') {
- if (name[0]=='\0') {
- if (ptrn[0]=='*') {
- ptrn++;
- continue;
- }
- return FALSE;
- }
- if (ptrn[0]=='?') {
- if (UNMATCHABLE(name[0]))
- return FALSE;
- }
- else if (ptrn[0]=='*') {
- if ((!UNMATCHABLE(name[0]))&&XkbNameMatchesPattern(name+1,ptrn))
- return TRUE;
- return XkbNameMatchesPattern(name,ptrn+1);
- }
- else if (ptrn[0]!=name[0])
- return FALSE;
- name++;
- ptrn++;
+ while (ptrn[0] != '\0') {
+ if (name[0] == '\0') {
+ if (ptrn[0] == '*') {
+ ptrn++;
+ continue;
+ }
+ return FALSE;
+ }
+ if (ptrn[0] == '?') {
+ if (UNMATCHABLE(name[0]))
+ return FALSE;
+ }
+ else if (ptrn[0] == '*') {
+ if ((!UNMATCHABLE(name[0])) &&
+ XkbNameMatchesPattern(name + 1, ptrn))
+ return TRUE;
+ return XkbNameMatchesPattern(name, ptrn + 1);
+ }
+ else if (ptrn[0] != name[0])
+ return FALSE;
+ name++;
+ ptrn++;
}
/* if we get here, the pattern is exhausted (-:just like me:-) */
- return name[0]=='\0';
+ return name[0] == '\0';
}
diff --git a/xkb/xkbgeom.h b/xkb/xkbgeom.h
index d10b956a6..bef3775db 100644
--- a/xkb/xkbgeom.h
+++ b/xkb/xkbgeom.h
@@ -71,88 +71,93 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#define XkbFreeGeomShapes SrvXkbFreeGeomShapes
#define XkbFreeGeometry SrvXkbFreeGeometry
-typedef struct _XkbProperty {
- char *name;
- char *value;
-} XkbPropertyRec,*XkbPropertyPtr;
+typedef struct _XkbProperty {
+ char *name;
+ char *value;
+} XkbPropertyRec, *XkbPropertyPtr;
typedef struct _XkbColor {
- unsigned int pixel;
- char * spec;
-} XkbColorRec,*XkbColorPtr;
+ unsigned int pixel;
+ char *spec;
+} XkbColorRec, *XkbColorPtr;
-typedef struct _XkbPoint {
- short x;
- short y;
+typedef struct _XkbPoint {
+ short x;
+ short y;
} XkbPointRec, *XkbPointPtr;
-typedef struct _XkbBounds {
- short x1,y1;
- short x2,y2;
+typedef struct _XkbBounds {
+ short x1, y1;
+ short x2, y2;
} XkbBoundsRec, *XkbBoundsPtr;
+
#define XkbBoundsWidth(b) (((b)->x2)-((b)->x1))
#define XkbBoundsHeight(b) (((b)->y2)-((b)->y1))
typedef struct _XkbOutline {
- unsigned short num_points;
- unsigned short sz_points;
- unsigned short corner_radius;
- XkbPointPtr points;
+ unsigned short num_points;
+ unsigned short sz_points;
+ unsigned short corner_radius;
+ XkbPointPtr points;
} XkbOutlineRec, *XkbOutlinePtr;
typedef struct _XkbShape {
- Atom name;
- unsigned short num_outlines;
- unsigned short sz_outlines;
- XkbOutlinePtr outlines;
- XkbOutlinePtr approx;
- XkbOutlinePtr primary;
- XkbBoundsRec bounds;
+ Atom name;
+ unsigned short num_outlines;
+ unsigned short sz_outlines;
+ XkbOutlinePtr outlines;
+ XkbOutlinePtr approx;
+ XkbOutlinePtr primary;
+ XkbBoundsRec bounds;
} XkbShapeRec, *XkbShapePtr;
+
#define XkbOutlineIndex(s,o) ((int)((o)-&(s)->outlines[0]))
typedef struct _XkbShapeDoodad {
- Atom name;
- unsigned char type;
- unsigned char priority;
- short top;
- short left;
- short angle;
- unsigned short color_ndx;
- unsigned short shape_ndx;
+ Atom name;
+ unsigned char type;
+ unsigned char priority;
+ short top;
+ short left;
+ short angle;
+ unsigned short color_ndx;
+ unsigned short shape_ndx;
} XkbShapeDoodadRec, *XkbShapeDoodadPtr;
+
#define XkbShapeDoodadColor(g,d) (&(g)->colors[(d)->color_ndx])
#define XkbShapeDoodadShape(g,d) (&(g)->shapes[(d)->shape_ndx])
#define XkbSetShapeDoodadColor(g,d,c) ((d)->color_ndx= (c)-&(g)->colors[0])
#define XkbSetShapeDoodadShape(g,d,s) ((d)->shape_ndx= (s)-&(g)->shapes[0])
typedef struct _XkbTextDoodad {
- Atom name;
- unsigned char type;
- unsigned char priority;
- short top;
- short left;
- short angle;
- short width;
- short height;
- unsigned short color_ndx;
- char * text;
- char * font;
+ Atom name;
+ unsigned char type;
+ unsigned char priority;
+ short top;
+ short left;
+ short angle;
+ short width;
+ short height;
+ unsigned short color_ndx;
+ char *text;
+ char *font;
} XkbTextDoodadRec, *XkbTextDoodadPtr;
+
#define XkbTextDoodadColor(g,d) (&(g)->colors[(d)->color_ndx])
#define XkbSetTextDoodadColor(g,d,c) ((d)->color_ndx= (c)-&(g)->colors[0])
typedef struct _XkbIndicatorDoodad {
- Atom name;
- unsigned char type;
- unsigned char priority;
- short top;
- short left;
- short angle;
- unsigned short shape_ndx;
- unsigned short on_color_ndx;
- unsigned short off_color_ndx;
+ Atom name;
+ unsigned char type;
+ unsigned char priority;
+ short top;
+ short left;
+ short angle;
+ unsigned short shape_ndx;
+ unsigned short on_color_ndx;
+ unsigned short off_color_ndx;
} XkbIndicatorDoodadRec, *XkbIndicatorDoodadPtr;
+
#define XkbIndicatorDoodadShape(g,d) (&(g)->shapes[(d)->shape_ndx])
#define XkbIndicatorDoodadOnColor(g,d) (&(g)->colors[(d)->on_color_ndx])
#define XkbIndicatorDoodadOffColor(g,d) (&(g)->colors[(d)->off_color_ndx])
@@ -164,36 +169,37 @@ typedef struct _XkbIndicatorDoodad {
((d)->shape_ndx= (s)-&(g)->shapes[0])
typedef struct _XkbLogoDoodad {
- Atom name;
- unsigned char type;
- unsigned char priority;
- short top;
- short left;
- short angle;
- unsigned short color_ndx;
- unsigned short shape_ndx;
- char * logo_name;
+ Atom name;
+ unsigned char type;
+ unsigned char priority;
+ short top;
+ short left;
+ short angle;
+ unsigned short color_ndx;
+ unsigned short shape_ndx;
+ char *logo_name;
} XkbLogoDoodadRec, *XkbLogoDoodadPtr;
+
#define XkbLogoDoodadColor(g,d) (&(g)->colors[(d)->color_ndx])
#define XkbLogoDoodadShape(g,d) (&(g)->shapes[(d)->shape_ndx])
#define XkbSetLogoDoodadColor(g,d,c) ((d)->color_ndx= (c)-&(g)->colors[0])
#define XkbSetLogoDoodadShape(g,d,s) ((d)->shape_ndx= (s)-&(g)->shapes[0])
typedef struct _XkbAnyDoodad {
- Atom name;
- unsigned char type;
- unsigned char priority;
- short top;
- short left;
- short angle;
+ Atom name;
+ unsigned char type;
+ unsigned char priority;
+ short top;
+ short left;
+ short angle;
} XkbAnyDoodadRec, *XkbAnyDoodadPtr;
typedef union _XkbDoodad {
- XkbAnyDoodadRec any;
- XkbShapeDoodadRec shape;
- XkbTextDoodadRec text;
- XkbIndicatorDoodadRec indicator;
- XkbLogoDoodadRec logo;
+ XkbAnyDoodadRec any;
+ XkbShapeDoodadRec shape;
+ XkbTextDoodadRec text;
+ XkbIndicatorDoodadRec indicator;
+ XkbLogoDoodadRec logo;
} XkbDoodadRec, *XkbDoodadPtr;
#define XkbUnknownDoodad 0
@@ -204,93 +210,95 @@ typedef union _XkbDoodad {
#define XkbLogoDoodad 5
typedef struct _XkbKey {
- XkbKeyNameRec name;
- short gap;
- unsigned char shape_ndx;
- unsigned char color_ndx;
+ XkbKeyNameRec name;
+ short gap;
+ unsigned char shape_ndx;
+ unsigned char color_ndx;
} XkbKeyRec, *XkbKeyPtr;
+
#define XkbKeyShape(g,k) (&(g)->shapes[(k)->shape_ndx])
#define XkbKeyColor(g,k) (&(g)->colors[(k)->color_ndx])
#define XkbSetKeyShape(g,k,s) ((k)->shape_ndx= (s)-&(g)->shapes[0])
#define XkbSetKeyColor(g,k,c) ((k)->color_ndx= (c)-&(g)->colors[0])
typedef struct _XkbRow {
- short top;
- short left;
- unsigned short num_keys;
- unsigned short sz_keys;
- int vertical;
- XkbKeyPtr keys;
- XkbBoundsRec bounds;
+ short top;
+ short left;
+ unsigned short num_keys;
+ unsigned short sz_keys;
+ int vertical;
+ XkbKeyPtr keys;
+ XkbBoundsRec bounds;
} XkbRowRec, *XkbRowPtr;
typedef struct _XkbSection {
- Atom name;
- unsigned char priority;
- short top;
- short left;
- unsigned short width;
- unsigned short height;
- short angle;
- unsigned short num_rows;
- unsigned short num_doodads;
- unsigned short num_overlays;
- unsigned short sz_rows;
- unsigned short sz_doodads;
- unsigned short sz_overlays;
- XkbRowPtr rows;
- XkbDoodadPtr doodads;
- XkbBoundsRec bounds;
- struct _XkbOverlay *overlays;
+ Atom name;
+ unsigned char priority;
+ short top;
+ short left;
+ unsigned short width;
+ unsigned short height;
+ short angle;
+ unsigned short num_rows;
+ unsigned short num_doodads;
+ unsigned short num_overlays;
+ unsigned short sz_rows;
+ unsigned short sz_doodads;
+ unsigned short sz_overlays;
+ XkbRowPtr rows;
+ XkbDoodadPtr doodads;
+ XkbBoundsRec bounds;
+ struct _XkbOverlay *overlays;
} XkbSectionRec, *XkbSectionPtr;
-typedef struct _XkbOverlayKey {
- XkbKeyNameRec over;
- XkbKeyNameRec under;
-} XkbOverlayKeyRec,*XkbOverlayKeyPtr;
+typedef struct _XkbOverlayKey {
+ XkbKeyNameRec over;
+ XkbKeyNameRec under;
+} XkbOverlayKeyRec, *XkbOverlayKeyPtr;
typedef struct _XkbOverlayRow {
- unsigned short row_under;
- unsigned short num_keys;
- unsigned short sz_keys;
- XkbOverlayKeyPtr keys;
-} XkbOverlayRowRec,*XkbOverlayRowPtr;
+ unsigned short row_under;
+ unsigned short num_keys;
+ unsigned short sz_keys;
+ XkbOverlayKeyPtr keys;
+} XkbOverlayRowRec, *XkbOverlayRowPtr;
typedef struct _XkbOverlay {
- Atom name;
- XkbSectionPtr section_under;
- unsigned short num_rows;
- unsigned short sz_rows;
- XkbOverlayRowPtr rows;
- XkbBoundsPtr bounds;
-} XkbOverlayRec,*XkbOverlayPtr;
+ Atom name;
+ XkbSectionPtr section_under;
+ unsigned short num_rows;
+ unsigned short sz_rows;
+ XkbOverlayRowPtr rows;
+ XkbBoundsPtr bounds;
+} XkbOverlayRec, *XkbOverlayPtr;
typedef struct _XkbGeometry {
- Atom name;
- unsigned short width_mm;
- unsigned short height_mm;
- char * label_font;
- XkbColorPtr label_color;
- XkbColorPtr base_color;
- unsigned short sz_properties;
- unsigned short sz_colors;
- unsigned short sz_shapes;
- unsigned short sz_sections;
- unsigned short sz_doodads;
- unsigned short sz_key_aliases;
- unsigned short num_properties;
- unsigned short num_colors;
- unsigned short num_shapes;
- unsigned short num_sections;
- unsigned short num_doodads;
- unsigned short num_key_aliases;
- XkbPropertyPtr properties;
- XkbColorPtr colors;
- XkbShapePtr shapes;
- XkbSectionPtr sections;
- XkbDoodadPtr doodads;
- XkbKeyAliasPtr key_aliases;
+ Atom name;
+ unsigned short width_mm;
+ unsigned short height_mm;
+ char *label_font;
+ XkbColorPtr label_color;
+ XkbColorPtr base_color;
+ unsigned short sz_properties;
+ unsigned short sz_colors;
+ unsigned short sz_shapes;
+ unsigned short sz_sections;
+ unsigned short sz_doodads;
+ unsigned short sz_key_aliases;
+ unsigned short num_properties;
+ unsigned short num_colors;
+ unsigned short num_shapes;
+ unsigned short num_sections;
+ unsigned short num_doodads;
+ unsigned short num_key_aliases;
+ XkbPropertyPtr properties;
+ XkbColorPtr colors;
+ XkbShapePtr shapes;
+ XkbSectionPtr sections;
+ XkbDoodadPtr doodads;
+ XkbKeyAliasPtr key_aliases;
} XkbGeometryRec;
+
#define XkbGeomColorIndex(g,c) ((int)((c)-&(g)->colors[0]))
#define XkbGeomPropertiesMask (1<<0)
@@ -302,350 +310,271 @@ typedef struct _XkbGeometry {
#define XkbGeomAllMask (0x3f)
typedef struct _XkbGeometrySizes {
- unsigned int which;
- unsigned short num_properties;
- unsigned short num_colors;
- unsigned short num_shapes;
- unsigned short num_sections;
- unsigned short num_doodads;
- unsigned short num_key_aliases;
-} XkbGeometrySizesRec,*XkbGeometrySizesPtr;
+ unsigned int which;
+ unsigned short num_properties;
+ unsigned short num_colors;
+ unsigned short num_shapes;
+ unsigned short num_sections;
+ unsigned short num_doodads;
+ unsigned short num_key_aliases;
+} XkbGeometrySizesRec, *XkbGeometrySizesPtr;
/**
* Specifies which items should be cleared in an XKB geometry array
* when the array is reallocated.
*/
-typedef enum
-{
- XKB_GEOM_CLEAR_NONE, /* Don't clear any items, just reallocate. */
- XKB_GEOM_CLEAR_EXCESS, /* Clear new extra items after reallocation. */
- XKB_GEOM_CLEAR_ALL /* Clear all items after reallocation. */
+typedef enum {
+ XKB_GEOM_CLEAR_NONE, /* Don't clear any items, just reallocate. */
+ XKB_GEOM_CLEAR_EXCESS, /* Clear new extra items after reallocation. */
+ XKB_GEOM_CLEAR_ALL /* Clear all items after reallocation. */
} XkbGeomClearance;
-extern XkbPropertyPtr
-XkbAddGeomProperty(
- XkbGeometryPtr /* geom */,
- char * /* name */,
- char * /* value */
-);
-
-extern XkbKeyAliasPtr
-XkbAddGeomKeyAlias(
- XkbGeometryPtr /* geom */,
- char * /* alias */,
- char * /* real */
-);
-
-extern XkbColorPtr
-XkbAddGeomColor(
- XkbGeometryPtr /* geom */,
- char * /* spec */,
- unsigned int /* pixel */
-);
-
-extern XkbOutlinePtr
-XkbAddGeomOutline(
- XkbShapePtr /* shape */,
- int /* sz_points */
-);
-
-extern XkbShapePtr
-XkbAddGeomShape(
- XkbGeometryPtr /* geom */,
- Atom /* name */,
- int /* sz_outlines */
-);
-
-extern XkbKeyPtr
-XkbAddGeomKey(
- XkbRowPtr /* row */
-);
-
-extern XkbRowPtr
-XkbAddGeomRow(
- XkbSectionPtr /* section */,
- int /* sz_keys */
-);
-
-extern XkbSectionPtr
-XkbAddGeomSection(
- XkbGeometryPtr /* geom */,
- Atom /* name */,
- int /* sz_rows */,
- int /* sz_doodads */,
- int /* sz_overlays */
-);
-
-extern XkbOverlayPtr
-XkbAddGeomOverlay(
- XkbSectionPtr /* section */,
- Atom /* name */,
- int /* sz_rows */
-);
-
-extern XkbOverlayRowPtr
-XkbAddGeomOverlayRow(
- XkbOverlayPtr /* overlay */,
- int /* row_under */,
- int /* sz_keys */
-);
-
-extern XkbOverlayKeyPtr
-XkbAddGeomOverlayKey(
- XkbOverlayPtr /* overlay */,
- XkbOverlayRowPtr /* row */,
- char * /* over */,
- char * /* under */
-);
-
-extern XkbDoodadPtr
-XkbAddGeomDoodad(
- XkbGeometryPtr /* geom */,
- XkbSectionPtr /* section */,
- Atom /* name */
-);
-
+extern XkbPropertyPtr XkbAddGeomProperty(XkbGeometryPtr /* geom */ ,
+ char * /* name */ ,
+ char * /* value */
+ );
+
+extern XkbKeyAliasPtr XkbAddGeomKeyAlias(XkbGeometryPtr /* geom */ ,
+ char * /* alias */ ,
+ char * /* real */
+ );
+
+extern XkbColorPtr XkbAddGeomColor(XkbGeometryPtr /* geom */ ,
+ char * /* spec */ ,
+ unsigned int /* pixel */
+ );
+
+extern XkbOutlinePtr XkbAddGeomOutline(XkbShapePtr /* shape */ ,
+ int /* sz_points */
+ );
+
+extern XkbShapePtr XkbAddGeomShape(XkbGeometryPtr /* geom */ ,
+ Atom /* name */ ,
+ int /* sz_outlines */
+ );
+
+extern XkbKeyPtr XkbAddGeomKey(XkbRowPtr /* row */
+ );
+
+extern XkbRowPtr XkbAddGeomRow(XkbSectionPtr /* section */ ,
+ int /* sz_keys */
+ );
+
+extern XkbSectionPtr XkbAddGeomSection(XkbGeometryPtr /* geom */ ,
+ Atom /* name */ ,
+ int /* sz_rows */ ,
+ int /* sz_doodads */ ,
+ int /* sz_overlays */
+ );
+
+extern XkbOverlayPtr XkbAddGeomOverlay(XkbSectionPtr /* section */ ,
+ Atom /* name */ ,
+ int /* sz_rows */
+ );
+
+extern XkbOverlayRowPtr XkbAddGeomOverlayRow(XkbOverlayPtr /* overlay */ ,
+ int /* row_under */ ,
+ int /* sz_keys */
+ );
+
+extern XkbOverlayKeyPtr XkbAddGeomOverlayKey(XkbOverlayPtr /* overlay */ ,
+ XkbOverlayRowPtr /* row */ ,
+ char * /* over */ ,
+ char * /* under */
+ );
+
+extern XkbDoodadPtr XkbAddGeomDoodad(XkbGeometryPtr /* geom */ ,
+ XkbSectionPtr /* section */ ,
+ Atom /* name */
+ );
extern void
-XkbFreeGeomKeyAliases(
- XkbGeometryPtr /* geom */,
- int /* first */,
- int /* count */,
- Bool /* freeAll */
-);
+ XkbFreeGeomKeyAliases(XkbGeometryPtr /* geom */ ,
+ int /* first */ ,
+ int /* count */ ,
+ Bool /* freeAll */
+ );
extern void
-XkbFreeGeomColors(
- XkbGeometryPtr /* geom */,
- int /* first */,
- int /* count */,
- Bool /* freeAll */
-);
+ XkbFreeGeomColors(XkbGeometryPtr /* geom */ ,
+ int /* first */ ,
+ int /* count */ ,
+ Bool /* freeAll */
+ );
extern void
-XkbFreeGeomDoodads(
- XkbDoodadPtr /* doodads */,
- int /* nDoodads */,
- Bool /* freeAll */
-);
-
+ XkbFreeGeomDoodads(XkbDoodadPtr /* doodads */ ,
+ int /* nDoodads */ ,
+ Bool /* freeAll */
+ );
extern void
-XkbFreeGeomProperties(
- XkbGeometryPtr /* geom */,
- int /* first */,
- int /* count */,
- Bool /* freeAll */
-);
+ XkbFreeGeomProperties(XkbGeometryPtr /* geom */ ,
+ int /* first */ ,
+ int /* count */ ,
+ Bool /* freeAll */
+ );
extern void
-XkbFreeGeomOverlayKeys(
- XkbOverlayRowPtr /* row */,
- int /* first */,
- int /* count */,
- Bool /* freeAll */
-);
+ XkbFreeGeomOverlayKeys(XkbOverlayRowPtr /* row */ ,
+ int /* first */ ,
+ int /* count */ ,
+ Bool /* freeAll */
+ );
extern void
-XkbFreeGeomOverlayRows(
- XkbOverlayPtr /* overlay */,
- int /* first */,
- int /* count */,
- Bool /* freeAll */
-);
+ XkbFreeGeomOverlayRows(XkbOverlayPtr /* overlay */ ,
+ int /* first */ ,
+ int /* count */ ,
+ Bool /* freeAll */
+ );
extern void
-XkbFreeGeomOverlays(
- XkbSectionPtr /* section */,
- int /* first */,
- int /* count */,
- Bool /* freeAll */
-);
+ XkbFreeGeomOverlays(XkbSectionPtr /* section */ ,
+ int /* first */ ,
+ int /* count */ ,
+ Bool /* freeAll */
+ );
extern void
-XkbFreeGeomKeys(
- XkbRowPtr /* row */,
- int /* first */,
- int /* count */,
- Bool /* freeAll */
-);
+ XkbFreeGeomKeys(XkbRowPtr /* row */ ,
+ int /* first */ ,
+ int /* count */ ,
+ Bool /* freeAll */
+ );
extern void
-XkbFreeGeomRows(
- XkbSectionPtr /* section */,
- int /* first */,
- int /* count */,
- Bool /* freeAll */
-);
+ XkbFreeGeomRows(XkbSectionPtr /* section */ ,
+ int /* first */ ,
+ int /* count */ ,
+ Bool /* freeAll */
+ );
extern void
-XkbFreeGeomSections(
- XkbGeometryPtr /* geom */,
- int /* first */,
- int /* count */,
- Bool /* freeAll */
-);
-
+ XkbFreeGeomSections(XkbGeometryPtr /* geom */ ,
+ int /* first */ ,
+ int /* count */ ,
+ Bool /* freeAll */
+ );
extern void
-XkbFreeGeomPoints(
- XkbOutlinePtr /* outline */,
- int /* first */,
- int /* count */,
- Bool /* freeAll */
-);
+ XkbFreeGeomPoints(XkbOutlinePtr /* outline */ ,
+ int /* first */ ,
+ int /* count */ ,
+ Bool /* freeAll */
+ );
extern void
-XkbFreeGeomOutlines(
- XkbShapePtr /* shape */,
- int /* first */,
- int /* count */,
- Bool /* freeAll */
-);
+ XkbFreeGeomOutlines(XkbShapePtr /* shape */ ,
+ int /* first */ ,
+ int /* count */ ,
+ Bool /* freeAll */
+ );
extern void
-XkbFreeGeomShapes(
- XkbGeometryPtr /* geom */,
- int /* first */,
- int /* count */,
- Bool /* freeAll */
-);
+ XkbFreeGeomShapes(XkbGeometryPtr /* geom */ ,
+ int /* first */ ,
+ int /* count */ ,
+ Bool /* freeAll */
+ );
extern void
-XkbFreeGeometry(
- XkbGeometryPtr /* geom */,
- unsigned int /* which */,
- Bool /* freeMap */
-);
+ XkbFreeGeometry(XkbGeometryPtr /* geom */ ,
+ unsigned int /* which */ ,
+ Bool /* freeMap */
+ );
+
+extern Bool
+ XkbGeomRealloc(void ** /* buffer */ ,
+ int /* szItems */ ,
+ int /* nrItems */ ,
+ int /* itemSize */ ,
+ XkbGeomClearance /* clearance */
+ );
+
+extern Status XkbAllocGeomProps(XkbGeometryPtr /* geom */ ,
+ int /* nProps */
+ );
+
+extern Status XkbAllocGeomKeyAliases(XkbGeometryPtr /* geom */ ,
+ int /* nAliases */
+ );
+
+extern Status XkbAllocGeomColors(XkbGeometryPtr /* geom */ ,
+ int /* nColors */
+ );
+
+extern Status XkbAllocGeomShapes(XkbGeometryPtr /* geom */ ,
+ int /* nShapes */
+ );
+
+extern Status XkbAllocGeomSections(XkbGeometryPtr /* geom */ ,
+ int /* nSections */
+ );
+
+extern Status XkbAllocGeomOverlays(XkbSectionPtr /* section */ ,
+ int /* num_needed */
+ );
+
+extern Status XkbAllocGeomOverlayRows(XkbOverlayPtr /* overlay */ ,
+ int /* num_needed */
+ );
+
+extern Status XkbAllocGeomOverlayKeys(XkbOverlayRowPtr /* row */ ,
+ int /* num_needed */
+ );
+
+extern Status XkbAllocGeomDoodads(XkbGeometryPtr /* geom */ ,
+ int /* nDoodads */
+ );
+
+extern Status XkbAllocGeomSectionDoodads(XkbSectionPtr /* section */ ,
+ int /* nDoodads */
+ );
+
+extern Status XkbAllocGeomOutlines(XkbShapePtr /* shape */ ,
+ int /* nOL */
+ );
+
+extern Status XkbAllocGeomRows(XkbSectionPtr /* section */ ,
+ int /* nRows */
+ );
+
+extern Status XkbAllocGeomPoints(XkbOutlinePtr /* ol */ ,
+ int /* nPts */
+ );
+
+extern Status XkbAllocGeomKeys(XkbRowPtr /* row */ ,
+ int /* nKeys */
+ );
+
+extern Status XkbAllocGeometry(XkbDescPtr /* xkb */ ,
+ XkbGeometrySizesPtr /* sizes */
+ );
+
+extern Bool
+ XkbComputeShapeTop(XkbShapePtr /* shape */ ,
+ XkbBoundsPtr /* bounds */
+ );
+
+extern Bool
+ XkbComputeShapeBounds(XkbShapePtr /* shape */
+ );
extern Bool
-XkbGeomRealloc(
- void ** /* buffer */,
- int /* szItems */,
- int /* nrItems */,
- int /* itemSize */,
- XkbGeomClearance /* clearance */
-);
-
-extern Status
-XkbAllocGeomProps(
- XkbGeometryPtr /* geom */,
- int /* nProps */
-);
-
-extern Status
-XkbAllocGeomKeyAliases(
- XkbGeometryPtr /* geom */,
- int /* nAliases */
-);
-
-extern Status
-XkbAllocGeomColors(
- XkbGeometryPtr /* geom */,
- int /* nColors */
-);
-
-extern Status
-XkbAllocGeomShapes(
- XkbGeometryPtr /* geom */,
- int /* nShapes */
-);
-
-extern Status
-XkbAllocGeomSections(
- XkbGeometryPtr /* geom */,
- int /* nSections */
-);
-
-extern Status
-XkbAllocGeomOverlays(
- XkbSectionPtr /* section */,
- int /* num_needed */
-);
-
-extern Status
-XkbAllocGeomOverlayRows(
- XkbOverlayPtr /* overlay */,
- int /* num_needed */
-);
-
-extern Status
-XkbAllocGeomOverlayKeys(
- XkbOverlayRowPtr /* row */,
- int /* num_needed */
-);
-
-extern Status
-XkbAllocGeomDoodads(
- XkbGeometryPtr /* geom */,
- int /* nDoodads */
-);
-
-extern Status
-XkbAllocGeomSectionDoodads(
- XkbSectionPtr /* section */,
- int /* nDoodads */
-);
-
-extern Status
-XkbAllocGeomOutlines(
- XkbShapePtr /* shape */,
- int /* nOL */
-);
-
-extern Status
-XkbAllocGeomRows(
- XkbSectionPtr /* section */,
- int /* nRows */
-);
-
-extern Status
-XkbAllocGeomPoints(
- XkbOutlinePtr /* ol */,
- int /* nPts */
-);
-
-extern Status
-XkbAllocGeomKeys(
- XkbRowPtr /* row */,
- int /* nKeys */
-);
-
-extern Status
-XkbAllocGeometry(
- XkbDescPtr /* xkb */,
- XkbGeometrySizesPtr /* sizes */
-);
-
-extern Bool
-XkbComputeShapeTop(
- XkbShapePtr /* shape */,
- XkbBoundsPtr /* bounds */
-);
-
-extern Bool
-XkbComputeShapeBounds(
- XkbShapePtr /* shape */
-);
-
-extern Bool
-XkbComputeRowBounds(
- XkbGeometryPtr /* geom */,
- XkbSectionPtr /* section */,
- XkbRowPtr /* row */
-);
-
-extern Bool
-XkbComputeSectionBounds(
- XkbGeometryPtr /* geom */,
- XkbSectionPtr /* section */
-);
-
-extern char *
-XkbFindOverlayForKey(
- XkbGeometryPtr /* geom */,
- XkbSectionPtr /* wanted */,
- char * /* under */
-);
-
-#endif /* _XKBGEOM_H_ */
+ XkbComputeRowBounds(XkbGeometryPtr /* geom */ ,
+ XkbSectionPtr /* section */ ,
+ XkbRowPtr /* row */
+ );
+
+extern Bool
+ XkbComputeSectionBounds(XkbGeometryPtr /* geom */ ,
+ XkbSectionPtr /* section */
+ );
+
+extern char *XkbFindOverlayForKey(XkbGeometryPtr /* geom */ ,
+ XkbSectionPtr /* wanted */ ,
+ char * /* under */
+ );
+
+#endif /* _XKBGEOM_H_ */
diff --git a/xkb/xkbout.c b/xkb/xkbout.c
index 889d5cc39..cd1ae0b4e 100644
--- a/xkb/xkbout.c
+++ b/xkb/xkbout.c
@@ -52,849 +52,874 @@
#define VMOD_COMMENT_VALUE 2
static Bool
-WriteXKBVModDecl(FILE *file,XkbDescPtr xkb,int showValue)
+WriteXKBVModDecl(FILE * file, XkbDescPtr xkb, int showValue)
{
-register int i,nMods;
-Atom * vmodNames;
-
- if (xkb==NULL)
- return FALSE;
- if (xkb->names!=NULL)
- vmodNames= xkb->names->vmods;
- else vmodNames= NULL;
-
- for (i=nMods=0;i<XkbNumVirtualMods;i++) {
- if ((vmodNames!=NULL)&&(vmodNames[i]!=None)) {
- if (nMods==0) fprintf(file," virtual_modifiers ");
- else fprintf(file,",");
- fprintf(file,"%s",XkbAtomText(vmodNames[i],XkbXKBFile));
- if ((showValue!=VMOD_HIDE_VALUE)&&
- (xkb->server)&&(xkb->server->vmods[i]!=XkbNoModifierMask)) {
- if (showValue==VMOD_COMMENT_VALUE) {
- fprintf(file,"/* = %s */",
- XkbModMaskText(xkb->server->vmods[i],XkbXKBFile));
- }
- else {
- fprintf(file,"= %s",
- XkbModMaskText(xkb->server->vmods[i],XkbXKBFile));
- }
- }
- nMods++;
- }
- }
- if (nMods>0)
- fprintf(file,";\n\n");
+ register int i, nMods;
+ Atom *vmodNames;
+
+ if (xkb == NULL)
+ return FALSE;
+ if (xkb->names != NULL)
+ vmodNames = xkb->names->vmods;
+ else
+ vmodNames = NULL;
+
+ for (i = nMods = 0; i < XkbNumVirtualMods; i++) {
+ if ((vmodNames != NULL) && (vmodNames[i] != None)) {
+ if (nMods == 0)
+ fprintf(file, " virtual_modifiers ");
+ else
+ fprintf(file, ",");
+ fprintf(file, "%s", XkbAtomText(vmodNames[i], XkbXKBFile));
+ if ((showValue != VMOD_HIDE_VALUE) &&
+ (xkb->server) && (xkb->server->vmods[i] != XkbNoModifierMask)) {
+ if (showValue == VMOD_COMMENT_VALUE) {
+ fprintf(file, "/* = %s */",
+ XkbModMaskText(xkb->server->vmods[i], XkbXKBFile));
+ }
+ else {
+ fprintf(file, "= %s",
+ XkbModMaskText(xkb->server->vmods[i], XkbXKBFile));
+ }
+ }
+ nMods++;
+ }
+ }
+ if (nMods > 0)
+ fprintf(file, ";\n\n");
return TRUE;
}
/***====================================================================***/
static Bool
-WriteXKBAction(FILE *file,XkbDescPtr xkb,XkbAnyAction *action)
+WriteXKBAction(FILE * file, XkbDescPtr xkb, XkbAnyAction * action)
{
- fprintf(file,"%s",XkbActionText(xkb,(XkbAction *)action,XkbXKBFile));
+ fprintf(file, "%s", XkbActionText(xkb, (XkbAction *) action, XkbXKBFile));
return TRUE;
}
/***====================================================================***/
Bool
-XkbWriteXKBKeycodes( FILE * file,
- XkbDescPtr xkb,
- Bool topLevel,
- Bool showImplicit,
- XkbFileAddOnFunc addOn,
- void * priv)
+XkbWriteXKBKeycodes(FILE * file,
+ XkbDescPtr xkb,
+ Bool topLevel,
+ Bool showImplicit, XkbFileAddOnFunc addOn, void *priv)
{
-Atom kcName;
-register unsigned i;
-const char * alternate;
-
- if ((!xkb)||(!xkb->names)||(!xkb->names->keys)) {
- _XkbLibError(_XkbErrMissingNames,"XkbWriteXKBKeycodes",0);
- return FALSE;
- }
- kcName= xkb->names->keycodes;
- if (kcName!=None)
- fprintf(file,"xkb_keycodes \"%s\" {\n",
- XkbAtomText(kcName,XkbXKBFile));
- else fprintf(file,"xkb_keycodes {\n");
- fprintf(file," minimum = %d;\n",xkb->min_key_code);
- fprintf(file," maximum = %d;\n",xkb->max_key_code);
- for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
- if (xkb->names->keys[i].name[0]!='\0') {
- if (XkbFindKeycodeByName(xkb,xkb->names->keys[i].name,TRUE)!=i)
- alternate= "alternate ";
- else alternate= "";
- fprintf(file," %s%6s = %d;\n",alternate,
- XkbKeyNameText(xkb->names->keys[i].name,XkbXKBFile),
- i);
- }
- }
- if (xkb->indicators!=NULL) {
- for (i=0;i<XkbNumIndicators;i++) {
- const char *type;
- if (xkb->indicators->phys_indicators&(1<<i))
- type= " ";
- else type= " virtual ";
- if (xkb->names->indicators[i]!=None) {
- fprintf(file,"%sindicator %d = \"%s\";\n",type,i+1,
- XkbAtomText(xkb->names->indicators[i],XkbXKBFile));
- }
- }
- }
- if (xkb->names->key_aliases!=NULL) {
- XkbKeyAliasPtr pAl;
- pAl= xkb->names->key_aliases;
- for (i=0;i<xkb->names->num_key_aliases;i++,pAl++) {
- fprintf(file," alias %6s = %6s;\n",
- XkbKeyNameText(pAl->alias,XkbXKBFile),
- XkbKeyNameText(pAl->real,XkbXKBFile));
- }
+ Atom kcName;
+ register unsigned i;
+ const char *alternate;
+
+ if ((!xkb) || (!xkb->names) || (!xkb->names->keys)) {
+ _XkbLibError(_XkbErrMissingNames, "XkbWriteXKBKeycodes", 0);
+ return FALSE;
+ }
+ kcName = xkb->names->keycodes;
+ if (kcName != None)
+ fprintf(file, "xkb_keycodes \"%s\" {\n",
+ XkbAtomText(kcName, XkbXKBFile));
+ else
+ fprintf(file, "xkb_keycodes {\n");
+ fprintf(file, " minimum = %d;\n", xkb->min_key_code);
+ fprintf(file, " maximum = %d;\n", xkb->max_key_code);
+ for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+ if (xkb->names->keys[i].name[0] != '\0') {
+ if (XkbFindKeycodeByName(xkb, xkb->names->keys[i].name, TRUE) != i)
+ alternate = "alternate ";
+ else
+ alternate = "";
+ fprintf(file, " %s%6s = %d;\n", alternate,
+ XkbKeyNameText(xkb->names->keys[i].name, XkbXKBFile), i);
+ }
+ }
+ if (xkb->indicators != NULL) {
+ for (i = 0; i < XkbNumIndicators; i++) {
+ const char *type;
+
+ if (xkb->indicators->phys_indicators & (1 << i))
+ type = " ";
+ else
+ type = " virtual ";
+ if (xkb->names->indicators[i] != None) {
+ fprintf(file, "%sindicator %d = \"%s\";\n", type, i + 1,
+ XkbAtomText(xkb->names->indicators[i], XkbXKBFile));
+ }
+ }
+ }
+ if (xkb->names->key_aliases != NULL) {
+ XkbKeyAliasPtr pAl;
+
+ pAl = xkb->names->key_aliases;
+ for (i = 0; i < xkb->names->num_key_aliases; i++, pAl++) {
+ fprintf(file, " alias %6s = %6s;\n",
+ XkbKeyNameText(pAl->alias, XkbXKBFile),
+ XkbKeyNameText(pAl->real, XkbXKBFile));
+ }
}
if (addOn)
- (*addOn)(file,xkb,topLevel,showImplicit,XkmKeyNamesIndex,priv);
- fprintf(file,"};\n\n");
+ (*addOn) (file, xkb, topLevel, showImplicit, XkmKeyNamesIndex, priv);
+ fprintf(file, "};\n\n");
return TRUE;
}
Bool
-XkbWriteXKBKeyTypes( FILE * file,
- XkbDescPtr xkb,
- Bool topLevel,
- Bool showImplicit,
- XkbFileAddOnFunc addOn,
- void * priv)
+XkbWriteXKBKeyTypes(FILE * file,
+ XkbDescPtr xkb,
+ Bool topLevel,
+ Bool showImplicit, XkbFileAddOnFunc addOn, void *priv)
{
-register unsigned i,n;
-XkbKeyTypePtr type;
-XkbKTMapEntryPtr entry;
-
- if ((!xkb)||(!xkb->map)||(!xkb->map->types)) {
- _XkbLibError(_XkbErrMissingTypes,"XkbWriteXKBKeyTypes",0);
- return FALSE;
- }
- if (xkb->map->num_types<XkbNumRequiredTypes) {
- _XkbLibError(_XkbErrMissingReqTypes,"XkbWriteXKBKeyTypes",0);
- return 0;
- }
- if ((xkb->names==NULL)||(xkb->names->types==None))
- fprintf(file,"xkb_types {\n\n");
- else fprintf(file,"xkb_types \"%s\" {\n\n",
- XkbAtomText(xkb->names->types,XkbXKBFile));
- WriteXKBVModDecl(file,xkb,
- (showImplicit?VMOD_COMMENT_VALUE:VMOD_HIDE_VALUE));
-
- type= xkb->map->types;
- for (i=0;i<xkb->map->num_types;i++,type++) {
- fprintf(file," type \"%s\" {\n",
- XkbAtomText(type->name,XkbXKBFile));
- fprintf(file," modifiers= %s;\n",
- XkbVModMaskText(xkb,type->mods.real_mods,type->mods.vmods,
- XkbXKBFile));
- entry= type->map;
- for (n=0;n<type->map_count;n++,entry++) {
- char *str;
- str=XkbVModMaskText(xkb,entry->mods.real_mods,entry->mods.vmods,
- XkbXKBFile);
- fprintf(file," map[%s]= Level%d;\n",str,entry->level+1);
- if ((type->preserve)&&((type->preserve[n].real_mods)||
- (type->preserve[n].vmods))) {
- fprintf(file," preserve[%s]= ",str);
- fprintf(file,"%s;\n",XkbVModMaskText(xkb,
- type->preserve[n].real_mods,
- type->preserve[n].vmods,
- XkbXKBFile));
- }
- }
- if (type->level_names!=NULL) {
- Atom *name= type->level_names;
- for (n=0;n<type->num_levels;n++,name++) {
- if ((*name)==None)
- continue;
- fprintf(file," level_name[Level%d]= \"%s\";\n",n+1,
- XkbAtomText(*name,XkbXKBFile));
- }
- }
- fprintf(file," };\n");
+ register unsigned i, n;
+ XkbKeyTypePtr type;
+ XkbKTMapEntryPtr entry;
+
+ if ((!xkb) || (!xkb->map) || (!xkb->map->types)) {
+ _XkbLibError(_XkbErrMissingTypes, "XkbWriteXKBKeyTypes", 0);
+ return FALSE;
+ }
+ if (xkb->map->num_types < XkbNumRequiredTypes) {
+ _XkbLibError(_XkbErrMissingReqTypes, "XkbWriteXKBKeyTypes", 0);
+ return 0;
+ }
+ if ((xkb->names == NULL) || (xkb->names->types == None))
+ fprintf(file, "xkb_types {\n\n");
+ else
+ fprintf(file, "xkb_types \"%s\" {\n\n",
+ XkbAtomText(xkb->names->types, XkbXKBFile));
+ WriteXKBVModDecl(file, xkb,
+ (showImplicit ? VMOD_COMMENT_VALUE : VMOD_HIDE_VALUE));
+
+ type = xkb->map->types;
+ for (i = 0; i < xkb->map->num_types; i++, type++) {
+ fprintf(file, " type \"%s\" {\n",
+ XkbAtomText(type->name, XkbXKBFile));
+ fprintf(file, " modifiers= %s;\n",
+ XkbVModMaskText(xkb, type->mods.real_mods, type->mods.vmods,
+ XkbXKBFile));
+ entry = type->map;
+ for (n = 0; n < type->map_count; n++, entry++) {
+ char *str;
+
+ str = XkbVModMaskText(xkb, entry->mods.real_mods, entry->mods.vmods,
+ XkbXKBFile);
+ fprintf(file, " map[%s]= Level%d;\n", str, entry->level + 1);
+ if ((type->preserve) && ((type->preserve[n].real_mods) ||
+ (type->preserve[n].vmods))) {
+ fprintf(file, " preserve[%s]= ", str);
+ fprintf(file, "%s;\n", XkbVModMaskText(xkb,
+ type->preserve[n].
+ real_mods,
+ type->preserve[n].vmods,
+ XkbXKBFile));
+ }
+ }
+ if (type->level_names != NULL) {
+ Atom *name = type->level_names;
+
+ for (n = 0; n < type->num_levels; n++, name++) {
+ if ((*name) == None)
+ continue;
+ fprintf(file, " level_name[Level%d]= \"%s\";\n", n + 1,
+ XkbAtomText(*name, XkbXKBFile));
+ }
+ }
+ fprintf(file, " };\n");
}
if (addOn)
- (*addOn)(file,xkb,topLevel,showImplicit,XkmTypesIndex,priv);
- fprintf(file,"};\n\n");
+ (*addOn) (file, xkb, topLevel, showImplicit, XkmTypesIndex, priv);
+ fprintf(file, "};\n\n");
return TRUE;
}
static Bool
-WriteXKBIndicatorMap( FILE * file,
- XkbDescPtr xkb,
- Atom name,
- XkbIndicatorMapPtr led,
- XkbFileAddOnFunc addOn,
- void * priv)
+WriteXKBIndicatorMap(FILE * file,
+ XkbDescPtr xkb,
+ Atom name,
+ XkbIndicatorMapPtr led, XkbFileAddOnFunc addOn, void *priv)
{
- fprintf(file," indicator \"%s\" {\n",NameForAtom(name));
- if (led->flags&XkbIM_NoExplicit)
- fprintf(file," !allowExplicit;\n");
- if (led->flags&XkbIM_LEDDrivesKB)
- fprintf(file," indicatorDrivesKeyboard;\n");
- if (led->which_groups!=0) {
- if (led->which_groups!=XkbIM_UseEffective) {
- fprintf(file," whichGroupState= %s;\n",
- XkbIMWhichStateMaskText(led->which_groups,XkbXKBFile));
- }
- fprintf(file," groups= 0x%02x;\n",led->groups);
- }
- if (led->which_mods!=0) {
- if (led->which_mods!=XkbIM_UseEffective) {
- fprintf(file," whichModState= %s;\n",
- XkbIMWhichStateMaskText(led->which_mods,XkbXKBFile));
- }
- fprintf(file," modifiers= %s;\n",
- XkbVModMaskText(xkb,
- led->mods.real_mods,led->mods.vmods,
- XkbXKBFile));
- }
- if (led->ctrls!=0) {
- fprintf(file," controls= %s;\n",
- XkbControlsMaskText(led->ctrls,XkbXKBFile));
+ fprintf(file, " indicator \"%s\" {\n", NameForAtom(name));
+ if (led->flags & XkbIM_NoExplicit)
+ fprintf(file, " !allowExplicit;\n");
+ if (led->flags & XkbIM_LEDDrivesKB)
+ fprintf(file, " indicatorDrivesKeyboard;\n");
+ if (led->which_groups != 0) {
+ if (led->which_groups != XkbIM_UseEffective) {
+ fprintf(file, " whichGroupState= %s;\n",
+ XkbIMWhichStateMaskText(led->which_groups, XkbXKBFile));
+ }
+ fprintf(file, " groups= 0x%02x;\n", led->groups);
+ }
+ if (led->which_mods != 0) {
+ if (led->which_mods != XkbIM_UseEffective) {
+ fprintf(file, " whichModState= %s;\n",
+ XkbIMWhichStateMaskText(led->which_mods, XkbXKBFile));
+ }
+ fprintf(file, " modifiers= %s;\n",
+ XkbVModMaskText(xkb,
+ led->mods.real_mods, led->mods.vmods,
+ XkbXKBFile));
+ }
+ if (led->ctrls != 0) {
+ fprintf(file, " controls= %s;\n",
+ XkbControlsMaskText(led->ctrls, XkbXKBFile));
}
if (addOn)
- (*addOn)(file,xkb,FALSE,TRUE,XkmIndicatorsIndex,priv);
- fprintf(file," };\n");
+ (*addOn) (file, xkb, FALSE, TRUE, XkmIndicatorsIndex, priv);
+ fprintf(file, " };\n");
return TRUE;
}
Bool
-XkbWriteXKBCompatMap( FILE * file,
- XkbDescPtr xkb,
- Bool topLevel,
- Bool showImplicit,
- XkbFileAddOnFunc addOn,
- void * priv)
+XkbWriteXKBCompatMap(FILE * file,
+ XkbDescPtr xkb,
+ Bool topLevel,
+ Bool showImplicit, XkbFileAddOnFunc addOn, void *priv)
{
-register unsigned i;
-XkbSymInterpretPtr interp;
-
- if ((!xkb)||(!xkb->compat)||(!xkb->compat->sym_interpret)) {
- _XkbLibError(_XkbErrMissingCompatMap,"XkbWriteXKBCompatMap",0);
- return FALSE;
- }
- if ((xkb->names==NULL)||(xkb->names->compat==None))
- fprintf(file,"xkb_compatibility {\n\n");
- else fprintf(file,"xkb_compatibility \"%s\" {\n\n",
- XkbAtomText(xkb->names->compat,XkbXKBFile));
- WriteXKBVModDecl(file,xkb,
- (showImplicit?VMOD_COMMENT_VALUE:VMOD_HIDE_VALUE));
-
- fprintf(file," interpret.useModMapMods= AnyLevel;\n");
- fprintf(file," interpret.repeat= FALSE;\n");
- fprintf(file," interpret.locking= FALSE;\n");
- interp= xkb->compat->sym_interpret;
- for (i=0;i<xkb->compat->num_si;i++,interp++) {
- fprintf(file," interpret %s+%s(%s) {\n",
- ((interp->sym==NoSymbol)?"Any":
- XkbKeysymText(interp->sym,XkbXKBFile)),
- XkbSIMatchText(interp->match,XkbXKBFile),
- XkbModMaskText(interp->mods,XkbXKBFile));
- if (interp->virtual_mod!=XkbNoModifier) {
- fprintf(file," virtualModifier= %s;\n",
- XkbVModIndexText(xkb,interp->virtual_mod,XkbXKBFile));
- }
- if (interp->match&XkbSI_LevelOneOnly)
- fprintf(file," useModMapMods=level1;\n");
- if (interp->flags&XkbSI_LockingKey)
- fprintf(file," locking= TRUE;\n");
- if (interp->flags&XkbSI_AutoRepeat)
- fprintf(file," repeat= TRUE;\n");
- fprintf(file," action= ");
- WriteXKBAction(file,xkb,&interp->act);
- fprintf(file,";\n");
- fprintf(file," };\n");
- }
- for (i=0;i<XkbNumKbdGroups;i++) {
- XkbModsPtr gc;
-
- gc= &xkb->compat->groups[i];
- if ((gc->real_mods==0)&&(gc->vmods==0))
- continue;
- fprintf(file," group %d = %s;\n",i+1,XkbVModMaskText(xkb,
- gc->real_mods,gc->vmods,
- XkbXKBFile));
+ register unsigned i;
+ XkbSymInterpretPtr interp;
+
+ if ((!xkb) || (!xkb->compat) || (!xkb->compat->sym_interpret)) {
+ _XkbLibError(_XkbErrMissingCompatMap, "XkbWriteXKBCompatMap", 0);
+ return FALSE;
+ }
+ if ((xkb->names == NULL) || (xkb->names->compat == None))
+ fprintf(file, "xkb_compatibility {\n\n");
+ else
+ fprintf(file, "xkb_compatibility \"%s\" {\n\n",
+ XkbAtomText(xkb->names->compat, XkbXKBFile));
+ WriteXKBVModDecl(file, xkb,
+ (showImplicit ? VMOD_COMMENT_VALUE : VMOD_HIDE_VALUE));
+
+ fprintf(file, " interpret.useModMapMods= AnyLevel;\n");
+ fprintf(file, " interpret.repeat= FALSE;\n");
+ fprintf(file, " interpret.locking= FALSE;\n");
+ interp = xkb->compat->sym_interpret;
+ for (i = 0; i < xkb->compat->num_si; i++, interp++) {
+ fprintf(file, " interpret %s+%s(%s) {\n",
+ ((interp->sym == NoSymbol) ? "Any" :
+ XkbKeysymText(interp->sym, XkbXKBFile)),
+ XkbSIMatchText(interp->match, XkbXKBFile),
+ XkbModMaskText(interp->mods, XkbXKBFile));
+ if (interp->virtual_mod != XkbNoModifier) {
+ fprintf(file, " virtualModifier= %s;\n",
+ XkbVModIndexText(xkb, interp->virtual_mod, XkbXKBFile));
+ }
+ if (interp->match & XkbSI_LevelOneOnly)
+ fprintf(file, " useModMapMods=level1;\n");
+ if (interp->flags & XkbSI_LockingKey)
+ fprintf(file, " locking= TRUE;\n");
+ if (interp->flags & XkbSI_AutoRepeat)
+ fprintf(file, " repeat= TRUE;\n");
+ fprintf(file, " action= ");
+ WriteXKBAction(file, xkb, &interp->act);
+ fprintf(file, ";\n");
+ fprintf(file, " };\n");
+ }
+ for (i = 0; i < XkbNumKbdGroups; i++) {
+ XkbModsPtr gc;
+
+ gc = &xkb->compat->groups[i];
+ if ((gc->real_mods == 0) && (gc->vmods == 0))
+ continue;
+ fprintf(file, " group %d = %s;\n", i + 1, XkbVModMaskText(xkb,
+ gc->
+ real_mods,
+ gc->vmods,
+ XkbXKBFile));
}
if (xkb->indicators) {
- for (i=0;i<XkbNumIndicators;i++) {
- XkbIndicatorMapPtr map= &xkb->indicators->maps[i];
- if ((map->flags!=0)||(map->which_groups!=0)||(map->groups!=0)||
- (map->which_mods!=0)||
- (map->mods.real_mods!=0)||(map->mods.vmods!=0)||
- (map->ctrls!=0)) {
- WriteXKBIndicatorMap(file,xkb,xkb->names->indicators[i],map,
- addOn,priv);
- }
- }
+ for (i = 0; i < XkbNumIndicators; i++) {
+ XkbIndicatorMapPtr map = &xkb->indicators->maps[i];
+
+ if ((map->flags != 0) || (map->which_groups != 0) ||
+ (map->groups != 0) || (map->which_mods != 0) ||
+ (map->mods.real_mods != 0) || (map->mods.vmods != 0) ||
+ (map->ctrls != 0)) {
+ WriteXKBIndicatorMap(file, xkb, xkb->names->indicators[i], map,
+ addOn, priv);
+ }
+ }
}
if (addOn)
- (*addOn)(file,xkb,topLevel,showImplicit,XkmCompatMapIndex,priv);
- fprintf(file,"};\n\n");
+ (*addOn) (file, xkb, topLevel, showImplicit, XkmCompatMapIndex, priv);
+ fprintf(file, "};\n\n");
return TRUE;
}
Bool
-XkbWriteXKBSymbols( FILE * file,
- XkbDescPtr xkb,
- Bool topLevel,
- Bool showImplicit,
- XkbFileAddOnFunc addOn,
- void * priv)
+XkbWriteXKBSymbols(FILE * file,
+ XkbDescPtr xkb,
+ Bool topLevel,
+ Bool showImplicit, XkbFileAddOnFunc addOn, void *priv)
{
-register unsigned i,tmp;
-XkbClientMapPtr map;
-XkbServerMapPtr srv;
-Bool showActions;
+ register unsigned i, tmp;
+ XkbClientMapPtr map;
+ XkbServerMapPtr srv;
+ Bool showActions;
if (!xkb) {
- _XkbLibError(_XkbErrMissingSymbols,"XkbWriteXKBSymbols",0);
- return FALSE;
- }
-
- map= xkb->map;
- if ((!map)||(!map->syms)||(!map->key_sym_map)) {
- _XkbLibError(_XkbErrMissingSymbols,"XkbWriteXKBSymbols",0);
- return FALSE;
- }
- if ((!xkb->names)||(!xkb->names->keys)) {
- _XkbLibError(_XkbErrMissingNames,"XkbWriteXKBSymbols",0);
- return FALSE;
- }
- if ((xkb->names==NULL)||(xkb->names->symbols==None))
- fprintf(file,"xkb_symbols {\n\n");
- else fprintf(file,"xkb_symbols \"%s\" {\n\n",
- XkbAtomText(xkb->names->symbols,XkbXKBFile));
- for (tmp=i=0;i<XkbNumKbdGroups;i++) {
- if (xkb->names->groups[i]!=None) {
- fprintf(file," name[group%d]=\"%s\";\n",i+1,
- XkbAtomText(xkb->names->groups[i],XkbXKBFile));
- tmp++;
- }
- }
- if (tmp>0)
- fprintf(file,"\n");
- srv= xkb->server;
- for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
- Bool simple;
- if ((int)XkbKeyNumSyms(xkb,i)<1)
- continue;
- if (XkbFindKeycodeByName(xkb,xkb->names->keys[i].name,TRUE)!=i)
- continue;
- simple= TRUE;
- fprintf(file," key %6s {",
- XkbKeyNameText(xkb->names->keys[i].name,XkbXKBFile));
- if (srv->explicit) {
- if (((srv->explicit[i]&XkbExplicitKeyTypesMask)!=0)||
- (showImplicit)) {
- int typeNdx,g;
- Bool multi;
- const char * comment=" ";
-
- if ((srv->explicit[i]&XkbExplicitKeyTypesMask)==0)
- comment= "//";
- multi= FALSE;
- typeNdx= XkbKeyKeyTypeIndex(xkb,i,0);
- for (g=1;(g<XkbKeyNumGroups(xkb,i))&&(!multi);g++) {
- if (XkbKeyKeyTypeIndex(xkb,i,g)!=typeNdx)
- multi= TRUE;
- }
- if (multi) {
- for (g=0;g<XkbKeyNumGroups(xkb,i);g++) {
- typeNdx= XkbKeyKeyTypeIndex(xkb,i,g);
- if (srv->explicit[i]&(1<<g)) {
- fprintf(file,"\n%s type[group%d]= \"%s\",",
- comment,g+1,
- XkbAtomText(map->types[typeNdx].name,
- XkbXKBFile));
- }
- else if (showImplicit) {
- fprintf(file,"\n// type[group%d]= \"%s\",",g+1,
- XkbAtomText(map->types[typeNdx].name,
- XkbXKBFile));
- }
- }
- }
- else {
- fprintf(file,"\n%s type= \"%s\",",comment,
- XkbAtomText(map->types[typeNdx].name,
- XkbXKBFile));
- }
- simple= FALSE;
- }
- if (((srv->explicit[i]&XkbExplicitAutoRepeatMask)!=0)&&
- (xkb->ctrls!=NULL)) {
- if (xkb->ctrls->per_key_repeat[i/8]&(1<<(i%8)))
- fprintf(file,"\n repeat= Yes,");
- else fprintf(file,"\n repeat= No,");
- simple= FALSE;
- }
- if ((xkb->server!=NULL)&&(xkb->server->vmodmap!=NULL)&&
- (xkb->server->vmodmap[i]!=0)) {
- if ((srv->explicit[i]&XkbExplicitVModMapMask)!=0) {
- fprintf(file,"\n virtualMods= %s,",
- XkbVModMaskText(xkb,0,
- xkb->server->vmodmap[i],
- XkbXKBFile));
- }
- else if (showImplicit) {
- fprintf(file,"\n// virtualMods= %s,",
- XkbVModMaskText(xkb,0,
- xkb->server->vmodmap[i],
- XkbXKBFile));
- }
- }
- }
- switch (XkbOutOfRangeGroupAction(XkbKeyGroupInfo(xkb,i))) {
- case XkbClampIntoRange:
- fprintf(file,"\n groupsClamp,");
- break;
- case XkbRedirectIntoRange:
- fprintf(file,"\n groupsRedirect= Group%d,",
- XkbOutOfRangeGroupNumber(XkbKeyGroupInfo(xkb,i))+1);
- break;
- }
- if (srv->behaviors!=NULL) {
- unsigned type;
- type= srv->behaviors[i].type&XkbKB_OpMask;
-
- if (type!=XkbKB_Default) {
- simple= FALSE;
- fprintf(file,"\n %s,",
- XkbBehaviorText(xkb,&srv->behaviors[i],XkbXKBFile));
- }
- }
- if ((srv->explicit==NULL) || showImplicit ||
- ((srv->explicit[i]&XkbExplicitInterpretMask)!=0))
- showActions= XkbKeyHasActions(xkb,i);
- else showActions= FALSE;
-
- if (((unsigned)XkbKeyNumGroups(xkb,i)>1)||showActions)
- simple= FALSE;
- if (simple) {
- KeySym *syms;
- unsigned s;
-
- syms= XkbKeySymsPtr(xkb,i);
- fprintf(file," [ ");
- for (s=0;s<XkbKeyGroupWidth(xkb,i,XkbGroup1Index);s++) {
- if (s!=0)
- fprintf(file,", ");
- fprintf(file,"%15s",XkbKeysymText(*syms++,XkbXKBFile));
- }
- fprintf(file," ] };\n");
- }
- else {
- unsigned g,s;
- KeySym *syms;
- XkbAction *acts;
- syms= XkbKeySymsPtr(xkb,i);
- acts= XkbKeyActionsPtr(xkb,i);
- for (g=0;g<XkbKeyNumGroups(xkb,i);g++) {
- if (g!=0)
- fprintf(file,",");
- fprintf(file,"\n symbols[Group%d]= [ ",g+1);
- for (s=0;s<XkbKeyGroupWidth(xkb,i,g);s++) {
- if (s!=0)
- fprintf(file,", ");
- fprintf(file,"%15s",XkbKeysymText(syms[s],XkbXKBFile));
- }
- fprintf(file," ]");
- syms+= XkbKeyGroupsWidth(xkb,i);
- if (showActions) {
- fprintf(file,",\n actions[Group%d]= [ ",g+1);
- for (s=0;s<XkbKeyGroupWidth(xkb,i,g);s++) {
- if (s!=0)
- fprintf(file,", ");
- WriteXKBAction(file,xkb,(XkbAnyAction *)&acts[s]);
- }
- fprintf(file," ]");
- acts+= XkbKeyGroupsWidth(xkb,i);
- }
- }
- fprintf(file,"\n };\n");
- }
+ _XkbLibError(_XkbErrMissingSymbols, "XkbWriteXKBSymbols", 0);
+ return FALSE;
+ }
+
+ map = xkb->map;
+ if ((!map) || (!map->syms) || (!map->key_sym_map)) {
+ _XkbLibError(_XkbErrMissingSymbols, "XkbWriteXKBSymbols", 0);
+ return FALSE;
+ }
+ if ((!xkb->names) || (!xkb->names->keys)) {
+ _XkbLibError(_XkbErrMissingNames, "XkbWriteXKBSymbols", 0);
+ return FALSE;
+ }
+ if ((xkb->names == NULL) || (xkb->names->symbols == None))
+ fprintf(file, "xkb_symbols {\n\n");
+ else
+ fprintf(file, "xkb_symbols \"%s\" {\n\n",
+ XkbAtomText(xkb->names->symbols, XkbXKBFile));
+ for (tmp = i = 0; i < XkbNumKbdGroups; i++) {
+ if (xkb->names->groups[i] != None) {
+ fprintf(file, " name[group%d]=\"%s\";\n", i + 1,
+ XkbAtomText(xkb->names->groups[i], XkbXKBFile));
+ tmp++;
+ }
+ }
+ if (tmp > 0)
+ fprintf(file, "\n");
+ srv = xkb->server;
+ for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+ Bool simple;
+
+ if ((int) XkbKeyNumSyms(xkb, i) < 1)
+ continue;
+ if (XkbFindKeycodeByName(xkb, xkb->names->keys[i].name, TRUE) != i)
+ continue;
+ simple = TRUE;
+ fprintf(file, " key %6s {",
+ XkbKeyNameText(xkb->names->keys[i].name, XkbXKBFile));
+ if (srv->explicit) {
+ if (((srv->explicit[i] & XkbExplicitKeyTypesMask) != 0) ||
+ (showImplicit)) {
+ int typeNdx, g;
+ Bool multi;
+ const char *comment = " ";
+
+ if ((srv->explicit[i] & XkbExplicitKeyTypesMask) == 0)
+ comment = "//";
+ multi = FALSE;
+ typeNdx = XkbKeyKeyTypeIndex(xkb, i, 0);
+ for (g = 1; (g < XkbKeyNumGroups(xkb, i)) && (!multi); g++) {
+ if (XkbKeyKeyTypeIndex(xkb, i, g) != typeNdx)
+ multi = TRUE;
+ }
+ if (multi) {
+ for (g = 0; g < XkbKeyNumGroups(xkb, i); g++) {
+ typeNdx = XkbKeyKeyTypeIndex(xkb, i, g);
+ if (srv->explicit[i] & (1 << g)) {
+ fprintf(file, "\n%s type[group%d]= \"%s\",",
+ comment, g + 1,
+ XkbAtomText(map->types[typeNdx].name,
+ XkbXKBFile));
+ }
+ else if (showImplicit) {
+ fprintf(file, "\n// type[group%d]= \"%s\",",
+ g + 1, XkbAtomText(map->types[typeNdx].name,
+ XkbXKBFile));
+ }
+ }
+ }
+ else {
+ fprintf(file, "\n%s type= \"%s\",", comment,
+ XkbAtomText(map->types[typeNdx].name, XkbXKBFile));
+ }
+ simple = FALSE;
+ }
+ if (((srv->explicit[i] & XkbExplicitAutoRepeatMask) != 0) &&
+ (xkb->ctrls != NULL)) {
+ if (xkb->ctrls->per_key_repeat[i / 8] & (1 << (i % 8)))
+ fprintf(file, "\n repeat= Yes,");
+ else
+ fprintf(file, "\n repeat= No,");
+ simple = FALSE;
+ }
+ if ((xkb->server != NULL) && (xkb->server->vmodmap != NULL) &&
+ (xkb->server->vmodmap[i] != 0)) {
+ if ((srv->explicit[i] & XkbExplicitVModMapMask) != 0) {
+ fprintf(file, "\n virtualMods= %s,",
+ XkbVModMaskText(xkb, 0,
+ xkb->server->vmodmap[i],
+ XkbXKBFile));
+ }
+ else if (showImplicit) {
+ fprintf(file, "\n// virtualMods= %s,",
+ XkbVModMaskText(xkb, 0,
+ xkb->server->vmodmap[i],
+ XkbXKBFile));
+ }
+ }
+ }
+ switch (XkbOutOfRangeGroupAction(XkbKeyGroupInfo(xkb, i))) {
+ case XkbClampIntoRange:
+ fprintf(file, "\n groupsClamp,");
+ break;
+ case XkbRedirectIntoRange:
+ fprintf(file, "\n groupsRedirect= Group%d,",
+ XkbOutOfRangeGroupNumber(XkbKeyGroupInfo(xkb, i)) + 1);
+ break;
+ }
+ if (srv->behaviors != NULL) {
+ unsigned type;
+
+ type = srv->behaviors[i].type & XkbKB_OpMask;
+
+ if (type != XkbKB_Default) {
+ simple = FALSE;
+ fprintf(file, "\n %s,",
+ XkbBehaviorText(xkb, &srv->behaviors[i], XkbXKBFile));
+ }
+ }
+ if ((srv->explicit == NULL) || showImplicit ||
+ ((srv->explicit[i] & XkbExplicitInterpretMask) != 0))
+ showActions = XkbKeyHasActions(xkb, i);
+ else
+ showActions = FALSE;
+
+ if (((unsigned) XkbKeyNumGroups(xkb, i) > 1) || showActions)
+ simple = FALSE;
+ if (simple) {
+ KeySym *syms;
+ unsigned s;
+
+ syms = XkbKeySymsPtr(xkb, i);
+ fprintf(file, " [ ");
+ for (s = 0; s < XkbKeyGroupWidth(xkb, i, XkbGroup1Index); s++) {
+ if (s != 0)
+ fprintf(file, ", ");
+ fprintf(file, "%15s", XkbKeysymText(*syms++, XkbXKBFile));
+ }
+ fprintf(file, " ] };\n");
+ }
+ else {
+ unsigned g, s;
+ KeySym *syms;
+ XkbAction *acts;
+
+ syms = XkbKeySymsPtr(xkb, i);
+ acts = XkbKeyActionsPtr(xkb, i);
+ for (g = 0; g < XkbKeyNumGroups(xkb, i); g++) {
+ if (g != 0)
+ fprintf(file, ",");
+ fprintf(file, "\n symbols[Group%d]= [ ", g + 1);
+ for (s = 0; s < XkbKeyGroupWidth(xkb, i, g); s++) {
+ if (s != 0)
+ fprintf(file, ", ");
+ fprintf(file, "%15s", XkbKeysymText(syms[s], XkbXKBFile));
+ }
+ fprintf(file, " ]");
+ syms += XkbKeyGroupsWidth(xkb, i);
+ if (showActions) {
+ fprintf(file, ",\n actions[Group%d]= [ ", g + 1);
+ for (s = 0; s < XkbKeyGroupWidth(xkb, i, g); s++) {
+ if (s != 0)
+ fprintf(file, ", ");
+ WriteXKBAction(file, xkb, (XkbAnyAction *) & acts[s]);
+ }
+ fprintf(file, " ]");
+ acts += XkbKeyGroupsWidth(xkb, i);
+ }
+ }
+ fprintf(file, "\n };\n");
+ }
}
if (map && map->modmap) {
- for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
- if (map->modmap[i]!=0) {
- register int n,bit;
- for (bit=1,n=0;n<XkbNumModifiers;n++,bit<<=1) {
- if (map->modmap[i]&bit) {
- char buf[5];
- memcpy(buf,xkb->names->keys[i].name,4);
- buf[4]= '\0';
- fprintf(file," modifier_map %s { <%s> };\n",
- XkbModIndexText(n,XkbXKBFile),buf);
- }
- }
- }
- }
+ for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+ if (map->modmap[i] != 0) {
+ register int n, bit;
+
+ for (bit = 1, n = 0; n < XkbNumModifiers; n++, bit <<= 1) {
+ if (map->modmap[i] & bit) {
+ char buf[5];
+
+ memcpy(buf, xkb->names->keys[i].name, 4);
+ buf[4] = '\0';
+ fprintf(file, " modifier_map %s { <%s> };\n",
+ XkbModIndexText(n, XkbXKBFile), buf);
+ }
+ }
+ }
+ }
}
if (addOn)
- (*addOn)(file,xkb,topLevel,showImplicit,XkmSymbolsIndex,priv);
- fprintf(file,"};\n\n");
+ (*addOn) (file, xkb, topLevel, showImplicit, XkmSymbolsIndex, priv);
+ fprintf(file, "};\n\n");
return TRUE;
}
static Bool
-WriteXKBOutline( FILE * file,
- XkbShapePtr shape,
- XkbOutlinePtr outline,
- int lastRadius,
- int first,
- int indent)
+WriteXKBOutline(FILE * file,
+ XkbShapePtr shape,
+ XkbOutlinePtr outline, int lastRadius, int first, int indent)
{
-register int i;
-XkbPointPtr pt;
-char * iStr;
-
- fprintf(file,"%s",iStr= XkbIndentText(first));
- if (first!=indent)
- iStr= XkbIndentText(indent);
- if (outline->corner_radius!=lastRadius) {
- fprintf(file,"corner= %s,",
- XkbGeomFPText(outline->corner_radius,XkbMessage));
- if (shape!=NULL) {
- fprintf(file,"\n%s",iStr);
- }
+ register int i;
+ XkbPointPtr pt;
+ char *iStr;
+
+ fprintf(file, "%s", iStr = XkbIndentText(first));
+ if (first != indent)
+ iStr = XkbIndentText(indent);
+ if (outline->corner_radius != lastRadius) {
+ fprintf(file, "corner= %s,",
+ XkbGeomFPText(outline->corner_radius, XkbMessage));
+ if (shape != NULL) {
+ fprintf(file, "\n%s", iStr);
+ }
}
if (shape) {
- if (outline==shape->approx)
- fprintf(file,"approx= ");
- else if (outline==shape->primary)
- fprintf(file,"primary= ");
- }
- fprintf(file,"{");
- for (pt=outline->points,i=0;i<outline->num_points;i++,pt++) {
- if (i==0) fprintf(file," ");
- else if ((i%4)==0) fprintf(file,",\n%s ",iStr);
- else fprintf(file,", ");
- fprintf(file,"[ %3s, %3s ]",XkbGeomFPText(pt->x,XkbXKBFile),
- XkbGeomFPText(pt->y,XkbXKBFile));
- }
- fprintf(file," }");
+ if (outline == shape->approx)
+ fprintf(file, "approx= ");
+ else if (outline == shape->primary)
+ fprintf(file, "primary= ");
+ }
+ fprintf(file, "{");
+ for (pt = outline->points, i = 0; i < outline->num_points; i++, pt++) {
+ if (i == 0)
+ fprintf(file, " ");
+ else if ((i % 4) == 0)
+ fprintf(file, ",\n%s ", iStr);
+ else
+ fprintf(file, ", ");
+ fprintf(file, "[ %3s, %3s ]", XkbGeomFPText(pt->x, XkbXKBFile),
+ XkbGeomFPText(pt->y, XkbXKBFile));
+ }
+ fprintf(file, " }");
return TRUE;
}
static Bool
-WriteXKBDoodad( FILE * file,
- unsigned indent,
- XkbGeometryPtr geom,
- XkbDoodadPtr doodad)
+WriteXKBDoodad(FILE * file,
+ unsigned indent, XkbGeometryPtr geom, XkbDoodadPtr doodad)
{
-register char * i_str;
-XkbShapePtr shape;
-XkbColorPtr color;
-
- i_str= XkbIndentText(indent);
- fprintf(file,"%s%s \"%s\" {\n",i_str,
- XkbDoodadTypeText(doodad->any.type,XkbMessage),
- XkbAtomText(doodad->any.name,XkbMessage));
- fprintf(file,"%s top= %s;\n",i_str,
- XkbGeomFPText(doodad->any.top,XkbXKBFile));
- fprintf(file,"%s left= %s;\n",i_str,
- XkbGeomFPText(doodad->any.left,XkbXKBFile));
- fprintf(file,"%s priority= %d;\n",i_str,doodad->any.priority);
+ register char *i_str;
+ XkbShapePtr shape;
+ XkbColorPtr color;
+
+ i_str = XkbIndentText(indent);
+ fprintf(file, "%s%s \"%s\" {\n", i_str,
+ XkbDoodadTypeText(doodad->any.type, XkbMessage),
+ XkbAtomText(doodad->any.name, XkbMessage));
+ fprintf(file, "%s top= %s;\n", i_str,
+ XkbGeomFPText(doodad->any.top, XkbXKBFile));
+ fprintf(file, "%s left= %s;\n", i_str,
+ XkbGeomFPText(doodad->any.left, XkbXKBFile));
+ fprintf(file, "%s priority= %d;\n", i_str, doodad->any.priority);
switch (doodad->any.type) {
- case XkbOutlineDoodad:
- case XkbSolidDoodad:
- if (doodad->shape.angle!=0) {
- fprintf(file,"%s angle= %s;\n",i_str,
- XkbGeomFPText(doodad->shape.angle,XkbXKBFile));
- }
- if (doodad->shape.color_ndx!=0) {
- fprintf(file,"%s color= \"%s\";\n",i_str,
- XkbShapeDoodadColor(geom,&doodad->shape)->spec);
- }
- shape= XkbShapeDoodadShape(geom,&doodad->shape);
- fprintf(file,"%s shape= \"%s\";\n",i_str,
- XkbAtomText(shape->name,XkbXKBFile));
- break;
- case XkbTextDoodad:
- if (doodad->text.angle!=0) {
- fprintf(file,"%s angle= %s;\n",i_str,
- XkbGeomFPText(doodad->text.angle,XkbXKBFile));
- }
- if (doodad->text.width!=0) {
- fprintf(file,"%s width= %s;\n",i_str,
- XkbGeomFPText(doodad->text.width,XkbXKBFile));
-
- }
- if (doodad->text.height!=0) {
- fprintf(file,"%s height= %s;\n",i_str,
- XkbGeomFPText(doodad->text.height,XkbXKBFile));
-
- }
- if (doodad->text.color_ndx!=0) {
- color= XkbTextDoodadColor(geom,&doodad->text);
- fprintf(file,"%s color= \"%s\";\n",i_str,
- XkbStringText(color->spec,XkbXKBFile));
- }
- fprintf(file,"%s XFont= \"%s\";\n",i_str,
- XkbStringText(doodad->text.font,XkbXKBFile));
- fprintf(file,"%s text= \"%s\";\n",i_str,
- XkbStringText(doodad->text.text,XkbXKBFile));
- break;
- case XkbIndicatorDoodad:
- shape= XkbIndicatorDoodadShape(geom,&doodad->indicator);
- color= XkbIndicatorDoodadOnColor(geom,&doodad->indicator);
- fprintf(file,"%s onColor= \"%s\";\n",i_str,
- XkbStringText(color->spec,XkbXKBFile));
- color= XkbIndicatorDoodadOffColor(geom,&doodad->indicator);
- fprintf(file,"%s offColor= \"%s\";\n",i_str,
- XkbStringText(color->spec,XkbXKBFile));
- fprintf(file,"%s shape= \"%s\";\n",i_str,
- XkbAtomText(shape->name,XkbXKBFile));
- break;
- case XkbLogoDoodad:
- fprintf(file,"%s logoName= \"%s\";\n",i_str,
- XkbStringText(doodad->logo.logo_name,XkbXKBFile));
- if (doodad->shape.angle!=0) {
- fprintf(file,"%s angle= %s;\n",i_str,
- XkbGeomFPText(doodad->logo.angle,XkbXKBFile));
- }
- if (doodad->shape.color_ndx!=0) {
- fprintf(file,"%s color= \"%s\";\n",i_str,
- XkbLogoDoodadColor(geom,&doodad->logo)->spec);
- }
- shape= XkbLogoDoodadShape(geom,&doodad->logo);
- fprintf(file,"%s shape= \"%s\";\n",i_str,
- XkbAtomText(shape->name,XkbXKBFile));
- break;
- }
- fprintf(file,"%s};\n",i_str);
+ case XkbOutlineDoodad:
+ case XkbSolidDoodad:
+ if (doodad->shape.angle != 0) {
+ fprintf(file, "%s angle= %s;\n", i_str,
+ XkbGeomFPText(doodad->shape.angle, XkbXKBFile));
+ }
+ if (doodad->shape.color_ndx != 0) {
+ fprintf(file, "%s color= \"%s\";\n", i_str,
+ XkbShapeDoodadColor(geom, &doodad->shape)->spec);
+ }
+ shape = XkbShapeDoodadShape(geom, &doodad->shape);
+ fprintf(file, "%s shape= \"%s\";\n", i_str,
+ XkbAtomText(shape->name, XkbXKBFile));
+ break;
+ case XkbTextDoodad:
+ if (doodad->text.angle != 0) {
+ fprintf(file, "%s angle= %s;\n", i_str,
+ XkbGeomFPText(doodad->text.angle, XkbXKBFile));
+ }
+ if (doodad->text.width != 0) {
+ fprintf(file, "%s width= %s;\n", i_str,
+ XkbGeomFPText(doodad->text.width, XkbXKBFile));
+
+ }
+ if (doodad->text.height != 0) {
+ fprintf(file, "%s height= %s;\n", i_str,
+ XkbGeomFPText(doodad->text.height, XkbXKBFile));
+
+ }
+ if (doodad->text.color_ndx != 0) {
+ color = XkbTextDoodadColor(geom, &doodad->text);
+ fprintf(file, "%s color= \"%s\";\n", i_str,
+ XkbStringText(color->spec, XkbXKBFile));
+ }
+ fprintf(file, "%s XFont= \"%s\";\n", i_str,
+ XkbStringText(doodad->text.font, XkbXKBFile));
+ fprintf(file, "%s text= \"%s\";\n", i_str,
+ XkbStringText(doodad->text.text, XkbXKBFile));
+ break;
+ case XkbIndicatorDoodad:
+ shape = XkbIndicatorDoodadShape(geom, &doodad->indicator);
+ color = XkbIndicatorDoodadOnColor(geom, &doodad->indicator);
+ fprintf(file, "%s onColor= \"%s\";\n", i_str,
+ XkbStringText(color->spec, XkbXKBFile));
+ color = XkbIndicatorDoodadOffColor(geom, &doodad->indicator);
+ fprintf(file, "%s offColor= \"%s\";\n", i_str,
+ XkbStringText(color->spec, XkbXKBFile));
+ fprintf(file, "%s shape= \"%s\";\n", i_str,
+ XkbAtomText(shape->name, XkbXKBFile));
+ break;
+ case XkbLogoDoodad:
+ fprintf(file, "%s logoName= \"%s\";\n", i_str,
+ XkbStringText(doodad->logo.logo_name, XkbXKBFile));
+ if (doodad->shape.angle != 0) {
+ fprintf(file, "%s angle= %s;\n", i_str,
+ XkbGeomFPText(doodad->logo.angle, XkbXKBFile));
+ }
+ if (doodad->shape.color_ndx != 0) {
+ fprintf(file, "%s color= \"%s\";\n", i_str,
+ XkbLogoDoodadColor(geom, &doodad->logo)->spec);
+ }
+ shape = XkbLogoDoodadShape(geom, &doodad->logo);
+ fprintf(file, "%s shape= \"%s\";\n", i_str,
+ XkbAtomText(shape->name, XkbXKBFile));
+ break;
+ }
+ fprintf(file, "%s};\n", i_str);
return TRUE;
}
-/*ARGSUSED*/
-static Bool
-WriteXKBOverlay( FILE * file,
- unsigned indent,
- XkbGeometryPtr geom,
- XkbOverlayPtr ol)
+ /*ARGSUSED*/ static Bool
+WriteXKBOverlay(FILE * file,
+ unsigned indent, XkbGeometryPtr geom, XkbOverlayPtr ol)
{
-register char * i_str;
-int r,k,nOut;
-XkbOverlayRowPtr row;
-XkbOverlayKeyPtr key;
-
- i_str= XkbIndentText(indent);
- if (ol->name!=None) {
- fprintf(file,"%soverlay \"%s\" {\n",i_str,
- XkbAtomText(ol->name,XkbMessage));
- }
- else fprintf(file,"%soverlay {\n",i_str);
- for (nOut=r=0,row=ol->rows;r<ol->num_rows;r++,row++) {
- for (k=0,key=row->keys;k<row->num_keys;k++,key++) {
- char *over,*under;
- over= XkbKeyNameText(key->over.name,XkbXKBFile);
- under= XkbKeyNameText(key->under.name,XkbXKBFile);
- if (nOut==0)
- fprintf(file,"%s %6s=%6s",i_str,under,over);
- else if ((nOut%4)==0)
- fprintf(file,",\n%s %6s=%6s",i_str,under,over);
- else fprintf(file,", %6s=%6s",under,over);
- nOut++;
- }
- }
- fprintf(file,"\n%s};\n",i_str);
+ register char *i_str;
+ int r, k, nOut;
+ XkbOverlayRowPtr row;
+ XkbOverlayKeyPtr key;
+
+ i_str = XkbIndentText(indent);
+ if (ol->name != None) {
+ fprintf(file, "%soverlay \"%s\" {\n", i_str,
+ XkbAtomText(ol->name, XkbMessage));
+ }
+ else
+ fprintf(file, "%soverlay {\n", i_str);
+ for (nOut = r = 0, row = ol->rows; r < ol->num_rows; r++, row++) {
+ for (k = 0, key = row->keys; k < row->num_keys; k++, key++) {
+ char *over, *under;
+
+ over = XkbKeyNameText(key->over.name, XkbXKBFile);
+ under = XkbKeyNameText(key->under.name, XkbXKBFile);
+ if (nOut == 0)
+ fprintf(file, "%s %6s=%6s", i_str, under, over);
+ else if ((nOut % 4) == 0)
+ fprintf(file, ",\n%s %6s=%6s", i_str, under, over);
+ else
+ fprintf(file, ", %6s=%6s", under, over);
+ nOut++;
+ }
+ }
+ fprintf(file, "\n%s};\n", i_str);
return TRUE;
}
static Bool
-WriteXKBSection( FILE * file,
- XkbSectionPtr s,
- XkbGeometryPtr geom)
+WriteXKBSection(FILE * file, XkbSectionPtr s, XkbGeometryPtr geom)
{
-register int i;
-XkbRowPtr row;
-int dfltKeyColor = 0;
-
- fprintf(file," section \"%s\" {\n",
- XkbAtomText(s->name,XkbXKBFile));
- if (s->rows&&(s->rows->num_keys>0)) {
- dfltKeyColor= s->rows->keys[0].color_ndx;
- fprintf(file," key.color= \"%s\";\n",
- XkbStringText(geom->colors[dfltKeyColor].spec,XkbXKBFile));
- }
- fprintf(file," priority= %d;\n",s->priority);
- fprintf(file," top= %s;\n",XkbGeomFPText(s->top,XkbXKBFile));
- fprintf(file," left= %s;\n",XkbGeomFPText(s->left,XkbXKBFile));
- fprintf(file," width= %s;\n",XkbGeomFPText(s->width,XkbXKBFile));
- fprintf(file," height= %s;\n",
- XkbGeomFPText(s->height,XkbXKBFile));
- if (s->angle!=0) {
- fprintf(file," angle= %s;\n",
- XkbGeomFPText(s->angle,XkbXKBFile));
- }
- for (i=0,row=s->rows;i<s->num_rows;i++,row++) {
- fprintf(file," row {\n");
- fprintf(file," top= %s;\n",
- XkbGeomFPText(row->top,XkbXKBFile));
- fprintf(file," left= %s;\n",
- XkbGeomFPText(row->left,XkbXKBFile));
- if (row->vertical)
- fprintf(file," vertical;\n");
- if (row->num_keys>0) {
- register int k;
- register XkbKeyPtr key;
- int forceNL=0;
- int nThisLine= 0;
- fprintf(file," keys {\n");
- for (k=0,key=row->keys;k<row->num_keys;k++,key++) {
- XkbShapePtr shape;
- if (key->color_ndx!=dfltKeyColor)
- forceNL= 1;
- if (k==0) {
- fprintf(file," ");
- nThisLine= 0;
- }
- else if (((nThisLine%2)==1)||(forceNL)) {
- fprintf(file,",\n ");
- forceNL= nThisLine= 0;
- }
- else {
- fprintf(file,", ");
- nThisLine++;
- }
- shape= XkbKeyShape(geom,key);
- fprintf(file,"{ %6s, \"%s\", %3s",
- XkbKeyNameText(key->name.name,XkbXKBFile),
- XkbAtomText(shape->name,XkbXKBFile),
- XkbGeomFPText(key->gap,XkbXKBFile));
- if (key->color_ndx!=dfltKeyColor) {
- fprintf(file,", color=\"%s\"",XkbKeyColor(geom,key)->spec);
- forceNL= 1;
- }
- fprintf(file," }");
- }
- fprintf(file,"\n };\n");
- }
- fprintf(file," };\n");
- }
- if (s->doodads!=NULL) {
- XkbDoodadPtr doodad;
- for (i=0,doodad=s->doodads;i<s->num_doodads;i++,doodad++) {
- WriteXKBDoodad(file,8,geom,doodad);
- }
- }
- if (s->overlays!=NULL) {
- XkbOverlayPtr ol;
- for (i=0,ol=s->overlays;i<s->num_overlays;i++,ol++) {
- WriteXKBOverlay(file,8,geom,ol);
- }
- }
- fprintf(file," }; // End of \"%s\" section\n\n",
- XkbAtomText(s->name,XkbXKBFile));
+ register int i;
+ XkbRowPtr row;
+ int dfltKeyColor = 0;
+
+ fprintf(file, " section \"%s\" {\n", XkbAtomText(s->name, XkbXKBFile));
+ if (s->rows && (s->rows->num_keys > 0)) {
+ dfltKeyColor = s->rows->keys[0].color_ndx;
+ fprintf(file, " key.color= \"%s\";\n",
+ XkbStringText(geom->colors[dfltKeyColor].spec, XkbXKBFile));
+ }
+ fprintf(file, " priority= %d;\n", s->priority);
+ fprintf(file, " top= %s;\n",
+ XkbGeomFPText(s->top, XkbXKBFile));
+ fprintf(file, " left= %s;\n",
+ XkbGeomFPText(s->left, XkbXKBFile));
+ fprintf(file, " width= %s;\n",
+ XkbGeomFPText(s->width, XkbXKBFile));
+ fprintf(file, " height= %s;\n",
+ XkbGeomFPText(s->height, XkbXKBFile));
+ if (s->angle != 0) {
+ fprintf(file, " angle= %s;\n",
+ XkbGeomFPText(s->angle, XkbXKBFile));
+ }
+ for (i = 0, row = s->rows; i < s->num_rows; i++, row++) {
+ fprintf(file, " row {\n");
+ fprintf(file, " top= %s;\n",
+ XkbGeomFPText(row->top, XkbXKBFile));
+ fprintf(file, " left= %s;\n",
+ XkbGeomFPText(row->left, XkbXKBFile));
+ if (row->vertical)
+ fprintf(file, " vertical;\n");
+ if (row->num_keys > 0) {
+ register int k;
+ register XkbKeyPtr key;
+ int forceNL = 0;
+ int nThisLine = 0;
+
+ fprintf(file, " keys {\n");
+ for (k = 0, key = row->keys; k < row->num_keys; k++, key++) {
+ XkbShapePtr shape;
+
+ if (key->color_ndx != dfltKeyColor)
+ forceNL = 1;
+ if (k == 0) {
+ fprintf(file, " ");
+ nThisLine = 0;
+ }
+ else if (((nThisLine % 2) == 1) || (forceNL)) {
+ fprintf(file, ",\n ");
+ forceNL = nThisLine = 0;
+ }
+ else {
+ fprintf(file, ", ");
+ nThisLine++;
+ }
+ shape = XkbKeyShape(geom, key);
+ fprintf(file, "{ %6s, \"%s\", %3s",
+ XkbKeyNameText(key->name.name, XkbXKBFile),
+ XkbAtomText(shape->name, XkbXKBFile),
+ XkbGeomFPText(key->gap, XkbXKBFile));
+ if (key->color_ndx != dfltKeyColor) {
+ fprintf(file, ", color=\"%s\"",
+ XkbKeyColor(geom, key)->spec);
+ forceNL = 1;
+ }
+ fprintf(file, " }");
+ }
+ fprintf(file, "\n };\n");
+ }
+ fprintf(file, " };\n");
+ }
+ if (s->doodads != NULL) {
+ XkbDoodadPtr doodad;
+
+ for (i = 0, doodad = s->doodads; i < s->num_doodads; i++, doodad++) {
+ WriteXKBDoodad(file, 8, geom, doodad);
+ }
+ }
+ if (s->overlays != NULL) {
+ XkbOverlayPtr ol;
+
+ for (i = 0, ol = s->overlays; i < s->num_overlays; i++, ol++) {
+ WriteXKBOverlay(file, 8, geom, ol);
+ }
+ }
+ fprintf(file, " }; // End of \"%s\" section\n\n",
+ XkbAtomText(s->name, XkbXKBFile));
return TRUE;
}
Bool
-XkbWriteXKBGeometry( FILE * file,
- XkbDescPtr xkb,
- Bool topLevel,
- Bool showImplicit,
- XkbFileAddOnFunc addOn,
- void * priv)
+XkbWriteXKBGeometry(FILE * file,
+ XkbDescPtr xkb,
+ Bool topLevel,
+ Bool showImplicit, XkbFileAddOnFunc addOn, void *priv)
{
-register unsigned i,n;
-XkbGeometryPtr geom;
-
- if ((!xkb)||(!xkb->geom)) {
- _XkbLibError(_XkbErrMissingGeometry,"XkbWriteXKBGeometry",0);
- return FALSE;
- }
- geom= xkb->geom;
- if (geom->name==None)
- fprintf(file,"xkb_geometry {\n\n");
- else fprintf(file,"xkb_geometry \"%s\" {\n\n",
- XkbAtomText(geom->name,XkbXKBFile));
- fprintf(file," width= %s;\n",
- XkbGeomFPText(geom->width_mm,XkbXKBFile));
- fprintf(file," height= %s;\n\n",
- XkbGeomFPText(geom->height_mm,XkbXKBFile));
-
- if (geom->key_aliases!=NULL) {
- XkbKeyAliasPtr pAl;
- pAl= geom->key_aliases;
- for (i=0;i<geom->num_key_aliases;i++,pAl++) {
- fprintf(file," alias %6s = %6s;\n",
- XkbKeyNameText(pAl->alias,XkbXKBFile),
- XkbKeyNameText(pAl->real,XkbXKBFile));
- }
- fprintf(file,"\n");
- }
-
- if (geom->base_color!=NULL)
- fprintf(file," baseColor= \"%s\";\n",
- XkbStringText(geom->base_color->spec,XkbXKBFile));
- if (geom->label_color!=NULL)
- fprintf(file," labelColor= \"%s\";\n",
- XkbStringText(geom->label_color->spec,XkbXKBFile));
- if (geom->label_font!=NULL)
- fprintf(file," xfont= \"%s\";\n",
- XkbStringText(geom->label_font,XkbXKBFile));
- if ((geom->num_colors>0)&&(showImplicit)) {
- XkbColorPtr color;
- for (color=geom->colors,i=0;i<geom->num_colors;i++,color++) {
- fprintf(file,"// color[%d]= \"%s\"\n",i,
- XkbStringText(color->spec,XkbXKBFile));
- }
- fprintf(file,"\n");
- }
- if (geom->num_properties>0) {
- XkbPropertyPtr prop;
- for (prop=geom->properties,i=0;i<geom->num_properties;i++,prop++) {
- fprintf(file," %s= \"%s\";\n",prop->name,
- XkbStringText(prop->value,XkbXKBFile));
- }
- fprintf(file,"\n");
- }
- if (geom->num_shapes>0) {
- XkbShapePtr shape;
- XkbOutlinePtr outline;
- int lastR;
- for (shape=geom->shapes,i=0;i<geom->num_shapes;i++,shape++) {
- lastR=0;
- fprintf(file," shape \"%s\" {",
- XkbAtomText(shape->name,XkbXKBFile));
- outline= shape->outlines;
- if (shape->num_outlines>1) {
- for (n=0;n<shape->num_outlines;n++,outline++) {
- if (n==0) fprintf(file,"\n");
- else fprintf(file,",\n");
- WriteXKBOutline(file,shape,outline,lastR,8,8);
- lastR= outline->corner_radius;
- }
- fprintf(file,"\n };\n");
- }
- else {
- WriteXKBOutline(file,NULL,outline,lastR,1,8);
- fprintf(file," };\n");
- }
- }
- }
- if (geom->num_sections>0) {
- XkbSectionPtr section;
- for (section=geom->sections,i=0;i<geom->num_sections;i++,section++){
- WriteXKBSection(file,section,geom);
- }
- }
- if (geom->num_doodads>0) {
- XkbDoodadPtr doodad;
- for (i=0,doodad=geom->doodads;i<geom->num_doodads;i++,doodad++) {
- WriteXKBDoodad(file,4,geom,doodad);
- }
+ register unsigned i, n;
+ XkbGeometryPtr geom;
+
+ if ((!xkb) || (!xkb->geom)) {
+ _XkbLibError(_XkbErrMissingGeometry, "XkbWriteXKBGeometry", 0);
+ return FALSE;
+ }
+ geom = xkb->geom;
+ if (geom->name == None)
+ fprintf(file, "xkb_geometry {\n\n");
+ else
+ fprintf(file, "xkb_geometry \"%s\" {\n\n",
+ XkbAtomText(geom->name, XkbXKBFile));
+ fprintf(file, " width= %s;\n",
+ XkbGeomFPText(geom->width_mm, XkbXKBFile));
+ fprintf(file, " height= %s;\n\n",
+ XkbGeomFPText(geom->height_mm, XkbXKBFile));
+
+ if (geom->key_aliases != NULL) {
+ XkbKeyAliasPtr pAl;
+
+ pAl = geom->key_aliases;
+ for (i = 0; i < geom->num_key_aliases; i++, pAl++) {
+ fprintf(file, " alias %6s = %6s;\n",
+ XkbKeyNameText(pAl->alias, XkbXKBFile),
+ XkbKeyNameText(pAl->real, XkbXKBFile));
+ }
+ fprintf(file, "\n");
+ }
+
+ if (geom->base_color != NULL)
+ fprintf(file, " baseColor= \"%s\";\n",
+ XkbStringText(geom->base_color->spec, XkbXKBFile));
+ if (geom->label_color != NULL)
+ fprintf(file, " labelColor= \"%s\";\n",
+ XkbStringText(geom->label_color->spec, XkbXKBFile));
+ if (geom->label_font != NULL)
+ fprintf(file, " xfont= \"%s\";\n",
+ XkbStringText(geom->label_font, XkbXKBFile));
+ if ((geom->num_colors > 0) && (showImplicit)) {
+ XkbColorPtr color;
+
+ for (color = geom->colors, i = 0; i < geom->num_colors; i++, color++) {
+ fprintf(file, "// color[%d]= \"%s\"\n", i,
+ XkbStringText(color->spec, XkbXKBFile));
+ }
+ fprintf(file, "\n");
+ }
+ if (geom->num_properties > 0) {
+ XkbPropertyPtr prop;
+
+ for (prop = geom->properties, i = 0; i < geom->num_properties;
+ i++, prop++) {
+ fprintf(file, " %s= \"%s\";\n", prop->name,
+ XkbStringText(prop->value, XkbXKBFile));
+ }
+ fprintf(file, "\n");
+ }
+ if (geom->num_shapes > 0) {
+ XkbShapePtr shape;
+ XkbOutlinePtr outline;
+ int lastR;
+
+ for (shape = geom->shapes, i = 0; i < geom->num_shapes; i++, shape++) {
+ lastR = 0;
+ fprintf(file, " shape \"%s\" {",
+ XkbAtomText(shape->name, XkbXKBFile));
+ outline = shape->outlines;
+ if (shape->num_outlines > 1) {
+ for (n = 0; n < shape->num_outlines; n++, outline++) {
+ if (n == 0)
+ fprintf(file, "\n");
+ else
+ fprintf(file, ",\n");
+ WriteXKBOutline(file, shape, outline, lastR, 8, 8);
+ lastR = outline->corner_radius;
+ }
+ fprintf(file, "\n };\n");
+ }
+ else {
+ WriteXKBOutline(file, NULL, outline, lastR, 1, 8);
+ fprintf(file, " };\n");
+ }
+ }
+ }
+ if (geom->num_sections > 0) {
+ XkbSectionPtr section;
+
+ for (section = geom->sections, i = 0; i < geom->num_sections;
+ i++, section++) {
+ WriteXKBSection(file, section, geom);
+ }
+ }
+ if (geom->num_doodads > 0) {
+ XkbDoodadPtr doodad;
+
+ for (i = 0, doodad = geom->doodads; i < geom->num_doodads;
+ i++, doodad++) {
+ WriteXKBDoodad(file, 4, geom, doodad);
+ }
}
if (addOn)
- (*addOn)(file,xkb,topLevel,showImplicit,XkmGeometryIndex,priv);
- fprintf(file,"};\n\n");
+ (*addOn) (file, xkb, topLevel, showImplicit, XkmGeometryIndex, priv);
+ fprintf(file, "};\n\n");
return TRUE;
}
diff --git a/xkb/xkbtext.c b/xkb/xkbtext.c
index 8ef2b05b0..f66a08f75 100644
--- a/xkb/xkbtext.c
+++ b/xkb/xkbtext.c
@@ -50,168 +50,179 @@
#define BUFFER_SIZE 512
static char textBuffer[BUFFER_SIZE];
-static int tbNext= 0;
+static int tbNext = 0;
static char *
tbGetBuffer(unsigned size)
{
-char *rtrn;
-
- if (size>=BUFFER_SIZE)
- return NULL;
- if ((BUFFER_SIZE-tbNext)<=size)
- tbNext= 0;
- rtrn= &textBuffer[tbNext];
- tbNext+= size;
+ char *rtrn;
+
+ if (size >= BUFFER_SIZE)
+ return NULL;
+ if ((BUFFER_SIZE - tbNext) <= size)
+ tbNext = 0;
+ rtrn = &textBuffer[tbNext];
+ tbNext += size;
return rtrn;
}
/***====================================================================***/
char *
-XkbAtomText(Atom atm,unsigned format)
+XkbAtomText(Atom atm, unsigned format)
{
-const char *atmstr;
-char *rtrn,*tmp;
+ const char *atmstr;
+ char *rtrn, *tmp;
atmstr = NameForAtom(atm);
if (atmstr != NULL) {
- int len;
- len= strlen(atmstr)+1;
- if (len>BUFFER_SIZE)
- len= BUFFER_SIZE-2;
- rtrn= tbGetBuffer(len);
- strlcpy(rtrn,atmstr,len);
+ int len;
+
+ len = strlen(atmstr) + 1;
+ if (len > BUFFER_SIZE)
+ len = BUFFER_SIZE - 2;
+ rtrn = tbGetBuffer(len);
+ strlcpy(rtrn, atmstr, len);
}
else {
- rtrn= tbGetBuffer(1);
- rtrn[0]= '\0';
+ rtrn = tbGetBuffer(1);
+ rtrn[0] = '\0';
}
- if (format==XkbCFile) {
- for (tmp=rtrn;*tmp!='\0';tmp++) {
- if ((tmp==rtrn)&&(!isalpha(*tmp)))
- *tmp= '_';
- else if (!isalnum(*tmp))
- *tmp= '_';
- }
+ if (format == XkbCFile) {
+ for (tmp = rtrn; *tmp != '\0'; tmp++) {
+ if ((tmp == rtrn) && (!isalpha(*tmp)))
+ *tmp = '_';
+ else if (!isalnum(*tmp))
+ *tmp = '_';
+ }
}
- return XkbStringText(rtrn,format);
+ return XkbStringText(rtrn, format);
}
/***====================================================================***/
char *
-XkbVModIndexText(XkbDescPtr xkb,unsigned ndx,unsigned format)
+XkbVModIndexText(XkbDescPtr xkb, unsigned ndx, unsigned format)
{
-register int len;
-register Atom *vmodNames;
-char *rtrn;
-const char *tmp;
-char numBuf[20];
+ register int len;
+ register Atom *vmodNames;
+ char *rtrn;
+ const char *tmp;
+ char numBuf[20];
if (xkb && xkb->names)
- vmodNames= xkb->names->vmods;
- else vmodNames= NULL;
-
- tmp= NULL;
- if (ndx>=XkbNumVirtualMods)
- tmp= "illegal";
- else if (vmodNames&&(vmodNames[ndx]!=None))
- tmp= NameForAtom(vmodNames[ndx]);
- if (tmp==NULL) {
- snprintf(numBuf,sizeof(numBuf),"%d",ndx);
- tmp = numBuf;
+ vmodNames = xkb->names->vmods;
+ else
+ vmodNames = NULL;
+
+ tmp = NULL;
+ if (ndx >= XkbNumVirtualMods)
+ tmp = "illegal";
+ else if (vmodNames && (vmodNames[ndx] != None))
+ tmp = NameForAtom(vmodNames[ndx]);
+ if (tmp == NULL) {
+ snprintf(numBuf, sizeof(numBuf), "%d", ndx);
+ tmp = numBuf;
}
- len= strlen(tmp)+1;
- if (format==XkbCFile)
- len+= 4;
- if (len>=BUFFER_SIZE)
- len= BUFFER_SIZE-1;
- rtrn= tbGetBuffer(len);
- if (format==XkbCFile) {
- strcpy(rtrn,"vmod_");
- strncpy(&rtrn[5],tmp,len-4);
+ len = strlen(tmp) + 1;
+ if (format == XkbCFile)
+ len += 4;
+ if (len >= BUFFER_SIZE)
+ len = BUFFER_SIZE - 1;
+ rtrn = tbGetBuffer(len);
+ if (format == XkbCFile) {
+ strcpy(rtrn, "vmod_");
+ strncpy(&rtrn[5], tmp, len - 4);
}
- else strncpy(rtrn,tmp,len);
+ else
+ strncpy(rtrn, tmp, len);
return rtrn;
}
char *
-XkbVModMaskText( XkbDescPtr xkb,
- unsigned modMask,
- unsigned mask,
- unsigned format)
+XkbVModMaskText(XkbDescPtr xkb,
+ unsigned modMask, unsigned mask, unsigned format)
{
-register int i,bit;
-int len;
-char *mm,*rtrn;
-char *str,buf[BUFFER_SIZE];
-
- if ((modMask==0)&&(mask==0)) {
- rtrn= tbGetBuffer(5);
- if (format==XkbCFile)
- sprintf(rtrn,"0");
- else sprintf(rtrn,"none");
- return rtrn;
+ register int i, bit;
+ int len;
+ char *mm, *rtrn;
+ char *str, buf[BUFFER_SIZE];
+
+ if ((modMask == 0) && (mask == 0)) {
+ rtrn = tbGetBuffer(5);
+ if (format == XkbCFile)
+ sprintf(rtrn, "0");
+ else
+ sprintf(rtrn, "none");
+ return rtrn;
}
- if (modMask!=0)
- mm= XkbModMaskText(modMask,format);
- else mm= NULL;
+ if (modMask != 0)
+ mm = XkbModMaskText(modMask, format);
+ else
+ mm = NULL;
- str= buf;
- buf[0]= '\0';
+ str = buf;
+ buf[0] = '\0';
if (mask) {
- char *tmp;
- for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
- if (mask&bit) {
- tmp= XkbVModIndexText(xkb,i,format);
- len= strlen(tmp)+1+(str==buf?0:1);
- if (format==XkbCFile)
- len+= 4;
- if ((str-(buf+len))<=BUFFER_SIZE) {
- if (str!=buf) {
- if (format==XkbCFile) *str++= '|';
- else *str++= '+';
- len--;
- }
- }
- if (format==XkbCFile)
- sprintf(str,"%sMask",tmp);
- else strcpy(str,tmp);
- str= &str[len-1];
- }
- }
- str= buf;
+ char *tmp;
+
+ for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+ if (mask & bit) {
+ tmp = XkbVModIndexText(xkb, i, format);
+ len = strlen(tmp) + 1 + (str == buf ? 0 : 1);
+ if (format == XkbCFile)
+ len += 4;
+ if ((str - (buf + len)) <= BUFFER_SIZE) {
+ if (str != buf) {
+ if (format == XkbCFile)
+ *str++ = '|';
+ else
+ *str++ = '+';
+ len--;
+ }
+ }
+ if (format == XkbCFile)
+ sprintf(str, "%sMask", tmp);
+ else
+ strcpy(str, tmp);
+ str = &str[len - 1];
+ }
+ }
+ str = buf;
}
- else str= NULL;
- if (mm)
- len= strlen(mm);
- else len= 0;
+ else
+ str = NULL;
+ if (mm)
+ len = strlen(mm);
+ else
+ len = 0;
if (str)
- len+= strlen(str)+(mm==NULL?0:1);
- if (len>=BUFFER_SIZE)
- len= BUFFER_SIZE-1;
- rtrn= tbGetBuffer(len+1);
- rtrn[0]= '\0';
-
- if (mm!=NULL) {
- i= strlen(mm);
- if (i>len)
- i= len;
- strcpy(rtrn,mm);
+ len += strlen(str) + (mm == NULL ? 0 : 1);
+ if (len >= BUFFER_SIZE)
+ len = BUFFER_SIZE - 1;
+ rtrn = tbGetBuffer(len + 1);
+ rtrn[0] = '\0';
+
+ if (mm != NULL) {
+ i = strlen(mm);
+ if (i > len)
+ i = len;
+ strcpy(rtrn, mm);
}
else {
- i=0;
+ i = 0;
}
- if (str!=NULL) {
- if (mm!=NULL) {
- if (format==XkbCFile) strcat(rtrn,"|");
- else strcat(rtrn,"+");
- }
- strncat(rtrn,str,len-i);
+ if (str != NULL) {
+ if (mm != NULL) {
+ if (format == XkbCFile)
+ strcat(rtrn, "|");
+ else
+ strcat(rtrn, "+");
+ }
+ strncat(rtrn, str, len - i);
}
- rtrn[len]= '\0';
+ rtrn[len] = '\0';
return rtrn;
}
@@ -220,111 +231,119 @@ static const char *modNames[XkbNumModifiers] = {
};
char *
-XkbModIndexText(unsigned ndx,unsigned format)
+XkbModIndexText(unsigned ndx, unsigned format)
{
-char * rtrn;
-char buf[100];
-
- if (format==XkbCFile) {
- if (ndx<XkbNumModifiers)
- snprintf(buf,sizeof(buf),"%sMapIndex",modNames[ndx]);
- else if (ndx==XkbNoModifier)
- snprintf(buf,sizeof(buf),"XkbNoModifier");
- else snprintf(buf,sizeof(buf),"0x%02x",ndx);
+ char *rtrn;
+ char buf[100];
+
+ if (format == XkbCFile) {
+ if (ndx < XkbNumModifiers)
+ snprintf(buf, sizeof(buf), "%sMapIndex", modNames[ndx]);
+ else if (ndx == XkbNoModifier)
+ snprintf(buf, sizeof(buf), "XkbNoModifier");
+ else
+ snprintf(buf, sizeof(buf), "0x%02x", ndx);
}
else {
- if (ndx<XkbNumModifiers)
- strcpy(buf,modNames[ndx]);
- else if (ndx==XkbNoModifier)
- strcpy(buf,"none");
- else snprintf(buf,sizeof(buf),"ILLEGAL_%02x",ndx);
+ if (ndx < XkbNumModifiers)
+ strcpy(buf, modNames[ndx]);
+ else if (ndx == XkbNoModifier)
+ strcpy(buf, "none");
+ else
+ snprintf(buf, sizeof(buf), "ILLEGAL_%02x", ndx);
}
- rtrn= tbGetBuffer(strlen(buf)+1);
- strcpy(rtrn,buf);
+ rtrn = tbGetBuffer(strlen(buf) + 1);
+ strcpy(rtrn, buf);
return rtrn;
}
char *
-XkbModMaskText(unsigned mask,unsigned format)
+XkbModMaskText(unsigned mask, unsigned format)
{
-register int i,bit;
-char buf[64],*rtrn;
-
- if ((mask&0xff)==0xff) {
- if (format==XkbCFile) strcpy(buf,"0xff");
- else strcpy(buf,"all");
+ register int i, bit;
+ char buf[64], *rtrn;
+
+ if ((mask & 0xff) == 0xff) {
+ if (format == XkbCFile)
+ strcpy(buf, "0xff");
+ else
+ strcpy(buf, "all");
}
- else if ((mask&0xff)==0) {
- if (format==XkbCFile) strcpy(buf,"0");
- else strcpy(buf,"none");
+ else if ((mask & 0xff) == 0) {
+ if (format == XkbCFile)
+ strcpy(buf, "0");
+ else
+ strcpy(buf, "none");
}
else {
- char *str= buf;
- buf[0]= '\0';
- for (i=0,bit=1;i<XkbNumModifiers;i++,bit<<=1) {
- if (mask&bit) {
- if (str!=buf) {
- if (format==XkbCFile) *str++= '|';
- else *str++= '+';
- }
- strcpy(str,modNames[i]);
- str= &str[strlen(str)];
- if (format==XkbCFile) {
- strcpy(str,"Mask");
- str+= 4;
- }
- }
- }
+ char *str = buf;
+
+ buf[0] = '\0';
+ for (i = 0, bit = 1; i < XkbNumModifiers; i++, bit <<= 1) {
+ if (mask & bit) {
+ if (str != buf) {
+ if (format == XkbCFile)
+ *str++ = '|';
+ else
+ *str++ = '+';
+ }
+ strcpy(str, modNames[i]);
+ str = &str[strlen(str)];
+ if (format == XkbCFile) {
+ strcpy(str, "Mask");
+ str += 4;
+ }
+ }
+ }
}
- rtrn= tbGetBuffer(strlen(buf)+1);
- strcpy(rtrn,buf);
+ rtrn = tbGetBuffer(strlen(buf) + 1);
+ strcpy(rtrn, buf);
return rtrn;
}
/***====================================================================***/
-/*ARGSUSED*/
-char *
-XkbConfigText(unsigned config,unsigned format)
+ /*ARGSUSED*/ char *
+XkbConfigText(unsigned config, unsigned format)
{
-static char *buf;
+ static char *buf;
- buf= tbGetBuffer(32);
+ buf = tbGetBuffer(32);
switch (config) {
- case XkmSemanticsFile:
- strcpy(buf,"Semantics");
- break;
- case XkmLayoutFile:
- strcpy(buf,"Layout");
- break;
- case XkmKeymapFile:
- strcpy(buf,"Keymap");
- break;
- case XkmGeometryFile:
- case XkmGeometryIndex:
- strcpy(buf,"Geometry");
- break;
- case XkmTypesIndex:
- strcpy(buf,"Types");
- break;
- case XkmCompatMapIndex:
- strcpy(buf,"CompatMap");
- break;
- case XkmSymbolsIndex:
- strcpy(buf,"Symbols");
- break;
- case XkmIndicatorsIndex:
- strcpy(buf,"Indicators");
- break;
- case XkmKeyNamesIndex:
- strcpy(buf,"KeyNames");
- break;
- case XkmVirtualModsIndex:
- strcpy(buf,"VirtualMods");
- break;
- default:
- sprintf(buf,"unknown(%d)",config);
- break;
+ case XkmSemanticsFile:
+ strcpy(buf, "Semantics");
+ break;
+ case XkmLayoutFile:
+ strcpy(buf, "Layout");
+ break;
+ case XkmKeymapFile:
+ strcpy(buf, "Keymap");
+ break;
+ case XkmGeometryFile:
+ case XkmGeometryIndex:
+ strcpy(buf, "Geometry");
+ break;
+ case XkmTypesIndex:
+ strcpy(buf, "Types");
+ break;
+ case XkmCompatMapIndex:
+ strcpy(buf, "CompatMap");
+ break;
+ case XkmSymbolsIndex:
+ strcpy(buf, "Symbols");
+ break;
+ case XkmIndicatorsIndex:
+ strcpy(buf, "Indicators");
+ break;
+ case XkmKeyNamesIndex:
+ strcpy(buf, "KeyNames");
+ break;
+ case XkmVirtualModsIndex:
+ strcpy(buf, "VirtualMods");
+ break;
+ default:
+ sprintf(buf, "unknown(%d)", config);
+ break;
}
return buf;
}
@@ -332,35 +351,37 @@ static char *buf;
/***====================================================================***/
char *
-XkbKeysymText(KeySym sym,unsigned format)
+XkbKeysymText(KeySym sym, unsigned format)
{
-static char buf[32];
+ static char buf[32];
- if (sym==NoSymbol)
- strcpy(buf,"NoSymbol");
- else snprintf(buf, sizeof(buf), "0x%lx", (long)sym);
+ if (sym == NoSymbol)
+ strcpy(buf, "NoSymbol");
+ else
+ snprintf(buf, sizeof(buf), "0x%lx", (long) sym);
return buf;
}
char *
-XkbKeyNameText(char *name,unsigned format)
+XkbKeyNameText(char *name, unsigned format)
{
-char *buf;
+ char *buf;
- if (format==XkbCFile) {
- buf= tbGetBuffer(5);
- memcpy(buf,name,4);
- buf[4]= '\0';
+ if (format == XkbCFile) {
+ buf = tbGetBuffer(5);
+ memcpy(buf, name, 4);
+ buf[4] = '\0';
}
else {
- int len;
- buf= tbGetBuffer(7);
- buf[0]= '<';
- memcpy(&buf[1],name,4);
- buf[5]= '\0';
- len= strlen(buf);
- buf[len++]= '>';
- buf[len]= '\0';
+ int len;
+
+ buf = tbGetBuffer(7);
+ buf[0] = '<';
+ memcpy(&buf[1], name, 4);
+ buf[5] = '\0';
+ len = strlen(buf);
+ buf[len++] = '>';
+ buf[len] = '\0';
}
return buf;
}
@@ -368,143 +389,156 @@ char *buf;
/***====================================================================***/
static const char *siMatchText[5] = {
- "NoneOf", "AnyOfOrNone", "AnyOf", "AllOf", "Exactly"
+ "NoneOf", "AnyOfOrNone", "AnyOf", "AllOf", "Exactly"
};
const char *
-XkbSIMatchText(unsigned type,unsigned format)
+XkbSIMatchText(unsigned type, unsigned format)
{
-static char buf[40];
-const char *rtrn;
-
- switch (type&XkbSI_OpMask) {
- case XkbSI_NoneOf: rtrn= siMatchText[0]; break;
- case XkbSI_AnyOfOrNone: rtrn= siMatchText[1]; break;
- case XkbSI_AnyOf: rtrn= siMatchText[2]; break;
- case XkbSI_AllOf: rtrn= siMatchText[3]; break;
- case XkbSI_Exactly: rtrn= siMatchText[4]; break;
- default: snprintf(buf,sizeof(buf),"0x%x",type&XkbSI_OpMask);
- return buf;
+ static char buf[40];
+ const char *rtrn;
+
+ switch (type & XkbSI_OpMask) {
+ case XkbSI_NoneOf:
+ rtrn = siMatchText[0];
+ break;
+ case XkbSI_AnyOfOrNone:
+ rtrn = siMatchText[1];
+ break;
+ case XkbSI_AnyOf:
+ rtrn = siMatchText[2];
+ break;
+ case XkbSI_AllOf:
+ rtrn = siMatchText[3];
+ break;
+ case XkbSI_Exactly:
+ rtrn = siMatchText[4];
+ break;
+ default:
+ snprintf(buf, sizeof(buf), "0x%x", type & XkbSI_OpMask);
+ return buf;
}
- if (format==XkbCFile) {
- if (type&XkbSI_LevelOneOnly)
- snprintf(buf,sizeof(buf),"XkbSI_LevelOneOnly|XkbSI_%s",rtrn);
- else snprintf(buf,sizeof(buf),"XkbSI_%s",rtrn);
- rtrn= buf;
+ if (format == XkbCFile) {
+ if (type & XkbSI_LevelOneOnly)
+ snprintf(buf, sizeof(buf), "XkbSI_LevelOneOnly|XkbSI_%s", rtrn);
+ else
+ snprintf(buf, sizeof(buf), "XkbSI_%s", rtrn);
+ rtrn = buf;
}
return rtrn;
}
/***====================================================================***/
-static const char *imWhichNames[]= {
- "base",
- "latched",
- "locked",
- "effective",
- "compat"
+static const char *imWhichNames[] = {
+ "base",
+ "latched",
+ "locked",
+ "effective",
+ "compat"
};
char *
-XkbIMWhichStateMaskText(unsigned use_which,unsigned format)
+XkbIMWhichStateMaskText(unsigned use_which, unsigned format)
{
-int len;
-unsigned i,bit,tmp;
-char * buf;
-
- if (use_which==0) {
- buf= tbGetBuffer(2);
- strcpy(buf,"0");
- return buf;
+ int len;
+ unsigned i, bit, tmp;
+ char *buf;
+
+ if (use_which == 0) {
+ buf = tbGetBuffer(2);
+ strcpy(buf, "0");
+ return buf;
}
- tmp= use_which&XkbIM_UseAnyMods;
- for (len=i=0,bit=1;tmp!=0;i++,bit<<=1) {
- if (tmp&bit) {
- tmp&= ~bit;
- len+= strlen(imWhichNames[i])+1;
- if (format==XkbCFile)
- len+= 9;
- }
+ tmp = use_which & XkbIM_UseAnyMods;
+ for (len = i = 0, bit = 1; tmp != 0; i++, bit <<= 1) {
+ if (tmp & bit) {
+ tmp &= ~bit;
+ len += strlen(imWhichNames[i]) + 1;
+ if (format == XkbCFile)
+ len += 9;
+ }
}
- buf= tbGetBuffer(len+1);
- tmp= use_which&XkbIM_UseAnyMods;
- for (len=i=0,bit=1;tmp!=0;i++,bit<<=1) {
- if (tmp&bit) {
- tmp&= ~bit;
- if (format==XkbCFile) {
- if (len!=0)
- buf[len++]= '|';
- sprintf(&buf[len],"XkbIM_Use%s",imWhichNames[i]);
- buf[len+9]= toupper(buf[len+9]);
- }
- else {
- if (len!=0)
- buf[len++]= '+';
- sprintf(&buf[len],"%s",imWhichNames[i]);
- }
- len+= strlen(&buf[len]);
- }
+ buf = tbGetBuffer(len + 1);
+ tmp = use_which & XkbIM_UseAnyMods;
+ for (len = i = 0, bit = 1; tmp != 0; i++, bit <<= 1) {
+ if (tmp & bit) {
+ tmp &= ~bit;
+ if (format == XkbCFile) {
+ if (len != 0)
+ buf[len++] = '|';
+ sprintf(&buf[len], "XkbIM_Use%s", imWhichNames[i]);
+ buf[len + 9] = toupper(buf[len + 9]);
+ }
+ else {
+ if (len != 0)
+ buf[len++] = '+';
+ sprintf(&buf[len], "%s", imWhichNames[i]);
+ }
+ len += strlen(&buf[len]);
+ }
}
return buf;
}
static const char *ctrlNames[] = {
- "repeatKeys",
- "slowKeys",
- "bounceKeys",
- "stickyKeys",
- "mouseKeys",
- "mouseKeysAccel",
- "accessXKeys",
- "accessXTimeout",
- "accessXFeedback",
- "audibleBell",
- "overlay1",
- "overlay2",
- "ignoreGroupLock"
+ "repeatKeys",
+ "slowKeys",
+ "bounceKeys",
+ "stickyKeys",
+ "mouseKeys",
+ "mouseKeysAccel",
+ "accessXKeys",
+ "accessXTimeout",
+ "accessXFeedback",
+ "audibleBell",
+ "overlay1",
+ "overlay2",
+ "ignoreGroupLock"
};
char *
-XkbControlsMaskText(unsigned ctrls,unsigned format)
+XkbControlsMaskText(unsigned ctrls, unsigned format)
{
-int len;
-unsigned i,bit,tmp;
-char * buf;
-
- if (ctrls==0) {
- buf= tbGetBuffer(5);
- if (format==XkbCFile)
- strcpy(buf,"0");
- else strcpy(buf,"none");
- return buf;
+ int len;
+ unsigned i, bit, tmp;
+ char *buf;
+
+ if (ctrls == 0) {
+ buf = tbGetBuffer(5);
+ if (format == XkbCFile)
+ strcpy(buf, "0");
+ else
+ strcpy(buf, "none");
+ return buf;
}
- tmp= ctrls&XkbAllBooleanCtrlsMask;
- for (len=i=0,bit=1;tmp!=0;i++,bit<<=1) {
- if (tmp&bit) {
- tmp&= ~bit;
- len+= strlen(ctrlNames[i])+1;
- if (format==XkbCFile)
- len+= 7;
- }
+ tmp = ctrls & XkbAllBooleanCtrlsMask;
+ for (len = i = 0, bit = 1; tmp != 0; i++, bit <<= 1) {
+ if (tmp & bit) {
+ tmp &= ~bit;
+ len += strlen(ctrlNames[i]) + 1;
+ if (format == XkbCFile)
+ len += 7;
+ }
}
- buf= tbGetBuffer(len+1);
- tmp= ctrls&XkbAllBooleanCtrlsMask;
- for (len=i=0,bit=1;tmp!=0;i++,bit<<=1) {
- if (tmp&bit) {
- tmp&= ~bit;
- if (format==XkbCFile) {
- if (len!=0)
- buf[len++]= '|';
- sprintf(&buf[len],"Xkb%sMask",ctrlNames[i]);
- buf[len+3]= toupper(buf[len+3]);
- }
- else {
- if (len!=0)
- buf[len++]= '+';
- sprintf(&buf[len],"%s",ctrlNames[i]);
- }
- len+= strlen(&buf[len]);
- }
+ buf = tbGetBuffer(len + 1);
+ tmp = ctrls & XkbAllBooleanCtrlsMask;
+ for (len = i = 0, bit = 1; tmp != 0; i++, bit <<= 1) {
+ if (tmp & bit) {
+ tmp &= ~bit;
+ if (format == XkbCFile) {
+ if (len != 0)
+ buf[len++] = '|';
+ sprintf(&buf[len], "Xkb%sMask", ctrlNames[i]);
+ buf[len + 3] = toupper(buf[len + 3]);
+ }
+ else {
+ if (len != 0)
+ buf[len++] = '+';
+ sprintf(&buf[len], "%s", ctrlNames[i]);
+ }
+ len += strlen(&buf[len]);
+ }
}
return buf;
}
@@ -512,700 +546,763 @@ char * buf;
/***====================================================================***/
char *
-XkbStringText(char *str,unsigned format)
+XkbStringText(char *str, unsigned format)
{
-char * buf;
-register char *in,*out;
-int len;
-Bool ok;
-
- if (str==NULL) {
- buf= tbGetBuffer(2);
- buf[0]='\0';
- return buf;
+ char *buf;
+ register char *in, *out;
+ int len;
+ Bool ok;
+
+ if (str == NULL) {
+ buf = tbGetBuffer(2);
+ buf[0] = '\0';
+ return buf;
}
- else if (format==XkbXKMFile)
- return str;
- for (ok= TRUE,len=0,in=str;*in!='\0';in++,len++) {
- if (!isprint(*in)) {
- ok= FALSE;
- switch (*in) {
- case '\n': case '\t': case '\v':
- case '\b': case '\r': case '\f':
- len++;
- break;
- default:
- len+= 4;
- break;
- }
- }
+ else if (format == XkbXKMFile)
+ return str;
+ for (ok = TRUE, len = 0, in = str; *in != '\0'; in++, len++) {
+ if (!isprint(*in)) {
+ ok = FALSE;
+ switch (*in) {
+ case '\n':
+ case '\t':
+ case '\v':
+ case '\b':
+ case '\r':
+ case '\f':
+ len++;
+ break;
+ default:
+ len += 4;
+ break;
+ }
+ }
}
if (ok)
- return str;
- buf= tbGetBuffer(len+1);
- for (in=str,out=buf;*in!='\0';in++) {
- if (isprint(*in))
- *out++= *in;
- else {
- *out++= '\\';
- if (*in=='\n') *out++= 'n';
- else if (*in=='\t') *out++= 't';
- else if (*in=='\v') *out++= 'v';
- else if (*in=='\b') *out++= 'b';
- else if (*in=='\r') *out++= 'r';
- else if (*in=='\f') *out++= 'f';
- else if ((*in=='\033')&&(format==XkbXKMFile)) {
- *out++= 'e';
- }
- else {
- *out++= '0';
- sprintf(out,"%o",*in);
- while (*out!='\0')
- out++;
- }
- }
+ return str;
+ buf = tbGetBuffer(len + 1);
+ for (in = str, out = buf; *in != '\0'; in++) {
+ if (isprint(*in))
+ *out++ = *in;
+ else {
+ *out++ = '\\';
+ if (*in == '\n')
+ *out++ = 'n';
+ else if (*in == '\t')
+ *out++ = 't';
+ else if (*in == '\v')
+ *out++ = 'v';
+ else if (*in == '\b')
+ *out++ = 'b';
+ else if (*in == '\r')
+ *out++ = 'r';
+ else if (*in == '\f')
+ *out++ = 'f';
+ else if ((*in == '\033') && (format == XkbXKMFile)) {
+ *out++ = 'e';
+ }
+ else {
+ *out++ = '0';
+ sprintf(out, "%o", *in);
+ while (*out != '\0')
+ out++;
+ }
+ }
}
- *out++= '\0';
+ *out++ = '\0';
return buf;
}
/***====================================================================***/
char *
-XkbGeomFPText(int val,unsigned format)
+XkbGeomFPText(int val, unsigned format)
{
-int whole,frac;
-char * buf;
+ int whole, frac;
+ char *buf;
- buf= tbGetBuffer(12);
- if (format==XkbCFile) {
- sprintf(buf,"%d",val);
+ buf = tbGetBuffer(12);
+ if (format == XkbCFile) {
+ sprintf(buf, "%d", val);
}
else {
- whole= val/XkbGeomPtsPerMM;
- frac= val%XkbGeomPtsPerMM;
- if (frac!=0)
- sprintf(buf,"%d.%d",whole,frac);
- else sprintf(buf,"%d",whole);
+ whole = val / XkbGeomPtsPerMM;
+ frac = val % XkbGeomPtsPerMM;
+ if (frac != 0)
+ sprintf(buf, "%d.%d", whole, frac);
+ else
+ sprintf(buf, "%d", whole);
}
return buf;
}
char *
-XkbDoodadTypeText(unsigned type,unsigned format)
+XkbDoodadTypeText(unsigned type, unsigned format)
{
-char * buf;
- if (format==XkbCFile) {
- buf= tbGetBuffer(24);
- if (type==XkbOutlineDoodad) strcpy(buf,"XkbOutlineDoodad");
- else if (type==XkbSolidDoodad) strcpy(buf,"XkbSolidDoodad");
- else if (type==XkbTextDoodad) strcpy(buf,"XkbTextDoodad");
- else if (type==XkbIndicatorDoodad) strcpy(buf,"XkbIndicatorDoodad");
- else if (type==XkbLogoDoodad) strcpy(buf,"XkbLogoDoodad");
- else sprintf(buf,"UnknownDoodad%d",type);
+ char *buf;
+
+ if (format == XkbCFile) {
+ buf = tbGetBuffer(24);
+ if (type == XkbOutlineDoodad)
+ strcpy(buf, "XkbOutlineDoodad");
+ else if (type == XkbSolidDoodad)
+ strcpy(buf, "XkbSolidDoodad");
+ else if (type == XkbTextDoodad)
+ strcpy(buf, "XkbTextDoodad");
+ else if (type == XkbIndicatorDoodad)
+ strcpy(buf, "XkbIndicatorDoodad");
+ else if (type == XkbLogoDoodad)
+ strcpy(buf, "XkbLogoDoodad");
+ else
+ sprintf(buf, "UnknownDoodad%d", type);
}
else {
- buf= tbGetBuffer(12);
- if (type==XkbOutlineDoodad) strcpy(buf,"outline");
- else if (type==XkbSolidDoodad) strcpy(buf,"solid");
- else if (type==XkbTextDoodad) strcpy(buf,"text");
- else if (type==XkbIndicatorDoodad) strcpy(buf,"indicator");
- else if (type==XkbLogoDoodad) strcpy(buf,"logo");
- else sprintf(buf,"unknown%d",type);
+ buf = tbGetBuffer(12);
+ if (type == XkbOutlineDoodad)
+ strcpy(buf, "outline");
+ else if (type == XkbSolidDoodad)
+ strcpy(buf, "solid");
+ else if (type == XkbTextDoodad)
+ strcpy(buf, "text");
+ else if (type == XkbIndicatorDoodad)
+ strcpy(buf, "indicator");
+ else if (type == XkbLogoDoodad)
+ strcpy(buf, "logo");
+ else
+ sprintf(buf, "unknown%d", type);
}
return buf;
}
-static const char *actionTypeNames[XkbSA_NumActions]= {
- "NoAction",
- "SetMods", "LatchMods", "LockMods",
- "SetGroup", "LatchGroup", "LockGroup",
+static const char *actionTypeNames[XkbSA_NumActions] = {
+ "NoAction",
+ "SetMods", "LatchMods", "LockMods",
+ "SetGroup", "LatchGroup", "LockGroup",
"MovePtr",
- "PtrBtn", "LockPtrBtn",
+ "PtrBtn", "LockPtrBtn",
"SetPtrDflt",
"ISOLock",
- "Terminate", "SwitchScreen",
- "SetControls", "LockControls",
+ "Terminate", "SwitchScreen",
+ "SetControls", "LockControls",
"ActionMessage",
"RedirectKey",
- "DeviceBtn", "LockDeviceBtn"
+ "DeviceBtn", "LockDeviceBtn"
};
const char *
-XkbActionTypeText(unsigned type,unsigned format)
+XkbActionTypeText(unsigned type, unsigned format)
{
-static char buf[32];
-const char *rtrn;
-
- if (type<=XkbSA_LastAction) {
- rtrn= actionTypeNames[type];
- if (format==XkbCFile) {
- snprintf(buf,sizeof(buf),"XkbSA_%s",rtrn);
- return buf;
- }
- return rtrn;
+ static char buf[32];
+ const char *rtrn;
+
+ if (type <= XkbSA_LastAction) {
+ rtrn = actionTypeNames[type];
+ if (format == XkbCFile) {
+ snprintf(buf, sizeof(buf), "XkbSA_%s", rtrn);
+ return buf;
+ }
+ return rtrn;
}
- snprintf(buf,sizeof(buf),"Private");
+ snprintf(buf, sizeof(buf), "Private");
return buf;
}
/***====================================================================***/
static int
-TryCopyStr(char *to,const char *from,int *pLeft)
+TryCopyStr(char *to, const char *from, int *pLeft)
{
-register int len;
- if (*pLeft>0) {
- len= strlen(from);
- if (len<((*pLeft)-3)) {
- strcat(to,from);
- *pLeft-= len;
- return TRUE;
- }
+ register int len;
+
+ if (*pLeft > 0) {
+ len = strlen(from);
+ if (len < ((*pLeft) - 3)) {
+ strcat(to, from);
+ *pLeft -= len;
+ return TRUE;
+ }
}
- *pLeft= -1;
+ *pLeft = -1;
return FALSE;
}
-/*ARGSUSED*/
-static Bool
-CopyNoActionArgs(XkbDescPtr xkb,XkbAction *action,char *buf,int*sz)
+ /*ARGSUSED*/ static Bool
+CopyNoActionArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
{
return TRUE;
}
static Bool
-CopyModActionArgs(XkbDescPtr xkb,XkbAction *action,char *buf,
- int* sz)
+CopyModActionArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
{
-XkbModAction * act;
-unsigned tmp;
-
- act= &action->mods;
- tmp= XkbModActionVMods(act);
- TryCopyStr(buf,"modifiers=",sz);
- if (act->flags&XkbSA_UseModMapMods)
- TryCopyStr(buf,"modMapMods",sz);
+ XkbModAction *act;
+ unsigned tmp;
+
+ act = &action->mods;
+ tmp = XkbModActionVMods(act);
+ TryCopyStr(buf, "modifiers=", sz);
+ if (act->flags & XkbSA_UseModMapMods)
+ TryCopyStr(buf, "modMapMods", sz);
else if (act->real_mods || tmp) {
- TryCopyStr(buf,
- XkbVModMaskText(xkb,act->real_mods,tmp,XkbXKBFile),
- sz);
+ TryCopyStr(buf,
+ XkbVModMaskText(xkb, act->real_mods, tmp, XkbXKBFile), sz);
}
- else TryCopyStr(buf,"none",sz);
- if (act->type==XkbSA_LockMods)
- return TRUE;
- if (act->flags&XkbSA_ClearLocks)
- TryCopyStr(buf,",clearLocks",sz);
- if (act->flags&XkbSA_LatchToLock)
- TryCopyStr(buf,",latchToLock",sz);
+ else
+ TryCopyStr(buf, "none", sz);
+ if (act->type == XkbSA_LockMods)
+ return TRUE;
+ if (act->flags & XkbSA_ClearLocks)
+ TryCopyStr(buf, ",clearLocks", sz);
+ if (act->flags & XkbSA_LatchToLock)
+ TryCopyStr(buf, ",latchToLock", sz);
return TRUE;
}
-/*ARGSUSED*/
-static Bool
-CopyGroupActionArgs(XkbDescPtr xkb,XkbAction *action,char *buf,
- int *sz)
+ /*ARGSUSED*/ static Bool
+CopyGroupActionArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
{
-XkbGroupAction * act;
-char tbuf[32];
-
- act= &action->group;
- TryCopyStr(buf,"group=",sz);
- if (act->flags&XkbSA_GroupAbsolute)
- snprintf(tbuf,sizeof(tbuf),"%d",XkbSAGroup(act)+1);
- else if (XkbSAGroup(act)<0)
- snprintf(tbuf,sizeof(tbuf),"%d",XkbSAGroup(act));
- else snprintf(tbuf,sizeof(tbuf),"+%d",XkbSAGroup(act));
- TryCopyStr(buf,tbuf,sz);
- if (act->type==XkbSA_LockGroup)
- return TRUE;
- if (act->flags&XkbSA_ClearLocks)
- TryCopyStr(buf,",clearLocks",sz);
- if (act->flags&XkbSA_LatchToLock)
- TryCopyStr(buf,",latchToLock",sz);
+ XkbGroupAction *act;
+ char tbuf[32];
+
+ act = &action->group;
+ TryCopyStr(buf, "group=", sz);
+ if (act->flags & XkbSA_GroupAbsolute)
+ snprintf(tbuf, sizeof(tbuf), "%d", XkbSAGroup(act) + 1);
+ else if (XkbSAGroup(act) < 0)
+ snprintf(tbuf, sizeof(tbuf), "%d", XkbSAGroup(act));
+ else
+ snprintf(tbuf, sizeof(tbuf), "+%d", XkbSAGroup(act));
+ TryCopyStr(buf, tbuf, sz);
+ if (act->type == XkbSA_LockGroup)
+ return TRUE;
+ if (act->flags & XkbSA_ClearLocks)
+ TryCopyStr(buf, ",clearLocks", sz);
+ if (act->flags & XkbSA_LatchToLock)
+ TryCopyStr(buf, ",latchToLock", sz);
return TRUE;
}
-/*ARGSUSED*/
-static Bool
-CopyMovePtrArgs(XkbDescPtr xkb,XkbAction *action,char *buf,int *sz)
+ /*ARGSUSED*/ static Bool
+CopyMovePtrArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
{
-XkbPtrAction * act;
-int x,y;
-char tbuf[32];
-
- act= &action->ptr;
- x= XkbPtrActionX(act);
- y= XkbPtrActionY(act);
- if ((act->flags&XkbSA_MoveAbsoluteX)||(x<0))
- snprintf(tbuf,sizeof(tbuf),"x=%d",x);
- else snprintf(tbuf,sizeof(tbuf),"x=+%d",x);
- TryCopyStr(buf,tbuf,sz);
-
- if ((act->flags&XkbSA_MoveAbsoluteY)||(y<0))
- snprintf(tbuf,sizeof(tbuf),",y=%d",y);
- else snprintf(tbuf,sizeof(tbuf),",y=+%d",y);
- TryCopyStr(buf,tbuf,sz);
- if (act->flags&XkbSA_NoAcceleration)
- TryCopyStr(buf,",!accel",sz);
+ XkbPtrAction *act;
+ int x, y;
+ char tbuf[32];
+
+ act = &action->ptr;
+ x = XkbPtrActionX(act);
+ y = XkbPtrActionY(act);
+ if ((act->flags & XkbSA_MoveAbsoluteX) || (x < 0))
+ snprintf(tbuf, sizeof(tbuf), "x=%d", x);
+ else
+ snprintf(tbuf, sizeof(tbuf), "x=+%d", x);
+ TryCopyStr(buf, tbuf, sz);
+
+ if ((act->flags & XkbSA_MoveAbsoluteY) || (y < 0))
+ snprintf(tbuf, sizeof(tbuf), ",y=%d", y);
+ else
+ snprintf(tbuf, sizeof(tbuf), ",y=+%d", y);
+ TryCopyStr(buf, tbuf, sz);
+ if (act->flags & XkbSA_NoAcceleration)
+ TryCopyStr(buf, ",!accel", sz);
return TRUE;
}
-/*ARGSUSED*/
-static Bool
-CopyPtrBtnArgs(XkbDescPtr xkb,XkbAction *action,char *buf,int *sz)
+ /*ARGSUSED*/ static Bool
+CopyPtrBtnArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
{
-XkbPtrBtnAction * act;
-char tbuf[32];
-
- act= &action->btn;
- TryCopyStr(buf,"button=",sz);
- if ((act->button>0)&&(act->button<6)) {
- snprintf(tbuf,sizeof(tbuf),"%d",act->button);
- TryCopyStr(buf,tbuf,sz);
+ XkbPtrBtnAction *act;
+ char tbuf[32];
+
+ act = &action->btn;
+ TryCopyStr(buf, "button=", sz);
+ if ((act->button > 0) && (act->button < 6)) {
+ snprintf(tbuf, sizeof(tbuf), "%d", act->button);
+ TryCopyStr(buf, tbuf, sz);
}
- else TryCopyStr(buf,"default",sz);
- if (act->count>0) {
- snprintf(tbuf,sizeof(tbuf),",count=%d",act->count);
- TryCopyStr(buf,tbuf,sz);
+ else
+ TryCopyStr(buf, "default", sz);
+ if (act->count > 0) {
+ snprintf(tbuf, sizeof(tbuf), ",count=%d", act->count);
+ TryCopyStr(buf, tbuf, sz);
}
- if (action->type==XkbSA_LockPtrBtn) {
- switch (act->flags&(XkbSA_LockNoUnlock|XkbSA_LockNoLock)) {
- case XkbSA_LockNoLock:
- TryCopyStr(buf,",affect=unlock",sz); break;
- case XkbSA_LockNoUnlock:
- TryCopyStr(buf,",affect=lock",sz); break;
- case XkbSA_LockNoUnlock|XkbSA_LockNoLock:
- TryCopyStr(buf,",affect=neither",sz); break;
- default:
- TryCopyStr(buf,",affect=both",sz); break;
- }
+ if (action->type == XkbSA_LockPtrBtn) {
+ switch (act->flags & (XkbSA_LockNoUnlock | XkbSA_LockNoLock)) {
+ case XkbSA_LockNoLock:
+ TryCopyStr(buf, ",affect=unlock", sz);
+ break;
+ case XkbSA_LockNoUnlock:
+ TryCopyStr(buf, ",affect=lock", sz);
+ break;
+ case XkbSA_LockNoUnlock | XkbSA_LockNoLock:
+ TryCopyStr(buf, ",affect=neither", sz);
+ break;
+ default:
+ TryCopyStr(buf, ",affect=both", sz);
+ break;
+ }
}
return TRUE;
}
-/*ARGSUSED*/
-static Bool
-CopySetPtrDfltArgs(XkbDescPtr xkb,XkbAction *action,char *buf,
- int *sz)
+ /*ARGSUSED*/ static Bool
+CopySetPtrDfltArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
{
-XkbPtrDfltAction * act;
-char tbuf[32];
-
- act= &action->dflt;
- if (act->affect==XkbSA_AffectDfltBtn) {
- TryCopyStr(buf,"affect=button,button=",sz);
- if ((act->flags&XkbSA_DfltBtnAbsolute)||(XkbSAPtrDfltValue(act)<0))
- snprintf(tbuf,sizeof(tbuf),"%d",XkbSAPtrDfltValue(act));
- else snprintf(tbuf,sizeof(tbuf),"+%d",XkbSAPtrDfltValue(act));
- TryCopyStr(buf,tbuf,sz);
+ XkbPtrDfltAction *act;
+ char tbuf[32];
+
+ act = &action->dflt;
+ if (act->affect == XkbSA_AffectDfltBtn) {
+ TryCopyStr(buf, "affect=button,button=", sz);
+ if ((act->flags & XkbSA_DfltBtnAbsolute) ||
+ (XkbSAPtrDfltValue(act) < 0))
+ snprintf(tbuf, sizeof(tbuf), "%d", XkbSAPtrDfltValue(act));
+ else
+ snprintf(tbuf, sizeof(tbuf), "+%d", XkbSAPtrDfltValue(act));
+ TryCopyStr(buf, tbuf, sz);
}
return TRUE;
}
static Bool
-CopyISOLockArgs(XkbDescPtr xkb,XkbAction *action,char *buf,int *sz)
+CopyISOLockArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
{
-XkbISOAction * act;
-char tbuf[64];
-
- act= &action->iso;
- if (act->flags&XkbSA_ISODfltIsGroup) {
- TryCopyStr(tbuf,"group=",sz);
- if (act->flags&XkbSA_GroupAbsolute)
- snprintf(tbuf,sizeof(tbuf),"%d",XkbSAGroup(act)+1);
- else if (XkbSAGroup(act)<0)
- snprintf(tbuf,sizeof(tbuf),"%d",XkbSAGroup(act));
- else snprintf(tbuf,sizeof(tbuf),"+%d",XkbSAGroup(act));
- TryCopyStr(buf,tbuf,sz);
+ XkbISOAction *act;
+ char tbuf[64];
+
+ act = &action->iso;
+ if (act->flags & XkbSA_ISODfltIsGroup) {
+ TryCopyStr(tbuf, "group=", sz);
+ if (act->flags & XkbSA_GroupAbsolute)
+ snprintf(tbuf, sizeof(tbuf), "%d", XkbSAGroup(act) + 1);
+ else if (XkbSAGroup(act) < 0)
+ snprintf(tbuf, sizeof(tbuf), "%d", XkbSAGroup(act));
+ else
+ snprintf(tbuf, sizeof(tbuf), "+%d", XkbSAGroup(act));
+ TryCopyStr(buf, tbuf, sz);
}
else {
- unsigned tmp;
- tmp= XkbModActionVMods(act);
- TryCopyStr(buf,"modifiers=",sz);
- if (act->flags&XkbSA_UseModMapMods)
- TryCopyStr(buf,"modMapMods",sz);
- else if (act->real_mods || tmp) {
- if (act->real_mods) {
- TryCopyStr(buf,XkbModMaskText(act->real_mods,XkbXKBFile),sz);
- if (tmp)
- TryCopyStr(buf,"+",sz);
- }
- if (tmp)
- TryCopyStr(buf,XkbVModMaskText(xkb,0,tmp,XkbXKBFile),sz);
- }
- else TryCopyStr(buf,"none",sz);
+ unsigned tmp;
+
+ tmp = XkbModActionVMods(act);
+ TryCopyStr(buf, "modifiers=", sz);
+ if (act->flags & XkbSA_UseModMapMods)
+ TryCopyStr(buf, "modMapMods", sz);
+ else if (act->real_mods || tmp) {
+ if (act->real_mods) {
+ TryCopyStr(buf, XkbModMaskText(act->real_mods, XkbXKBFile), sz);
+ if (tmp)
+ TryCopyStr(buf, "+", sz);
+ }
+ if (tmp)
+ TryCopyStr(buf, XkbVModMaskText(xkb, 0, tmp, XkbXKBFile), sz);
+ }
+ else
+ TryCopyStr(buf, "none", sz);
}
- TryCopyStr(buf,",affect=",sz);
- if ((act->affect&XkbSA_ISOAffectMask)==0)
- TryCopyStr(buf,"all",sz);
+ TryCopyStr(buf, ",affect=", sz);
+ if ((act->affect & XkbSA_ISOAffectMask) == 0)
+ TryCopyStr(buf, "all", sz);
else {
- int nOut= 0;
- if ((act->affect&XkbSA_ISONoAffectMods)==0) {
- TryCopyStr(buf,"mods",sz);
- nOut++;
- }
- if ((act->affect&XkbSA_ISONoAffectGroup)==0) {
- snprintf(tbuf,sizeof(tbuf),"%sgroups",(nOut>0?"+":""));
- TryCopyStr(buf,tbuf,sz);
- nOut++;
- }
- if ((act->affect&XkbSA_ISONoAffectPtr)==0) {
- snprintf(tbuf,sizeof(tbuf),"%spointer",(nOut>0?"+":""));
- TryCopyStr(buf,tbuf,sz);
- nOut++;
- }
- if ((act->affect&XkbSA_ISONoAffectCtrls)==0) {
- snprintf(tbuf,sizeof(tbuf),"%scontrols",(nOut>0?"+":""));
- TryCopyStr(buf,tbuf,sz);
- nOut++;
- }
+ int nOut = 0;
+
+ if ((act->affect & XkbSA_ISONoAffectMods) == 0) {
+ TryCopyStr(buf, "mods", sz);
+ nOut++;
+ }
+ if ((act->affect & XkbSA_ISONoAffectGroup) == 0) {
+ snprintf(tbuf, sizeof(tbuf), "%sgroups", (nOut > 0 ? "+" : ""));
+ TryCopyStr(buf, tbuf, sz);
+ nOut++;
+ }
+ if ((act->affect & XkbSA_ISONoAffectPtr) == 0) {
+ snprintf(tbuf, sizeof(tbuf), "%spointer", (nOut > 0 ? "+" : ""));
+ TryCopyStr(buf, tbuf, sz);
+ nOut++;
+ }
+ if ((act->affect & XkbSA_ISONoAffectCtrls) == 0) {
+ snprintf(tbuf, sizeof(tbuf), "%scontrols", (nOut > 0 ? "+" : ""));
+ TryCopyStr(buf, tbuf, sz);
+ nOut++;
+ }
}
return TRUE;
}
-/*ARGSUSED*/
-static Bool
-CopySwitchScreenArgs(XkbDescPtr xkb,XkbAction *action,char *buf,
- int *sz)
+ /*ARGSUSED*/ static Bool
+CopySwitchScreenArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
{
-XkbSwitchScreenAction * act;
-char tbuf[32];
-
- act= &action->screen;
- if ((act->flags&XkbSA_SwitchAbsolute)||(XkbSAScreen(act)<0))
- snprintf(tbuf,sizeof(tbuf),"screen=%d",XkbSAScreen(act));
- else snprintf(tbuf,sizeof(tbuf),"screen=+%d",XkbSAScreen(act));
- TryCopyStr(buf,tbuf,sz);
- if (act->flags&XkbSA_SwitchApplication)
- TryCopyStr(buf,",!same",sz);
- else TryCopyStr(buf,",same",sz);
+ XkbSwitchScreenAction *act;
+ char tbuf[32];
+
+ act = &action->screen;
+ if ((act->flags & XkbSA_SwitchAbsolute) || (XkbSAScreen(act) < 0))
+ snprintf(tbuf, sizeof(tbuf), "screen=%d", XkbSAScreen(act));
+ else
+ snprintf(tbuf, sizeof(tbuf), "screen=+%d", XkbSAScreen(act));
+ TryCopyStr(buf, tbuf, sz);
+ if (act->flags & XkbSA_SwitchApplication)
+ TryCopyStr(buf, ",!same", sz);
+ else
+ TryCopyStr(buf, ",same", sz);
return TRUE;
}
-/*ARGSUSED*/
-static Bool
-CopySetLockControlsArgs(XkbDescPtr xkb,XkbAction *action,
- char *buf,int *sz)
+ /*ARGSUSED*/ static Bool
+CopySetLockControlsArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
{
-XkbCtrlsAction * act;
-unsigned tmp;
-char tbuf[32];
-
- act= &action->ctrls;
- tmp= XkbActionCtrls(act);
- TryCopyStr(buf,"controls=",sz);
- if (tmp==0)
- TryCopyStr(buf,"none",sz);
- else if ((tmp&XkbAllBooleanCtrlsMask)==XkbAllBooleanCtrlsMask)
- TryCopyStr(buf,"all",sz);
+ XkbCtrlsAction *act;
+ unsigned tmp;
+ char tbuf[32];
+
+ act = &action->ctrls;
+ tmp = XkbActionCtrls(act);
+ TryCopyStr(buf, "controls=", sz);
+ if (tmp == 0)
+ TryCopyStr(buf, "none", sz);
+ else if ((tmp & XkbAllBooleanCtrlsMask) == XkbAllBooleanCtrlsMask)
+ TryCopyStr(buf, "all", sz);
else {
- int nOut= 0;
- if (tmp&XkbRepeatKeysMask) {
- snprintf(tbuf,sizeof(tbuf),"%sRepeatKeys",(nOut>0?"+":""));
- TryCopyStr(buf,tbuf,sz);
- nOut++;
- }
- if (tmp&XkbSlowKeysMask) {
- snprintf(tbuf,sizeof(tbuf),"%sSlowKeys",(nOut>0?"+":""));
- TryCopyStr(buf,tbuf,sz);
- nOut++;
- }
- if (tmp&XkbBounceKeysMask) {
- snprintf(tbuf,sizeof(tbuf),"%sBounceKeys",(nOut>0?"+":""));
- TryCopyStr(buf,tbuf,sz);
- nOut++;
- }
- if (tmp&XkbStickyKeysMask) {
- snprintf(tbuf,sizeof(tbuf),"%sStickyKeys",(nOut>0?"+":""));
- TryCopyStr(buf,tbuf,sz);
- nOut++;
- }
- if (tmp&XkbMouseKeysMask) {
- snprintf(tbuf,sizeof(tbuf),"%sMouseKeys",(nOut>0?"+":""));
- TryCopyStr(buf,tbuf,sz);
- nOut++;
- }
- if (tmp&XkbMouseKeysAccelMask) {
- snprintf(tbuf,sizeof(tbuf),"%sMouseKeysAccel",(nOut>0?"+":""));
- TryCopyStr(buf,tbuf,sz);
- nOut++;
- }
- if (tmp&XkbAccessXKeysMask) {
- snprintf(tbuf,sizeof(tbuf),"%sAccessXKeys",(nOut>0?"+":""));
- TryCopyStr(buf,tbuf,sz);
- nOut++;
- }
- if (tmp&XkbAccessXTimeoutMask) {
- snprintf(tbuf,sizeof(tbuf),"%sAccessXTimeout",(nOut>0?"+":""));
- TryCopyStr(buf,tbuf,sz);
- nOut++;
- }
- if (tmp&XkbAccessXFeedbackMask) {
- snprintf(tbuf,sizeof(tbuf),"%sAccessXFeedback",(nOut>0?"+":""));
- TryCopyStr(buf,tbuf,sz);
- nOut++;
- }
- if (tmp&XkbAudibleBellMask) {
- snprintf(tbuf,sizeof(tbuf),"%sAudibleBell",(nOut>0?"+":""));
- TryCopyStr(buf,tbuf,sz);
- nOut++;
- }
- if (tmp&XkbOverlay1Mask) {
- snprintf(tbuf,sizeof(tbuf),"%sOverlay1",(nOut>0?"+":""));
- TryCopyStr(buf,tbuf,sz);
- nOut++;
- }
- if (tmp&XkbOverlay2Mask) {
- snprintf(tbuf,sizeof(tbuf),"%sOverlay2",(nOut>0?"+":""));
- TryCopyStr(buf,tbuf,sz);
- nOut++;
- }
- if (tmp&XkbIgnoreGroupLockMask) {
- snprintf(tbuf,sizeof(tbuf),"%sIgnoreGroupLock",(nOut>0?"+":""));
- TryCopyStr(buf,tbuf,sz);
- nOut++;
- }
+ int nOut = 0;
+
+ if (tmp & XkbRepeatKeysMask) {
+ snprintf(tbuf, sizeof(tbuf), "%sRepeatKeys", (nOut > 0 ? "+" : ""));
+ TryCopyStr(buf, tbuf, sz);
+ nOut++;
+ }
+ if (tmp & XkbSlowKeysMask) {
+ snprintf(tbuf, sizeof(tbuf), "%sSlowKeys", (nOut > 0 ? "+" : ""));
+ TryCopyStr(buf, tbuf, sz);
+ nOut++;
+ }
+ if (tmp & XkbBounceKeysMask) {
+ snprintf(tbuf, sizeof(tbuf), "%sBounceKeys", (nOut > 0 ? "+" : ""));
+ TryCopyStr(buf, tbuf, sz);
+ nOut++;
+ }
+ if (tmp & XkbStickyKeysMask) {
+ snprintf(tbuf, sizeof(tbuf), "%sStickyKeys", (nOut > 0 ? "+" : ""));
+ TryCopyStr(buf, tbuf, sz);
+ nOut++;
+ }
+ if (tmp & XkbMouseKeysMask) {
+ snprintf(tbuf, sizeof(tbuf), "%sMouseKeys", (nOut > 0 ? "+" : ""));
+ TryCopyStr(buf, tbuf, sz);
+ nOut++;
+ }
+ if (tmp & XkbMouseKeysAccelMask) {
+ snprintf(tbuf, sizeof(tbuf), "%sMouseKeysAccel",
+ (nOut > 0 ? "+" : ""));
+ TryCopyStr(buf, tbuf, sz);
+ nOut++;
+ }
+ if (tmp & XkbAccessXKeysMask) {
+ snprintf(tbuf, sizeof(tbuf), "%sAccessXKeys",
+ (nOut > 0 ? "+" : ""));
+ TryCopyStr(buf, tbuf, sz);
+ nOut++;
+ }
+ if (tmp & XkbAccessXTimeoutMask) {
+ snprintf(tbuf, sizeof(tbuf), "%sAccessXTimeout",
+ (nOut > 0 ? "+" : ""));
+ TryCopyStr(buf, tbuf, sz);
+ nOut++;
+ }
+ if (tmp & XkbAccessXFeedbackMask) {
+ snprintf(tbuf, sizeof(tbuf), "%sAccessXFeedback",
+ (nOut > 0 ? "+" : ""));
+ TryCopyStr(buf, tbuf, sz);
+ nOut++;
+ }
+ if (tmp & XkbAudibleBellMask) {
+ snprintf(tbuf, sizeof(tbuf), "%sAudibleBell",
+ (nOut > 0 ? "+" : ""));
+ TryCopyStr(buf, tbuf, sz);
+ nOut++;
+ }
+ if (tmp & XkbOverlay1Mask) {
+ snprintf(tbuf, sizeof(tbuf), "%sOverlay1", (nOut > 0 ? "+" : ""));
+ TryCopyStr(buf, tbuf, sz);
+ nOut++;
+ }
+ if (tmp & XkbOverlay2Mask) {
+ snprintf(tbuf, sizeof(tbuf), "%sOverlay2", (nOut > 0 ? "+" : ""));
+ TryCopyStr(buf, tbuf, sz);
+ nOut++;
+ }
+ if (tmp & XkbIgnoreGroupLockMask) {
+ snprintf(tbuf, sizeof(tbuf), "%sIgnoreGroupLock",
+ (nOut > 0 ? "+" : ""));
+ TryCopyStr(buf, tbuf, sz);
+ nOut++;
+ }
}
return TRUE;
}
-/*ARGSUSED*/
-static Bool
-CopyActionMessageArgs(XkbDescPtr xkb,XkbAction *action,char *buf,
- int *sz)
+ /*ARGSUSED*/ static Bool
+CopyActionMessageArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
{
-XkbMessageAction * act;
-unsigned all;
-char tbuf[32];
-
- act= &action->msg;
- all= XkbSA_MessageOnPress|XkbSA_MessageOnRelease;
- TryCopyStr(buf,"report=",sz);
- if ((act->flags&all)==0)
- TryCopyStr(buf,"none",sz);
- else if ((act->flags&all)==all)
- TryCopyStr(buf,"all",sz);
- else if (act->flags&XkbSA_MessageOnPress)
- TryCopyStr(buf,"KeyPress",sz);
- else TryCopyStr(buf,"KeyRelease",sz);
- snprintf(tbuf,sizeof(tbuf),",data[0]=0x%02x",act->message[0]); TryCopyStr(buf,tbuf,sz);
- snprintf(tbuf,sizeof(tbuf),",data[1]=0x%02x",act->message[1]); TryCopyStr(buf,tbuf,sz);
- snprintf(tbuf,sizeof(tbuf),",data[2]=0x%02x",act->message[2]); TryCopyStr(buf,tbuf,sz);
- snprintf(tbuf,sizeof(tbuf),",data[3]=0x%02x",act->message[3]); TryCopyStr(buf,tbuf,sz);
- snprintf(tbuf,sizeof(tbuf),",data[4]=0x%02x",act->message[4]); TryCopyStr(buf,tbuf,sz);
- snprintf(tbuf,sizeof(tbuf),",data[5]=0x%02x",act->message[5]); TryCopyStr(buf,tbuf,sz);
+ XkbMessageAction *act;
+ unsigned all;
+ char tbuf[32];
+
+ act = &action->msg;
+ all = XkbSA_MessageOnPress | XkbSA_MessageOnRelease;
+ TryCopyStr(buf, "report=", sz);
+ if ((act->flags & all) == 0)
+ TryCopyStr(buf, "none", sz);
+ else if ((act->flags & all) == all)
+ TryCopyStr(buf, "all", sz);
+ else if (act->flags & XkbSA_MessageOnPress)
+ TryCopyStr(buf, "KeyPress", sz);
+ else
+ TryCopyStr(buf, "KeyRelease", sz);
+ snprintf(tbuf, sizeof(tbuf), ",data[0]=0x%02x", act->message[0]);
+ TryCopyStr(buf, tbuf, sz);
+ snprintf(tbuf, sizeof(tbuf), ",data[1]=0x%02x", act->message[1]);
+ TryCopyStr(buf, tbuf, sz);
+ snprintf(tbuf, sizeof(tbuf), ",data[2]=0x%02x", act->message[2]);
+ TryCopyStr(buf, tbuf, sz);
+ snprintf(tbuf, sizeof(tbuf), ",data[3]=0x%02x", act->message[3]);
+ TryCopyStr(buf, tbuf, sz);
+ snprintf(tbuf, sizeof(tbuf), ",data[4]=0x%02x", act->message[4]);
+ TryCopyStr(buf, tbuf, sz);
+ snprintf(tbuf, sizeof(tbuf), ",data[5]=0x%02x", act->message[5]);
+ TryCopyStr(buf, tbuf, sz);
return TRUE;
}
static Bool
-CopyRedirectKeyArgs(XkbDescPtr xkb,XkbAction *action,char *buf,
- int *sz)
+CopyRedirectKeyArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
{
-XkbRedirectKeyAction * act;
-char tbuf[32],*tmp;
-unsigned kc;
-unsigned vmods,vmods_mask;
-
- act= &action->redirect;
- kc= act->new_key;
- vmods= XkbSARedirectVMods(act);
- vmods_mask= XkbSARedirectVModsMask(act);
- if (xkb && xkb->names && xkb->names->keys && (kc<=xkb->max_key_code) &&
- (xkb->names->keys[kc].name[0]!='\0')) {
- char *kn;
- kn= XkbKeyNameText(xkb->names->keys[kc].name,XkbXKBFile);
- snprintf(tbuf,sizeof(tbuf),"key=%s",kn);
+ XkbRedirectKeyAction *act;
+ char tbuf[32], *tmp;
+ unsigned kc;
+ unsigned vmods, vmods_mask;
+
+ act = &action->redirect;
+ kc = act->new_key;
+ vmods = XkbSARedirectVMods(act);
+ vmods_mask = XkbSARedirectVModsMask(act);
+ if (xkb && xkb->names && xkb->names->keys && (kc <= xkb->max_key_code) &&
+ (xkb->names->keys[kc].name[0] != '\0')) {
+ char *kn;
+
+ kn = XkbKeyNameText(xkb->names->keys[kc].name, XkbXKBFile);
+ snprintf(tbuf, sizeof(tbuf), "key=%s", kn);
}
- else snprintf(tbuf,sizeof(tbuf),"key=%d",kc);
- TryCopyStr(buf,tbuf,sz);
- if ((act->mods_mask==0)&&(vmods_mask==0))
- return TRUE;
- if ((act->mods_mask==XkbAllModifiersMask)&&
- (vmods_mask==XkbAllVirtualModsMask)) {
- tmp= XkbVModMaskText(xkb,act->mods,vmods,XkbXKBFile);
- TryCopyStr(buf,",mods=",sz);
- TryCopyStr(buf,tmp,sz);
+ else
+ snprintf(tbuf, sizeof(tbuf), "key=%d", kc);
+ TryCopyStr(buf, tbuf, sz);
+ if ((act->mods_mask == 0) && (vmods_mask == 0))
+ return TRUE;
+ if ((act->mods_mask == XkbAllModifiersMask) &&
+ (vmods_mask == XkbAllVirtualModsMask)) {
+ tmp = XkbVModMaskText(xkb, act->mods, vmods, XkbXKBFile);
+ TryCopyStr(buf, ",mods=", sz);
+ TryCopyStr(buf, tmp, sz);
}
else {
- if ((act->mods_mask&act->mods)||(vmods_mask&vmods)) {
- tmp= XkbVModMaskText(xkb,act->mods_mask&act->mods,
- vmods_mask&vmods,XkbXKBFile);
- TryCopyStr(buf,",mods= ",sz);
- TryCopyStr(buf,tmp,sz);
- }
- if ((act->mods_mask&(~act->mods))||(vmods_mask&(~vmods))) {
- tmp= XkbVModMaskText(xkb,act->mods_mask&(~act->mods),
- vmods_mask&(~vmods),XkbXKBFile);
- TryCopyStr(buf,",clearMods= ",sz);
- TryCopyStr(buf,tmp,sz);
- }
+ if ((act->mods_mask & act->mods) || (vmods_mask & vmods)) {
+ tmp = XkbVModMaskText(xkb, act->mods_mask & act->mods,
+ vmods_mask & vmods, XkbXKBFile);
+ TryCopyStr(buf, ",mods= ", sz);
+ TryCopyStr(buf, tmp, sz);
+ }
+ if ((act->mods_mask & (~act->mods)) || (vmods_mask & (~vmods))) {
+ tmp = XkbVModMaskText(xkb, act->mods_mask & (~act->mods),
+ vmods_mask & (~vmods), XkbXKBFile);
+ TryCopyStr(buf, ",clearMods= ", sz);
+ TryCopyStr(buf, tmp, sz);
+ }
}
return TRUE;
}
-/*ARGSUSED*/
-static Bool
-CopyDeviceBtnArgs(XkbDescPtr xkb,XkbAction *action,char *buf,
- int *sz)
+ /*ARGSUSED*/ static Bool
+CopyDeviceBtnArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
{
-XkbDeviceBtnAction * act;
-char tbuf[32];
-
- act= &action->devbtn;
- snprintf(tbuf,sizeof(tbuf),"device= %d",act->device); TryCopyStr(buf,tbuf,sz);
- TryCopyStr(buf,",button=",sz);
- snprintf(tbuf,sizeof(tbuf),"%d",act->button);
- TryCopyStr(buf,tbuf,sz);
- if (act->count>0) {
- snprintf(tbuf,sizeof(tbuf),",count=%d",act->count);
- TryCopyStr(buf,tbuf,sz);
+ XkbDeviceBtnAction *act;
+ char tbuf[32];
+
+ act = &action->devbtn;
+ snprintf(tbuf, sizeof(tbuf), "device= %d", act->device);
+ TryCopyStr(buf, tbuf, sz);
+ TryCopyStr(buf, ",button=", sz);
+ snprintf(tbuf, sizeof(tbuf), "%d", act->button);
+ TryCopyStr(buf, tbuf, sz);
+ if (act->count > 0) {
+ snprintf(tbuf, sizeof(tbuf), ",count=%d", act->count);
+ TryCopyStr(buf, tbuf, sz);
}
- if (action->type==XkbSA_LockDeviceBtn) {
- switch (act->flags&(XkbSA_LockNoUnlock|XkbSA_LockNoLock)) {
- case XkbSA_LockNoLock:
- TryCopyStr(buf,",affect=unlock",sz); break;
- case XkbSA_LockNoUnlock:
- TryCopyStr(buf,",affect=lock",sz); break;
- case XkbSA_LockNoUnlock|XkbSA_LockNoLock:
- TryCopyStr(buf,",affect=neither",sz); break;
- default:
- TryCopyStr(buf,",affect=both",sz); break;
- }
+ if (action->type == XkbSA_LockDeviceBtn) {
+ switch (act->flags & (XkbSA_LockNoUnlock | XkbSA_LockNoLock)) {
+ case XkbSA_LockNoLock:
+ TryCopyStr(buf, ",affect=unlock", sz);
+ break;
+ case XkbSA_LockNoUnlock:
+ TryCopyStr(buf, ",affect=lock", sz);
+ break;
+ case XkbSA_LockNoUnlock | XkbSA_LockNoLock:
+ TryCopyStr(buf, ",affect=neither", sz);
+ break;
+ default:
+ TryCopyStr(buf, ",affect=both", sz);
+ break;
+ }
}
return TRUE;
}
-/*ARGSUSED*/
-static Bool
-CopyOtherArgs(XkbDescPtr xkb,XkbAction *action,char *buf,int *sz)
+ /*ARGSUSED*/ static Bool
+CopyOtherArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
{
-XkbAnyAction * act;
-char tbuf[32];
-
- act= &action->any;
- snprintf(tbuf,sizeof(tbuf),"type=0x%02x",act->type); TryCopyStr(buf,tbuf,sz);
- snprintf(tbuf,sizeof(tbuf),",data[0]=0x%02x",act->data[0]); TryCopyStr(buf,tbuf,sz);
- snprintf(tbuf,sizeof(tbuf),",data[1]=0x%02x",act->data[1]); TryCopyStr(buf,tbuf,sz);
- snprintf(tbuf,sizeof(tbuf),",data[2]=0x%02x",act->data[2]); TryCopyStr(buf,tbuf,sz);
- snprintf(tbuf,sizeof(tbuf),",data[3]=0x%02x",act->data[3]); TryCopyStr(buf,tbuf,sz);
- snprintf(tbuf,sizeof(tbuf),",data[4]=0x%02x",act->data[4]); TryCopyStr(buf,tbuf,sz);
- snprintf(tbuf,sizeof(tbuf),",data[5]=0x%02x",act->data[5]); TryCopyStr(buf,tbuf,sz);
- snprintf(tbuf,sizeof(tbuf),",data[6]=0x%02x",act->data[6]); TryCopyStr(buf,tbuf,sz);
+ XkbAnyAction *act;
+ char tbuf[32];
+
+ act = &action->any;
+ snprintf(tbuf, sizeof(tbuf), "type=0x%02x", act->type);
+ TryCopyStr(buf, tbuf, sz);
+ snprintf(tbuf, sizeof(tbuf), ",data[0]=0x%02x", act->data[0]);
+ TryCopyStr(buf, tbuf, sz);
+ snprintf(tbuf, sizeof(tbuf), ",data[1]=0x%02x", act->data[1]);
+ TryCopyStr(buf, tbuf, sz);
+ snprintf(tbuf, sizeof(tbuf), ",data[2]=0x%02x", act->data[2]);
+ TryCopyStr(buf, tbuf, sz);
+ snprintf(tbuf, sizeof(tbuf), ",data[3]=0x%02x", act->data[3]);
+ TryCopyStr(buf, tbuf, sz);
+ snprintf(tbuf, sizeof(tbuf), ",data[4]=0x%02x", act->data[4]);
+ TryCopyStr(buf, tbuf, sz);
+ snprintf(tbuf, sizeof(tbuf), ",data[5]=0x%02x", act->data[5]);
+ TryCopyStr(buf, tbuf, sz);
+ snprintf(tbuf, sizeof(tbuf), ",data[6]=0x%02x", act->data[6]);
+ TryCopyStr(buf, tbuf, sz);
return TRUE;
}
-typedef Bool (*actionCopy)(
- XkbDescPtr /* xkb */,
- XkbAction * /* action */,
- char * /* buf */,
- int* /* sz */
-);
-static actionCopy copyActionArgs[XkbSA_NumActions] = {
- CopyNoActionArgs /* NoAction */,
- CopyModActionArgs /* SetMods */,
- CopyModActionArgs /* LatchMods */,
- CopyModActionArgs /* LockMods */,
- CopyGroupActionArgs /* SetGroup */,
- CopyGroupActionArgs /* LatchGroup */,
- CopyGroupActionArgs /* LockGroup */,
- CopyMovePtrArgs /* MovePtr */,
- CopyPtrBtnArgs /* PtrBtn */,
- CopyPtrBtnArgs /* LockPtrBtn */,
- CopySetPtrDfltArgs /* SetPtrDflt */,
- CopyISOLockArgs /* ISOLock */,
- CopyNoActionArgs /* Terminate */,
- CopySwitchScreenArgs /* SwitchScreen */,
- CopySetLockControlsArgs /* SetControls */,
- CopySetLockControlsArgs /* LockControls */,
- CopyActionMessageArgs /* ActionMessage*/,
- CopyRedirectKeyArgs /* RedirectKey */,
- CopyDeviceBtnArgs /* DeviceBtn */,
- CopyDeviceBtnArgs /* LockDeviceBtn*/
+typedef Bool (*actionCopy) (XkbDescPtr /* xkb */ ,
+ XkbAction * /* action */ ,
+ char * /* buf */ ,
+ int * /* sz */
+ );
+
+static actionCopy copyActionArgs[XkbSA_NumActions] = {
+ CopyNoActionArgs /* NoAction */ ,
+ CopyModActionArgs /* SetMods */ ,
+ CopyModActionArgs /* LatchMods */ ,
+ CopyModActionArgs /* LockMods */ ,
+ CopyGroupActionArgs /* SetGroup */ ,
+ CopyGroupActionArgs /* LatchGroup */ ,
+ CopyGroupActionArgs /* LockGroup */ ,
+ CopyMovePtrArgs /* MovePtr */ ,
+ CopyPtrBtnArgs /* PtrBtn */ ,
+ CopyPtrBtnArgs /* LockPtrBtn */ ,
+ CopySetPtrDfltArgs /* SetPtrDflt */ ,
+ CopyISOLockArgs /* ISOLock */ ,
+ CopyNoActionArgs /* Terminate */ ,
+ CopySwitchScreenArgs /* SwitchScreen */ ,
+ CopySetLockControlsArgs /* SetControls */ ,
+ CopySetLockControlsArgs /* LockControls */ ,
+ CopyActionMessageArgs /* ActionMessage */ ,
+ CopyRedirectKeyArgs /* RedirectKey */ ,
+ CopyDeviceBtnArgs /* DeviceBtn */ ,
+ CopyDeviceBtnArgs /* LockDeviceBtn */
};
#define ACTION_SZ 256
char *
-XkbActionText(XkbDescPtr xkb,XkbAction *action,unsigned format)
+XkbActionText(XkbDescPtr xkb, XkbAction *action, unsigned format)
{
-char buf[ACTION_SZ],*tmp;
-int sz;
-
- if (format==XkbCFile) {
- snprintf(buf,sizeof(buf),
- "{ %20s, { 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x } }",
- XkbActionTypeText(action->type,XkbCFile),
- action->any.data[0],action->any.data[1],action->any.data[2],
- action->any.data[3],action->any.data[4],action->any.data[5],
- action->any.data[6]);
+ char buf[ACTION_SZ], *tmp;
+ int sz;
+
+ if (format == XkbCFile) {
+ snprintf(buf, sizeof(buf),
+ "{ %20s, { 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x } }",
+ XkbActionTypeText(action->type, XkbCFile),
+ action->any.data[0], action->any.data[1], action->any.data[2],
+ action->any.data[3], action->any.data[4], action->any.data[5],
+ action->any.data[6]);
}
else {
- snprintf(buf,sizeof(buf),"%s(",XkbActionTypeText(action->type,XkbXKBFile));
- sz= ACTION_SZ-strlen(buf)+2; /* room for close paren and NULL */
- if (action->type<(unsigned)XkbSA_NumActions)
- (*copyActionArgs[action->type])(xkb,action,buf,&sz);
- else CopyOtherArgs(xkb,action,buf,&sz);
- TryCopyStr(buf,")",&sz);
+ snprintf(buf, sizeof(buf), "%s(",
+ XkbActionTypeText(action->type, XkbXKBFile));
+ sz = ACTION_SZ - strlen(buf) + 2; /* room for close paren and NULL */
+ if (action->type < (unsigned) XkbSA_NumActions)
+ (*copyActionArgs[action->type]) (xkb, action, buf, &sz);
+ else
+ CopyOtherArgs(xkb, action, buf, &sz);
+ TryCopyStr(buf, ")", &sz);
}
- tmp= tbGetBuffer(strlen(buf)+1);
- if (tmp!=NULL)
- strcpy(tmp,buf);
+ tmp = tbGetBuffer(strlen(buf) + 1);
+ if (tmp != NULL)
+ strcpy(tmp, buf);
return tmp;
}
char *
-XkbBehaviorText(XkbDescPtr xkb,XkbBehavior *behavior,unsigned format)
+XkbBehaviorText(XkbDescPtr xkb, XkbBehavior * behavior, unsigned format)
{
-char buf[256],*tmp;
-
- if (format==XkbCFile) {
- if (behavior->type==XkbKB_Default)
- snprintf(buf,sizeof(buf),"{ 0, 0 }");
- else snprintf(buf,sizeof(buf),"{ %3d, 0x%02x }",behavior->type,behavior->data);
+ char buf[256], *tmp;
+
+ if (format == XkbCFile) {
+ if (behavior->type == XkbKB_Default)
+ snprintf(buf, sizeof(buf), "{ 0, 0 }");
+ else
+ snprintf(buf, sizeof(buf), "{ %3d, 0x%02x }", behavior->type,
+ behavior->data);
}
else {
- unsigned type,permanent;
- type= behavior->type&XkbKB_OpMask;
- permanent=((behavior->type&XkbKB_Permanent)!=0);
-
- if (type==XkbKB_Lock) {
- snprintf(buf,sizeof(buf),"lock= %s",(permanent?"Permanent":"TRUE"));
- }
- else if (type==XkbKB_RadioGroup) {
- int g;
- char *tmp;
- g= ((behavior->data)&(~XkbKB_RGAllowNone))+1;
- if (XkbKB_RGAllowNone&behavior->data) {
- snprintf(buf,sizeof(buf),"allowNone,");
- tmp= &buf[strlen(buf)];
- }
- else tmp= buf;
- if (permanent)
- sprintf(tmp,"permanentRadioGroup= %d",g);
- else sprintf(tmp,"radioGroup= %d",g);
- }
- else if ((type==XkbKB_Overlay1)||(type==XkbKB_Overlay2)) {
- int ndx,kc;
- char *kn;
-
- ndx= ((type==XkbKB_Overlay1)?1:2);
- kc= behavior->data;
- if ((xkb)&&(xkb->names)&&(xkb->names->keys))
- kn= XkbKeyNameText(xkb->names->keys[kc].name,XkbXKBFile);
- else {
- static char tbuf[8];
- snprintf(tbuf,sizeof(tbuf),"%d",kc);
- kn= tbuf;
- }
- if (permanent)
- snprintf(buf,sizeof(buf),"permanentOverlay%d= %s",ndx,kn);
- else snprintf(buf,sizeof(buf),"overlay%d= %s",ndx,kn);
- }
+ unsigned type, permanent;
+
+ type = behavior->type & XkbKB_OpMask;
+ permanent = ((behavior->type & XkbKB_Permanent) != 0);
+
+ if (type == XkbKB_Lock) {
+ snprintf(buf, sizeof(buf), "lock= %s",
+ (permanent ? "Permanent" : "TRUE"));
+ }
+ else if (type == XkbKB_RadioGroup) {
+ int g;
+ char *tmp;
+
+ g = ((behavior->data) & (~XkbKB_RGAllowNone)) + 1;
+ if (XkbKB_RGAllowNone & behavior->data) {
+ snprintf(buf, sizeof(buf), "allowNone,");
+ tmp = &buf[strlen(buf)];
+ }
+ else
+ tmp = buf;
+ if (permanent)
+ sprintf(tmp, "permanentRadioGroup= %d", g);
+ else
+ sprintf(tmp, "radioGroup= %d", g);
+ }
+ else if ((type == XkbKB_Overlay1) || (type == XkbKB_Overlay2)) {
+ int ndx, kc;
+ char *kn;
+
+ ndx = ((type == XkbKB_Overlay1) ? 1 : 2);
+ kc = behavior->data;
+ if ((xkb) && (xkb->names) && (xkb->names->keys))
+ kn = XkbKeyNameText(xkb->names->keys[kc].name, XkbXKBFile);
+ else {
+ static char tbuf[8];
+
+ snprintf(tbuf, sizeof(tbuf), "%d", kc);
+ kn = tbuf;
+ }
+ if (permanent)
+ snprintf(buf, sizeof(buf), "permanentOverlay%d= %s", ndx, kn);
+ else
+ snprintf(buf, sizeof(buf), "overlay%d= %s", ndx, kn);
+ }
}
- tmp= tbGetBuffer(strlen(buf)+1);
- if (tmp!=NULL)
- strcpy(tmp,buf);
+ tmp = tbGetBuffer(strlen(buf) + 1);
+ if (tmp != NULL)
+ strcpy(tmp, buf);
return tmp;
}
@@ -1214,15 +1311,15 @@ char buf[256],*tmp;
char *
XkbIndentText(unsigned size)
{
-static char buf[32];
-register int i;
+ static char buf[32];
+ register int i;
- if (size>31)
- size= 31;
+ if (size > 31)
+ size = 31;
- for (i=0;i<size;i++) {
- buf[i]= ' ';
+ for (i = 0; i < size; i++) {
+ buf[i] = ' ';
}
- buf[size]= '\0';
+ buf[size] = '\0';
return buf;
}
diff --git a/xkb/xkmread.c b/xkb/xkmread.c
index a5c1ecfff..45da965dc 100644
--- a/xkb/xkmread.c
+++ b/xkb/xkmread.c
@@ -44,34 +44,36 @@
#include "xkbgeom.h"
Atom
-XkbInternAtom(char *str,Bool only_if_exists)
+XkbInternAtom(char *str, Bool only_if_exists)
{
- if (str==NULL)
- return None;
- return MakeAtom(str,strlen(str),!only_if_exists);
+ if (str == NULL)
+ return None;
+ return MakeAtom(str, strlen(str), !only_if_exists);
}
/***====================================================================***/
static void *
-XkmInsureSize(void *oldPtr,int oldCount,int *newCountRtrn,int elemSize)
+XkmInsureSize(void *oldPtr, int oldCount, int *newCountRtrn, int elemSize)
{
-int newCount= *newCountRtrn;
+ int newCount = *newCountRtrn;
- if (oldPtr==NULL) {
- if (newCount==0)
- return NULL;
- oldPtr= calloc(newCount,elemSize);
+ if (oldPtr == NULL) {
+ if (newCount == 0)
+ return NULL;
+ oldPtr = calloc(newCount, elemSize);
}
- else if (oldCount<newCount) {
- oldPtr= realloc(oldPtr,newCount*elemSize);
- if (oldPtr!=NULL) {
- char *tmp= (char *)oldPtr;
- memset(&tmp[oldCount*elemSize], 0, (newCount-oldCount)*elemSize);
- }
+ else if (oldCount < newCount) {
+ oldPtr = realloc(oldPtr, newCount * elemSize);
+ if (oldPtr != NULL) {
+ char *tmp = (char *) oldPtr;
+
+ memset(&tmp[oldCount * elemSize], 0,
+ (newCount - oldCount) * elemSize);
+ }
}
- else if (newCount<oldCount) {
- *newCountRtrn= oldCount;
+ else if (newCount < oldCount) {
+ *newCountRtrn = oldCount;
}
return oldPtr;
}
@@ -79,114 +81,120 @@ int newCount= *newCountRtrn;
#define XkmInsureTypedSize(p,o,n,t) ((p)=((t *)XkmInsureSize((char *)(p),(o),(n),sizeof(t))))
static CARD8
-XkmGetCARD8(FILE *file,int *pNRead)
+XkmGetCARD8(FILE * file, int *pNRead)
{
-int tmp;
- tmp= getc(file);
- if (pNRead&&(tmp!=EOF))
- (*pNRead)+= 1;
+ int tmp;
+
+ tmp = getc(file);
+ if (pNRead && (tmp != EOF))
+ (*pNRead) += 1;
return tmp;
}
static CARD16
-XkmGetCARD16(FILE *file,int *pNRead)
+XkmGetCARD16(FILE * file, int *pNRead)
{
-CARD16 val;
+ CARD16 val;
- if ((fread(&val,2,1,file)==1)&&(pNRead))
- (*pNRead)+= 2;
+ if ((fread(&val, 2, 1, file) == 1) && (pNRead))
+ (*pNRead) += 2;
return val;
}
static CARD32
-XkmGetCARD32(FILE *file,int *pNRead)
+XkmGetCARD32(FILE * file, int *pNRead)
{
-CARD32 val;
+ CARD32 val;
- if ((fread(&val,4,1,file)==1)&&(pNRead))
- (*pNRead)+= 4;
+ if ((fread(&val, 4, 1, file) == 1) && (pNRead))
+ (*pNRead) += 4;
return val;
}
static int
-XkmSkipPadding(FILE *file,unsigned pad)
+XkmSkipPadding(FILE * file, unsigned pad)
{
-register int i,nRead=0;
+ register int i, nRead = 0;
- for (i=0;i<pad;i++) {
- if (getc(file)!=EOF)
- nRead++;
+ for (i = 0; i < pad; i++) {
+ if (getc(file) != EOF)
+ nRead++;
}
return nRead;
}
static int
-XkmGetCountedString(FILE *file,char *str,int max_len)
+XkmGetCountedString(FILE * file, char *str, int max_len)
{
-int count,nRead=0;
-
- count= XkmGetCARD16(file,&nRead);
- if (count>0) {
- int tmp;
- if (count>max_len) {
- tmp= fread(str,1,max_len,file);
- while (tmp<count) {
- if ((getc(file))!=EOF)
- tmp++;
- else break;
- }
- }
- else {
- tmp= fread(str,1,count,file);
- }
- nRead+= tmp;
+ int count, nRead = 0;
+
+ count = XkmGetCARD16(file, &nRead);
+ if (count > 0) {
+ int tmp;
+
+ if (count > max_len) {
+ tmp = fread(str, 1, max_len, file);
+ while (tmp < count) {
+ if ((getc(file)) != EOF)
+ tmp++;
+ else
+ break;
+ }
+ }
+ else {
+ tmp = fread(str, 1, count, file);
+ }
+ nRead += tmp;
}
- if (count>=max_len) str[max_len-1]= '\0';
- else str[count]= '\0';
- count= XkbPaddedSize(nRead)-nRead;
- if (count>0)
- nRead+= XkmSkipPadding(file,count);
+ if (count >= max_len)
+ str[max_len - 1] = '\0';
+ else
+ str[count] = '\0';
+ count = XkbPaddedSize(nRead) - nRead;
+ if (count > 0)
+ nRead += XkmSkipPadding(file, count);
return nRead;
}
/***====================================================================***/
static int
-ReadXkmVirtualMods(FILE *file,XkbDescPtr xkb,XkbChangesPtr changes)
+ReadXkmVirtualMods(FILE * file, XkbDescPtr xkb, XkbChangesPtr changes)
{
-register unsigned int i,bit;
-unsigned int bound,named,tmp;
-int nRead=0;
+ register unsigned int i, bit;
+ unsigned int bound, named, tmp;
+ int nRead = 0;
- if (XkbAllocServerMap(xkb,XkbVirtualModsMask,0)!=Success) {
- _XkbLibError(_XkbErrBadAlloc,"ReadXkmVirtualMods",0);
- return -1;
+ if (XkbAllocServerMap(xkb, XkbVirtualModsMask, 0) != Success) {
+ _XkbLibError(_XkbErrBadAlloc, "ReadXkmVirtualMods", 0);
+ return -1;
}
- bound= XkmGetCARD16(file,&nRead);
- named= XkmGetCARD16(file,&nRead);
- for (i=tmp=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
- if (bound&bit) {
- xkb->server->vmods[i]= XkmGetCARD8(file,&nRead);
- if (changes)
- changes->map.vmods|= bit;
- tmp++;
- }
+ bound = XkmGetCARD16(file, &nRead);
+ named = XkmGetCARD16(file, &nRead);
+ for (i = tmp = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+ if (bound & bit) {
+ xkb->server->vmods[i] = XkmGetCARD8(file, &nRead);
+ if (changes)
+ changes->map.vmods |= bit;
+ tmp++;
+ }
}
- if ((i= XkbPaddedSize(tmp)-tmp)>0)
- nRead+= XkmSkipPadding(file,i);
- if (XkbAllocNames(xkb,XkbVirtualModNamesMask,0,0)!=Success) {
- _XkbLibError(_XkbErrBadAlloc,"ReadXkmVirtualMods",0);
- return -1;
+ if ((i = XkbPaddedSize(tmp) - tmp) > 0)
+ nRead += XkmSkipPadding(file, i);
+ if (XkbAllocNames(xkb, XkbVirtualModNamesMask, 0, 0) != Success) {
+ _XkbLibError(_XkbErrBadAlloc, "ReadXkmVirtualMods", 0);
+ return -1;
}
- for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
- char name[100];
- if (named&bit) {
- if (nRead+=XkmGetCountedString(file,name,100)) {
- xkb->names->vmods[i]= XkbInternAtom(name,FALSE);
- if (changes)
- changes->names.changed_vmods|= bit;
- }
- }
+ for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+ char name[100];
+
+ if (named & bit) {
+ if (nRead += XkmGetCountedString(file, name, 100)) {
+ xkb->names->vmods[i] = XkbInternAtom(name, FALSE);
+ if (changes)
+ changes->names.changed_vmods |= bit;
+ }
+ }
}
return nRead;
}
@@ -194,200 +202,208 @@ int nRead=0;
/***====================================================================***/
static int
-ReadXkmKeycodes(FILE *file,XkbDescPtr xkb,XkbChangesPtr changes)
+ReadXkmKeycodes(FILE * file, XkbDescPtr xkb, XkbChangesPtr changes)
{
-register int i;
-unsigned minKC,maxKC,nAl;
-int nRead=0;
-char name[100];
-XkbKeyNamePtr pN;
-
- name[0]= '\0';
- nRead+= XkmGetCountedString(file,name,100);
- minKC= XkmGetCARD8(file,&nRead);
- maxKC= XkmGetCARD8(file,&nRead);
- if (xkb->min_key_code==0) {
- xkb->min_key_code= minKC;
- xkb->max_key_code= maxKC;
+ register int i;
+ unsigned minKC, maxKC, nAl;
+ int nRead = 0;
+ char name[100];
+ XkbKeyNamePtr pN;
+
+ name[0] = '\0';
+ nRead += XkmGetCountedString(file, name, 100);
+ minKC = XkmGetCARD8(file, &nRead);
+ maxKC = XkmGetCARD8(file, &nRead);
+ if (xkb->min_key_code == 0) {
+ xkb->min_key_code = minKC;
+ xkb->max_key_code = maxKC;
}
else {
- if (minKC<xkb->min_key_code)
- xkb->min_key_code= minKC;
- if (maxKC>xkb->max_key_code) {
- _XkbLibError(_XkbErrBadValue,"ReadXkmKeycodes",maxKC);
- return -1;
- }
+ if (minKC < xkb->min_key_code)
+ xkb->min_key_code = minKC;
+ if (maxKC > xkb->max_key_code) {
+ _XkbLibError(_XkbErrBadValue, "ReadXkmKeycodes", maxKC);
+ return -1;
+ }
}
- nAl= XkmGetCARD8(file,&nRead);
- nRead+= XkmSkipPadding(file,1);
+ nAl = XkmGetCARD8(file, &nRead);
+ nRead += XkmSkipPadding(file, 1);
#define WANTED (XkbKeycodesNameMask|XkbKeyNamesMask|XkbKeyAliasesMask)
- if (XkbAllocNames(xkb,WANTED,0,nAl)!=Success) {
- _XkbLibError(_XkbErrBadAlloc,"ReadXkmKeycodes",0);
- return -1;
+ if (XkbAllocNames(xkb, WANTED, 0, nAl) != Success) {
+ _XkbLibError(_XkbErrBadAlloc, "ReadXkmKeycodes", 0);
+ return -1;
}
- if (name[0]!='\0') {
- xkb->names->keycodes= XkbInternAtom(name,FALSE);
+ if (name[0] != '\0') {
+ xkb->names->keycodes = XkbInternAtom(name, FALSE);
}
- for (pN=&xkb->names->keys[minKC],i=minKC;i<=(int)maxKC;i++,pN++) {
- if (fread(pN,1,XkbKeyNameLength,file)!=XkbKeyNameLength) {
- _XkbLibError(_XkbErrBadLength,"ReadXkmKeycodes",0);
- return -1;
- }
- nRead+= XkbKeyNameLength;
+ for (pN = &xkb->names->keys[minKC], i = minKC; i <= (int) maxKC; i++, pN++) {
+ if (fread(pN, 1, XkbKeyNameLength, file) != XkbKeyNameLength) {
+ _XkbLibError(_XkbErrBadLength, "ReadXkmKeycodes", 0);
+ return -1;
+ }
+ nRead += XkbKeyNameLength;
}
- if (nAl>0) {
- XkbKeyAliasPtr pAl;
- for (pAl= xkb->names->key_aliases,i=0;i<nAl;i++,pAl++) {
- int tmp;
- tmp= fread(pAl,1,2*XkbKeyNameLength,file);
- if (tmp!=2*XkbKeyNameLength) {
- _XkbLibError(_XkbErrBadLength,"ReadXkmKeycodes",0);
- return -1;
- }
- nRead+= 2*XkbKeyNameLength;
- }
- if (changes)
- changes->names.changed|= XkbKeyAliasesMask;
+ if (nAl > 0) {
+ XkbKeyAliasPtr pAl;
+
+ for (pAl = xkb->names->key_aliases, i = 0; i < nAl; i++, pAl++) {
+ int tmp;
+
+ tmp = fread(pAl, 1, 2 * XkbKeyNameLength, file);
+ if (tmp != 2 * XkbKeyNameLength) {
+ _XkbLibError(_XkbErrBadLength, "ReadXkmKeycodes", 0);
+ return -1;
+ }
+ nRead += 2 * XkbKeyNameLength;
+ }
+ if (changes)
+ changes->names.changed |= XkbKeyAliasesMask;
}
if (changes)
- changes->names.changed|= XkbKeyNamesMask;
+ changes->names.changed |= XkbKeyNamesMask;
return nRead;
}
/***====================================================================***/
static int
-ReadXkmKeyTypes(FILE *file,XkbDescPtr xkb,XkbChangesPtr changes)
+ReadXkmKeyTypes(FILE * file, XkbDescPtr xkb, XkbChangesPtr changes)
{
-register unsigned i,n;
-unsigned num_types;
-int nRead=0;
-int tmp;
-XkbKeyTypePtr type;
-xkmKeyTypeDesc wire;
-XkbKTMapEntryPtr entry;
-xkmKTMapEntryDesc wire_entry;
-char buf[100];
-
- if ((tmp= XkmGetCountedString(file,buf,100))<1) {
- _XkbLibError(_XkbErrBadLength,"ReadXkmKeyTypes",0);
- return -1;
- }
- nRead+= tmp;
- if (buf[0]!='\0') {
- if (XkbAllocNames(xkb,XkbTypesNameMask,0,0)!=Success) {
- _XkbLibError(_XkbErrBadAlloc,"ReadXkmKeyTypes",0);
- return -1;
+ register unsigned i, n;
+ unsigned num_types;
+ int nRead = 0;
+ int tmp;
+ XkbKeyTypePtr type;
+ xkmKeyTypeDesc wire;
+ XkbKTMapEntryPtr entry;
+ xkmKTMapEntryDesc wire_entry;
+ char buf[100];
+
+ if ((tmp = XkmGetCountedString(file, buf, 100)) < 1) {
+ _XkbLibError(_XkbErrBadLength, "ReadXkmKeyTypes", 0);
+ return -1;
+ }
+ nRead += tmp;
+ if (buf[0] != '\0') {
+ if (XkbAllocNames(xkb, XkbTypesNameMask, 0, 0) != Success) {
+ _XkbLibError(_XkbErrBadAlloc, "ReadXkmKeyTypes", 0);
+ return -1;
}
- xkb->names->types= XkbInternAtom(buf,FALSE);
+ xkb->names->types = XkbInternAtom(buf, FALSE);
}
- num_types= XkmGetCARD16(file,&nRead);
- nRead+= XkmSkipPadding(file,2);
- if (num_types<1)
- return nRead;
- if (XkbAllocClientMap(xkb,XkbKeyTypesMask,num_types)!=Success) {
- _XkbLibError(_XkbErrBadAlloc,"ReadXkmKeyTypes",0);
- return nRead;
+ num_types = XkmGetCARD16(file, &nRead);
+ nRead += XkmSkipPadding(file, 2);
+ if (num_types < 1)
+ return nRead;
+ if (XkbAllocClientMap(xkb, XkbKeyTypesMask, num_types) != Success) {
+ _XkbLibError(_XkbErrBadAlloc, "ReadXkmKeyTypes", 0);
+ return nRead;
}
- xkb->map->num_types= num_types;
- if (num_types<XkbNumRequiredTypes) {
- _XkbLibError(_XkbErrMissingReqTypes,"ReadXkmKeyTypes",0);
- return -1;
+ xkb->map->num_types = num_types;
+ if (num_types < XkbNumRequiredTypes) {
+ _XkbLibError(_XkbErrMissingReqTypes, "ReadXkmKeyTypes", 0);
+ return -1;
}
- type= xkb->map->types;
- for (i=0;i<num_types;i++,type++) {
- if ((int)fread(&wire,SIZEOF(xkmKeyTypeDesc),1,file)<1) {
- _XkbLibError(_XkbErrBadLength,"ReadXkmKeyTypes",0);
- return -1;
- }
- nRead+= SIZEOF(xkmKeyTypeDesc);
- if (((i==XkbOneLevelIndex)&&(wire.numLevels!=1))||
- (((i==XkbTwoLevelIndex)||(i==XkbAlphabeticIndex)||
- ((i)==XkbKeypadIndex))&&(wire.numLevels!=2))) {
- _XkbLibError(_XkbErrBadTypeWidth,"ReadXkmKeyTypes",i);
- return -1;
- }
- tmp= wire.nMapEntries;
- XkmInsureTypedSize(type->map,type->map_count,&tmp,XkbKTMapEntryRec);
- if ((wire.nMapEntries>0)&&(type->map==NULL)) {
- _XkbLibError(_XkbErrBadValue,"ReadXkmKeyTypes",wire.nMapEntries);
- return -1;
- }
- for (n=0,entry= type->map;n<wire.nMapEntries;n++,entry++) {
- if (fread(&wire_entry,SIZEOF(xkmKTMapEntryDesc),1,file)<(int)1) {
- _XkbLibError(_XkbErrBadLength,"ReadXkmKeyTypes",0);
- return -1;
- }
- nRead+= SIZEOF(xkmKTMapEntryDesc);
- entry->active= (wire_entry.virtualMods==0);
- entry->level= wire_entry.level;
- entry->mods.mask= wire_entry.realMods;
- entry->mods.real_mods= wire_entry.realMods;
- entry->mods.vmods= wire_entry.virtualMods;
- }
- nRead+= XkmGetCountedString(file,buf,100);
- if (((i==XkbOneLevelIndex)&&(strcmp(buf,"ONE_LEVEL")!=0))||
- ((i==XkbTwoLevelIndex)&&(strcmp(buf,"TWO_LEVEL")!=0))||
- ((i==XkbAlphabeticIndex)&&(strcmp(buf,"ALPHABETIC")!=0))||
- ((i==XkbKeypadIndex)&&(strcmp(buf,"KEYPAD")!=0))) {
- _XkbLibError(_XkbErrBadTypeName,"ReadXkmKeyTypes",0);
- return -1;
- }
- if (buf[0]!='\0') {
- type->name= XkbInternAtom(buf,FALSE);
- }
- else type->name= None;
-
- if (wire.preserve) {
- xkmModsDesc p_entry;
- XkbModsPtr pre;
- XkmInsureTypedSize(type->preserve,type->map_count,&tmp,
- XkbModsRec);
- if (type->preserve==NULL) {
- _XkbLibError(_XkbErrBadMatch,"ReadXkmKeycodes",0);
- return -1;
- }
- for (n=0,pre=type->preserve;n<wire.nMapEntries;n++,pre++) {
- if (fread(&p_entry,SIZEOF(xkmModsDesc),1,file)<1) {
- _XkbLibError(_XkbErrBadLength,"ReadXkmKeycodes",0);
- return -1;
- }
- nRead+= SIZEOF(xkmModsDesc);
- pre->mask= p_entry.realMods;
- pre->real_mods= p_entry.realMods;
- pre->vmods= p_entry.virtualMods;
- }
- }
- if (wire.nLevelNames>0) {
- int width= wire.numLevels;
- if (wire.nLevelNames>(unsigned)width) {
- _XkbLibError(_XkbErrBadMatch,"ReadXkmKeycodes",0);
- return -1;
- }
- XkmInsureTypedSize(type->level_names,type->num_levels,&width,Atom);
- if (type->level_names!=NULL) {
- for (n=0;n<wire.nLevelNames;n++) {
- if ((tmp=XkmGetCountedString(file,buf,100))<1)
- return -1;
- nRead+= tmp;
- if (strlen(buf)==0)
- type->level_names[n]= None;
- else type->level_names[n]= XkbInternAtom(buf,0);
- }
- }
- }
- type->mods.mask= wire.realMods;
- type->mods.real_mods= wire.realMods;
- type->mods.vmods= wire.virtualMods;
- type->num_levels= wire.numLevels;
- type->map_count= wire.nMapEntries;
+ type = xkb->map->types;
+ for (i = 0; i < num_types; i++, type++) {
+ if ((int) fread(&wire, SIZEOF(xkmKeyTypeDesc), 1, file) < 1) {
+ _XkbLibError(_XkbErrBadLength, "ReadXkmKeyTypes", 0);
+ return -1;
+ }
+ nRead += SIZEOF(xkmKeyTypeDesc);
+ if (((i == XkbOneLevelIndex) && (wire.numLevels != 1)) ||
+ (((i == XkbTwoLevelIndex) || (i == XkbAlphabeticIndex) ||
+ ((i) == XkbKeypadIndex)) && (wire.numLevels != 2))) {
+ _XkbLibError(_XkbErrBadTypeWidth, "ReadXkmKeyTypes", i);
+ return -1;
+ }
+ tmp = wire.nMapEntries;
+ XkmInsureTypedSize(type->map, type->map_count, &tmp, XkbKTMapEntryRec);
+ if ((wire.nMapEntries > 0) && (type->map == NULL)) {
+ _XkbLibError(_XkbErrBadValue, "ReadXkmKeyTypes", wire.nMapEntries);
+ return -1;
+ }
+ for (n = 0, entry = type->map; n < wire.nMapEntries; n++, entry++) {
+ if (fread(&wire_entry, SIZEOF(xkmKTMapEntryDesc), 1, file) <
+ (int) 1) {
+ _XkbLibError(_XkbErrBadLength, "ReadXkmKeyTypes", 0);
+ return -1;
+ }
+ nRead += SIZEOF(xkmKTMapEntryDesc);
+ entry->active = (wire_entry.virtualMods == 0);
+ entry->level = wire_entry.level;
+ entry->mods.mask = wire_entry.realMods;
+ entry->mods.real_mods = wire_entry.realMods;
+ entry->mods.vmods = wire_entry.virtualMods;
+ }
+ nRead += XkmGetCountedString(file, buf, 100);
+ if (((i == XkbOneLevelIndex) && (strcmp(buf, "ONE_LEVEL") != 0)) ||
+ ((i == XkbTwoLevelIndex) && (strcmp(buf, "TWO_LEVEL") != 0)) ||
+ ((i == XkbAlphabeticIndex) && (strcmp(buf, "ALPHABETIC") != 0)) ||
+ ((i == XkbKeypadIndex) && (strcmp(buf, "KEYPAD") != 0))) {
+ _XkbLibError(_XkbErrBadTypeName, "ReadXkmKeyTypes", 0);
+ return -1;
+ }
+ if (buf[0] != '\0') {
+ type->name = XkbInternAtom(buf, FALSE);
+ }
+ else
+ type->name = None;
+
+ if (wire.preserve) {
+ xkmModsDesc p_entry;
+ XkbModsPtr pre;
+
+ XkmInsureTypedSize(type->preserve, type->map_count, &tmp,
+ XkbModsRec);
+ if (type->preserve == NULL) {
+ _XkbLibError(_XkbErrBadMatch, "ReadXkmKeycodes", 0);
+ return -1;
+ }
+ for (n = 0, pre = type->preserve; n < wire.nMapEntries; n++, pre++) {
+ if (fread(&p_entry, SIZEOF(xkmModsDesc), 1, file) < 1) {
+ _XkbLibError(_XkbErrBadLength, "ReadXkmKeycodes", 0);
+ return -1;
+ }
+ nRead += SIZEOF(xkmModsDesc);
+ pre->mask = p_entry.realMods;
+ pre->real_mods = p_entry.realMods;
+ pre->vmods = p_entry.virtualMods;
+ }
+ }
+ if (wire.nLevelNames > 0) {
+ int width = wire.numLevels;
+
+ if (wire.nLevelNames > (unsigned) width) {
+ _XkbLibError(_XkbErrBadMatch, "ReadXkmKeycodes", 0);
+ return -1;
+ }
+ XkmInsureTypedSize(type->level_names, type->num_levels, &width,
+ Atom);
+ if (type->level_names != NULL) {
+ for (n = 0; n < wire.nLevelNames; n++) {
+ if ((tmp = XkmGetCountedString(file, buf, 100)) < 1)
+ return -1;
+ nRead += tmp;
+ if (strlen(buf) == 0)
+ type->level_names[n] = None;
+ else
+ type->level_names[n] = XkbInternAtom(buf, 0);
+ }
+ }
+ }
+ type->mods.mask = wire.realMods;
+ type->mods.real_mods = wire.realMods;
+ type->mods.vmods = wire.virtualMods;
+ type->num_levels = wire.numLevels;
+ type->map_count = wire.nMapEntries;
}
if (changes) {
- changes->map.changed|= XkbKeyTypesMask;
- changes->map.first_type= 0;
- changes->map.num_types= xkb->map->num_types;
+ changes->map.changed |= XkbKeyTypesMask;
+ changes->map.first_type = 0;
+ changes->map.num_types = xkb->map->num_types;
}
return nRead;
}
@@ -395,47 +411,47 @@ char buf[100];
/***====================================================================***/
static int
-ReadXkmCompatMap(FILE *file,XkbDescPtr xkb,XkbChangesPtr changes)
+ReadXkmCompatMap(FILE * file, XkbDescPtr xkb, XkbChangesPtr changes)
{
-register int i;
-unsigned num_si,groups;
-char name[100];
-XkbSymInterpretPtr interp;
-xkmSymInterpretDesc wire;
-unsigned tmp;
-int nRead=0;
-XkbCompatMapPtr compat;
-XkbAction *act;
-
- if ((tmp= XkmGetCountedString(file,name,100))<1) {
- _XkbLibError(_XkbErrBadLength,"ReadXkmCompatMap",0);
- return -1;
+ register int i;
+ unsigned num_si, groups;
+ char name[100];
+ XkbSymInterpretPtr interp;
+ xkmSymInterpretDesc wire;
+ unsigned tmp;
+ int nRead = 0;
+ XkbCompatMapPtr compat;
+ XkbAction *act;
+
+ if ((tmp = XkmGetCountedString(file, name, 100)) < 1) {
+ _XkbLibError(_XkbErrBadLength, "ReadXkmCompatMap", 0);
+ return -1;
}
- nRead+= tmp;
- if (name[0]!='\0') {
- if (XkbAllocNames(xkb,XkbCompatNameMask,0,0)!=Success) {
- _XkbLibError(_XkbErrBadAlloc,"ReadXkmCompatMap",0);
- return -1;
- }
- xkb->names->compat= XkbInternAtom(name,FALSE);
+ nRead += tmp;
+ if (name[0] != '\0') {
+ if (XkbAllocNames(xkb, XkbCompatNameMask, 0, 0) != Success) {
+ _XkbLibError(_XkbErrBadAlloc, "ReadXkmCompatMap", 0);
+ return -1;
+ }
+ xkb->names->compat = XkbInternAtom(name, FALSE);
}
- num_si= XkmGetCARD16(file,&nRead);
- groups= XkmGetCARD8(file,&nRead);
- nRead+= XkmSkipPadding(file,1);
- if (XkbAllocCompatMap(xkb,XkbAllCompatMask,num_si)!=Success)
- return -1;
- compat= xkb->compat;
- compat->num_si= 0;
- interp= compat->sym_interpret;
- for (i=0;i<num_si;i++) {
- tmp= fread(&wire,SIZEOF(xkmSymInterpretDesc),1,file);
- nRead+= tmp*SIZEOF(xkmSymInterpretDesc);
- interp->sym= wire.sym;
- interp->mods= wire.mods;
- interp->match= wire.match;
- interp->virtual_mod= wire.virtualMod;
- interp->flags= wire.flags;
- interp->act.type= wire.actionType;
+ num_si = XkmGetCARD16(file, &nRead);
+ groups = XkmGetCARD8(file, &nRead);
+ nRead += XkmSkipPadding(file, 1);
+ if (XkbAllocCompatMap(xkb, XkbAllCompatMask, num_si) != Success)
+ return -1;
+ compat = xkb->compat;
+ compat->num_si = 0;
+ interp = compat->sym_interpret;
+ for (i = 0; i < num_si; i++) {
+ tmp = fread(&wire, SIZEOF(xkmSymInterpretDesc), 1, file);
+ nRead += tmp * SIZEOF(xkmSymInterpretDesc);
+ interp->sym = wire.sym;
+ interp->mods = wire.mods;
+ interp->match = wire.match;
+ interp->virtual_mod = wire.virtualMod;
+ interp->flags = wire.flags;
+ interp->act.type = wire.actionType;
act = (XkbAction *) &interp->act;
switch (interp->act.type) {
@@ -545,7 +561,7 @@ XkbAction *act;
}
/* copy the kind of action */
memcpy(act->any.data, wire.actionData, XkbAnyActionDataSize);
- break ;
+ break;
case XkbSA_Terminate:
/* no args, kinda (note: untrue for xfree86). */
@@ -557,624 +573,648 @@ XkbAction *act;
interp++;
compat->num_si++;
}
- if ((num_si>0)&&(changes)) {
- changes->compat.first_si= 0;
- changes->compat.num_si= compat->num_si;
+ if ((num_si > 0) && (changes)) {
+ changes->compat.first_si = 0;
+ changes->compat.num_si = compat->num_si;
}
if (groups) {
- register unsigned bit;
- for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
- xkmModsDesc md;
- if (groups&bit) {
- tmp= fread(&md,SIZEOF(xkmModsDesc),1,file);
- nRead+= tmp*SIZEOF(xkmModsDesc);
- xkb->compat->groups[i].real_mods= md.realMods;
- xkb->compat->groups[i].vmods= md.virtualMods;
- if (md.virtualMods != 0) {
- unsigned mask;
- if (XkbVirtualModsToReal(xkb,md.virtualMods,&mask))
- xkb->compat->groups[i].mask= md.realMods|mask;
- }
- else xkb->compat->groups[i].mask= md.realMods;
- }
- }
- if (changes)
- changes->compat.changed_groups|= groups;
+ register unsigned bit;
+
+ for (i = 0, bit = 1; i < XkbNumKbdGroups; i++, bit <<= 1) {
+ xkmModsDesc md;
+
+ if (groups & bit) {
+ tmp = fread(&md, SIZEOF(xkmModsDesc), 1, file);
+ nRead += tmp * SIZEOF(xkmModsDesc);
+ xkb->compat->groups[i].real_mods = md.realMods;
+ xkb->compat->groups[i].vmods = md.virtualMods;
+ if (md.virtualMods != 0) {
+ unsigned mask;
+
+ if (XkbVirtualModsToReal(xkb, md.virtualMods, &mask))
+ xkb->compat->groups[i].mask = md.realMods | mask;
+ }
+ else
+ xkb->compat->groups[i].mask = md.realMods;
+ }
+ }
+ if (changes)
+ changes->compat.changed_groups |= groups;
}
return nRead;
}
static int
-ReadXkmIndicators(FILE *file,XkbDescPtr xkb,XkbChangesPtr changes)
+ReadXkmIndicators(FILE * file, XkbDescPtr xkb, XkbChangesPtr changes)
{
-register unsigned nLEDs;
-xkmIndicatorMapDesc wire;
-char buf[100];
-unsigned tmp;
-int nRead=0;
-
- if ((xkb->indicators==NULL)&&(XkbAllocIndicatorMaps(xkb)!=Success)) {
- _XkbLibError(_XkbErrBadAlloc,"indicator rec",0);
- return -1;
+ register unsigned nLEDs;
+ xkmIndicatorMapDesc wire;
+ char buf[100];
+ unsigned tmp;
+ int nRead = 0;
+
+ if ((xkb->indicators == NULL) && (XkbAllocIndicatorMaps(xkb) != Success)) {
+ _XkbLibError(_XkbErrBadAlloc, "indicator rec", 0);
+ return -1;
}
- if (XkbAllocNames(xkb,XkbIndicatorNamesMask,0,0)!=Success) {
- _XkbLibError(_XkbErrBadAlloc,"indicator names",0);
- return -1;
+ if (XkbAllocNames(xkb, XkbIndicatorNamesMask, 0, 0) != Success) {
+ _XkbLibError(_XkbErrBadAlloc, "indicator names", 0);
+ return -1;
}
- nLEDs= XkmGetCARD8(file,&nRead);
- nRead+= XkmSkipPadding(file,3);
- xkb->indicators->phys_indicators= XkmGetCARD32(file,&nRead);
- while (nLEDs-->0) {
- Atom name;
- XkbIndicatorMapPtr map;
-
- if ((tmp=XkmGetCountedString(file,buf,100))<1) {
- _XkbLibError(_XkbErrBadLength,"ReadXkmIndicators",0);
- return -1;
- }
- nRead+= tmp;
- if (buf[0]!='\0')
- name= XkbInternAtom(buf,FALSE);
- else name= None;
- if ((tmp=fread(&wire,SIZEOF(xkmIndicatorMapDesc),1,file))<1) {
- _XkbLibError(_XkbErrBadLength,"ReadXkmIndicators",0);
- return -1;
- }
- nRead+= tmp*SIZEOF(xkmIndicatorMapDesc);
- if (xkb->names) {
- xkb->names->indicators[wire.indicator-1]= name;
- if (changes)
- changes->names.changed_indicators|= (1<<(wire.indicator-1));
- }
- map= &xkb->indicators->maps[wire.indicator-1];
- map->flags= wire.flags;
- map->which_groups= wire.which_groups;
- map->groups= wire.groups;
- map->which_mods= wire.which_mods;
- map->mods.mask= wire.real_mods;
- map->mods.real_mods= wire.real_mods;
- map->mods.vmods= wire.vmods;
- map->ctrls= wire.ctrls;
+ nLEDs = XkmGetCARD8(file, &nRead);
+ nRead += XkmSkipPadding(file, 3);
+ xkb->indicators->phys_indicators = XkmGetCARD32(file, &nRead);
+ while (nLEDs-- > 0) {
+ Atom name;
+ XkbIndicatorMapPtr map;
+
+ if ((tmp = XkmGetCountedString(file, buf, 100)) < 1) {
+ _XkbLibError(_XkbErrBadLength, "ReadXkmIndicators", 0);
+ return -1;
+ }
+ nRead += tmp;
+ if (buf[0] != '\0')
+ name = XkbInternAtom(buf, FALSE);
+ else
+ name = None;
+ if ((tmp = fread(&wire, SIZEOF(xkmIndicatorMapDesc), 1, file)) < 1) {
+ _XkbLibError(_XkbErrBadLength, "ReadXkmIndicators", 0);
+ return -1;
+ }
+ nRead += tmp * SIZEOF(xkmIndicatorMapDesc);
+ if (xkb->names) {
+ xkb->names->indicators[wire.indicator - 1] = name;
+ if (changes)
+ changes->names.changed_indicators |=
+ (1 << (wire.indicator - 1));
+ }
+ map = &xkb->indicators->maps[wire.indicator - 1];
+ map->flags = wire.flags;
+ map->which_groups = wire.which_groups;
+ map->groups = wire.groups;
+ map->which_mods = wire.which_mods;
+ map->mods.mask = wire.real_mods;
+ map->mods.real_mods = wire.real_mods;
+ map->mods.vmods = wire.vmods;
+ map->ctrls = wire.ctrls;
}
return nRead;
}
static XkbKeyTypePtr
-FindTypeForKey(XkbDescPtr xkb,Atom name,unsigned width,KeySym *syms)
+FindTypeForKey(XkbDescPtr xkb, Atom name, unsigned width, KeySym * syms)
{
- if ((!xkb)||(!xkb->map))
- return NULL;
- if (name!=None) {
- register unsigned i;
- for (i=0;i<xkb->map->num_types;i++) {
- if (xkb->map->types[i].name==name) {
- if (xkb->map->types[i].num_levels!=width)
- DebugF("Group width mismatch between key and type\n");
- return &xkb->map->types[i];
- }
- }
+ if ((!xkb) || (!xkb->map))
+ return NULL;
+ if (name != None) {
+ register unsigned i;
+
+ for (i = 0; i < xkb->map->num_types; i++) {
+ if (xkb->map->types[i].name == name) {
+ if (xkb->map->types[i].num_levels != width)
+ DebugF("Group width mismatch between key and type\n");
+ return &xkb->map->types[i];
+ }
+ }
}
- if ((width<2)||((syms!=NULL)&&(syms[1]==NoSymbol)))
- return &xkb->map->types[XkbOneLevelIndex];
- if (syms!=NULL) {
- if (XkbKSIsLower(syms[0])&&XkbKSIsUpper(syms[1]))
- return &xkb->map->types[XkbAlphabeticIndex];
- else if (XkbKSIsKeypad(syms[0])||XkbKSIsKeypad(syms[1]))
- return &xkb->map->types[XkbKeypadIndex];
+ if ((width < 2) || ((syms != NULL) && (syms[1] == NoSymbol)))
+ return &xkb->map->types[XkbOneLevelIndex];
+ if (syms != NULL) {
+ if (XkbKSIsLower(syms[0]) && XkbKSIsUpper(syms[1]))
+ return &xkb->map->types[XkbAlphabeticIndex];
+ else if (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1]))
+ return &xkb->map->types[XkbKeypadIndex];
}
return &xkb->map->types[XkbTwoLevelIndex];
}
static int
-ReadXkmSymbols(FILE *file,XkbDescPtr xkb)
+ReadXkmSymbols(FILE * file, XkbDescPtr xkb)
{
-register int i,g,s,totalVModMaps;
-xkmKeySymMapDesc wireMap;
-char buf[100];
-unsigned minKC,maxKC,groupNames,tmp;
-int nRead=0;
-
- if ((tmp=XkmGetCountedString(file,buf,100))<1)
- return -1;
- nRead+= tmp;
- minKC= XkmGetCARD8(file,&nRead);
- maxKC= XkmGetCARD8(file,&nRead);
- groupNames= XkmGetCARD8(file,&nRead);
- totalVModMaps= XkmGetCARD8(file,&nRead);
+ register int i, g, s, totalVModMaps;
+ xkmKeySymMapDesc wireMap;
+ char buf[100];
+ unsigned minKC, maxKC, groupNames, tmp;
+ int nRead = 0;
+
+ if ((tmp = XkmGetCountedString(file, buf, 100)) < 1)
+ return -1;
+ nRead += tmp;
+ minKC = XkmGetCARD8(file, &nRead);
+ maxKC = XkmGetCARD8(file, &nRead);
+ groupNames = XkmGetCARD8(file, &nRead);
+ totalVModMaps = XkmGetCARD8(file, &nRead);
if (XkbAllocNames(xkb,
- XkbSymbolsNameMask|XkbPhysSymbolsNameMask|XkbGroupNamesMask,
- 0,0)!=Success) {
- _XkbLibError(_XkbErrBadAlloc,"physical names",0);
- return -1;
+ XkbSymbolsNameMask | XkbPhysSymbolsNameMask |
+ XkbGroupNamesMask, 0, 0) != Success) {
+ _XkbLibError(_XkbErrBadAlloc, "physical names", 0);
+ return -1;
}
- if ((buf[0]!='\0')&&(xkb->names)) {
- Atom name;
- name= XkbInternAtom(buf,0);
- xkb->names->symbols= name;
- xkb->names->phys_symbols= name;
+ if ((buf[0] != '\0') && (xkb->names)) {
+ Atom name;
+
+ name = XkbInternAtom(buf, 0);
+ xkb->names->symbols = name;
+ xkb->names->phys_symbols = name;
}
- for (i=0,g=1;i<XkbNumKbdGroups;i++,g<<=1) {
- if (groupNames&g) {
- if ((tmp=XkmGetCountedString(file,buf,100))<1)
- return -1;
- nRead+= tmp;
-
- if (!xkb->names)
- continue;
-
- if (buf[0]!='\0') {
- Atom name;
- name= XkbInternAtom(buf,0);
- xkb->names->groups[i]= name;
- }
- else xkb->names->groups[i]= None;
- }
+ for (i = 0, g = 1; i < XkbNumKbdGroups; i++, g <<= 1) {
+ if (groupNames & g) {
+ if ((tmp = XkmGetCountedString(file, buf, 100)) < 1)
+ return -1;
+ nRead += tmp;
+
+ if (!xkb->names)
+ continue;
+
+ if (buf[0] != '\0') {
+ Atom name;
+
+ name = XkbInternAtom(buf, 0);
+ xkb->names->groups[i] = name;
+ }
+ else
+ xkb->names->groups[i] = None;
+ }
}
- if (XkbAllocServerMap(xkb,XkbAllServerInfoMask,0)!=Success) {
- _XkbLibError(_XkbErrBadAlloc,"server map",0);
- return -1;
+ if (XkbAllocServerMap(xkb, XkbAllServerInfoMask, 0) != Success) {
+ _XkbLibError(_XkbErrBadAlloc, "server map", 0);
+ return -1;
}
- if (XkbAllocClientMap(xkb,XkbAllClientInfoMask,0)!=Success) {
- _XkbLibError(_XkbErrBadAlloc,"client map",0);
- return -1;
+ if (XkbAllocClientMap(xkb, XkbAllClientInfoMask, 0) != Success) {
+ _XkbLibError(_XkbErrBadAlloc, "client map", 0);
+ return -1;
}
- if (XkbAllocControls(xkb,XkbAllControlsMask)!=Success) {
- _XkbLibError(_XkbErrBadAlloc,"controls",0);
- return -1;
+ if (XkbAllocControls(xkb, XkbAllControlsMask) != Success) {
+ _XkbLibError(_XkbErrBadAlloc, "controls", 0);
+ return -1;
}
- if ((xkb->map==NULL)||(xkb->server==NULL))
- return -1;
- if (xkb->min_key_code<8) xkb->min_key_code= minKC;
- if (xkb->max_key_code<8) xkb->max_key_code= maxKC;
- if ((minKC>=8)&&(minKC<xkb->min_key_code))
- xkb->min_key_code= minKC;
- if ((maxKC>=8)&&(maxKC>xkb->max_key_code)) {
- _XkbLibError(_XkbErrBadValue,"keys in symbol map",maxKC);
- return -1;
+ if ((xkb->map == NULL) || (xkb->server == NULL))
+ return -1;
+ if (xkb->min_key_code < 8)
+ xkb->min_key_code = minKC;
+ if (xkb->max_key_code < 8)
+ xkb->max_key_code = maxKC;
+ if ((minKC >= 8) && (minKC < xkb->min_key_code))
+ xkb->min_key_code = minKC;
+ if ((maxKC >= 8) && (maxKC > xkb->max_key_code)) {
+ _XkbLibError(_XkbErrBadValue, "keys in symbol map", maxKC);
+ return -1;
}
- for (i=minKC;i<=(int)maxKC;i++) {
- Atom typeName[XkbNumKbdGroups];
- XkbKeyTypePtr type[XkbNumKbdGroups];
- if ((tmp=fread(&wireMap,SIZEOF(xkmKeySymMapDesc),1,file))<1) {
- _XkbLibError(_XkbErrBadLength,"ReadXkmSymbols",0);
- return -1;
- }
- nRead+= tmp*SIZEOF(xkmKeySymMapDesc);
- memset((char *)typeName, 0, XkbNumKbdGroups*sizeof(Atom));
- memset((char *)type, 0, XkbNumKbdGroups*sizeof(XkbKeyTypePtr));
- if (wireMap.flags&XkmKeyHasTypes) {
- register int g;
- for (g=0;g<XkbNumKbdGroups;g++) {
- if ((wireMap.flags&(1<<g))&&
- ((tmp=XkmGetCountedString(file,buf,100))>0)) {
- typeName[g]= XkbInternAtom(buf,1);
- nRead+= tmp;
- }
- type[g]=FindTypeForKey(xkb,typeName[g],wireMap.width,NULL);
- if (type[g]==NULL) {
- _XkbLibError(_XkbErrMissingTypes,"ReadXkmSymbols",0);
- return -1;
- }
- if (typeName[g]==type[g]->name)
- xkb->server->explicit[i]|= (1<<g);
- }
- }
- if (wireMap.flags&XkmRepeatingKey) {
- xkb->ctrls->per_key_repeat[i/8]|= (1<<(i%8));
- xkb->server->explicit[i]|= XkbExplicitAutoRepeatMask;
- }
- else if (wireMap.flags&XkmNonRepeatingKey) {
- xkb->ctrls->per_key_repeat[i/8]&= ~(1<<(i%8));
- xkb->server->explicit[i]|= XkbExplicitAutoRepeatMask;
- }
- xkb->map->modmap[i]= wireMap.modifier_map;
- if (XkbNumGroups(wireMap.num_groups)>0) {
- KeySym *sym;
- int nSyms;
-
- if (XkbNumGroups(wireMap.num_groups)>xkb->ctrls->num_groups)
- xkb->ctrls->num_groups= wireMap.num_groups;
- nSyms= XkbNumGroups(wireMap.num_groups)*wireMap.width;
- sym= XkbResizeKeySyms(xkb,i,nSyms);
- if (!sym)
- return -1;
- for (s=0;s<nSyms;s++) {
- *sym++= XkmGetCARD32(file,&nRead);
- }
- if (wireMap.flags&XkmKeyHasActions) {
- XkbAction * act;
- act= XkbResizeKeyActions(xkb,i,nSyms);
- for (s=0;s<nSyms;s++,act++) {
- tmp=fread(act,SIZEOF(xkmActionDesc),1,file);
- nRead+= tmp*SIZEOF(xkmActionDesc);
- }
- xkb->server->explicit[i]|= XkbExplicitInterpretMask;
- }
- }
- for (g=0;g<XkbNumGroups(wireMap.num_groups);g++) {
- if (((xkb->server->explicit[i]&(1<<g))==0)||(type[g]==NULL)) {
- KeySym *tmpSyms;
- tmpSyms= XkbKeySymsPtr(xkb,i)+(wireMap.width*g);
- type[g]= FindTypeForKey(xkb,None,wireMap.width,tmpSyms);
- }
- xkb->map->key_sym_map[i].kt_index[g]= type[g]-(&xkb->map->types[0]);
- }
- xkb->map->key_sym_map[i].group_info= wireMap.num_groups;
- xkb->map->key_sym_map[i].width= wireMap.width;
- if (wireMap.flags&XkmKeyHasBehavior) {
- xkmBehaviorDesc b;
- tmp= fread(&b,SIZEOF(xkmBehaviorDesc),1,file);
- nRead+= tmp*SIZEOF(xkmBehaviorDesc);
- xkb->server->behaviors[i].type= b.type;
- xkb->server->behaviors[i].data= b.data;
- xkb->server->explicit[i]|= XkbExplicitBehaviorMask;
- }
+ for (i = minKC; i <= (int) maxKC; i++) {
+ Atom typeName[XkbNumKbdGroups];
+ XkbKeyTypePtr type[XkbNumKbdGroups];
+
+ if ((tmp = fread(&wireMap, SIZEOF(xkmKeySymMapDesc), 1, file)) < 1) {
+ _XkbLibError(_XkbErrBadLength, "ReadXkmSymbols", 0);
+ return -1;
+ }
+ nRead += tmp * SIZEOF(xkmKeySymMapDesc);
+ memset((char *) typeName, 0, XkbNumKbdGroups * sizeof(Atom));
+ memset((char *) type, 0, XkbNumKbdGroups * sizeof(XkbKeyTypePtr));
+ if (wireMap.flags & XkmKeyHasTypes) {
+ register int g;
+
+ for (g = 0; g < XkbNumKbdGroups; g++) {
+ if ((wireMap.flags & (1 << g)) &&
+ ((tmp = XkmGetCountedString(file, buf, 100)) > 0)) {
+ typeName[g] = XkbInternAtom(buf, 1);
+ nRead += tmp;
+ }
+ type[g] = FindTypeForKey(xkb, typeName[g], wireMap.width, NULL);
+ if (type[g] == NULL) {
+ _XkbLibError(_XkbErrMissingTypes, "ReadXkmSymbols", 0);
+ return -1;
+ }
+ if (typeName[g] == type[g]->name)
+ xkb->server->explicit[i] |= (1 << g);
+ }
+ }
+ if (wireMap.flags & XkmRepeatingKey) {
+ xkb->ctrls->per_key_repeat[i / 8] |= (1 << (i % 8));
+ xkb->server->explicit[i] |= XkbExplicitAutoRepeatMask;
+ }
+ else if (wireMap.flags & XkmNonRepeatingKey) {
+ xkb->ctrls->per_key_repeat[i / 8] &= ~(1 << (i % 8));
+ xkb->server->explicit[i] |= XkbExplicitAutoRepeatMask;
+ }
+ xkb->map->modmap[i] = wireMap.modifier_map;
+ if (XkbNumGroups(wireMap.num_groups) > 0) {
+ KeySym *sym;
+ int nSyms;
+
+ if (XkbNumGroups(wireMap.num_groups) > xkb->ctrls->num_groups)
+ xkb->ctrls->num_groups = wireMap.num_groups;
+ nSyms = XkbNumGroups(wireMap.num_groups) * wireMap.width;
+ sym = XkbResizeKeySyms(xkb, i, nSyms);
+ if (!sym)
+ return -1;
+ for (s = 0; s < nSyms; s++) {
+ *sym++ = XkmGetCARD32(file, &nRead);
+ }
+ if (wireMap.flags & XkmKeyHasActions) {
+ XkbAction *act;
+
+ act = XkbResizeKeyActions(xkb, i, nSyms);
+ for (s = 0; s < nSyms; s++, act++) {
+ tmp = fread(act, SIZEOF(xkmActionDesc), 1, file);
+ nRead += tmp * SIZEOF(xkmActionDesc);
+ }
+ xkb->server->explicit[i] |= XkbExplicitInterpretMask;
+ }
+ }
+ for (g = 0; g < XkbNumGroups(wireMap.num_groups); g++) {
+ if (((xkb->server->explicit[i] & (1 << g)) == 0) ||
+ (type[g] == NULL)) {
+ KeySym *tmpSyms;
+
+ tmpSyms = XkbKeySymsPtr(xkb, i) + (wireMap.width * g);
+ type[g] = FindTypeForKey(xkb, None, wireMap.width, tmpSyms);
+ }
+ xkb->map->key_sym_map[i].kt_index[g] =
+ type[g] - (&xkb->map->types[0]);
+ }
+ xkb->map->key_sym_map[i].group_info = wireMap.num_groups;
+ xkb->map->key_sym_map[i].width = wireMap.width;
+ if (wireMap.flags & XkmKeyHasBehavior) {
+ xkmBehaviorDesc b;
+
+ tmp = fread(&b, SIZEOF(xkmBehaviorDesc), 1, file);
+ nRead += tmp * SIZEOF(xkmBehaviorDesc);
+ xkb->server->behaviors[i].type = b.type;
+ xkb->server->behaviors[i].data = b.data;
+ xkb->server->explicit[i] |= XkbExplicitBehaviorMask;
+ }
}
- if (totalVModMaps>0) {
- xkmVModMapDesc v;
- for (i=0;i<totalVModMaps;i++) {
- tmp= fread(&v,SIZEOF(xkmVModMapDesc),1,file);
- nRead+= tmp*SIZEOF(xkmVModMapDesc);
- if (tmp>0)
- xkb->server->vmodmap[v.key]= v.vmods;
- }
+ if (totalVModMaps > 0) {
+ xkmVModMapDesc v;
+
+ for (i = 0; i < totalVModMaps; i++) {
+ tmp = fread(&v, SIZEOF(xkmVModMapDesc), 1, file);
+ nRead += tmp * SIZEOF(xkmVModMapDesc);
+ if (tmp > 0)
+ xkb->server->vmodmap[v.key] = v.vmods;
+ }
}
return nRead;
}
static int
-ReadXkmGeomDoodad(
- FILE * file,
- XkbGeometryPtr geom,
- XkbSectionPtr section)
+ReadXkmGeomDoodad(FILE * file, XkbGeometryPtr geom, XkbSectionPtr section)
{
-XkbDoodadPtr doodad;
-xkmDoodadDesc doodadWire;
-char buf[100];
-unsigned tmp;
-int nRead=0;
-
- nRead+= XkmGetCountedString(file,buf,100);
- tmp= fread(&doodadWire,SIZEOF(xkmDoodadDesc),1,file);
- nRead+= SIZEOF(xkmDoodadDesc)*tmp;
- doodad= XkbAddGeomDoodad(geom,section,XkbInternAtom(buf,FALSE));
+ XkbDoodadPtr doodad;
+ xkmDoodadDesc doodadWire;
+ char buf[100];
+ unsigned tmp;
+ int nRead = 0;
+
+ nRead += XkmGetCountedString(file, buf, 100);
+ tmp = fread(&doodadWire, SIZEOF(xkmDoodadDesc), 1, file);
+ nRead += SIZEOF(xkmDoodadDesc) * tmp;
+ doodad = XkbAddGeomDoodad(geom, section, XkbInternAtom(buf, FALSE));
if (!doodad)
- return nRead;
- doodad->any.type= doodadWire.any.type;
- doodad->any.priority= doodadWire.any.priority;
- doodad->any.top= doodadWire.any.top;
- doodad->any.left= doodadWire.any.left;
+ return nRead;
+ doodad->any.type = doodadWire.any.type;
+ doodad->any.priority = doodadWire.any.priority;
+ doodad->any.top = doodadWire.any.top;
+ doodad->any.left = doodadWire.any.left;
switch (doodadWire.any.type) {
- case XkbOutlineDoodad:
- case XkbSolidDoodad:
- doodad->shape.angle= doodadWire.shape.angle;
- doodad->shape.color_ndx= doodadWire.shape.color_ndx;
- doodad->shape.shape_ndx= doodadWire.shape.shape_ndx;
- break;
- case XkbTextDoodad:
- doodad->text.angle= doodadWire.text.angle;
- doodad->text.width= doodadWire.text.width;
- doodad->text.height= doodadWire.text.height;
- doodad->text.color_ndx= doodadWire.text.color_ndx;
- nRead+= XkmGetCountedString(file,buf,100);
- doodad->text.text= Xstrdup(buf);
- nRead+= XkmGetCountedString(file,buf,100);
- doodad->text.font= Xstrdup(buf);
- break;
- case XkbIndicatorDoodad:
- doodad->indicator.shape_ndx= doodadWire.indicator.shape_ndx;
- doodad->indicator.on_color_ndx= doodadWire.indicator.on_color_ndx;
- doodad->indicator.off_color_ndx= doodadWire.indicator.off_color_ndx;
- break;
- case XkbLogoDoodad:
- doodad->logo.angle= doodadWire.logo.angle;
- doodad->logo.color_ndx= doodadWire.logo.color_ndx;
- doodad->logo.shape_ndx= doodadWire.logo.shape_ndx;
- nRead+= XkmGetCountedString(file,buf,100);
- doodad->logo.logo_name= Xstrdup(buf);
- break;
- default:
- /* report error? */
- return nRead;
+ case XkbOutlineDoodad:
+ case XkbSolidDoodad:
+ doodad->shape.angle = doodadWire.shape.angle;
+ doodad->shape.color_ndx = doodadWire.shape.color_ndx;
+ doodad->shape.shape_ndx = doodadWire.shape.shape_ndx;
+ break;
+ case XkbTextDoodad:
+ doodad->text.angle = doodadWire.text.angle;
+ doodad->text.width = doodadWire.text.width;
+ doodad->text.height = doodadWire.text.height;
+ doodad->text.color_ndx = doodadWire.text.color_ndx;
+ nRead += XkmGetCountedString(file, buf, 100);
+ doodad->text.text = Xstrdup(buf);
+ nRead += XkmGetCountedString(file, buf, 100);
+ doodad->text.font = Xstrdup(buf);
+ break;
+ case XkbIndicatorDoodad:
+ doodad->indicator.shape_ndx = doodadWire.indicator.shape_ndx;
+ doodad->indicator.on_color_ndx = doodadWire.indicator.on_color_ndx;
+ doodad->indicator.off_color_ndx = doodadWire.indicator.off_color_ndx;
+ break;
+ case XkbLogoDoodad:
+ doodad->logo.angle = doodadWire.logo.angle;
+ doodad->logo.color_ndx = doodadWire.logo.color_ndx;
+ doodad->logo.shape_ndx = doodadWire.logo.shape_ndx;
+ nRead += XkmGetCountedString(file, buf, 100);
+ doodad->logo.logo_name = Xstrdup(buf);
+ break;
+ default:
+ /* report error? */
+ return nRead;
}
return nRead;
}
static int
-ReadXkmGeomOverlay( FILE * file,
- XkbGeometryPtr geom,
- XkbSectionPtr section)
+ReadXkmGeomOverlay(FILE * file, XkbGeometryPtr geom, XkbSectionPtr section)
{
-char buf[100];
-unsigned tmp;
-int nRead=0;
-XkbOverlayPtr ol;
-XkbOverlayRowPtr row;
-xkmOverlayDesc olWire;
-xkmOverlayRowDesc rowWire;
-register int r;
-
- nRead+= XkmGetCountedString(file,buf,100);
- tmp= fread(&olWire,SIZEOF(xkmOverlayDesc),1,file);
- nRead+= tmp*SIZEOF(xkmOverlayDesc);
- ol= XkbAddGeomOverlay(section,XkbInternAtom(buf,FALSE),
- olWire.num_rows);
+ char buf[100];
+ unsigned tmp;
+ int nRead = 0;
+ XkbOverlayPtr ol;
+ XkbOverlayRowPtr row;
+ xkmOverlayDesc olWire;
+ xkmOverlayRowDesc rowWire;
+ register int r;
+
+ nRead += XkmGetCountedString(file, buf, 100);
+ tmp = fread(&olWire, SIZEOF(xkmOverlayDesc), 1, file);
+ nRead += tmp * SIZEOF(xkmOverlayDesc);
+ ol = XkbAddGeomOverlay(section, XkbInternAtom(buf, FALSE), olWire.num_rows);
if (!ol)
- return nRead;
- for (r=0;r<olWire.num_rows;r++) {
- int k;
- xkmOverlayKeyDesc keyWire;
- tmp= fread(&rowWire,SIZEOF(xkmOverlayRowDesc),1,file);
- nRead+= tmp*SIZEOF(xkmOverlayRowDesc);
- row= XkbAddGeomOverlayRow(ol,rowWire.row_under,rowWire.num_keys);
- if (!row) {
- _XkbLibError(_XkbErrBadAlloc,"ReadXkmGeomOverlay",0);
- return nRead;
- }
- for (k=0;k<rowWire.num_keys;k++) {
- tmp= fread(&keyWire,SIZEOF(xkmOverlayKeyDesc),1,file);
- nRead+= tmp*SIZEOF(xkmOverlayKeyDesc);
- memcpy(row->keys[k].over.name,keyWire.over,XkbKeyNameLength);
- memcpy(row->keys[k].under.name,keyWire.under,XkbKeyNameLength);
- }
- row->num_keys= rowWire.num_keys;
+ return nRead;
+ for (r = 0; r < olWire.num_rows; r++) {
+ int k;
+ xkmOverlayKeyDesc keyWire;
+
+ tmp = fread(&rowWire, SIZEOF(xkmOverlayRowDesc), 1, file);
+ nRead += tmp * SIZEOF(xkmOverlayRowDesc);
+ row = XkbAddGeomOverlayRow(ol, rowWire.row_under, rowWire.num_keys);
+ if (!row) {
+ _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeomOverlay", 0);
+ return nRead;
+ }
+ for (k = 0; k < rowWire.num_keys; k++) {
+ tmp = fread(&keyWire, SIZEOF(xkmOverlayKeyDesc), 1, file);
+ nRead += tmp * SIZEOF(xkmOverlayKeyDesc);
+ memcpy(row->keys[k].over.name, keyWire.over, XkbKeyNameLength);
+ memcpy(row->keys[k].under.name, keyWire.under, XkbKeyNameLength);
+ }
+ row->num_keys = rowWire.num_keys;
}
return nRead;
}
static int
-ReadXkmGeomSection( FILE * file,
- XkbGeometryPtr geom)
+ReadXkmGeomSection(FILE * file, XkbGeometryPtr geom)
{
-register int i;
-XkbSectionPtr section;
-xkmSectionDesc sectionWire;
-unsigned tmp;
-int nRead= 0;
-char buf[100];
-Atom nameAtom;
-
- nRead+= XkmGetCountedString(file,buf,100);
- nameAtom= XkbInternAtom(buf,FALSE);
- tmp= fread(&sectionWire,SIZEOF(xkmSectionDesc),1,file);
- nRead+= SIZEOF(xkmSectionDesc)*tmp;
- section= XkbAddGeomSection(geom,nameAtom,sectionWire.num_rows,
- sectionWire.num_doodads,
- sectionWire.num_overlays);
+ register int i;
+ XkbSectionPtr section;
+ xkmSectionDesc sectionWire;
+ unsigned tmp;
+ int nRead = 0;
+ char buf[100];
+ Atom nameAtom;
+
+ nRead += XkmGetCountedString(file, buf, 100);
+ nameAtom = XkbInternAtom(buf, FALSE);
+ tmp = fread(&sectionWire, SIZEOF(xkmSectionDesc), 1, file);
+ nRead += SIZEOF(xkmSectionDesc) * tmp;
+ section = XkbAddGeomSection(geom, nameAtom, sectionWire.num_rows,
+ sectionWire.num_doodads,
+ sectionWire.num_overlays);
if (!section) {
- _XkbLibError(_XkbErrBadAlloc,"ReadXkmGeomSection",0);
- return nRead;
+ _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeomSection", 0);
+ return nRead;
}
- section->top= sectionWire.top;
- section->left= sectionWire.left;
- section->width= sectionWire.width;
- section->height= sectionWire.height;
- section->angle= sectionWire.angle;
- section->priority= sectionWire.priority;
- if (sectionWire.num_rows>0) {
- register int k;
- XkbRowPtr row;
- xkmRowDesc rowWire;
- XkbKeyPtr key;
- xkmKeyDesc keyWire;
-
- for (i=0;i<sectionWire.num_rows;i++) {
- tmp= fread(&rowWire,SIZEOF(xkmRowDesc),1,file);
- nRead+= SIZEOF(xkmRowDesc)*tmp;
- row= XkbAddGeomRow(section,rowWire.num_keys);
- if (!row) {
- _XkbLibError(_XkbErrBadAlloc,"ReadXkmKeycodes",0);
- return nRead;
- }
- row->top= rowWire.top;
- row->left= rowWire.left;
- row->vertical= rowWire.vertical;
- for (k=0;k<rowWire.num_keys;k++) {
- tmp= fread(&keyWire,SIZEOF(xkmKeyDesc),1,file);
- nRead+= SIZEOF(xkmKeyDesc)*tmp;
- key= XkbAddGeomKey(row);
- if (!key) {
- _XkbLibError(_XkbErrBadAlloc,"ReadXkmGeomSection",0);
- return nRead;
- }
- memcpy(key->name.name,keyWire.name,XkbKeyNameLength);
- key->gap= keyWire.gap;
- key->shape_ndx= keyWire.shape_ndx;
- key->color_ndx= keyWire.color_ndx;
- }
- }
+ section->top = sectionWire.top;
+ section->left = sectionWire.left;
+ section->width = sectionWire.width;
+ section->height = sectionWire.height;
+ section->angle = sectionWire.angle;
+ section->priority = sectionWire.priority;
+ if (sectionWire.num_rows > 0) {
+ register int k;
+ XkbRowPtr row;
+ xkmRowDesc rowWire;
+ XkbKeyPtr key;
+ xkmKeyDesc keyWire;
+
+ for (i = 0; i < sectionWire.num_rows; i++) {
+ tmp = fread(&rowWire, SIZEOF(xkmRowDesc), 1, file);
+ nRead += SIZEOF(xkmRowDesc) * tmp;
+ row = XkbAddGeomRow(section, rowWire.num_keys);
+ if (!row) {
+ _XkbLibError(_XkbErrBadAlloc, "ReadXkmKeycodes", 0);
+ return nRead;
+ }
+ row->top = rowWire.top;
+ row->left = rowWire.left;
+ row->vertical = rowWire.vertical;
+ for (k = 0; k < rowWire.num_keys; k++) {
+ tmp = fread(&keyWire, SIZEOF(xkmKeyDesc), 1, file);
+ nRead += SIZEOF(xkmKeyDesc) * tmp;
+ key = XkbAddGeomKey(row);
+ if (!key) {
+ _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeomSection", 0);
+ return nRead;
+ }
+ memcpy(key->name.name, keyWire.name, XkbKeyNameLength);
+ key->gap = keyWire.gap;
+ key->shape_ndx = keyWire.shape_ndx;
+ key->color_ndx = keyWire.color_ndx;
+ }
+ }
}
- if (sectionWire.num_doodads>0) {
- for (i=0;i<sectionWire.num_doodads;i++) {
- tmp= ReadXkmGeomDoodad(file,geom,section);
- nRead+= tmp;
- if (tmp<1)
- return nRead;
- }
+ if (sectionWire.num_doodads > 0) {
+ for (i = 0; i < sectionWire.num_doodads; i++) {
+ tmp = ReadXkmGeomDoodad(file, geom, section);
+ nRead += tmp;
+ if (tmp < 1)
+ return nRead;
+ }
}
- if (sectionWire.num_overlays>0) {
- for (i=0;i<sectionWire.num_overlays;i++) {
- tmp= ReadXkmGeomOverlay(file,geom,section);
- nRead+= tmp;
- if (tmp<1)
- return nRead;
- }
+ if (sectionWire.num_overlays > 0) {
+ for (i = 0; i < sectionWire.num_overlays; i++) {
+ tmp = ReadXkmGeomOverlay(file, geom, section);
+ nRead += tmp;
+ if (tmp < 1)
+ return nRead;
+ }
}
return nRead;
}
static int
-ReadXkmGeometry(FILE *file,XkbDescPtr xkb)
+ReadXkmGeometry(FILE * file, XkbDescPtr xkb)
{
-register int i;
-char buf[100];
-unsigned tmp;
-int nRead= 0;
-xkmGeometryDesc wireGeom;
-XkbGeometryPtr geom;
-XkbGeometrySizesRec sizes;
-
- nRead+= XkmGetCountedString(file,buf,100);
- tmp= fread(&wireGeom,SIZEOF(xkmGeometryDesc),1,file);
- nRead+= tmp*SIZEOF(xkmGeometryDesc);
- sizes.which= XkbGeomAllMask;
- sizes.num_properties= wireGeom.num_properties;
- sizes.num_colors= wireGeom.num_colors;
- sizes.num_shapes= wireGeom.num_shapes;
- sizes.num_sections= wireGeom.num_sections;
- sizes.num_doodads= wireGeom.num_doodads;
- sizes.num_key_aliases= wireGeom.num_key_aliases;
- if (XkbAllocGeometry(xkb,&sizes)!=Success) {
- _XkbLibError(_XkbErrBadAlloc,"ReadXkmGeometry",0);
- return nRead;
+ register int i;
+ char buf[100];
+ unsigned tmp;
+ int nRead = 0;
+ xkmGeometryDesc wireGeom;
+ XkbGeometryPtr geom;
+ XkbGeometrySizesRec sizes;
+
+ nRead += XkmGetCountedString(file, buf, 100);
+ tmp = fread(&wireGeom, SIZEOF(xkmGeometryDesc), 1, file);
+ nRead += tmp * SIZEOF(xkmGeometryDesc);
+ sizes.which = XkbGeomAllMask;
+ sizes.num_properties = wireGeom.num_properties;
+ sizes.num_colors = wireGeom.num_colors;
+ sizes.num_shapes = wireGeom.num_shapes;
+ sizes.num_sections = wireGeom.num_sections;
+ sizes.num_doodads = wireGeom.num_doodads;
+ sizes.num_key_aliases = wireGeom.num_key_aliases;
+ if (XkbAllocGeometry(xkb, &sizes) != Success) {
+ _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeometry", 0);
+ return nRead;
}
- geom= xkb->geom;
- geom->name= XkbInternAtom(buf,FALSE);
- geom->width_mm= wireGeom.width_mm;
- geom->height_mm= wireGeom.height_mm;
- nRead+= XkmGetCountedString(file,buf,100);
- geom->label_font= Xstrdup(buf);
- if (wireGeom.num_properties>0) {
- char val[1024];
- for (i=0;i<wireGeom.num_properties;i++) {
- nRead+= XkmGetCountedString(file,buf,100);
- nRead+= XkmGetCountedString(file,val,1024);
- if (XkbAddGeomProperty(geom,buf,val)==NULL) {
- _XkbLibError(_XkbErrBadAlloc,"ReadXkmGeometry",0);
- return nRead;
- }
- }
+ geom = xkb->geom;
+ geom->name = XkbInternAtom(buf, FALSE);
+ geom->width_mm = wireGeom.width_mm;
+ geom->height_mm = wireGeom.height_mm;
+ nRead += XkmGetCountedString(file, buf, 100);
+ geom->label_font = Xstrdup(buf);
+ if (wireGeom.num_properties > 0) {
+ char val[1024];
+
+ for (i = 0; i < wireGeom.num_properties; i++) {
+ nRead += XkmGetCountedString(file, buf, 100);
+ nRead += XkmGetCountedString(file, val, 1024);
+ if (XkbAddGeomProperty(geom, buf, val) == NULL) {
+ _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeometry", 0);
+ return nRead;
+ }
+ }
}
- if (wireGeom.num_colors>0) {
- for (i=0;i<wireGeom.num_colors;i++) {
- nRead+= XkmGetCountedString(file,buf,100);
- if (XkbAddGeomColor(geom,buf,i)==NULL) {
- _XkbLibError(_XkbErrBadAlloc,"ReadXkmGeometry",0);
- return nRead;
- }
- }
+ if (wireGeom.num_colors > 0) {
+ for (i = 0; i < wireGeom.num_colors; i++) {
+ nRead += XkmGetCountedString(file, buf, 100);
+ if (XkbAddGeomColor(geom, buf, i) == NULL) {
+ _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeometry", 0);
+ return nRead;
+ }
+ }
}
- geom->base_color= &geom->colors[wireGeom.base_color_ndx];
- geom->label_color= &geom->colors[wireGeom.label_color_ndx];
- if (wireGeom.num_shapes>0) {
- XkbShapePtr shape;
- xkmShapeDesc shapeWire;
- Atom nameAtom;
- for (i=0;i<wireGeom.num_shapes;i++) {
- register int n;
- XkbOutlinePtr ol;
- xkmOutlineDesc olWire;
- nRead+= XkmGetCountedString(file,buf,100);
- nameAtom= XkbInternAtom(buf,FALSE);
- tmp= fread(&shapeWire,SIZEOF(xkmShapeDesc),1,file);
- nRead+= tmp*SIZEOF(xkmShapeDesc);
- shape= XkbAddGeomShape(geom,nameAtom,shapeWire.num_outlines);
- if (!shape) {
- _XkbLibError(_XkbErrBadAlloc,"ReadXkmGeometry",0);
- return nRead;
- }
- for (n=0;n<shapeWire.num_outlines;n++) {
- register int p;
- xkmPointDesc ptWire;
- tmp= fread(&olWire,SIZEOF(xkmOutlineDesc),1,file);
- nRead+= tmp*SIZEOF(xkmOutlineDesc);
- ol= XkbAddGeomOutline(shape,olWire.num_points);
- if (!ol) {
- _XkbLibError(_XkbErrBadAlloc,"ReadXkmGeometry",0);
- return nRead;
- }
- ol->num_points= olWire.num_points;
- ol->corner_radius= olWire.corner_radius;
- for (p=0;p<olWire.num_points;p++) {
- tmp= fread(&ptWire,SIZEOF(xkmPointDesc),1,file);
- nRead+= tmp*SIZEOF(xkmPointDesc);
- ol->points[p].x= ptWire.x;
- ol->points[p].y= ptWire.y;
- if (ptWire.x<shape->bounds.x1) shape->bounds.x1= ptWire.x;
- if (ptWire.x>shape->bounds.x2) shape->bounds.x2= ptWire.x;
- if (ptWire.y<shape->bounds.y1) shape->bounds.y1= ptWire.y;
- if (ptWire.y>shape->bounds.y2) shape->bounds.y2= ptWire.y;
- }
- }
- if (shapeWire.primary_ndx!=XkbNoShape)
- shape->primary= &shape->outlines[shapeWire.primary_ndx];
- if (shapeWire.approx_ndx!=XkbNoShape)
- shape->approx= &shape->outlines[shapeWire.approx_ndx];
- }
+ geom->base_color = &geom->colors[wireGeom.base_color_ndx];
+ geom->label_color = &geom->colors[wireGeom.label_color_ndx];
+ if (wireGeom.num_shapes > 0) {
+ XkbShapePtr shape;
+ xkmShapeDesc shapeWire;
+ Atom nameAtom;
+
+ for (i = 0; i < wireGeom.num_shapes; i++) {
+ register int n;
+ XkbOutlinePtr ol;
+ xkmOutlineDesc olWire;
+
+ nRead += XkmGetCountedString(file, buf, 100);
+ nameAtom = XkbInternAtom(buf, FALSE);
+ tmp = fread(&shapeWire, SIZEOF(xkmShapeDesc), 1, file);
+ nRead += tmp * SIZEOF(xkmShapeDesc);
+ shape = XkbAddGeomShape(geom, nameAtom, shapeWire.num_outlines);
+ if (!shape) {
+ _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeometry", 0);
+ return nRead;
+ }
+ for (n = 0; n < shapeWire.num_outlines; n++) {
+ register int p;
+ xkmPointDesc ptWire;
+
+ tmp = fread(&olWire, SIZEOF(xkmOutlineDesc), 1, file);
+ nRead += tmp * SIZEOF(xkmOutlineDesc);
+ ol = XkbAddGeomOutline(shape, olWire.num_points);
+ if (!ol) {
+ _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeometry", 0);
+ return nRead;
+ }
+ ol->num_points = olWire.num_points;
+ ol->corner_radius = olWire.corner_radius;
+ for (p = 0; p < olWire.num_points; p++) {
+ tmp = fread(&ptWire, SIZEOF(xkmPointDesc), 1, file);
+ nRead += tmp * SIZEOF(xkmPointDesc);
+ ol->points[p].x = ptWire.x;
+ ol->points[p].y = ptWire.y;
+ if (ptWire.x < shape->bounds.x1)
+ shape->bounds.x1 = ptWire.x;
+ if (ptWire.x > shape->bounds.x2)
+ shape->bounds.x2 = ptWire.x;
+ if (ptWire.y < shape->bounds.y1)
+ shape->bounds.y1 = ptWire.y;
+ if (ptWire.y > shape->bounds.y2)
+ shape->bounds.y2 = ptWire.y;
+ }
+ }
+ if (shapeWire.primary_ndx != XkbNoShape)
+ shape->primary = &shape->outlines[shapeWire.primary_ndx];
+ if (shapeWire.approx_ndx != XkbNoShape)
+ shape->approx = &shape->outlines[shapeWire.approx_ndx];
+ }
}
- if (wireGeom.num_sections>0) {
- for (i=0;i<wireGeom.num_sections;i++) {
- tmp= ReadXkmGeomSection(file,geom);
- nRead+= tmp;
- if (tmp==0)
- return nRead;
- }
+ if (wireGeom.num_sections > 0) {
+ for (i = 0; i < wireGeom.num_sections; i++) {
+ tmp = ReadXkmGeomSection(file, geom);
+ nRead += tmp;
+ if (tmp == 0)
+ return nRead;
+ }
}
- if (wireGeom.num_doodads>0) {
- for (i=0;i<wireGeom.num_doodads;i++) {
- tmp= ReadXkmGeomDoodad(file,geom,NULL);
- nRead+= tmp;
- if (tmp==0)
- return nRead;
- }
+ if (wireGeom.num_doodads > 0) {
+ for (i = 0; i < wireGeom.num_doodads; i++) {
+ tmp = ReadXkmGeomDoodad(file, geom, NULL);
+ nRead += tmp;
+ if (tmp == 0)
+ return nRead;
+ }
}
- if ((wireGeom.num_key_aliases>0)&&(geom->key_aliases)) {
- int sz= XkbKeyNameLength*2;
- int num= wireGeom.num_key_aliases;
- if (fread(geom->key_aliases,sz,num,file)!=num) {
- _XkbLibError(_XkbErrBadLength,"ReadXkmGeometry",0);
- return -1;
- }
- nRead+= (num*sz);
- geom->num_key_aliases= num;
+ if ((wireGeom.num_key_aliases > 0) && (geom->key_aliases)) {
+ int sz = XkbKeyNameLength * 2;
+ int num = wireGeom.num_key_aliases;
+
+ if (fread(geom->key_aliases, sz, num, file) != num) {
+ _XkbLibError(_XkbErrBadLength, "ReadXkmGeometry", 0);
+ return -1;
+ }
+ nRead += (num * sz);
+ geom->num_key_aliases = num;
}
return nRead;
}
Bool
-XkmProbe(FILE *file)
+XkmProbe(FILE * file)
{
-unsigned hdr,tmp;
-int nRead=0;
-
- hdr= (('x'<<24)|('k'<<16)|('m'<<8)|XkmFileVersion);
- tmp= XkmGetCARD32(file,&nRead);
- if (tmp!=hdr) {
- if ((tmp&(~0xff))==(hdr&(~0xff))) {
- _XkbLibError(_XkbErrBadFileVersion,"XkmProbe",tmp&0xff);
- }
- return 0;
+ unsigned hdr, tmp;
+ int nRead = 0;
+
+ hdr = (('x' << 24) | ('k' << 16) | ('m' << 8) | XkmFileVersion);
+ tmp = XkmGetCARD32(file, &nRead);
+ if (tmp != hdr) {
+ if ((tmp & (~0xff)) == (hdr & (~0xff))) {
+ _XkbLibError(_XkbErrBadFileVersion, "XkmProbe", tmp & 0xff);
+ }
+ return 0;
}
return 1;
}
static Bool
-XkmReadTOC(FILE *file,xkmFileInfo* file_info,int max_toc,xkmSectionInfo *toc)
+XkmReadTOC(FILE * file, xkmFileInfo * file_info, int max_toc,
+ xkmSectionInfo * toc)
{
-unsigned hdr,tmp;
-int nRead=0;
-unsigned i,size_toc;
-
- hdr= (('x'<<24)|('k'<<16)|('m'<<8)|XkmFileVersion);
- tmp= XkmGetCARD32(file,&nRead);
- if (tmp!=hdr) {
- if ((tmp&(~0xff))==(hdr&(~0xff))) {
- _XkbLibError(_XkbErrBadFileVersion,"XkmReadTOC",tmp&0xff);
- }
- else {
- _XkbLibError(_XkbErrBadFileType,"XkmReadTOC",tmp);
- }
- return 0;
+ unsigned hdr, tmp;
+ int nRead = 0;
+ unsigned i, size_toc;
+
+ hdr = (('x' << 24) | ('k' << 16) | ('m' << 8) | XkmFileVersion);
+ tmp = XkmGetCARD32(file, &nRead);
+ if (tmp != hdr) {
+ if ((tmp & (~0xff)) == (hdr & (~0xff))) {
+ _XkbLibError(_XkbErrBadFileVersion, "XkmReadTOC", tmp & 0xff);
+ }
+ else {
+ _XkbLibError(_XkbErrBadFileType, "XkmReadTOC", tmp);
+ }
+ return 0;
}
- fread(file_info,SIZEOF(xkmFileInfo),1,file);
- size_toc= file_info->num_toc;
- if (size_toc>max_toc) {
- DebugF("Warning! Too many TOC entries; last %d ignored\n",
- size_toc-max_toc);
- size_toc= max_toc;
+ fread(file_info, SIZEOF(xkmFileInfo), 1, file);
+ size_toc = file_info->num_toc;
+ if (size_toc > max_toc) {
+ DebugF("Warning! Too many TOC entries; last %d ignored\n",
+ size_toc - max_toc);
+ size_toc = max_toc;
}
- for (i=0;i<size_toc;i++) {
- fread(&toc[i],SIZEOF(xkmSectionInfo),1,file);
+ for (i = 0; i < size_toc; i++) {
+ fread(&toc[i], SIZEOF(xkmSectionInfo), 1, file);
}
return 1;
}
@@ -1183,71 +1223,72 @@ unsigned i,size_toc;
#define MAX_TOC 16
unsigned
-XkmReadFile(FILE *file,unsigned need,unsigned want,XkbDescPtr *xkb)
+XkmReadFile(FILE * file, unsigned need, unsigned want, XkbDescPtr *xkb)
{
-register unsigned i;
-xkmSectionInfo toc[MAX_TOC],tmpTOC;
-xkmFileInfo fileInfo;
-unsigned tmp,nRead=0;
-unsigned which= need|want;
-
- if (!XkmReadTOC(file,&fileInfo,MAX_TOC,toc))
- return which;
- if ((fileInfo.present&need)!=need) {
- _XkbLibError(_XkbErrIllegalContents,"XkmReadFile",
- need&(~fileInfo.present));
- return which;
+ register unsigned i;
+ xkmSectionInfo toc[MAX_TOC], tmpTOC;
+ xkmFileInfo fileInfo;
+ unsigned tmp, nRead = 0;
+ unsigned which = need | want;
+
+ if (!XkmReadTOC(file, &fileInfo, MAX_TOC, toc))
+ return which;
+ if ((fileInfo.present & need) != need) {
+ _XkbLibError(_XkbErrIllegalContents, "XkmReadFile",
+ need & (~fileInfo.present));
+ return which;
}
- if (*xkb==NULL)
- *xkb= XkbAllocKeyboard();
- for (i=0;i<fileInfo.num_toc;i++) {
- fseek(file,toc[i].offset,SEEK_SET);
- tmp= fread(&tmpTOC,SIZEOF(xkmSectionInfo),1,file);
- nRead= tmp*SIZEOF(xkmSectionInfo);
- if ((tmpTOC.type!=toc[i].type)||(tmpTOC.format!=toc[i].format)||
- (tmpTOC.size!=toc[i].size)||(tmpTOC.offset!=toc[i].offset)) {
- return which;
- }
- if ((which&(1<<tmpTOC.type))==0) {
- continue;
- }
- switch (tmpTOC.type) {
- case XkmVirtualModsIndex:
- tmp= ReadXkmVirtualMods(file,*xkb,NULL);
- break;
- case XkmTypesIndex:
- tmp= ReadXkmKeyTypes(file,*xkb,NULL);
- break;
- case XkmCompatMapIndex:
- tmp= ReadXkmCompatMap(file,*xkb,NULL);
- break;
- case XkmKeyNamesIndex:
- tmp= ReadXkmKeycodes(file,*xkb,NULL);
- break;
- case XkmIndicatorsIndex:
- tmp= ReadXkmIndicators(file,*xkb,NULL);
- break;
- case XkmSymbolsIndex:
- tmp= ReadXkmSymbols(file,*xkb);
- break;
- case XkmGeometryIndex:
- tmp= ReadXkmGeometry(file,*xkb);
- break;
- default:
- _XkbLibError(_XkbErrBadImplementation,
- XkbConfigText(tmpTOC.type,XkbMessage),0);
- tmp= 0;
- break;
- }
- if (tmp>0) {
- nRead+= tmp;
- which&= ~(1<<toc[i].type);
- (*xkb)->defined|= (1<<toc[i].type);
- }
- if (nRead!=tmpTOC.size) {
- _XkbLibError(_XkbErrBadLength,XkbConfigText(tmpTOC.type,XkbMessage),
- nRead-tmpTOC.size);
- }
+ if (*xkb == NULL)
+ *xkb = XkbAllocKeyboard();
+ for (i = 0; i < fileInfo.num_toc; i++) {
+ fseek(file, toc[i].offset, SEEK_SET);
+ tmp = fread(&tmpTOC, SIZEOF(xkmSectionInfo), 1, file);
+ nRead = tmp * SIZEOF(xkmSectionInfo);
+ if ((tmpTOC.type != toc[i].type) || (tmpTOC.format != toc[i].format) ||
+ (tmpTOC.size != toc[i].size) || (tmpTOC.offset != toc[i].offset)) {
+ return which;
+ }
+ if ((which & (1 << tmpTOC.type)) == 0) {
+ continue;
+ }
+ switch (tmpTOC.type) {
+ case XkmVirtualModsIndex:
+ tmp = ReadXkmVirtualMods(file, *xkb, NULL);
+ break;
+ case XkmTypesIndex:
+ tmp = ReadXkmKeyTypes(file, *xkb, NULL);
+ break;
+ case XkmCompatMapIndex:
+ tmp = ReadXkmCompatMap(file, *xkb, NULL);
+ break;
+ case XkmKeyNamesIndex:
+ tmp = ReadXkmKeycodes(file, *xkb, NULL);
+ break;
+ case XkmIndicatorsIndex:
+ tmp = ReadXkmIndicators(file, *xkb, NULL);
+ break;
+ case XkmSymbolsIndex:
+ tmp = ReadXkmSymbols(file, *xkb);
+ break;
+ case XkmGeometryIndex:
+ tmp = ReadXkmGeometry(file, *xkb);
+ break;
+ default:
+ _XkbLibError(_XkbErrBadImplementation,
+ XkbConfigText(tmpTOC.type, XkbMessage), 0);
+ tmp = 0;
+ break;
+ }
+ if (tmp > 0) {
+ nRead += tmp;
+ which &= ~(1 << toc[i].type);
+ (*xkb)->defined |= (1 << toc[i].type);
+ }
+ if (nRead != tmpTOC.size) {
+ _XkbLibError(_XkbErrBadLength,
+ XkbConfigText(tmpTOC.type, XkbMessage),
+ nRead - tmpTOC.size);
+ }
}
return which;
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-30 05:42:22 +0000