1701 lines
39 KiB
C
1701 lines
39 KiB
C
/* $Xorg: xkbtext.c,v 1.3 2000/08/17 19:46:44 cpqbld Exp $ */
|
|
/************************************************************
|
|
Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
|
|
|
|
Permission to use, copy, modify, and distribute this
|
|
software and its documentation for any purpose and without
|
|
fee is hereby granted, provided that the above copyright
|
|
notice appear in all copies and that both that copyright
|
|
notice and this permission notice appear in supporting
|
|
documentation, and that the name of Silicon Graphics not be
|
|
used in advertising or publicity pertaining to distribution
|
|
of the software without specific prior written permission.
|
|
Silicon Graphics makes no representation about the suitability
|
|
of this software for any purpose. It is provided "as is"
|
|
without any express or implied warranty.
|
|
|
|
SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
|
|
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
|
AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
|
|
GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
|
|
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
|
DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
|
|
OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
|
|
THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
|
|
********************************************************/
|
|
|
|
#include <stdio.h>
|
|
#include <ctype.h>
|
|
#ifndef X_NOT_STDC_ENV
|
|
#include <stdlib.h>
|
|
#endif
|
|
|
|
#include <X11/Xos.h>
|
|
|
|
#ifndef XKB_IN_SERVER
|
|
|
|
#include <X11/Xlib.h>
|
|
#include <X11/XKBlib.h>
|
|
#include <X11/extensions/XKBgeom.h>
|
|
|
|
#include "XKMformat.h"
|
|
#include "XKBfileInt.h"
|
|
|
|
#else
|
|
|
|
#include "X.h"
|
|
#define NEED_EVENTS
|
|
#include "Xproto.h"
|
|
#include "misc.h"
|
|
#include "inputstr.h"
|
|
#include "dix.h"
|
|
#include "XKBstr.h"
|
|
#define XKBSRV_NEED_FILE_FUNCS 1
|
|
#include "XKBsrv.h"
|
|
#include "XKBgeom.h"
|
|
|
|
#endif
|
|
|
|
/***====================================================================***/
|
|
|
|
#define BUFFER_SIZE 512
|
|
|
|
static char textBuffer[BUFFER_SIZE];
|
|
static int tbNext= 0;
|
|
|
|
static char *
|
|
#if NeedFunctionPrototypes
|
|
tbGetBuffer(unsigned size)
|
|
#else
|
|
tbGetBuffer(size)
|
|
unsigned size;
|
|
#endif
|
|
{
|
|
char *rtrn;
|
|
|
|
if (size>=BUFFER_SIZE)
|
|
return NULL;
|
|
if ((BUFFER_SIZE-tbNext)<=size)
|
|
tbNext= 0;
|
|
rtrn= &textBuffer[tbNext];
|
|
tbNext+= size;
|
|
return rtrn;
|
|
}
|
|
|
|
/***====================================================================***/
|
|
|
|
char *
|
|
#if NeedFunctionPrototypes
|
|
XkbAtomText(Display *dpy,Atom atm,unsigned format)
|
|
#else
|
|
XkbAtomText(dpy,atm,format)
|
|
Display * dpy;
|
|
Atom atm;
|
|
unsigned format;
|
|
#endif
|
|
{
|
|
char *rtrn,*tmp;
|
|
|
|
tmp= XkbAtomGetString(dpy,atm);
|
|
if (tmp!=NULL) {
|
|
int len;
|
|
len= strlen(tmp)+1;
|
|
if (len>BUFFER_SIZE)
|
|
len= BUFFER_SIZE-2;
|
|
rtrn= tbGetBuffer(len);
|
|
strncpy(rtrn,tmp,len);
|
|
rtrn[len]= '\0';
|
|
}
|
|
else {
|
|
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= '_';
|
|
}
|
|
}
|
|
return XkbStringText(rtrn,format);
|
|
}
|
|
|
|
/***====================================================================***/
|
|
|
|
char *
|
|
#if NeedFunctionPrototypes
|
|
XkbVModIndexText(Display *dpy,XkbDescPtr xkb,unsigned ndx,unsigned format)
|
|
#else
|
|
XkbVModIndexText(dpy,xkb,ndx,format)
|
|
Display * dpy;
|
|
XkbDescPtr xkb;
|
|
unsigned ndx;
|
|
unsigned format;
|
|
#endif
|
|
{
|
|
register int len;
|
|
register Atom *vmodNames;
|
|
char *rtrn,*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= XkbAtomGetString(dpy,vmodNames[ndx]);
|
|
if (tmp==NULL)
|
|
sprintf(tmp=numBuf,"%d",ndx);
|
|
|
|
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);
|
|
return rtrn;
|
|
}
|
|
|
|
char *
|
|
#if NeedFunctionPrototypes
|
|
XkbVModMaskText( Display * dpy,
|
|
XkbDescPtr xkb,
|
|
unsigned modMask,
|
|
unsigned mask,
|
|
unsigned format)
|
|
#else
|
|
XkbVModMaskText(dpy,xkb,modMask,mask,format)
|
|
Display * dpy;
|
|
XkbDescPtr xkb;
|
|
unsigned modMask;
|
|
unsigned mask;
|
|
unsigned format;
|
|
#endif
|
|
{
|
|
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;
|
|
|
|
str= buf;
|
|
buf[0]= '\0';
|
|
if (mask) {
|
|
char *tmp;
|
|
for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
|
|
if (mask&bit) {
|
|
tmp= XkbVModIndexText(dpy,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;
|
|
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);
|
|
}
|
|
else {
|
|
i=0;
|
|
}
|
|
if (str!=NULL) {
|
|
if (mm!=NULL) {
|
|
if (format==XkbCFile) strcat(rtrn,"|");
|
|
else strcat(rtrn,"+");
|
|
}
|
|
strncat(rtrn,str,len-i);
|
|
}
|
|
rtrn[len]= '\0';
|
|
return rtrn;
|
|
}
|
|
|
|
static char *modNames[XkbNumModifiers] = {
|
|
"Shift", "Lock", "Control", "Mod1", "Mod2", "Mod3", "Mod4", "Mod5"
|
|
};
|
|
|
|
char *
|
|
#if NeedFunctionPrototypes
|
|
XkbModIndexText(unsigned ndx,unsigned format)
|
|
#else
|
|
XkbModIndexText(ndx,format)
|
|
unsigned ndx;
|
|
unsigned format;
|
|
#endif
|
|
{
|
|
char * rtrn;
|
|
char buf[100];
|
|
|
|
if (format==XkbCFile) {
|
|
if (ndx<XkbNumModifiers)
|
|
sprintf(buf,"%sMapIndex",modNames[ndx]);
|
|
else if (ndx==XkbNoModifier)
|
|
sprintf(buf,"XkbNoModifier");
|
|
else sprintf(buf,"0x%02x",ndx);
|
|
}
|
|
else {
|
|
if (ndx<XkbNumModifiers)
|
|
strcpy(buf,modNames[ndx]);
|
|
else if (ndx==XkbNoModifier)
|
|
strcpy(buf,"none");
|
|
else sprintf(buf,"ILLEGAL_%02x",ndx);
|
|
}
|
|
rtrn= tbGetBuffer(strlen(buf)+1);
|
|
strcpy(rtrn,buf);
|
|
return rtrn;
|
|
}
|
|
|
|
char *
|
|
#if NeedFunctionPrototypes
|
|
XkbModMaskText(unsigned mask,unsigned format)
|
|
#else
|
|
XkbModMaskText(mask,format)
|
|
unsigned mask;
|
|
unsigned format;
|
|
#endif
|
|
{
|
|
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 {
|
|
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);
|
|
return rtrn;
|
|
}
|
|
|
|
/***====================================================================***/
|
|
|
|
/*ARGSUSED*/
|
|
char *
|
|
#if NeedFunctionPrototypes
|
|
XkbConfigText(unsigned config,unsigned format)
|
|
#else
|
|
XkbConfigText(config,format)
|
|
unsigned config;
|
|
unsigned format;
|
|
#endif
|
|
{
|
|
static char *buf;
|
|
|
|
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;
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
/***====================================================================***/
|
|
|
|
char *
|
|
#if NeedFunctionPrototypes
|
|
XkbKeysymText(KeySym sym,unsigned format)
|
|
#else
|
|
XkbKeysymText(sym,format)
|
|
KeySym sym;
|
|
unsigned format;
|
|
#endif
|
|
{
|
|
static char buf[32],*rtrn;
|
|
|
|
#ifndef XKB_IN_SERVER
|
|
if (sym==NoSymbol)
|
|
strcpy(rtrn=buf,"NoSymbol");
|
|
else if ((rtrn=XKeysymToString(sym))==NULL)
|
|
sprintf(rtrn=buf,"0x%x",sym);
|
|
else if (format==XkbCFile) {
|
|
sprintf(buf,"XK_%s",rtrn);
|
|
rtrn= buf;
|
|
}
|
|
return rtrn;
|
|
#else /* def XKB_IN_SERVER */
|
|
if (sym==NoSymbol)
|
|
strcpy(rtrn=buf,"NoSymbol");
|
|
else sprintf(rtrn=buf,"0x%x",sym);
|
|
return rtrn;
|
|
#endif /* XKB_IN_SERVER */
|
|
}
|
|
|
|
char *
|
|
#if NeedFunctionPrototypes
|
|
XkbKeyNameText(char *name,unsigned format)
|
|
#else
|
|
XkbKeyNameText(name,format)
|
|
char * name;
|
|
unsigned format;
|
|
#endif
|
|
{
|
|
char *buf;
|
|
|
|
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';
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
/***====================================================================***/
|
|
|
|
static char *siMatchText[5] = {
|
|
"NoneOf", "AnyOfOrNone", "AnyOf", "AllOf", "Exactly"
|
|
};
|
|
|
|
char *
|
|
#if NeedFunctionPrototypes
|
|
XkbSIMatchText(unsigned type,unsigned format)
|
|
#else
|
|
XkbSIMatchText(type,format)
|
|
unsigned type;
|
|
unsigned format;
|
|
#endif
|
|
{
|
|
static char buf[40];
|
|
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: sprintf(buf,"0x%x",type&XkbSI_OpMask);
|
|
return buf;
|
|
}
|
|
if (format==XkbCFile) {
|
|
if (type&XkbSI_LevelOneOnly)
|
|
sprintf(buf,"XkbSI_LevelOneOnly|XkbSI_%s",rtrn);
|
|
else sprintf(buf,"XkbSI_%s",rtrn);
|
|
rtrn= buf;
|
|
}
|
|
return rtrn;
|
|
}
|
|
|
|
/***====================================================================***/
|
|
|
|
static char *imWhichNames[]= {
|
|
"base",
|
|
"latched",
|
|
"locked",
|
|
"effective",
|
|
"compat"
|
|
};
|
|
|
|
char *
|
|
#if NeedFunctionPrototypes
|
|
XkbIMWhichStateMaskText(unsigned use_which,unsigned format)
|
|
#else
|
|
XkbIMWhichStateMaskText(use_which,format)
|
|
unsigned use_which;
|
|
unsigned format;
|
|
#endif
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
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;
|
|
}
|
|
|
|
char *
|
|
#if NeedFunctionPrototypes
|
|
XkbAccessXDetailText(unsigned state,unsigned format)
|
|
#else
|
|
XkbAccessXDetailText(state,format)
|
|
unsigned state;
|
|
unsigned format;
|
|
#endif
|
|
{
|
|
char *buf,*prefix;
|
|
|
|
buf= tbGetBuffer(32);
|
|
if (format==XkbMessage) prefix= "";
|
|
else prefix= "XkbAXN_";
|
|
switch (state){
|
|
case XkbAXN_SKPress: sprintf(buf,"%sSKPress",prefix); break;
|
|
case XkbAXN_SKAccept: sprintf(buf,"%sSKAccept",prefix); break;
|
|
case XkbAXN_SKRelease: sprintf(buf,"%sSKRelease",prefix); break;
|
|
case XkbAXN_SKReject: sprintf(buf,"%sSKReject",prefix); break;
|
|
case XkbAXN_BKAccept: sprintf(buf,"%sBKAccept",prefix); break;
|
|
case XkbAXN_BKReject: sprintf(buf,"%sBKReject",prefix); break;
|
|
case XkbAXN_AXKWarning: sprintf(buf,"%sAXKWarning",prefix); break;
|
|
default: sprintf(buf,"ILLEGAL"); break;
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
static char *nknNames[] = {
|
|
"keycodes", "geometry", "deviceID"
|
|
};
|
|
#define NUM_NKN (sizeof(nknNames)/sizeof(char *))
|
|
|
|
char *
|
|
#if NeedFunctionPrototypes
|
|
XkbNKNDetailMaskText(unsigned detail,unsigned format)
|
|
#else
|
|
XkbNKNDetailMaskText(detail,format)
|
|
unsigned detail;
|
|
unsigned format;
|
|
#endif
|
|
{
|
|
char *buf,*prefix,*suffix;
|
|
register int i;
|
|
register unsigned bit;
|
|
int len,plen,slen;
|
|
|
|
|
|
if ((detail&XkbAllNewKeyboardEventsMask)==0) {
|
|
char * tmp;
|
|
if (format==XkbCFile) tmp= "0";
|
|
else if (format==XkbMessage) tmp= "none";
|
|
buf= tbGetBuffer(strlen(tmp)+1);
|
|
strcpy(buf,tmp);
|
|
return buf;
|
|
}
|
|
else if ((detail&XkbAllNewKeyboardEventsMask)==XkbAllNewKeyboardEventsMask){
|
|
char * tmp;
|
|
if (format==XkbCFile) tmp= "XkbAllNewKeyboardEventsMask";
|
|
else tmp= "all";
|
|
buf= tbGetBuffer(strlen(tmp)+1);
|
|
strcpy(buf,tmp);
|
|
return buf;
|
|
}
|
|
if (format==XkbMessage) {
|
|
prefix= "";
|
|
suffix= "";
|
|
slen= plen= 0;
|
|
}
|
|
else {
|
|
prefix= "XkbNKN_";
|
|
plen= 7;
|
|
if (format==XkbCFile)
|
|
suffix= "Mask";
|
|
else suffix= "";
|
|
slen= strlen(suffix);
|
|
}
|
|
for (len=0,i=0,bit=1;i<NUM_NKN;i++,bit<<=1) {
|
|
if (detail&bit) {
|
|
if (len!=0) len+= 1; /* room for '+' or '|' */
|
|
len+= plen+slen+strlen(nknNames[i]);
|
|
}
|
|
}
|
|
buf= tbGetBuffer(len+1);
|
|
buf[0]= '\0';
|
|
for (len=0,i=0,bit=1;i<NUM_NKN;i++,bit<<=1) {
|
|
if (detail&bit) {
|
|
if (len!=0) {
|
|
if (format==XkbCFile) buf[len++]= '|';
|
|
else buf[len++]= '+';
|
|
}
|
|
if (plen) {
|
|
strcpy(&buf[len],prefix);
|
|
len+= plen;
|
|
}
|
|
strcpy(&buf[len],nknNames[i]);
|
|
len+= strlen(nknNames[i]);
|
|
if (slen) {
|
|
strcpy(&buf[len],suffix);
|
|
len+= slen;
|
|
}
|
|
}
|
|
}
|
|
buf[len++]= '\0';
|
|
return buf;
|
|
}
|
|
|
|
static char *ctrlNames[] = {
|
|
"repeatKeys",
|
|
"slowKeys",
|
|
"bounceKeys",
|
|
"stickyKeys",
|
|
"mouseKeys",
|
|
"mouseKeysAccel",
|
|
"accessXKeys",
|
|
"accessXTimeout",
|
|
"accessXFeedback",
|
|
"audibleBell",
|
|
"overlay1",
|
|
"overlay2",
|
|
"ignoreGroupLock"
|
|
};
|
|
|
|
char *
|
|
#if NeedFunctionPrototypes
|
|
XkbControlsMaskText(unsigned ctrls,unsigned format)
|
|
#else
|
|
XkbControlsMaskText(ctrls,format)
|
|
unsigned ctrls;
|
|
unsigned format;
|
|
#endif
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
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;
|
|
}
|
|
|
|
/***====================================================================***/
|
|
|
|
char *
|
|
#if NeedFunctionPrototypes
|
|
XkbStringText(char *str,unsigned format)
|
|
#else
|
|
XkbStringText(str,format)
|
|
char * str;
|
|
unsigned format;
|
|
#endif
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
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++;
|
|
}
|
|
}
|
|
}
|
|
*out++= '\0';
|
|
return buf;
|
|
}
|
|
|
|
/***====================================================================***/
|
|
|
|
char *
|
|
#if NeedFunctionPrototypes
|
|
XkbGeomFPText(int val,unsigned format)
|
|
#else
|
|
XkbGeomFPText(val,format)
|
|
int val;
|
|
unsigned format;
|
|
#endif
|
|
{
|
|
int whole,frac;
|
|
char * buf;
|
|
|
|
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);
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
char *
|
|
#if NeedFunctionPrototypes
|
|
XkbDoodadTypeText(unsigned type,unsigned format)
|
|
#else
|
|
XkbDoodadTypeText(type,format)
|
|
unsigned type;
|
|
unsigned format;
|
|
#endif
|
|
{
|
|
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);
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
static char *actionTypeNames[XkbSA_NumActions]= {
|
|
"NoAction",
|
|
"SetMods", "LatchMods", "LockMods",
|
|
"SetGroup", "LatchGroup", "LockGroup",
|
|
"MovePtr",
|
|
"PtrBtn", "LockPtrBtn",
|
|
"SetPtrDflt",
|
|
"ISOLock",
|
|
"Terminate", "SwitchScreen",
|
|
"SetControls", "LockControls",
|
|
"ActionMessage",
|
|
"RedirectKey",
|
|
"DeviceBtn", "LockDeviceBtn"
|
|
};
|
|
|
|
char *
|
|
#if NeedFunctionPrototypes
|
|
XkbActionTypeText(unsigned type,unsigned format)
|
|
#else
|
|
XkbActionTypeText(type,format)
|
|
unsigned type;
|
|
unsigned format;
|
|
#endif
|
|
{
|
|
static char buf[32];
|
|
char *rtrn;
|
|
|
|
if (type<=XkbSA_LastAction) {
|
|
rtrn= actionTypeNames[type];
|
|
if (format==XkbCFile) {
|
|
sprintf(buf,"XkbSA_%s",rtrn);
|
|
return buf;
|
|
}
|
|
return rtrn;
|
|
}
|
|
sprintf(buf,"0x%x",type);
|
|
return buf;
|
|
}
|
|
|
|
/***====================================================================***/
|
|
|
|
static int
|
|
#if NeedFunctionPrototypes
|
|
TryCopyStr(char *to,char *from,int *pLeft)
|
|
#else
|
|
TryCopyStr(to,from,pLeft)
|
|
char * to;
|
|
char * from;
|
|
int * pLeft;
|
|
#endif
|
|
{
|
|
register int len;
|
|
if (*pLeft>0) {
|
|
len= strlen(from);
|
|
if (len<((*pLeft)-3)) {
|
|
strcat(to,from);
|
|
*pLeft-= len;
|
|
return True;
|
|
}
|
|
}
|
|
*pLeft= -1;
|
|
return False;
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Bool
|
|
#if NeedFunctionPrototypes
|
|
CopyNoActionArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,int*sz)
|
|
#else
|
|
CopyNoActionArgs(dpy,xkb,action,buf,sz)
|
|
Display * dpy;
|
|
XkbDescPtr xkb;
|
|
XkbAction * action;
|
|
char * buf;
|
|
int * sz;
|
|
#endif
|
|
{
|
|
return True;
|
|
}
|
|
|
|
static Bool
|
|
#if NeedFunctionPrototypes
|
|
CopyModActionArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,
|
|
int* sz)
|
|
#else
|
|
CopyModActionArgs(dpy,xkb,action,buf,sz)
|
|
Display * dpy;
|
|
XkbDescPtr xkb;
|
|
XkbAction * action;
|
|
char * buf;
|
|
int * sz;
|
|
#endif
|
|
{
|
|
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(dpy,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);
|
|
return True;
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Bool
|
|
#if NeedFunctionPrototypes
|
|
CopyGroupActionArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,
|
|
int *sz)
|
|
#else
|
|
CopyGroupActionArgs(dpy,xkb,action,buf,sz)
|
|
Display * dpy;
|
|
XkbDescPtr xkb;
|
|
XkbAction * action;
|
|
char * buf;
|
|
int * sz;
|
|
#endif
|
|
{
|
|
XkbGroupAction * act;
|
|
char tbuf[32];
|
|
|
|
act= &action->group;
|
|
TryCopyStr(buf,"group=",sz);
|
|
if (act->flags&XkbSA_GroupAbsolute)
|
|
sprintf(tbuf,"%d",XkbSAGroup(act)+1);
|
|
else if (XkbSAGroup(act)<0)
|
|
sprintf(tbuf,"%d",XkbSAGroup(act));
|
|
else sprintf(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
|
|
#if NeedFunctionPrototypes
|
|
CopyMovePtrArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,int *sz)
|
|
#else
|
|
CopyMovePtrArgs(dpy,xkb,action,buf,sz)
|
|
Display * dpy;
|
|
XkbDescPtr xkb;
|
|
XkbAction * action;
|
|
char * buf;
|
|
int * sz;
|
|
#endif
|
|
{
|
|
XkbPtrAction * act;
|
|
int x,y;
|
|
char tbuf[32];
|
|
|
|
act= &action->ptr;
|
|
x= XkbPtrActionX(act);
|
|
y= XkbPtrActionY(act);
|
|
if ((act->flags&XkbSA_MoveAbsoluteX)||(x<0))
|
|
sprintf(tbuf,"x=%d",x);
|
|
else sprintf(tbuf,"x=+%d",x);
|
|
TryCopyStr(buf,tbuf,sz);
|
|
|
|
if ((act->flags&XkbSA_MoveAbsoluteY)||(y<0))
|
|
sprintf(tbuf,",y=%d",y);
|
|
else sprintf(tbuf,",y=+%d",y);
|
|
TryCopyStr(buf,tbuf,sz);
|
|
if (act->flags&XkbSA_NoAcceleration)
|
|
TryCopyStr(buf,",!accel",sz);
|
|
return True;
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Bool
|
|
#if NeedFunctionPrototypes
|
|
CopyPtrBtnArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,int *sz)
|
|
#else
|
|
CopyPtrBtnArgs(dpy,xkb,action,buf,sz)
|
|
Display * dpy;
|
|
XkbDescPtr xkb;
|
|
XkbAction * action;
|
|
char * buf;
|
|
int * sz;
|
|
#endif
|
|
{
|
|
XkbPtrBtnAction * act;
|
|
char tbuf[32];
|
|
|
|
act= &action->btn;
|
|
TryCopyStr(buf,"button=",sz);
|
|
if ((act->button>0)&&(act->button<6)) {
|
|
sprintf(tbuf,"%d",act->button);
|
|
TryCopyStr(buf,tbuf,sz);
|
|
}
|
|
else TryCopyStr(buf,"default",sz);
|
|
if (act->count>0) {
|
|
sprintf(tbuf,",count=%d",act->count);
|
|
TryCopyStr(buf,tbuf,sz);
|
|
}
|
|
if (action->type==XkbSA_LockPtrBtn) {
|
|
switch (act->flags&(XkbSA_LockNoUnlock|XkbSA_LockNoLock)) {
|
|
case XkbSA_LockNoLock:
|
|
sprintf(tbuf,",affect=unlock"); break;
|
|
case XkbSA_LockNoUnlock:
|
|
sprintf(tbuf,",affect=lock"); break;
|
|
case XkbSA_LockNoUnlock|XkbSA_LockNoLock:
|
|
sprintf(tbuf,",affect=neither"); break;
|
|
default:
|
|
sprintf(tbuf,",affect=both"); break;
|
|
}
|
|
TryCopyStr(buf,tbuf,sz);
|
|
}
|
|
return True;
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Bool
|
|
#if NeedFunctionPrototypes
|
|
CopySetPtrDfltArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,
|
|
int *sz)
|
|
#else
|
|
CopySetPtrDfltArgs(dpy,xkb,action,buf,sz)
|
|
Display * dpy;
|
|
XkbDescPtr xkb;
|
|
XkbAction * action;
|
|
char * buf;
|
|
int * sz;
|
|
#endif
|
|
{
|
|
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))
|
|
sprintf(tbuf,"%d",XkbSAPtrDfltValue(act));
|
|
else sprintf(tbuf,"+%d",XkbSAPtrDfltValue(act));
|
|
TryCopyStr(buf,tbuf,sz);
|
|
}
|
|
return True;
|
|
}
|
|
|
|
static Bool
|
|
#if NeedFunctionPrototypes
|
|
CopyISOLockArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,int *sz)
|
|
#else
|
|
CopyISOLockArgs(dpy,xkb,action,buf,sz)
|
|
Display * dpy;
|
|
XkbDescPtr xkb;
|
|
XkbAction * action;
|
|
char * buf;
|
|
int * sz;
|
|
#endif
|
|
{
|
|
XkbISOAction * act;
|
|
char tbuf[64];
|
|
|
|
act= &action->iso;
|
|
if (act->flags&XkbSA_ISODfltIsGroup) {
|
|
TryCopyStr(tbuf,"group=",sz);
|
|
if (act->flags&XkbSA_GroupAbsolute)
|
|
sprintf(tbuf,"%d",XkbSAGroup(act)+1);
|
|
else if (XkbSAGroup(act)<0)
|
|
sprintf(tbuf,"%d",XkbSAGroup(act));
|
|
else sprintf(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(dpy,xkb,0,tmp,XkbXKBFile),sz);
|
|
}
|
|
else TryCopyStr(buf,"none",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) {
|
|
sprintf(tbuf,"%sgroups",(nOut>0?"+":""));
|
|
TryCopyStr(buf,tbuf,sz);
|
|
nOut++;
|
|
}
|
|
if ((act->affect&XkbSA_ISONoAffectPtr)==0) {
|
|
sprintf(tbuf,"%spointer",(nOut>0?"+":""));
|
|
TryCopyStr(buf,tbuf,sz);
|
|
nOut++;
|
|
}
|
|
if ((act->affect&XkbSA_ISONoAffectCtrls)==0) {
|
|
sprintf(tbuf,"%scontrols",(nOut>0?"+":""));
|
|
TryCopyStr(buf,tbuf,sz);
|
|
nOut++;
|
|
}
|
|
}
|
|
return True;
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Bool
|
|
#if NeedFunctionPrototypes
|
|
CopySwitchScreenArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,
|
|
int *sz)
|
|
#else
|
|
CopySwitchScreenArgs(dpy,xkb,action,buf,sz)
|
|
Display * dpy;
|
|
XkbDescPtr xkb;
|
|
XkbAction * action;
|
|
char * buf;
|
|
int * sz;
|
|
#endif
|
|
{
|
|
XkbSwitchScreenAction * act;
|
|
char tbuf[32];
|
|
|
|
act= &action->screen;
|
|
if ((act->flags&XkbSA_SwitchAbsolute)||(XkbSAScreen(act)<0))
|
|
sprintf(tbuf,"screen=%d",XkbSAScreen(act));
|
|
else sprintf(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
|
|
#if NeedFunctionPrototypes
|
|
CopySetLockControlsArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,
|
|
char *buf,int *sz)
|
|
#else
|
|
CopySetLockControlsArgs(dpy,xkb,action,buf,sz)
|
|
Display * dpy;
|
|
XkbDescPtr xkb;
|
|
XkbAction * action;
|
|
char * buf;
|
|
int * sz;
|
|
#endif
|
|
{
|
|
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) {
|
|
sprintf(tbuf,"%sRepeatKeys",(nOut>0?"+":""));
|
|
TryCopyStr(buf,tbuf,sz);
|
|
nOut++;
|
|
}
|
|
if (tmp&XkbSlowKeysMask) {
|
|
sprintf(tbuf,"%sSlowKeys",(nOut>0?"+":""));
|
|
TryCopyStr(buf,tbuf,sz);
|
|
nOut++;
|
|
}
|
|
if (tmp&XkbBounceKeysMask) {
|
|
sprintf(tbuf,"%sBounceKeys",(nOut>0?"+":""));
|
|
TryCopyStr(buf,tbuf,sz);
|
|
nOut++;
|
|
}
|
|
if (tmp&XkbStickyKeysMask) {
|
|
sprintf(tbuf,"%sStickyKeys",(nOut>0?"+":""));
|
|
TryCopyStr(buf,tbuf,sz);
|
|
nOut++;
|
|
}
|
|
if (tmp&XkbMouseKeysMask) {
|
|
sprintf(tbuf,"%sMouseKeys",(nOut>0?"+":""));
|
|
TryCopyStr(buf,tbuf,sz);
|
|
nOut++;
|
|
}
|
|
if (tmp&XkbMouseKeysAccelMask) {
|
|
sprintf(tbuf,"%sMouseKeysAccel",(nOut>0?"+":""));
|
|
TryCopyStr(buf,tbuf,sz);
|
|
nOut++;
|
|
}
|
|
if (tmp&XkbAccessXKeysMask) {
|
|
sprintf(tbuf,"%sAccessXKeys",(nOut>0?"+":""));
|
|
TryCopyStr(buf,tbuf,sz);
|
|
nOut++;
|
|
}
|
|
if (tmp&XkbAccessXTimeoutMask) {
|
|
sprintf(tbuf,"%sAccessXTimeout",(nOut>0?"+":""));
|
|
TryCopyStr(buf,tbuf,sz);
|
|
nOut++;
|
|
}
|
|
if (tmp&XkbAccessXFeedbackMask) {
|
|
sprintf(tbuf,"%sAccessXFeedback",(nOut>0?"+":""));
|
|
TryCopyStr(buf,tbuf,sz);
|
|
nOut++;
|
|
}
|
|
if (tmp&XkbAudibleBellMask) {
|
|
sprintf(tbuf,"%sAudibleBell",(nOut>0?"+":""));
|
|
TryCopyStr(buf,tbuf,sz);
|
|
nOut++;
|
|
}
|
|
if (tmp&XkbOverlay1Mask) {
|
|
sprintf(tbuf,"%sOverlay1",(nOut>0?"+":""));
|
|
TryCopyStr(buf,tbuf,sz);
|
|
nOut++;
|
|
}
|
|
if (tmp&XkbOverlay2Mask) {
|
|
sprintf(tbuf,"%sOverlay2",(nOut>0?"+":""));
|
|
TryCopyStr(buf,tbuf,sz);
|
|
nOut++;
|
|
}
|
|
if (tmp&XkbIgnoreGroupLockMask) {
|
|
sprintf(tbuf,"%sIgnoreGroupLock",(nOut>0?"+":""));
|
|
TryCopyStr(buf,tbuf,sz);
|
|
nOut++;
|
|
}
|
|
}
|
|
return True;
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Bool
|
|
#if NeedFunctionPrototypes
|
|
CopyActionMessageArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,
|
|
int *sz)
|
|
#else
|
|
CopyActionMessageArgs(dpy,xkb,action,buf,sz)
|
|
Display * dpy;
|
|
XkbDescPtr xkb;
|
|
XkbAction * action;
|
|
char * buf;
|
|
int * sz;
|
|
#endif
|
|
{
|
|
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);
|
|
sprintf(tbuf,",data[0]=0x%02x",act->message[0]); TryCopyStr(buf,tbuf,sz);
|
|
sprintf(tbuf,",data[1]=0x%02x",act->message[1]); TryCopyStr(buf,tbuf,sz);
|
|
sprintf(tbuf,",data[2]=0x%02x",act->message[2]); TryCopyStr(buf,tbuf,sz);
|
|
sprintf(tbuf,",data[3]=0x%02x",act->message[3]); TryCopyStr(buf,tbuf,sz);
|
|
sprintf(tbuf,",data[4]=0x%02x",act->message[4]); TryCopyStr(buf,tbuf,sz);
|
|
sprintf(tbuf,",data[5]=0x%02x",act->message[5]); TryCopyStr(buf,tbuf,sz);
|
|
return True;
|
|
}
|
|
|
|
static Bool
|
|
#if NeedFunctionPrototypes
|
|
CopyRedirectKeyArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,
|
|
int *sz)
|
|
#else
|
|
CopyRedirectKeyArgs(dpy,xkb,action,buf,sz)
|
|
Display * dpy;
|
|
XkbDescPtr xkb;
|
|
XkbAction * action;
|
|
char * buf;
|
|
int * sz;
|
|
#endif
|
|
{
|
|
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);
|
|
sprintf(tbuf,"key=%s",kn);
|
|
}
|
|
else sprintf(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(dpy,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(dpy,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(dpy,xkb,act->mods_mask&(~act->mods),
|
|
vmods_mask&(~vmods),XkbXKBFile);
|
|
TryCopyStr(buf,",clearMods= ",sz);
|
|
TryCopyStr(buf,tmp,sz);
|
|
}
|
|
}
|
|
return True;
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Bool
|
|
#if NeedFunctionPrototypes
|
|
CopyDeviceBtnArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,
|
|
int *sz)
|
|
#else
|
|
CopyDeviceBtnArgs(dpy,xkb,action,buf,sz)
|
|
Display * dpy;
|
|
XkbDescPtr xkb;
|
|
XkbAction * action;
|
|
char * buf;
|
|
int * sz;
|
|
#endif
|
|
{
|
|
XkbDeviceBtnAction * act;
|
|
char tbuf[32];
|
|
|
|
act= &action->devbtn;
|
|
sprintf(tbuf,"device= %d",act->device); TryCopyStr(buf,tbuf,sz);
|
|
TryCopyStr(buf,",button=",sz);
|
|
sprintf(tbuf,"%d",act->button);
|
|
TryCopyStr(buf,tbuf,sz);
|
|
if (act->count>0) {
|
|
sprintf(tbuf,",count=%d",act->count);
|
|
TryCopyStr(buf,tbuf,sz);
|
|
}
|
|
if (action->type==XkbSA_LockDeviceBtn) {
|
|
switch (act->flags&(XkbSA_LockNoUnlock|XkbSA_LockNoLock)) {
|
|
case XkbSA_LockNoLock:
|
|
sprintf(tbuf,",affect=unlock"); break;
|
|
case XkbSA_LockNoUnlock:
|
|
sprintf(tbuf,",affect=lock"); break;
|
|
case XkbSA_LockNoUnlock|XkbSA_LockNoLock:
|
|
sprintf(tbuf,",affect=neither"); break;
|
|
default:
|
|
sprintf(tbuf,",affect=both"); break;
|
|
}
|
|
TryCopyStr(buf,tbuf,sz);
|
|
}
|
|
return True;
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Bool
|
|
#if NeedFunctionPrototypes
|
|
CopyOtherArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,int *sz)
|
|
#else
|
|
CopyOtherArgs(dpy,xkb,action,buf,sz)
|
|
Display * dpy;
|
|
XkbDescPtr xkb;
|
|
XkbAction * action;
|
|
char * buf;
|
|
int * sz;
|
|
#endif
|
|
{
|
|
XkbAnyAction * act;
|
|
char tbuf[32];
|
|
|
|
act= &action->any;
|
|
sprintf(tbuf,"type=0x%02x",act->type); TryCopyStr(buf,tbuf,sz);
|
|
sprintf(tbuf,",data[0]=0x%02x",act->data[0]); TryCopyStr(buf,tbuf,sz);
|
|
sprintf(tbuf,",data[1]=0x%02x",act->data[1]); TryCopyStr(buf,tbuf,sz);
|
|
sprintf(tbuf,",data[2]=0x%02x",act->data[2]); TryCopyStr(buf,tbuf,sz);
|
|
sprintf(tbuf,",data[3]=0x%02x",act->data[3]); TryCopyStr(buf,tbuf,sz);
|
|
sprintf(tbuf,",data[4]=0x%02x",act->data[4]); TryCopyStr(buf,tbuf,sz);
|
|
sprintf(tbuf,",data[5]=0x%02x",act->data[5]); TryCopyStr(buf,tbuf,sz);
|
|
sprintf(tbuf,",data[6]=0x%02x",act->data[6]); TryCopyStr(buf,tbuf,sz);
|
|
return True;
|
|
}
|
|
|
|
typedef Bool (*actionCopy)(
|
|
#if NeedFunctionPrototypes
|
|
Display * /* dpy */,
|
|
XkbDescPtr /* xkb */,
|
|
XkbAction * /* action */,
|
|
char * /* buf */,
|
|
int* /* sz */
|
|
#endif
|
|
);
|
|
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 *
|
|
#if NeedFunctionPrototypes
|
|
XkbActionText(Display *dpy,XkbDescPtr xkb,XkbAction *action,unsigned format)
|
|
#else
|
|
XkbActionText(dpy,xkb,action,format)
|
|
Display * dpy;
|
|
XkbDescPtr xkb;
|
|
XkbAction * action;
|
|
unsigned format;
|
|
#endif
|
|
{
|
|
char buf[ACTION_SZ],*tmp;
|
|
int sz;
|
|
|
|
if (format==XkbCFile) {
|
|
sprintf(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 {
|
|
sprintf(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])(dpy,xkb,action,buf,&sz);
|
|
else CopyOtherArgs(dpy,xkb,action,buf,&sz);
|
|
TryCopyStr(buf,")",&sz);
|
|
}
|
|
tmp= tbGetBuffer(strlen(buf)+1);
|
|
if (tmp!=NULL)
|
|
strcpy(tmp,buf);
|
|
return tmp;
|
|
}
|
|
|
|
char *
|
|
#if NeedFunctionPrototypes
|
|
XkbBehaviorText(XkbDescPtr xkb,XkbBehavior *behavior,unsigned format)
|
|
#else
|
|
XkbBehaviorText(xkb,behavior,format)
|
|
XkbDescPtr xkb;
|
|
XkbBehavior * behavior;
|
|
unsigned format;
|
|
#endif
|
|
{
|
|
char buf[256],*tmp;
|
|
|
|
if (format==XkbCFile) {
|
|
if (behavior->type==XkbKB_Default)
|
|
sprintf(buf,"{ 0, 0 }");
|
|
else sprintf(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) {
|
|
sprintf(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) {
|
|
sprintf(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];
|
|
sprintf(tbuf,"%d",kc);
|
|
kn= tbuf;
|
|
}
|
|
if (permanent)
|
|
sprintf(buf,"permanentOverlay%d= %s",ndx,kn);
|
|
else sprintf(buf,"overlay%d= %s",ndx,kn);
|
|
}
|
|
}
|
|
tmp= tbGetBuffer(strlen(buf)+1);
|
|
if (tmp!=NULL)
|
|
strcpy(tmp,buf);
|
|
return tmp;
|
|
}
|
|
|
|
/***====================================================================***/
|
|
|
|
char *
|
|
#if NeedFunctionPrototypes
|
|
XkbIndentText(unsigned size)
|
|
#else
|
|
XkbIndentText(size)
|
|
unsigned size;
|
|
#endif
|
|
{
|
|
static char buf[32];
|
|
register int i;
|
|
|
|
if (size>31)
|
|
size= 31;
|
|
|
|
for (i=0;i<size;i++) {
|
|
buf[i]= ' ';
|
|
}
|
|
buf[size]= '\0';
|
|
return buf;
|
|
}
|
|
|
|
#ifndef XKB_IN_SERVER
|
|
|
|
/***====================================================================***/
|
|
|
|
#define PIXEL_MAX 65535
|
|
|
|
Bool
|
|
#if NeedFunctionPrototypes
|
|
XkbLookupCanonicalRGBColor(char *def,XColor *color)
|
|
#else
|
|
XkbLookupCanonicalRGBColor(def,color)
|
|
char * def;
|
|
XColor * color;
|
|
#endif
|
|
{
|
|
int tmp;
|
|
|
|
if (_XkbStrCaseEqual(def,"black")) {
|
|
color->red= color->green= color->blue= 0;
|
|
return True;
|
|
}
|
|
else if (_XkbStrCaseEqual(def,"white")) {
|
|
color->red= color->green= color->blue= PIXEL_MAX;
|
|
return True;
|
|
}
|
|
else if ((sscanf(def,"grey%d",&tmp)==1)||
|
|
(sscanf(def,"gray%d",&tmp)==1)||
|
|
(sscanf(def,"Grey%d",&tmp)==1)||
|
|
(sscanf(def,"Gray%d",&tmp)==1)) {
|
|
if ((tmp>0)&&(tmp<=100)) {
|
|
tmp= (PIXEL_MAX*tmp)/100;
|
|
color->red= color->green= color->blue= tmp;
|
|
return True;
|
|
}
|
|
}
|
|
else if ((tmp=(_XkbStrCaseEqual(def,"red")*100))||
|
|
(sscanf(def,"red%d",&tmp)==1)) {
|
|
if ((tmp>0)&&(tmp<=100)) {
|
|
tmp= (PIXEL_MAX*tmp)/100;
|
|
color->red= tmp;
|
|
color->green= color->blue= 0;
|
|
return True;
|
|
}
|
|
}
|
|
else if ((tmp=(_XkbStrCaseEqual(def,"green")*100))||
|
|
(sscanf(def,"green%d",&tmp)==1)) {
|
|
if ((tmp>0)&&(tmp<=100)) {
|
|
tmp= (PIXEL_MAX*tmp)/100;
|
|
color->green= tmp;
|
|
color->red= color->blue= 0;
|
|
return True;
|
|
}
|
|
}
|
|
else if ((tmp=(_XkbStrCaseEqual(def,"blue")*100))||
|
|
(sscanf(def,"blue%d",&tmp)==1)) {
|
|
if ((tmp>0)&&(tmp<=100)) {
|
|
tmp= (PIXEL_MAX*tmp)/100;
|
|
color->blue= tmp;
|
|
color->red= color->green= 0;
|
|
return True;
|
|
}
|
|
}
|
|
else if ((tmp=(_XkbStrCaseEqual(def,"magenta")*100))||
|
|
(sscanf(def,"magenta%d",&tmp)==1)) {
|
|
if ((tmp>0)&&(tmp<=100)) {
|
|
tmp= (PIXEL_MAX*tmp)/100;
|
|
color->green= 0;
|
|
color->red= color->blue= tmp;
|
|
return True;
|
|
}
|
|
}
|
|
else if ((tmp=(_XkbStrCaseEqual(def,"cyan")*100))||
|
|
(sscanf(def,"cyan%d",&tmp)==1)) {
|
|
if ((tmp>0)&&(tmp<=100)) {
|
|
tmp= (PIXEL_MAX*tmp)/100;
|
|
color->red= 0;
|
|
color->green= color->blue= tmp;
|
|
return True;
|
|
}
|
|
}
|
|
else if ((tmp=(_XkbStrCaseEqual(def,"yellow")*100))||
|
|
(sscanf(def,"yellow%d",&tmp)==1)) {
|
|
if ((tmp>0)&&(tmp<=100)) {
|
|
tmp= (PIXEL_MAX*tmp)/100;
|
|
color->blue= 0;
|
|
color->red= color->green= tmp;
|
|
return True;
|
|
}
|
|
}
|
|
return False;
|
|
}
|
|
|
|
#endif
|