← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/xserver-xgl/intrepid

« back to all changes in this revision

Viewing changes to xkb/xkbtext.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthew Garrett
  • Date: 2006-02-13 14:21:43 UTC
  • Revision ID: james.westby@ubuntu.com-20060213142143-mad6z9xzem7hzxz9
Tags: upstream-7.0.0
Import upstream version 7.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
xkb/xkbtext.c
 
1
/* $Xorg: xkbtext.c,v 1.3 2000/08/17 19:46:44 cpqbld Exp $ */
 
2
/************************************************************
 
3
 Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
 
4
 
 
5
 Permission to use, copy, modify, and distribute this
 
6
 software and its documentation for any purpose and without
 
7
 fee is hereby granted, provided that the above copyright
 
8
 notice appear in all copies and that both that copyright
 
9
 notice and this permission notice appear in supporting
 
10
 documentation, and that the name of Silicon Graphics not be 
 
11
 used in advertising or publicity pertaining to distribution 
 
12
 of the software without specific prior written permission.
 
13
 Silicon Graphics makes no representation about the suitability 
 
14
 of this software for any purpose. It is provided "as is"
 
15
 without any express or implied warranty.
 
16
 
 
17
 SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS 
 
18
 SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 
 
19
 AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
 
20
 GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
 
21
 DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 
 
22
 DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 
 
23
 OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
 
24
 THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
25
 
 
26
 ********************************************************/
 
27
/* $XFree86: xc/lib/xkbfile/xkbtext.c,v 3.11 2002/12/21 18:49:02 paulo Exp $ */
 
28
 
 
29
#ifdef HAVE_DIX_CONFIG_H
 
30
#include <dix-config.h>
 
31
#elif defined(HAVE_CONFIG_H)
 
32
#include <config.h>
 
33
#endif
 
34
 
 
35
#include <stdio.h>
 
36
#include <ctype.h>
 
37
#include <stdlib.h>
 
38
 
 
39
#include <X11/Xos.h>
 
40
 
 
41
#ifndef XKB_IN_SERVER
 
42
 
 
43
#include <X11/Xlib.h>
 
44
#include <X11/XKBlib.h>
 
45
#include <X11/extensions/XKBgeom.h>
 
46
 
 
47
#include "XKMformat.h"
 
48
#include "XKBfileInt.h"
 
49
 
 
50
#else
 
51
 
 
52
#include <X11/X.h>
 
53
#define NEED_EVENTS
 
54
#include <X11/Xproto.h>
 
55
#include "misc.h"
 
56
#include "inputstr.h"
 
57
#include "dix.h"
 
58
#include <X11/extensions/XKBstr.h>
 
59
#define XKBSRV_NEED_FILE_FUNCS  1
 
60
#include <X11/extensions/XKBsrv.h>
 
61
#include <X11/extensions/XKBgeom.h>
 
62
 
 
63
#endif
 
64
 
 
65
/***====================================================================***/
 
66
 
 
67
#define BUFFER_SIZE     512
 
68
 
 
69
static char textBuffer[BUFFER_SIZE];
 
70
static int  tbNext= 0;
 
71
 
 
72
static char *
 
73
tbGetBuffer(unsigned size)
 
74
{
 
75
char *rtrn;
 
76
 
 
77
    if (size>=BUFFER_SIZE)
 
78
        return NULL;
 
79
    if ((BUFFER_SIZE-tbNext)<=size)
 
80
        tbNext= 0;
 
81
    rtrn= &textBuffer[tbNext];
 
82
    tbNext+= size;
 
83
    return rtrn;
 
84
}
 
85
 
 
86
/***====================================================================***/
 
87
 
 
88
char *
 
89
XkbAtomText(Display *dpy,Atom atm,unsigned format)
 
90
{
 
91
char    *rtrn,*tmp;
 
92
 
 
93
    tmp= XkbAtomGetString(dpy,atm);
 
94
    if (tmp!=NULL) {
 
95
        int     len;
 
96
        len= strlen(tmp)+1;
 
97
        if (len>BUFFER_SIZE)
 
98
            len= BUFFER_SIZE-2;
 
99
        rtrn= tbGetBuffer(len);
 
100
        strncpy(rtrn,tmp,len);
 
101
        rtrn[len]= '\0';
 
102
    }
 
103
    else {
 
104
        rtrn= tbGetBuffer(1);
 
105
        rtrn[0]= '\0';
 
106
    }
 
107
    if (format==XkbCFile) {
 
108
        for (tmp=rtrn;*tmp!='\0';tmp++) {
 
109
            if ((tmp==rtrn)&&(!isalpha(*tmp)))
 
110
                *tmp= '_';
 
111
            else if (!isalnum(*tmp))
 
112
                *tmp= '_';
 
113
        }
 
114
    }
 
115
    return XkbStringText(rtrn,format);
 
116
}
 
117
 
 
118
/***====================================================================***/
 
119
 
 
120
char *
 
121
XkbVModIndexText(Display *dpy,XkbDescPtr xkb,unsigned ndx,unsigned format)
 
122
{
 
123
register int len;
 
124
register Atom *vmodNames;
 
125
char *rtrn,*tmp;
 
126
char  numBuf[20];
 
127
 
 
128
    if (xkb && xkb->names)
 
129
         vmodNames= xkb->names->vmods;
 
130
    else vmodNames= NULL;
 
131
 
 
132
    tmp= NULL;
 
133
    if (ndx>=XkbNumVirtualMods)
 
134
         tmp= "illegal";
 
135
    else if (vmodNames&&(vmodNames[ndx]!=None))
 
136
         tmp= XkbAtomGetString(dpy,vmodNames[ndx]);
 
137
    if (tmp==NULL)
 
138
        sprintf(tmp=numBuf,"%d",ndx);
 
139
 
 
140
    len= strlen(tmp)+1;
 
141
    if (format==XkbCFile)
 
142
        len+= 4;
 
143
    if (len>=BUFFER_SIZE)
 
144
        len= BUFFER_SIZE-1;
 
145
    rtrn= tbGetBuffer(len);
 
146
    if (format==XkbCFile) {
 
147
         strcpy(rtrn,"vmod_");
 
148
         strncpy(&rtrn[5],tmp,len-4);
 
149
    }
 
150
    else strncpy(rtrn,tmp,len);
 
151
    return rtrn;
 
152
}
 
153
 
 
154
char *
 
155
XkbVModMaskText(        Display *       dpy,
 
156
                        XkbDescPtr      xkb,
 
157
                        unsigned        modMask,
 
158
                        unsigned        mask,
 
159
                        unsigned        format)
 
160
{
 
161
register int i,bit;
 
162
int      len;
 
163
char *mm,*rtrn;
 
164
char *str,buf[BUFFER_SIZE];
 
165
 
 
166
    if ((modMask==0)&&(mask==0)) {
 
167
        rtrn= tbGetBuffer(5);
 
168
        if (format==XkbCFile)
 
169
             sprintf(rtrn,"0");
 
170
        else sprintf(rtrn,"none");
 
171
        return rtrn;
 
172
    }
 
173
    if (modMask!=0)
 
174
         mm= XkbModMaskText(modMask,format);
 
175
    else mm= NULL;
 
176
 
 
177
    str= buf;
 
178
    buf[0]= '\0';
 
179
    if (mask) {
 
180
        char *tmp;
 
181
        for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
 
182
            if (mask&bit) {
 
183
                tmp= XkbVModIndexText(dpy,xkb,i,format);
 
184
                len= strlen(tmp)+1+(str==buf?0:1);
 
185
                if (format==XkbCFile)
 
186
                    len+= 4;
 
187
                if ((str-(buf+len))<=BUFFER_SIZE) {
 
188
                    if (str!=buf) {
 
189
                        if (format==XkbCFile)   *str++= '|';
 
190
                        else                    *str++= '+';
 
191
                        len--;
 
192
                    }
 
193
                }
 
194
                if (format==XkbCFile)
 
195
                     sprintf(str,"%sMask",tmp);
 
196
                else strcpy(str,tmp);
 
197
                str= &str[len-1];
 
198
            }
 
199
        }
 
200
        str= buf;
 
201
    }
 
