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
  61          tmp = keymap->vmod_names[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 <<=
  98                  1) {
  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 XkbcFileTypeText(enum xkb_file_type type)
 190 {
 191     switch (type) {
 192     case FILE_TYPE_KEYMAP:
 193         return "Keymap";
 194     case FILE_TYPE_TYPES:
 195         return "Types";
 196     case FILE_TYPE_COMPAT:
 197         return "CompatMap";
 198     case FILE_TYPE_SYMBOLS:
 199         return "Symbols";
 200     case FILE_TYPE_KEYCODES:
 201         return "KeyNames";
 202     case FILE_TYPE_RULES:
 203         return "Rules";
 204     default:
 205         return "unknown";
 206     }
 207 }
 208
 209 static const char *actionTypeNames[XkbSA_NumActions] = {
 210     "NoAction",         /* XkbSA_NoAction */
 211     "SetMods",          /* XkbSA_SetMods */
 212     "LatchMods",        /* XkbSA_LatchMods */
 213     "LockMods",         /* XkbSA_LockMods */
 214     "SetGroup",         /* XkbSA_SetGroup */
 215     "LatchGroup",       /* XkbSA_LatchGroup */
 216     "LockGroup",        /* XkbSA_LockGroup */
 217     "MovePtr",          /* XkbSA_MovePtr */
 218     "PtrBtn",           /* XkbSA_PtrBtn */
 219     "LockPtrBtn",       /* XkbSA_LockPtrBtn */
 220     "SetPtrDflt",       /* XkbSA_SetPtrDflt */
 221     "ISOLock",          /* XkbSA_ISOLock */
 222     "Terminate",        /* XkbSA_Terminate */
 223     "SwitchScreen",     /* XkbSA_SwitchScreen */
 224     "SetControls",      /* XkbSA_SetControls */
 225     "LockControls",     /* XkbSA_LockControls */
 226     "ActionMessage",    /* XkbSA_ActionMessage */
 227     "RedirectKey",      /* XkbSA_RedirectKey */
 228     "DeviceBtn",        /* XkbSA_DeviceBtn */
 229     "LockDeviceBtn",    /* XkbSA_LockDeviceBtn */
 230     "DeviceValuator"    /* XkbSA_DeviceValuator */
 231 };
 232
 233 const char *
 234 XkbcActionTypeText(unsigned type)
 235 {
 236     if (type <= XkbSA_LastAction)
 237         return actionTypeNames[type];
 238     return "Private";
 239 }
 240
 241 const char *
 242 XkbcKeysymText(xkb_keysym_t sym)
 243 {
 244     static char buffer[64];
 245
 246     xkb_keysym_get_name(sym, buffer, sizeof buffer);
 247
 248     return buffer;
 249 }
 250
 251 const char *
 252 XkbcKeyNameText(char *name)
 253 {
 254     char *buf;
 255     int len;
 256
 257     buf = tbGetBuffer(7);
 258     buf[0] = '<';
 259     strncpy(&buf[1], name, 4);
 260     buf[5] = '\0';
 261     len = strlen(buf);
 262     buf[len++] = '>';
 263     buf[len] = '\0';
 264
 265     return buf;
 266 }
 267
 268 static const char *siMatchText[5] = {
 269     "NoneOf",       /* XkbSI_NoneOf */
 270     "AnyOfOrNone",  /* XkbSI_AnyOfOrNone */
 271     "AnyOf",        /* XkbSI_AnyOf */
 272     "AllOf",        /* XkbSI_AllOf */
 273     "Exactly"       /* XkbSI_Exactly */
 274 };
 275
 276 const char *
 277 XkbcSIMatchText(unsigned type)
 278 {
 279     char *buf;
 280
 281     switch (type & XkbSI_OpMask) {
 282     case XkbSI_NoneOf:
 283         return siMatchText[0];
 284     case XkbSI_AnyOfOrNone:
 285         return siMatchText[1];
 286     case XkbSI_AnyOf:
 287         return siMatchText[2];
 288     case XkbSI_AllOf:
 289         return siMatchText[3];
 290     case XkbSI_Exactly:
 291         return siMatchText[4];
 292     default:
 293         buf = tbGetBuffer(40);
 294         snprintf(buf, 40, "0x%x", type & XkbSI_OpMask);
 295         return buf;
 296     }
 297 }