src/text.c

   1 /************************************************************
   2  Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
   3
   4  Permission to use, copy, modify, and distribute this
   5  software and its documentation for any purpose and without
   6  fee is hereby granted, provided that the above copyright
   7  notice appear in all copies and that both that copyright
   8  notice and this permission notice appear in supporting
   9  documentation, and that the name of Silicon Graphics not be
  10  used in advertising or publicity pertaining to distribution
  11  of the software without specific prior written permission.
  12  Silicon Graphics makes no representation about the suitability
  13  of this software for any purpose. It is provided "as is"
  14  without any express or implied warranty.
  15
  16  SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  17  SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  18  AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
  19  GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  20  DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  21  DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  22  OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
  23  THE USE OR PERFORMANCE OF THIS SOFTWARE.
  24
  25  ********************************************************/
  26
  27 #include "text.h"
  28
  29 #define BUFFER_SIZE 1024
  30 static char textBuffer[BUFFER_SIZE];
  31 static unsigned int tbNext = 0;
  32
  33 static char *
  34 tbGetBuffer(unsigned int size)
  35 {
  36     char *rtrn;
  37
  38     if (size >= BUFFER_SIZE)
  39         return NULL;
  40
  41     if ((BUFFER_SIZE - tbNext) <= size)
  42         tbNext = 0;
  43
  44     rtrn = &textBuffer[tbNext];
  45     tbNext += size;
  46
  47     return rtrn;
  48 }
  49
  50 static const char *
  51 XkbcVModIndexText(struct xkb_keymap *keymap, unsigned ndx)
  52 {
  53     int len;
  54     char *rtrn;
  55     const char *tmp = NULL;
  56     char buf[20];
  57
  58     if (ndx >= XkbNumVirtualMods)
  59          tmp = "illegal";
  60     else if (keymap && keymap->names)
  61          tmp = keymap->names->vmods[ndx];
  62
  63     if (!tmp) {
  64         snprintf(buf, sizeof(buf) - 1, "%d", ndx);
  65         tmp = buf;
  66     }
  67
  68     len = strlen(tmp) + 1;
  69     if (len >= BUFFER_SIZE)
  70         len = BUFFER_SIZE - 1;
  71
  72     rtrn = tbGetBuffer(len);
  73     strncpy(rtrn, tmp, len);
  74
  75     return rtrn;
  76 }
  77
  78 const char *
  79 XkbcVModMaskText(struct xkb_keymap *keymap, unsigned modMask, unsigned mask)
  80 {
  81     int i, bit, len, rem;
  82     const char *mm = NULL;
  83     char *rtrn, *str;
  84     char buf[BUFFER_SIZE];
  85
  86     if ((modMask == 0) && (mask == 0))
  87         return "none";
  88
  89     if (modMask != 0)
  90         mm = XkbcModMaskText(modMask, false);
  91
  92     str = buf;
  93     buf[0]= '\0';
  94     rem = BUFFER_SIZE;
  95
  96     if (mask) {
  97         for (i = 0, bit = 1; i < XkbNumVirtualMods && rem > 1; i++, bit <<= 1)
  98         {
  99             if (!(mask & bit))
 100                 continue;
 101
 102             len = snprintf(str, rem, "%s%s",
 103                            (str != buf) ? "+" : "",
 104                            XkbcVModIndexText(keymap, i));
 105             rem -= len;
 106             str += len;
 107         }
 108
 109         str = buf;
 110     }
 111     else
 112         str = NULL;
 113
 114     len = ((str) ? strlen(str) : 0) + ((mm) ? strlen(mm) : 0) +
 115           ((str && mm) ? 1 : 0);
 116     if (len >= BUFFER_SIZE)
 117         len = BUFFER_SIZE - 1;
 118
 119     rtrn = tbGetBuffer(len + 1);
 120     rtrn[0] = '\0';
 121
 122     snprintf(rtrn, len + 1, "%s%s%s", (mm) ? mm : "",
 123              (mm && str) ? "+" : "", (str) ? str : "");
 124
 125     return rtrn;
 126 }
 127
 128 static const char *modNames[XkbNumModifiers] = {
 129     "Shift",
 130     "Lock",
 131     "Control",
 132     "Mod1",
 133     "Mod2",
 134     "Mod3",
 135     "Mod4",
 136     "Mod5"
 137 };
 138
 139 const char *
 140 XkbcModIndexText(unsigned ndx)
 141 {
 142     char *buf;
 143
 144     if (ndx < XkbNumModifiers)
 145         return modNames[ndx];
 146     else if (ndx == XkbNoModifier)
 147         return "none";
 148
 149     buf = tbGetBuffer(32);
 150     snprintf(buf, 32, "ILLEGAL_%02x", ndx);
 151
 152     return buf;
 153 }
 154
 155 const char *
 156 XkbcModMaskText(unsigned mask, bool cFormat)
 157 {
 158     int i, rem, bit;
 159     char *str, *buf;
 160
 161     if ((mask & 0xff) == 0xff)
 162         return (cFormat ? "0xff" : "all");
 163
 164     if ((mask & 0xff) == 0)
 165         return (cFormat ? "0" : "none");
 166
 167     rem = 64;
 168     buf = tbGetBuffer(rem);
 169     str = buf;
 170     buf[0] = '\0';
 171     for (i = 0, bit = 1; i < XkbNumModifiers && rem > 1; i++, bit <<= 1) {
 172         int len;
 173
 174         if (!(mask & bit))
 175             continue;
 176
 177         len = snprintf(str, rem, "%s%s%s",
 178                        (str != buf) ? (cFormat ? "|" : "+") : "",
 179                        modNames[i],
 180                        cFormat ? "Mask" : "");
 181         rem -= len;
 182         str += len;
 183     }
 184
 185     return buf;
 186 }
 187
 188 const char *
 189 XkbcConfigText(unsigned config)
 190 {
 191     switch (config) {
 192     case XkmKeymapFile:
 193         return "Keymap";
 194     case XkmTypesIndex:
 195         return "Types";
 196     case XkmCompatMapIndex:
 197         return "CompatMap";
 198     case XkmSymbolsIndex:
 199         return "Symbols";
 200     case XkmKeyNamesIndex:
 201         return "KeyNames";
 202     default:
 203         return "unknown";
 204     }
 205 }
 206
 207 static const char *actionTypeNames[XkbSA_NumActions]= {
 208     "NoAction",         /* XkbSA_NoAction */
 209     "SetMods",          /* XkbSA_SetMods */
 210     "LatchMods",        /* XkbSA_LatchMods */
 211     "LockMods",         /* XkbSA_LockMods */
 212     "SetGroup",         /* XkbSA_SetGroup */
 213     "LatchGroup",       /* XkbSA_LatchGroup */
 214     "LockGroup",        /* XkbSA_LockGroup */
 215     "MovePtr",          /* XkbSA_MovePtr */
 216     "PtrBtn",           /* XkbSA_PtrBtn */
 217     "LockPtrBtn",       /* XkbSA_LockPtrBtn */
 218     "SetPtrDflt",       /* XkbSA_SetPtrDflt */
 219     "ISOLock",          /* XkbSA_ISOLock */
 220     "Terminate",        /* XkbSA_Terminate */
 221     "SwitchScreen",     /* XkbSA_SwitchScreen */
 222     "SetControls",      /* XkbSA_SetControls */
 223     "LockControls",     /* XkbSA_LockControls */
 224     "ActionMessage",    /* XkbSA_ActionMessage */
 225     "RedirectKey",      /* XkbSA_RedirectKey */
 226     "DeviceBtn",        /* XkbSA_DeviceBtn */
 227     "LockDeviceBtn",    /* XkbSA_LockDeviceBtn */
 228     "DeviceValuator"    /* XkbSA_DeviceValuator */
 229 };
 230
 231 const char *
 232 XkbcActionTypeText(unsigned type)
 233 {
 234     if (type <= XkbSA_LastAction)
 235         return actionTypeNames[type];
 236     return "Private";
 237 }
 238
 239 const char *
 240 XkbcKeysymText(xkb_keysym_t sym)
 241 {
 242     static char buffer[16];
 243
 244     xkb_keysym_get_name(sym, buffer, sizeof buffer);
 245
 246     return buffer;
 247 }
 248
 249 const char *
 250 XkbcKeyNameText(char *name)
 251 {
 252     char *buf;
 253     int len;
 254
 255     buf = tbGetBuffer(7);
 256     buf[0] = '<';
 257     strncpy(&buf[1], name, 4);
 258     buf[5] = '\0';
 259     len = strlen(buf);
 260     buf[len++] = '>';
 261     buf[len] = '\0';
 262
 263     return buf;
 264 }
 265
 266 static const char *siMatchText[5] = {
 267     "NoneOf",       /* XkbSI_NoneOf */
 268     "AnyOfOrNone",  /* XkbSI_AnyOfOrNone */
 269     "AnyOf",        /* XkbSI_AnyOf */
 270     "AllOf",        /* XkbSI_AllOf */
 271     "Exactly"       /* XkbSI_Exactly */
 272 };
 273
 274 const char *
 275 XkbcSIMatchText(unsigned type)
 276 {
 277     char *buf;
 278
 279     switch (type & XkbSI_OpMask) {
 280     case XkbSI_NoneOf:
 281         return siMatchText[0];
 282     case XkbSI_AnyOfOrNone:
 283         return siMatchText[1];
 284     case XkbSI_AnyOf:
 285         return siMatchText[2];
 286     case XkbSI_AllOf:
 287         return siMatchText[3];
 288     case XkbSI_Exactly:
 289         return siMatchText[4];
 290     default:
 291         buf = tbGetBuffer(40);
 292         snprintf(buf, 40, "0x%x", type & XkbSI_OpMask);
 293         return buf;
 294     }
 295 }