202
    else str= NULL;
 
203
    if (mm)     
 
204
        len= strlen(mm);
 
205
    else        len= 0;
 
206
    if (str)
 
207
        len+= strlen(str)+(mm==NULL?0:1);
 
208
    if (len>=BUFFER_SIZE)
 
209
        len= BUFFER_SIZE-1;
 
210
    rtrn= tbGetBuffer(len+1);
 
211
    rtrn[0]= '\0';
 
212
 
 
213
    if (mm!=NULL) {
 
214
        i= strlen(mm);
 
215
        if (i>len)
 
216
            i= len;
 
217
        strcpy(rtrn,mm);
 
218
    }
 
219
    else {
 
220
        i=0;
 
221
    }
 
222
    if (str!=NULL) {
 
223
        if (mm!=NULL) {
 
224
            if (format==XkbCFile)       strcat(rtrn,"|");
 
225
            else                        strcat(rtrn,"+");
 
226
        }
 
227
        strncat(rtrn,str,len-i);
 
228
    }
 
229
    rtrn[len]= '\0';
 
230
    return rtrn;
 
231
}
 
232
 
 
233
static char *modNames[XkbNumModifiers] = {
 
234
    "Shift", "Lock", "Control", "Mod1", "Mod2", "Mod3", "Mod4", "Mod5"
 
235
};
 
236
 
 
237
char *
 
238
XkbModIndexText(unsigned ndx,unsigned format)
 
239
{
 
240
char *  rtrn;
 
241
char    buf[100];
 
242
 
 
243
    if (format==XkbCFile) {
 
244
        if (ndx<XkbNumModifiers)
 
245
             sprintf(buf,"%sMapIndex",modNames[ndx]);
 
246
        else if (ndx==XkbNoModifier)
 
247
             sprintf(buf,"XkbNoModifier");
 
248
        else sprintf(buf,"0x%02x",ndx);
 
249
    }
 
250
    else {
 
251
        if (ndx<XkbNumModifiers)
 
252
             strcpy(buf,modNames[ndx]);
 
253
        else if (ndx==XkbNoModifier)
 
254
             strcpy(buf,"none");
 
255
        else sprintf(buf,"ILLEGAL_%02x",ndx);
 
256
    }
 
257
    rtrn= tbGetBuffer(strlen(buf)+1);
 
258
    strcpy(rtrn,buf);
 
259
    return rtrn;
 
260
}
 
261
 
 
262
char *
 
263
XkbModMaskText(unsigned mask,unsigned format)
 
264
{
 
265
register int i,bit;
 
266
char buf[64],*rtrn;
 
267
 
 
268
    if ((mask&0xff)==0xff) {
 
269
        if (format==XkbCFile)           strcpy(buf,"0xff");
 
270
        else                            strcpy(buf,"all");
 
271
    }
 
272
    else if ((mask&0xff)==0) {
 
273
        if (format==XkbCFile)           strcpy(buf,"0");
 
274
        else                            strcpy(buf,"none");
 
275
    }
 
276
    else {
 
277
        char *str= buf;
 
278
        buf[0]= '\0';
 
279
        for (i=0,bit=1;i<XkbNumModifiers;i++,bit<<=1) {
 
280
            if (mask&bit) {
 
281
                if (str!=buf) {
 
282
                    if (format==XkbCFile)       *str++= '|';
 
283
                    else                        *str++= '+';
 
284
                }
 
285
                strcpy(str,modNames[i]);
 
286
                str= &str[strlen(str)];
 
287
                if (format==XkbCFile) {
 
288
                    strcpy(str,"Mask");
 
289
                    str+= 4;
 
290
                }
 
291
            }
 
292
        }
 
293
    }
 
294
    rtrn= tbGetBuffer(strlen(buf)+1);
 
295
    strcpy(rtrn,buf);
 
296
    return rtrn;
 
297
}
 
298
 
 
299
/***====================================================================***/
 
300
 
 
301
/*ARGSUSED*/
 
302
char *
 
303
XkbConfigText(unsigned config,unsigned format)
 
304
{
 
305
static char *buf;
 
306
 
 
307
    buf= tbGetBuffer(32);
 
308
    switch (config) {
 
309
        case XkmSemanticsFile:
 
310
            strcpy(buf,"Semantics");
 
311
            break;
 
312
        case XkmLayoutFile:
 
313
            strcpy(buf,"Layout");
 
314
            break;
 
315
        case XkmKeymapFile:
 
316
            strcpy(buf,"Keymap");
 
317
            break;
 
318
        case XkmGeometryFile:
 
319
        case XkmGeometryIndex:
 
320
            strcpy(buf,"Geometry");
 
321
            break;
 
322
        case XkmTypesIndex:
 
323
            strcpy(buf,"Types");
 
324
            break;
 
325
        case XkmCompatMapIndex:
 
326
            strcpy(buf,"CompatMap");
 
327
            break;
 
328
        case XkmSymbolsIndex:
 
329
            strcpy(buf,"Symbols");
 
330
            break;
 
331
        case XkmIndicatorsIndex:
 
332
            strcpy(buf,"Indicators");
 
333
            break;
 
334
        case XkmKeyNamesIndex:
 
335
            strcpy(buf,"KeyNames");
 
336
            break;
 
337
        case XkmVirtualModsIndex:
 
338
            strcpy(buf,"VirtualMods");
 
339
            break;
 
340
        default:
 
341
            sprintf(buf,"unknown(%d)",config);
 
342
            break;
 
343
    }
 
344
    return buf;
 
345
}
 
346
 
 
347
/***====================================================================***/
 
348
 
 
349
char *
 
350
XkbKeysymText(KeySym sym,unsigned format)
 
351
{
 
352
static char buf[32],*rtrn;
 
353
 
 
354
#ifndef XKB_IN_SERVER
 
355
    if (sym==NoSymbol)
 
356
        strcpy(rtrn=buf,"NoSymbol");
 
357
    else if ((rtrn=XKeysymToString(sym))==NULL)
 
358
        sprintf(rtrn=buf, "0x%lx", (long)sym);
 
359
    else if (format==XkbCFile) {
 
360
        sprintf(buf,"XK_%s",rtrn);
 
361
        rtrn= buf;
 
362
    }
 
363
    return rtrn;
 
364
#else /* def XKB_IN_SERVER */
 
365
    if (sym==NoSymbol)
 
366
         strcpy(rtrn=buf,"NoSymbol");
 
367
    else sprintf(rtrn=buf, "0x%lx", (long)sym);
 
368
    return rtrn;
 
369
#endif /* XKB_IN_SERVER */
 
370
}
 
371
 
 
372
char *
 
373
XkbKeyNameText(char *name,unsigned format)
 
374
{
 
375
char *buf;
 
376
 
 
377
    if (format==XkbCFile) {
 
378
        buf= tbGetBuffer(5);
 
379
        memcpy(buf,name,4);
 
380
        buf[4]= '\0';
 
381
    }
 
382
    else {
 
383
        int len;
 
384
        buf= tbGetBuffer(7);
 
385
        buf[0]= '<';
 
386
        memcpy(&buf[1],name,4);
 
387
        buf[5]= '\0';
 
388
        len= strlen(buf);
 
389
        buf[len++]= '>';
 
390
        buf[len]= '\0';
 
391
    }
 
392
    return buf;
 
393
}
 
394
 
 
395
/***====================================================================***/
 
396
 
 
397
static char *siMatchText[5] = {
 
398
        "NoneOf", "AnyOfOrNone", "AnyOf", "AllOf", "Exactly"
 
399
};
 
400
 
 
401
char *
 
402
XkbSIMatchText(unsigned type,unsigned format)
 
403
{
 
404
static char buf[40];
 
405
char *rtrn;
 
406
 
 
407
    switch (type&XkbSI_OpMask) {
 
408
        case XkbSI_NoneOf:      rtrn= siMatchText[0]; break;
 
409
        case XkbSI_AnyOfOrNone: rtrn= siMatchText[1]; break;
 
410
        case XkbSI_AnyOf:       rtrn= siMatchText[2]; break;
 
411
        case XkbSI_AllOf:       rtrn= siMatchText[3]; break;
 
412
        case XkbSI_Exactly:     rtrn= siMatchText[4]; break;
 
413
        default:                sprintf(buf,"0x%x",type&XkbSI_OpMask);
 
414
                                return buf;
 
415
    }
 
416
    if (format==XkbCFile) {
 
417
        if (type&XkbSI_LevelOneOnly)
 
418
             sprintf(buf,"XkbSI_LevelOneOnly|XkbSI_%s",rtrn);
 
419
        else sprintf(buf,"XkbSI_%s",rtrn);
 
420
        rtrn= buf;
 
421
    }
 
422
    return rtrn;
 
423
}
 
424
 
 
425
/***====================================================================***/
 
426
 
 
427
static char *imWhichNames[]= {
 
428
        "base",
 
429
        "latched",
 
430
        "locked",
 
431
        "effective",
 
432
        "compat"
 
433
};
 
434
 
 
435
char *
 
436
XkbIMWhichStateMaskText(unsigned use_which,unsigned format)
 
437
{
 
438
int             len;
 
439
unsigned        i,bit,tmp;
 
440
char *          buf;
 
441
 
 
442
    if (use_which==0) {
 
443
        buf= tbGetBuffer(2);
 
444
        strcpy(buf,"0");
 
445
        return buf;
 
446
    }
 
447
    tmp= use_which&XkbIM_UseAnyMods;
 
448
    for (len=i=0,bit=1;tmp!=0;i++,bit<<=1) {
 
449
        if (tmp&bit) {
 
450
            tmp&= ~bit;
 
451
            len+= strlen(imWhichNames[i])+1;
 
452
            if (format==XkbCFile)
 
453
                len+= 9;
 
454
        }
 
455
    }
 
456
    buf= tbGetBuffer(len+1);
 
457
    tmp= use_which&XkbIM_UseAnyMods;
 
458
    for (len=i=0,bit=1;tmp!=0;i++,bit<<=1) {
 
459
        if (tmp&bit) {
 
460
            tmp&= ~bit;
 
461
            if (format==XkbCFile) {
 
462
                if (len!=0)
 
463
                    buf[len++]= '|';
 
464
                sprintf(&buf[len],"XkbIM_Use%s",imWhichNames[i]);
 
465
                buf[len+9]= toupper(buf[len+9]);
 
466
            }
 
467
            else {
 
468
                if (len!=0)
 
469
                    buf[len++]= '+';
 
470
                sprintf(&buf[len],"%s",imWhichNames[i]);
 
471
            }
 
472
            len+= strlen(&buf[len]);
 
473
        }
 
474
    }
 
475
    return buf;
 
476
}
 
477
 
 
478
char *
 
479
XkbAccessXDetailText(unsigned state,unsigned format)
 
480
{
 
481
char *buf,*prefix;
 
482
 
 
483
    buf= tbGetBuffer(32);
 
484
    if (format==XkbMessage)     prefix= "";
 
485
    else                        prefix= "XkbAXN_";
 
486
    switch (state){
 
487
        case XkbAXN_SKPress:    sprintf(buf,"%sSKPress",prefix); break;
 
488
        case XkbAXN_SKAccept:   sprintf(buf,"%sSKAccept",prefix); break;
 
489
        case XkbAXN_SKRelease:  sprintf(buf,"%sSKRelease",prefix); break;
 
490
        case XkbAXN_SKReject:   sprintf(buf,"%sSKReject",prefix); break;
 
491
        case XkbAXN_BKAccept:   sprintf(buf,"%sBKAccept",prefix); break;
 
492
        case XkbAXN_BKReject:   sprintf(buf,"%sBKReject",prefix); break;
 
493
        case XkbAXN_AXKWarning: sprintf(buf,"%sAXKWarning",prefix); break;
 
494
        default:                sprintf(buf,"ILLEGAL"); break;
 
495
    }
 
496
    return buf;
 
497
}
 
498
 
 
499
static char *nknNames[] = {
 
500
        "keycodes", "geometry", "deviceID"
 
501
};
 
502
#define NUM_NKN (sizeof(nknNames)/sizeof(char *))
 
503
 
 
504
char *
 
505
XkbNKNDetailMaskText(unsigned detail,unsigned format)
 
506
{
 
507
char *buf,*prefix,*suffix;
 
508
register int            i;
 
509
register unsigned       bit;
 
510
int                     len,plen,slen;
 
511
 
 
512
 
 
513
    if ((detail&XkbAllNewKeyboardEventsMask)==0) {
 
514
        char *tmp = "";
 
515
        if (format==XkbCFile)                   tmp= "0";
 
516
        else if (format==XkbMessage)            tmp= "none";
 
517
        buf=  tbGetBuffer(strlen(tmp)+1);
 
518
        strcpy(buf,tmp);
 
519
        return buf;
 
520
    }
 
521
    else if ((detail&XkbAllNewKeyboardEventsMask)==XkbAllNewKeyboardEventsMask){
 
522
        char *  tmp;
 
523
        if (format==XkbCFile)           tmp= "XkbAllNewKeyboardEventsMask";
 
524
        else                            tmp= "all";
 
525
        buf=  tbGetBuffer(strlen(tmp)+1);
 
526
        strcpy(buf,tmp);
 
527
        return buf;
 
528
    }
 
529
    if (format==XkbMessage) {
 
530
        prefix= "";
 
531
        suffix= "";
 
532
        slen= plen= 0;
 
533
    }
 
534
    else {
 
535
        prefix= "XkbNKN_";
 
536
        plen= 7;
 
537
        if (format==XkbCFile)
 
538
             suffix= "Mask";
 
539
        else suffix= "";
 
540
        slen= strlen(suffix);
 
541
    }
 
542
    for (len=0,i=0,bit=1;i<NUM_NKN;i++,bit<<=1) {
 
543
        if (detail&bit) {
 
544
            if (len!=0) len+= 1;        /* room for '+' or '|' */
 
545
            len+= plen+slen+strlen(nknNames[i]);
 
546
        }
 
547
    }
 
548
    buf= tbGetBuffer(len+1);
 
549
    buf[0]= '\0';
 
550
    for (len=0,i=0,bit=1;i<NUM_NKN;i++,bit<<=1) {
 
551
        if (detail&bit) {
 
552
            if (len!=0) {
 
553
                if (format==XkbCFile)   buf[len++]= '|';
 
554
                else                    buf[len++]= '+';
 
555
            }
 
556
            if (plen) {
 
557
                strcpy(&buf[len],prefix);
 
558
                len+= plen;
 
559
            }
 
560
            strcpy(&buf[len],nknNames[i]);
 
561
            len+= strlen(nknNames[i]);
 
562
            if (slen) {
 
563
                strcpy(&buf[len],suffix);
 
564
                len+= slen;
 
565
            }
 
566
        }
 
567
    }
 
568
    buf[len++]= '\0';
 
569
    return buf;
 
570
}
 
571
 
 
572
static char *ctrlNames[] = {
 
573
        "repeatKeys",
 
574
        "slowKeys",
 
575
        "bounceKeys",
 
576
        "stickyKeys",
 
577
        "mouseKeys",
 
578
        "mouseKeysAccel",
 
579
        "accessXKeys",
 
580
        "accessXTimeout",
 
581
        "accessXFeedback",
 
582
        "audibleBell",
 
583
        "overlay1",
 
584
        "overlay2",
 
585
        "ignoreGroupLock"
 
586
};
 
587
 
 
588
char *
 
589
XkbControlsMaskText(unsigned ctrls,unsigned format)
 
590
{
 
591
int             len;
 
592
unsigned        i,bit,tmp;
 
593
char *          buf;
 
594
 
 
595
    if (ctrls==0) {
 
596
        buf= tbGetBuffer(5);
 
597
        if (format==XkbCFile)
 
598
             strcpy(buf,"0");
 
599
        else strcpy(buf,"none");
 
600
        return buf;
 
601
    }
 
602
    tmp= ctrls&XkbAllBooleanCtrlsMask;
 
603
    for (len=i=0,bit=1;tmp!=0;i++,bit<<=1) {
 
604
        if (tmp&bit) {
 
605
            tmp&= ~bit;
 
606
            len+= strlen(ctrlNames[i])+1;
 
607
            if (format==XkbCFile)
 
608
                len+= 7;
 
609
        }
 
610
    }
 
611
    buf= tbGetBuffer(len+1);
 
612
    tmp= ctrls&XkbAllBooleanCtrlsMask;
 
613
    for (len=i=0,bit=1;tmp!=0;i++,bit<<=1) {
 
614
        if (tmp&bit) {
 
615
            tmp&= ~bit;
 
616
            if (format==XkbCFile) {
 
617
                if (len!=0)
 
618
                    buf[len++]= '|';
 
619
                sprintf(&buf[len],"Xkb%sMask",ctrlNames[i]);
 
620
                buf[len+3]= toupper(buf[len+3]);
 
621
            }
 
622
            else {
 
623
                if (len!=0)
 
624
                    buf[len++]= '+';
 
625
                sprintf(&buf[len],"%s",ctrlNames[i]);
 
626
            }
 
627
            len+= strlen(&buf[len]);
 
628
        }
 
629
    }
 
630
    return buf;
 
631
}
 
632
 
 
633
/***====================================================================***/
 
634
 
 
635
char *
 
636
XkbStringText(char *str,unsigned format)
 
637
{
 
638
char *  buf;
 
639
register char *in,*out;
 
640
int     len;
 
641
Bool    ok;
 
642
 
 
643
    if (str==NULL) {
 
644
        buf= tbGetBuffer(2);
 
645
        buf[0]='\0';
 
646
        return buf;
 
647
    }
 
648
    else if (format==XkbXKMFile)
 
649
        return str;
 
650
    for (ok= True,len=0,in=str;*in!='\0';in++,len++) {
 
651
        if (!isprint(*in)) {
 
652
            ok= False;
 
653
            switch (*in) {
 
654
                case '\n': case '\t': case '\v':
 
655
                case '\b': case '\r': case '\f':
 
656
                    len++;
 
657
                    break;
 
658
                default:
 
659
                    len+= 4;
 
660
                    break;
 
661
            }
 
662
        }
 
663
    }
 
664
    if (ok)
 
665
        return str;
 
666
    buf= tbGetBuffer(len+1);
 
667
    for (in=str,out=buf;*in!='\0';in++) {
 
668
        if (isprint(*in))
 
669
            *out++= *in;
 
670
        else {
 
671
            *out++= '\\';
 
672
            if (*in=='\n')      *out++= 'n';
 
673
            else if (*in=='\t') *out++= 't';
 
674
            else if (*in=='\v') *out++= 'v';
 
675
            else if (*in=='\b') *out++= 'b';
 
676
            else if (*in=='\r') *out++= 'r';
 
677
            else if (*in=='\f') *out++= 'f';
 
678
            else if ((*in=='\033')&&(format==XkbXKMFile)) {
 
679
                *out++= 'e';
 
680
            }
 
681
            else {
 
682
                *out++= '0';
 
683
                sprintf(out,"%o",*in);
 
684
                while (*out!='\0')
 
685
                    out++;
 
686
            }
 
687
        }
 
688
    }
 
689
    *out++= '\0';
 
690
    return buf;
 
691
}
 
692
 
 
693
/***====================================================================***/
 
694
 
 
695
char *
 
696
XkbGeomFPText(int val,unsigned format)
 
697
{
 
698
int     whole,frac;
 
699
char *  buf;
 
700
 
 
701
    buf= tbGetBuffer(12);
 
702
    if (format==XkbCFile) {
 
703
        sprintf(buf,"%d",val);
 
704
    }
 
705
    else {
 
706
        whole= val/XkbGeomPtsPerMM;
 
707
        frac= val%XkbGeomPtsPerMM;
 
708
        if (frac!=0)
 
709
             sprintf(buf,"%d.%d",whole,frac);
 
710
        else sprintf(buf,"%d",whole);
 
711
    }
 
712
    return buf;
 
713
}
 
714
 
 
715
char *
 
716
XkbDoodadTypeText(unsigned type,unsigned format)
 
717
{
 
718
char *  buf;
 
719
    if (format==XkbCFile) {
 
720
        buf= tbGetBuffer(24);
 
721
        if (type==XkbOutlineDoodad)        strcpy(buf,"XkbOutlineDoodad");
 
722
        else if (type==XkbSolidDoodad)     strcpy(buf,"XkbSolidDoodad");
 
723
        else if (type==XkbTextDoodad)      strcpy(buf,"XkbTextDoodad");
 
724
        else if (type==XkbIndicatorDoodad) strcpy(buf,"XkbIndicatorDoodad");
 
725
        else if (type==XkbLogoDoodad)      strcpy(buf,"XkbLogoDoodad");
 
726
        else                               sprintf(buf,"UnknownDoodad%d",type);
 
727
    }
 
728
    else {
 
729
        buf= tbGetBuffer(12);
 
730
        if (type==XkbOutlineDoodad)        strcpy(buf,"outline");
 
731
        else if (type==XkbSolidDoodad)     strcpy(buf,"solid");
 
732
        else if (type==XkbTextDoodad)      strcpy(buf,"text");
 
733
        else if (type==XkbIndicatorDoodad) strcpy(buf,"indicator");
 
734
        else if (type==XkbLogoDoodad)      strcpy(buf,"logo");
 
735
        else                               sprintf(buf,"unknown%d",type);
 
736
    }
 
737
    return buf;
 
738
}
 
739
 
 
740
static char *actionTypeNames[XkbSA_NumActions]= {
 
741
    "NoAction", 
 
742
    "SetMods",      "LatchMods",    "LockMods", 
 
743
    "SetGroup",     "LatchGroup",   "LockGroup",
 
744
    "MovePtr",
 
745
    "PtrBtn",       "LockPtrBtn",
 
746
    "SetPtrDflt",
 
747
    "ISOLock",
 
748
    "Terminate",    "SwitchScreen", 
 
749
    "SetControls",  "LockControls",
 
750
    "ActionMessage",
 
751
    "RedirectKey",
 
752
    "DeviceBtn",    "LockDeviceBtn"
 
753
};
 
754
 
 
755
char *
 
756
XkbActionTypeText(unsigned type,unsigned format)
 
757
{
 
758
static char buf[32];
 
759
char *rtrn;
 
760
 
 
761
    if (type<=XkbSA_LastAction) {
 
762
        rtrn= actionTypeNames[type];
 
763
        if (format==XkbCFile) {
 
764
            sprintf(buf,"XkbSA_%s",rtrn);
 
765
            return buf;
 
766
        }
 
767
        return rtrn;
 
768
    }
 
769
    sprintf(buf,"Private");
 
770
    return buf;
 
771
}
 
772
 
 
773
/***====================================================================***/
 
774
 
 
775
static int
 
776
TryCopyStr(char *to,char *from,int *pLeft)
 
777
{
 
778
register int len;
 
779
    if (*pLeft>0) {
 
780
        len= strlen(from);
 
781
        if (len<((*pLeft)-3)) {
 
782
            strcat(to,from);
 
783
            *pLeft-= len;
 
784
            return True;
 
785
        }
 
786
    }
 
787
    *pLeft= -1;
 
788
    return False;
 
789
}
 
790
 
 
791
/*ARGSUSED*/
 
792
static Bool
 
793
CopyNoActionArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,int*sz)
 
794
{
 
795
    return True;
 
796
}
 
797
 
 
798
static Bool
 
799
CopyModActionArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,
 
800
                                                                int* sz)
 
801
{
 
802
XkbModAction *  act;
 
803
unsigned        tmp;
 
804
 
 
805
    act= &action->mods;
 
806
    tmp= XkbModActionVMods(act);
 
807
    TryCopyStr(buf,"modifiers=",sz);
 
808
    if (act->flags&XkbSA_UseModMapMods)
 
809
          TryCopyStr(buf,"modMapMods",sz);
 
810
    else if (act->real_mods || tmp) {
 
811
         TryCopyStr(buf,
 
812
                     XkbVModMaskText(dpy,xkb,act->real_mods,tmp,XkbXKBFile),
 
813
                     sz);
 
814
    }
 
815
    else TryCopyStr(buf,"none",sz);
 
816
    if (act->type==XkbSA_LockMods)
 
817
        return True;
 
818
    if (act->flags&XkbSA_ClearLocks)
 
819
        TryCopyStr(buf,",clearLocks",sz);
 
820
    if (act->flags&XkbSA_LatchToLock)
 
821
        TryCopyStr(buf,",latchToLock",sz);
 
822
    return True;
 
823
}
 
824
 
 
825
/*ARGSUSED*/
 
826
static Bool
 
827
CopyGroupActionArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,
 
828
                                                                int *sz)
 
829
{
 
830
XkbGroupAction *        act;
 
831
char                    tbuf[32];
 
832
 
 
833
    act= &action->group;
 
834
    TryCopyStr(buf,"group=",sz);
 
835
    if (act->flags&XkbSA_GroupAbsolute)
 
836
         sprintf(tbuf,"%d",XkbSAGroup(act)+1);
 
837
    else if (XkbSAGroup(act)<0)
 
838
         sprintf(tbuf,"%d",XkbSAGroup(act));
 
839
    else sprintf(tbuf,"+%d",XkbSAGroup(act));
 
840
    TryCopyStr(buf,tbuf,sz);
 
841
    if (act->type==XkbSA_LockGroup)
 
842
        return True;
 
843
    if (act->flags&XkbSA_ClearLocks)
 
844
        TryCopyStr(buf,",clearLocks",sz);
 
845
    if (act->flags&XkbSA_LatchToLock)
 
846
        TryCopyStr(buf,",latchToLock",sz);
 
847
    return True;
 
848
}
 
849
 
 
850
/*ARGSUSED*/
 
851
static Bool
 
852
CopyMovePtrArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,int *sz)
 
853
{
 
854
XkbPtrAction *  act;
 
855
int             x,y;
 
856
char            tbuf[32];
 
857
 
 
858
    act= &action->ptr;
 
859
    x= XkbPtrActionX(act);
 
860
    y= XkbPtrActionY(act);
 
861
    if ((act->flags&XkbSA_MoveAbsoluteX)||(x<0))
 
862
         sprintf(tbuf,"x=%d",x);
 
863
    else sprintf(tbuf,"x=+%d",x);
 
864
    TryCopyStr(buf,tbuf,sz);
 
865
 
 
866
    if ((act->flags&XkbSA_MoveAbsoluteY)||(y<0))
 
867
         sprintf(tbuf,",y=%d",y);
 
868
    else sprintf(tbuf,",y=+%d",y);
 
869
    TryCopyStr(buf,tbuf,sz);
 
870
    if (act->flags&XkbSA_NoAcceleration)
 
871
        TryCopyStr(buf,",!accel",sz);
 
872
    return True;
 
873
}
 
874
 
 
875
/*ARGSUSED*/
 
876
static Bool
 
877
CopyPtrBtnArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,int *sz)
 
878
{
 
879
XkbPtrBtnAction *       act;
 
880
char                    tbuf[32];
 
881
 
 
882
    act= &action->btn;
 
883
    TryCopyStr(buf,"button=",sz);
 
884
    if ((act->button>0)&&(act->button<6)) {
 
885
         sprintf(tbuf,"%d",act->button);
 
886
         TryCopyStr(buf,tbuf,sz);
 
887
    }
 
888
    else TryCopyStr(buf,"default",sz);
 
889
    if (act->count>0) {
 
890
        sprintf(tbuf,",count=%d",act->count);
 
891
        TryCopyStr(buf,tbuf,sz);
 
892
    }
 
893
    if (action->type==XkbSA_LockPtrBtn) {
 
894
        switch (act->flags&(XkbSA_LockNoUnlock|XkbSA_LockNoLock)) {
 
895
            case XkbSA_LockNoLock:
 
896
                sprintf(tbuf,",affect=unlock"); break;
 
897
            case XkbSA_LockNoUnlock:
 
898
                sprintf(tbuf,",affect=lock"); break;
 
899
            case XkbSA_LockNoUnlock|XkbSA_LockNoLock:
 
900
                sprintf(tbuf,",affect=neither"); break;
 
901
            default:
 
902
                sprintf(tbuf,",affect=both"); break;
 
903
        }
 
904
        TryCopyStr(buf,tbuf,sz);
 
905
    }
 
906
    return True;
 
907
}
 
908
 
 
909
/*ARGSUSED*/
 
910
static Bool
 
911
CopySetPtrDfltArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,
 
912
                                                                int *sz)
 
913
{
 
914
XkbPtrDfltAction *      act;
 
915
char                    tbuf[32];
 
916
 
 
917
    act= &action->dflt;
 
918
    if (act->affect==XkbSA_AffectDfltBtn) {
 
919
        TryCopyStr(buf,"affect=button,button=",sz);
 
920
        if ((act->flags&XkbSA_DfltBtnAbsolute)||(XkbSAPtrDfltValue(act)<0))
 
921
             sprintf(tbuf,"%d",XkbSAPtrDfltValue(act));
 
922
        else sprintf(tbuf,"+%d",XkbSAPtrDfltValue(act));
 
923
        TryCopyStr(buf,tbuf,sz);
 
924
    }
 
925
    return True;
 
926
}
 
927
 
 
928
static Bool
 
929
CopyISOLockArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,int *sz)
 
930
{
 
931
XkbISOAction *  act;
 
932
char            tbuf[64];
 
933
 
 
934
    act= &action->iso;
 
935
    if (act->flags&XkbSA_ISODfltIsGroup) {
 
936
        TryCopyStr(tbuf,"group=",sz);
 
937
        if (act->flags&XkbSA_GroupAbsolute)
 
938
             sprintf(tbuf,"%d",XkbSAGroup(act)+1);
 
939
        else if (XkbSAGroup(act)<0)
 
940
             sprintf(tbuf,"%d",XkbSAGroup(act));
 
941
        else sprintf(tbuf,"+%d",XkbSAGroup(act));
 
942
        TryCopyStr(buf,tbuf,sz);
 
943
    }
 
944
    else {
 
945
        unsigned tmp;
 
946
        tmp= XkbModActionVMods(act);
 
947
        TryCopyStr(buf,"modifiers=",sz);
 
948
        if (act->flags&XkbSA_UseModMapMods)
 
949
             TryCopyStr(buf,"modMapMods",sz);
 
950
        else if (act->real_mods || tmp) {
 
951
            if (act->real_mods) {
 
952
                TryCopyStr(buf,XkbModMaskText(act->real_mods,XkbXKBFile),sz);
 
953
                if (tmp)
 
954
                    TryCopyStr(buf,"+",sz);
 
955
            }
 
956
            if (tmp)
 
957
                TryCopyStr(buf,XkbVModMaskText(dpy,xkb,0,tmp,XkbXKBFile),sz);
 
958
        }
 
959
        else TryCopyStr(buf,"none",sz);
 
960
    }
 
961
    TryCopyStr(buf,",affect=",sz);
 
962
    if ((act->affect&XkbSA_ISOAffectMask)==0)
 
963
        TryCopyStr(buf,"all",sz);
 
964
    else {
 
965
        int nOut= 0;
 
966
        if ((act->affect&XkbSA_ISONoAffectMods)==0) {
 
967
            TryCopyStr(buf,"mods",sz);
 
968
            nOut++;
 
969
        }
 
970
        if ((act->affect&XkbSA_ISONoAffectGroup)==0) {
 
971
            sprintf(tbuf,"%sgroups",(nOut>0?"+":""));
 
972
            TryCopyStr(buf,tbuf,sz);
 
973
            nOut++;
 
974
        }
 
975
        if ((act->affect&XkbSA_ISONoAffectPtr)==0) {
 
976
            sprintf(tbuf,"%spointer",(nOut>0?"+":""));
 
977
            TryCopyStr(buf,tbuf,sz);
 
978
            nOut++;
 
979
        }
 
980
        if ((act->affect&XkbSA_ISONoAffectCtrls)==0) {
 
981
            sprintf(tbuf,"%scontrols",(nOut>0?"+":""));
 
982
            TryCopyStr(buf,tbuf,sz);
 
983
            nOut++;
 
984
        }
 
985
    }
 
986
    return True;
 
987
}
 
988
 
 
989
/*ARGSUSED*/
 
990
static Bool
 
991
CopySwitchScreenArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,
 
992
                                                                int *sz)
 
993
{
 
994
XkbSwitchScreenAction * act;
 
995
char                    tbuf[32];
 
996
 
 
997
    act= &action->screen;
 
998
    if ((act->flags&XkbSA_SwitchAbsolute)||(XkbSAScreen(act)<0))
 
999
         sprintf(tbuf,"screen=%d",XkbSAScreen(act));
 
1000
    else sprintf(tbuf,"screen=+%d",XkbSAScreen(act));
 
1001
    TryCopyStr(buf,tbuf,sz);
 
1002
    if (act->flags&XkbSA_SwitchApplication)
 
1003
         TryCopyStr(buf,",!same",sz);
 
1004
    else TryCopyStr(buf,",same",sz);
 
1005
    return True;
 
1006
}
 
1007
 
 
1008
/*ARGSUSED*/
 
1009
static Bool
 
1010
CopySetLockControlsArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,
 
1011
                                                        char *buf,int *sz)
 
1012
{
 
1013
XkbCtrlsAction *        act;
 
1014
unsigned                tmp;
 
1015
char                    tbuf[32];
 
1016
 
 
1017
    act= &action->ctrls;
 
1018
    tmp= XkbActionCtrls(act);
 
1019
    TryCopyStr(buf,"controls=",sz);
 
1020
    if (tmp==0)
 
1021
        TryCopyStr(buf,"none",sz);
 
1022
    else if ((tmp&XkbAllBooleanCtrlsMask)==XkbAllBooleanCtrlsMask)
 
1023
        TryCopyStr(buf,"all",sz);
 
1024
    else {
 
1025
        int nOut= 0;
 
1026
        if (tmp&XkbRepeatKeysMask) {
 
1027
            sprintf(tbuf,"%sRepeatKeys",(nOut>0?"+":""));
 
1028
            TryCopyStr(buf,tbuf,sz);
 
1029
            nOut++;
 
1030
        }
 
1031
        if (tmp&XkbSlowKeysMask) {
 
1032
            sprintf(tbuf,"%sSlowKeys",(nOut>0?"+":""));
 
1033
            TryCopyStr(buf,tbuf,sz);
 
1034
            nOut++;
 
1035
        }
 
1036
        if (tmp&XkbBounceKeysMask) {
 
1037
            sprintf(tbuf,"%sBounceKeys",(nOut>0?"+":""));
 
1038
            TryCopyStr(buf,tbuf,sz);
 
1039
            nOut++;
 
1040
        }
 
1041
        if (tmp&XkbStickyKeysMask) {
 
1042
            sprintf(tbuf,"%sStickyKeys",(nOut>0?"+":""));
 
1043
            TryCopyStr(buf,tbuf,sz);
 
1044
            nOut++;
 
1045
        }
 
1046
        if (tmp&XkbMouseKeysMask) {
 
1047
            sprintf(tbuf,"%sMouseKeys",(nOut>0?"+":""));
 
1048
            TryCopyStr(buf,tbuf,sz);
 
1049
            nOut++;
 
1050
        }
 
1051
        if (tmp&XkbMouseKeysAccelMask) {
 
1052
            sprintf(tbuf,"%sMouseKeysAccel",(nOut>0?"+":""));
 
1053
            TryCopyStr(buf,tbuf,sz);
 
1054
            nOut++;
 
1055
        }
 
1056
        if (tmp&XkbAccessXKeysMask) {
 
1057
            sprintf(tbuf,"%sAccessXKeys",(nOut>0?"+":""));
 
1058
            TryCopyStr(buf,tbuf,sz);
 
1059
            nOut++;
 
1060
        }
 
1061
        if (tmp&XkbAccessXTimeoutMask) {
 
1062
            sprintf(tbuf,"%sAccessXTimeout",(nOut>0?"+":""));
 
1063
            TryCopyStr(buf,tbuf,sz);
 
1064
            nOut++;
 
1065
        }
 
1066
        if (tmp&XkbAccessXFeedbackMask) {
 
1067
            sprintf(tbuf,"%sAccessXFeedback",(nOut>0?"+":""));
 
1068
            TryCopyStr(buf,tbuf,sz);
 
1069
            nOut++;
 
1070
        }
 
1071
        if (tmp&XkbAudibleBellMask) {
 
1072
            sprintf(tbuf,"%sAudibleBell",(nOut>0?"+":""));
 
1073
            TryCopyStr(buf,tbuf,sz);
 
1074
            nOut++;
 
1075
        }
 
1076
        if (tmp&XkbOverlay1Mask) {
 
1077
            sprintf(tbuf,"%sOverlay1",(nOut>0?"+":""));
 
1078
            TryCopyStr(buf,tbuf,sz);
 
1079
            nOut++;
 
1080
        }
 
1081
        if (tmp&XkbOverlay2Mask) {
 
1082
            sprintf(tbuf,"%sOverlay2",(nOut>0?"+":""));
 
1083
            TryCopyStr(buf,tbuf,sz);
 
1084
            nOut++;
 
1085
        }
 
1086
        if (tmp&XkbIgnoreGroupLockMask) {
 
1087
            sprintf(tbuf,"%sIgnoreGroupLock",(nOut>0?"+":""));
 
1088
            TryCopyStr(buf,tbuf,sz);
 
1089
            nOut++;
 
1090
        }
 
1091
    }
 
1092
    return True;
 
1093
}
 
1094
 
 
1095
/*ARGSUSED*/
 
1096
static Bool
 
1097
CopyActionMessageArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,
 
1098
                                                                int *sz)
 
1099
{
 
1100
XkbMessageAction *      act;
 
1101
unsigned                all;
 
1102
char                    tbuf[32];
 
1103
 
 
1104
    act= &action->msg;
 
1105
    all= XkbSA_MessageOnPress|XkbSA_MessageOnRelease;
 
1106
    TryCopyStr(buf,"report=",sz);
 
1107
    if ((act->flags&all)==0)
 
1108
        TryCopyStr(buf,"none",sz);
 
1109
    else if ((act->flags&all)==all)
 
1110
        TryCopyStr(buf,"all",sz);
 
1111
    else if (act->flags&XkbSA_MessageOnPress)
 
1112
         TryCopyStr(buf,"KeyPress",sz);
 
1113
    else TryCopyStr(buf,"KeyRelease",sz);
 
1114
    sprintf(tbuf,",data[0]=0x%02x",act->message[0]); TryCopyStr(buf,tbuf,sz);
 
1115
    sprintf(tbuf,",data[1]=0x%02x",act->message[1]); TryCopyStr(buf,tbuf,sz);
 
1116
    sprintf(tbuf,",data[2]=0x%02x",act->message[2]); TryCopyStr(buf,tbuf,sz);
 
1117
    sprintf(tbuf,",data[3]=0x%02x",act->message[3]); TryCopyStr(buf,tbuf,sz);
 
1118
    sprintf(tbuf,",data[4]=0x%02x",act->message[4]); TryCopyStr(buf,tbuf,sz);
 
1119
    sprintf(tbuf,",data[5]=0x%02x",act->message[5]); TryCopyStr(buf,tbuf,sz);
 
1120
    return True;
 
1121
}
 
1122
 
 
1123
static Bool
 
1124
CopyRedirectKeyArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,
 
1125
                                                                int *sz)
 
1126
{
 
1127
XkbRedirectKeyAction *  act;
 
1128
char                    tbuf[32],*tmp;
 
1129
unsigned                kc;
 
1130
unsigned                vmods,vmods_mask;
 
1131
 
 
1132
    act= &action->redirect;
 
1133
    kc= act->new_key;
 
1134
    vmods= XkbSARedirectVMods(act);
 
1135
    vmods_mask= XkbSARedirectVModsMask(act);
 
1136
    if (xkb && xkb->names && xkb->names->keys && (kc<=xkb->max_key_code) &&
 
1137
                                (xkb->names->keys[kc].name[0]!='\0')) {
 
1138
        char *kn;
 
1139
        kn= XkbKeyNameText(xkb->names->keys[kc].name,XkbXKBFile);
 
1140
        sprintf(tbuf,"key=%s",kn);
 
1141
    }
 
1142
    else sprintf(tbuf,"key=%d",kc);
 
1143
    TryCopyStr(buf,tbuf,sz);
 
1144
    if ((act->mods_mask==0)&&(vmods_mask==0))
 
1145
        return True;
 
1146
    if ((act->mods_mask==XkbAllModifiersMask)&&
 
1147
        (vmods_mask==XkbAllVirtualModsMask)) {
 
1148
        tmp= XkbVModMaskText(dpy,xkb,act->mods,vmods,XkbXKBFile);
 
1149
        TryCopyStr(buf,",mods=",sz);
 
1150
        TryCopyStr(buf,tmp,sz);
 
1151
    }
 
1152
    else {
 
1153
        if ((act->mods_mask&act->mods)||(vmods_mask&vmods)) {
 
1154
            tmp= XkbVModMaskText(dpy,xkb,act->mods_mask&act->mods,
 
1155
                                         vmods_mask&vmods,XkbXKBFile);
 
1156
            TryCopyStr(buf,",mods= ",sz);
 
1157
            TryCopyStr(buf,tmp,sz);
 
1158
        }
 
1159
        if ((act->mods_mask&(~act->mods))||(vmods_mask&(~vmods))) {
 
1160
            tmp= XkbVModMaskText(dpy,xkb,act->mods_mask&(~act->mods),
 
1161
                                         vmods_mask&(~vmods),XkbXKBFile);
 
1162
            TryCopyStr(buf,",clearMods= ",sz);
 
1163
            TryCopyStr(buf,tmp,sz);
 
1164
        }
 
1165
    }
 
1166
    return True;
 
1167
}
 
1168
 
 
1169
/*ARGSUSED*/
 
1170
static Bool
 
1171
CopyDeviceBtnArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,
 
1172
                                                                int *sz)
 
1173
{
 
1174
XkbDeviceBtnAction *    act;
 
1175
char                    tbuf[32];
 
1176
 
 
1177
    act= &action->devbtn;
 
1178
    sprintf(tbuf,"device= %d",act->device); TryCopyStr(buf,tbuf,sz);
 
1179
    TryCopyStr(buf,",button=",sz);
 
1180
    sprintf(tbuf,"%d",act->button);
 
1181
    TryCopyStr(buf,tbuf,sz);
 
1182
    if (act->count>0) {
 
1183
        sprintf(tbuf,",count=%d",act->count);
 
1184
        TryCopyStr(buf,tbuf,sz);
 
1185
    }
 
1186
    if (action->type==XkbSA_LockDeviceBtn) {
 
1187
        switch (act->flags&(XkbSA_LockNoUnlock|XkbSA_LockNoLock)) {
 
1188
            case XkbSA_LockNoLock:
 
1189
                sprintf(tbuf,",affect=unlock"); break;
 
1190
            case XkbSA_LockNoUnlock:
 
1191
                sprintf(tbuf,",affect=lock"); break;
 
1192
            case XkbSA_LockNoUnlock|XkbSA_LockNoLock:
 
1193
                sprintf(tbuf,",affect=neither"); break;
 
1194
            default:
 
1195
                sprintf(tbuf,",affect=both"); break;
 
1196
        }
 
1197
        TryCopyStr(buf,tbuf,sz);
 
1198
    }
 
1199
    return True;
 
1200
}
 
1201
 
 
1202
/*ARGSUSED*/
 
1203
static Bool
 
1204
CopyOtherArgs(Display *dpy,XkbDescPtr xkb,XkbAction *action,char *buf,int *sz)
 
1205
{
 
1206
XkbAnyAction *  act;
 
1207
char            tbuf[32];
 
1208
 
 
1209
    act= &action->any;
 
1210
    sprintf(tbuf,"type=0x%02x",act->type); TryCopyStr(buf,tbuf,sz);
 
1211
    sprintf(tbuf,",data[0]=0x%02x",act->data[0]); TryCopyStr(buf,tbuf,sz);
 
1212
    sprintf(tbuf,",data[1]=0x%02x",act->data[1]); TryCopyStr(buf,tbuf,sz);
 
1213
    sprintf(tbuf,",data[2]=0x%02x",act->data[2]); TryCopyStr(buf,tbuf,sz);
 
1214
    sprintf(tbuf,",data[3]=0x%02x",act->data[3]); TryCopyStr(buf,tbuf,sz);
 
1215
    sprintf(tbuf,",data[4]=0x%02x",act->data[4]); TryCopyStr(buf,tbuf,sz);
 
1216
    sprintf(tbuf,",data[5]=0x%02x",act->data[5]); TryCopyStr(buf,tbuf,sz);
 
1217
    sprintf(tbuf,",data[6]=0x%02x",act->data[6]); TryCopyStr(buf,tbuf,sz);
 
1218
    return True;
 
1219
}
 
1220
 
 
1221
typedef Bool    (*actionCopy)(
 
1222
        Display *       /* dpy */,
 
1223
        XkbDescPtr      /* xkb */,
 
1224
        XkbAction *     /* action */,
 
1225
        char *          /* buf */,
 
1226
        int*            /* sz */
 
1227
);
 
1228
static actionCopy       copyActionArgs[XkbSA_NumActions] = {
 
1229
        CopyNoActionArgs                /* NoAction     */,
 
1230
        CopyModActionArgs               /* SetMods      */,
 
1231
        CopyModActionArgs               /* LatchMods    */,
 
1232
        CopyModActionArgs               /* LockMods     */,
 
1233
        CopyGroupActionArgs             /* SetGroup     */,
 
1234
        CopyGroupActionArgs             /* LatchGroup   */,
 
1235
        CopyGroupActionArgs             /* LockGroup    */,
 
1236
        CopyMovePtrArgs                 /* MovePtr      */,
 
1237
        CopyPtrBtnArgs                  /* PtrBtn       */,
 
1238
        CopyPtrBtnArgs                  /* LockPtrBtn   */,
 
1239
        CopySetPtrDfltArgs              /* SetPtrDflt   */,
 
1240
        CopyISOLockArgs                 /* ISOLock      */,
 
1241
        CopyNoActionArgs                /* Terminate    */,
 
1242
        CopySwitchScreenArgs            /* SwitchScreen */,
 
1243
        CopySetLockControlsArgs         /* SetControls  */,
 
1244
        CopySetLockControlsArgs         /* LockControls */,
 
1245
        CopyActionMessageArgs           /* ActionMessage*/,
 
1246
        CopyRedirectKeyArgs             /* RedirectKey  */,
 
1247
        CopyDeviceBtnArgs               /* DeviceBtn    */,
 
1248
        CopyDeviceBtnArgs               /* LockDeviceBtn*/
 
1249
};
 
1250
 
 
1251
#define ACTION_SZ       256
 
1252
 
 
1253
char *
 
1254
XkbActionText(Display *dpy,XkbDescPtr xkb,XkbAction *action,unsigned format)
 
1255
{
 
1256
char    buf[ACTION_SZ],*tmp;
 
1257
int     sz;
 
1258
 
 
1259
    if (format==XkbCFile) {
 
1260
        sprintf(buf,
 
1261
            "{ %20s, { 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x } }",
 
1262
            XkbActionTypeText(action->type,XkbCFile),
 
1263
            action->any.data[0],action->any.data[1],action->any.data[2],
 
1264
            action->any.data[3],action->any.data[4],action->any.data[5],
 
1265
            action->any.data[6]);
 
1266
    }
 
1267
    else {
 
1268
        sprintf(buf,"%s(",XkbActionTypeText(action->type,XkbXKBFile));
 
1269
        sz= ACTION_SZ-strlen(buf)+2; /* room for close paren and NULL */
 
1270
        if (action->type<(unsigned)XkbSA_NumActions)
 
1271
             (*copyActionArgs[action->type])(dpy,xkb,action,buf,&sz);
 
1272
        else CopyOtherArgs(dpy,xkb,action,buf,&sz);
 
1273
        TryCopyStr(buf,")",&sz);
 
1274
    }
 
1275
    tmp= tbGetBuffer(strlen(buf)+1);
 
1276
    if (tmp!=NULL)
 
1277
        strcpy(tmp,buf);
 
1278
    return tmp;
 
1279
}
 
1280
 
 
1281
char *
 
1282
XkbBehaviorText(XkbDescPtr xkb,XkbBehavior *behavior,unsigned format)
 
1283
{
 
1284
char    buf[256],*tmp;
 
1285
 
 
1286
    if (format==XkbCFile) {
 
1287
        if (behavior->type==XkbKB_Default)
 
1288
             sprintf(buf,"{   0,    0 }");
 
1289
        else sprintf(buf,"{ %3d, 0x%02x }",behavior->type,behavior->data);
 
1290
    }
 
1291
    else {
 
1292
        unsigned        type,permanent;
 
1293
        type= behavior->type&XkbKB_OpMask;
 
1294
        permanent=((behavior->type&XkbKB_Permanent)!=0);
 
1295
 
 
1296
        if (type==XkbKB_Lock) {
 
1297
            sprintf(buf,"lock= %s",(permanent?"Permanent":"True"));
 
1298
        }
 
1299
        else if (type==XkbKB_RadioGroup) {
 
1300
            int         g;
 
1301
            char        *tmp;
 
1302
            g= ((behavior->data)&(~XkbKB_RGAllowNone))+1;
 
1303
            if (XkbKB_RGAllowNone&behavior->data) {
 
1304
                sprintf(buf,"allowNone,");
 
1305
                tmp= &buf[strlen(buf)];
 
1306
            }
 
1307
            else tmp= buf;
 
1308
            if (permanent)
 
1309
                 sprintf(tmp,"permanentRadioGroup= %d",g);
 
1310
            else sprintf(tmp,"radioGroup= %d",g);
 
1311
        }
 
1312
        else if ((type==XkbKB_Overlay1)||(type==XkbKB_Overlay2)) {
 
1313
            int ndx,kc;
 
1314
            char *kn;
 
1315
 
 
1316
            ndx= ((type==XkbKB_Overlay1)?1:2);
 
1317
            kc= behavior->data;
 
1318
            if ((xkb)&&(xkb->names)&&(xkb->names->keys))
 
1319
                kn= XkbKeyNameText(xkb->names->keys[kc].name,XkbXKBFile);
 
1320
            else {
 
1321
                static char tbuf[8];
 
1322
                sprintf(tbuf,"%d",kc);
 
1323
                kn= tbuf;
 
1324
            }
 
1325
            if (permanent)
 
1326
                 sprintf(buf,"permanentOverlay%d= %s",ndx,kn);
 
1327
            else sprintf(buf,"overlay%d= %s",ndx,kn);
 
1328
        }
 
1329
    }
 
1330
    tmp= tbGetBuffer(strlen(buf)+1);
 
1331
    if (tmp!=NULL)
 
1332
        strcpy(tmp,buf);
 
1333
    return tmp;
 
1334
}
 
1335
 
 
1336
/***====================================================================***/
 
1337
 
 
1338
char *
 
1339
XkbIndentText(unsigned size)
 
1340
{
 
1341
static char buf[32];
 
1342
register int i;
 
1343
 
 
1344
    if (size>31)
 
1345
        size= 31;
 
1346
 
 
1347
    for (i=0;i<size;i++) {
 
1348
        buf[i]= ' ';
 
1349
    }
 
1350
    buf[size]= '\0';
 
1351
    return buf;
 
1352
}
 
1353
 
 
1354
#ifndef XKB_IN_SERVER
 
1355
 
 
1356
/***====================================================================***/
 
1357
 
 
1358
#define PIXEL_MAX       65535
 
1359
 
 
1360
Bool
 
1361
XkbLookupCanonicalRGBColor(char *def,XColor *color)
 
1362
{
 
1363
int     tmp;
 
1364
 
 
1365
    if (_XkbStrCaseEqual(def,"black")) {
 
1366
        color->red= color->green= color->blue= 0;
 
1367
        return True;
 
1368
    }
 
1369
    else if (_XkbStrCaseEqual(def,"white")) {
 
1370
        color->red= color->green= color->blue= PIXEL_MAX;
 
1371
        return True;
 
1372
    }
 
1373
    else if ((sscanf(def,"grey%d",&tmp)==1)||
 
1374
        (sscanf(def,"gray%d",&tmp)==1)||
 
1375
        (sscanf(def,"Grey%d",&tmp)==1)||
 
1376
        (sscanf(def,"Gray%d",&tmp)==1)) {
 
1377
        if ((tmp>0)&&(tmp<=100)) {
 
1378
            tmp= (PIXEL_MAX*tmp)/100;
 
1379
            color->red= color->green= color->blue= tmp;
 
1380
            return True;
 
1381
        }
 
1382
    }
 
1383
    else if ((tmp=(_XkbStrCaseEqual(def,"red")*100))||
 
1384
             (sscanf(def,"red%d",&tmp)==1)) {
 
1385
        if ((tmp>0)&&(tmp<=100)) {
 
1386
            tmp= (PIXEL_MAX*tmp)/100;
 
1387
            color->red= tmp;
 
1388
            color->green= color->blue= 0;
 
1389
            return True;
 
1390
        }
 
1391
    }
 
1392
    else if ((tmp=(_XkbStrCaseEqual(def,"green")*100))||
 
1393
             (sscanf(def,"green%d",&tmp)==1)) {
 
1394
        if ((tmp>0)&&(tmp<=100)) {
 
1395
            tmp= (PIXEL_MAX*tmp)/100;
 
1396
            color->green= tmp;
 
1397
            color->red= color->blue= 0;
 
1398
            return True;
 
1399
        }
 
1400
    }
 
1401
    else if ((tmp=(_XkbStrCaseEqual(def,"blue")*100))||
 
1402
             (sscanf(def,"blue%d",&tmp)==1)) {
 
1403
        if ((tmp>0)&&(tmp<=100)) {
 
1404
            tmp= (PIXEL_MAX*tmp)/100;
 
1405
            color->blue= tmp;
 
1406
            color->red= color->green= 0;
 
1407
            return True;
 
1408
        }
 
1409
    }
 
1410
    else if ((tmp=(_XkbStrCaseEqual(def,"magenta")*100))||
 
1411
             (sscanf(def,"magenta%d",&tmp)==1)) {
 
1412
        if ((tmp>0)&&(tmp<=100)) {
 
1413
            tmp= (PIXEL_MAX*tmp)/100;
 
1414
            color->green= 0;
 
1415
            color->red= color->blue= tmp;
 
1416
            return True;
 
1417
        }
 
1418
    }
 
1419
    else if ((tmp=(_XkbStrCaseEqual(def,"cyan")*100))||
 
1420
             (sscanf(def,"cyan%d",&tmp)==1)) {
 
1421
        if ((tmp>0)&&(tmp<=100)) {
 
1422
            tmp= (PIXEL_MAX*tmp)/100;
 
1423
            color->red= 0;
 
1424
            color->green= color->blue= tmp;
 
1425
            return True;
 
1426
        }
 
1427
    }
 
1428
    else if ((tmp=(_XkbStrCaseEqual(def,"yellow")*100))||
 
1429
             (sscanf(def,"yellow%d",&tmp)==1)) {
 
1430
        if ((tmp>0)&&(tmp<=100)) {
 
1431
            tmp= (PIXEL_MAX*tmp)/100;
 
1432
            color->blue= 0;
 
1433
            color->red= color->green= tmp;
 
1434
            return True;
 
1435
        }
 
1436
    }
 
1437
    return False;
 
1438
}
 
1439
 
 
1440
#endif