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, xkb_mod_index_t 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, xkb_mod_mask_t modMask,
  80                  xkb_mod_mask_t mask)
  81 {
  82     xkb_mod_index_t i;
  83     xkb_mod_mask_t bit;
  84     int len, rem;
  85     const char *mm = NULL;
  86     char *rtrn, *str;
  87     char buf[BUFFER_SIZE];
  88
  89     if (modMask == 0 && mask == 0)
  90         return "none";
  91
  92     if (modMask != 0)
  93         mm = XkbcModMaskText(modMask, false);
  94
  95     str = buf;
  96     buf[0] = '\0';
  97     rem = BUFFER_SIZE;
  98
  99     if (mask) {
 100         for (i = 0, bit = 1; i < XkbNumVirtualMods && rem > 1; i++, bit <<=
 101                  1) {
 102             if (!(mask & bit))
 103                 continue;
 104
 105             len = snprintf(str, rem, "%s%s",
 106                            (str != buf) ? "+" : "",
 107                            XkbcVModIndexText(keymap, i));
 108             rem -= len;
 109             str += len;
 110         }
 111
 112         str = buf;
 113     }
 114     else
 115         str = NULL;
 116
 117     len = (str ? strlen(str) : 0) + (mm ? strlen(mm) : 0) +
 118           (str && mm ? 1 : 0);
 119     if (len >= BUFFER_SIZE)
 120         len = BUFFER_SIZE - 1;
 121
 122     rtrn = tbGetBuffer(len + 1);
 123     rtrn[0] = '\0';
 124
 125     snprintf(rtrn, len + 1, "%s%s%s", (mm ? mm : ""),
 126              (mm && str ? "+" : ""), (str ? str : ""));
 127
 128     return rtrn;
 129 }
 130
 131 static const char *modNames[XkbNumModifiers] = {
 132     "Shift",
 133     "Lock",
 134     "Control",
 135     "Mod1",
 136     "Mod2",
 137     "Mod3",
 138     "Mod4",
 139     "Mod5"
 140 };
 141
 142 const char *
 143 XkbcModIndexText(xkb_mod_index_t ndx)
 144 {
 145     char *buf;
 146
 147     if (ndx < XkbNumModifiers)
 148         return modNames[ndx];
 149     else if (ndx == XkbNoModifier)
 150         return "none";
 151
 152     buf = tbGetBuffer(32);
 153     snprintf(buf, 32, "ILLEGAL_%02x", ndx);
 154
 155     return buf;
 156 }
 157
 158 const char *
 159 XkbcModMaskText(xkb_mod_mask_t mask, bool cFormat)
 160 {
 161     int i, rem;
 162     xkb_mod_index_t bit;
 163     char *str, *buf;
 164
 165     if ((mask & 0xff) == 0xff)
 166         return (cFormat ? "0xff" : "all");
 167
 168     if ((mask & 0xff) == 0)
 169         return (cFormat ? "0" : "none");
 170
 171     rem = 64;
 172     buf = tbGetBuffer(rem);
 173     str = buf;
 174     buf[0] = '\0';
 175     for (i = 0, bit = 1; i < XkbNumModifiers && rem > 1; i++, bit <<= 1) {
 176         int len;
 177
 178         if (!(mask & bit))
 179             continue;
 180
 181         len = snprintf(str, rem, "%s%s%s",
 182                        (str != buf) ? (cFormat ? "|" : "+") : "",
 183                        modNames[i],
 184                        cFormat ? "Mask" : "");
 185         rem -= len;
 186         str += len;
 187     }
 188
 189     return buf;
 190 }
 191
 192 const char *
 193 XkbcFileTypeText(enum xkb_file_type type)
 194 {
 195     switch (type) {
 196     case FILE_TYPE_KEYMAP:
 197         return "Keymap";
 198     case FILE_TYPE_TYPES:
 199         return "Types";
 200     case FILE_TYPE_COMPAT:
 201         return "CompatMap";
 202     case FILE_TYPE_SYMBOLS:
 203         return "Symbols";
 204     case FILE_TYPE_KEYCODES:
 205         return "KeyNames";
 206     case FILE_TYPE_RULES:
 207         return "Rules";
 208     default:
 209         return "unknown";
 210     }
 211 }
 212
 213 static const char *actionTypeNames[XkbSA_NumActions] = {
 214     "NoAction",         /* XkbSA_NoAction */
 215     "SetMods",          /* XkbSA_SetMods */
 216     "LatchMods",        /* XkbSA_LatchMods */
 217     "LockMods",         /* XkbSA_LockMods */
 218     "SetGroup",         /* XkbSA_SetGroup */
 219     "LatchGroup",       /* XkbSA_LatchGroup */
 220     "LockGroup",        /* XkbSA_LockGroup */
 221     "MovePtr",          /* XkbSA_MovePtr */
 222     "PtrBtn",           /* XkbSA_PtrBtn */
 223     "LockPtrBtn",       /* XkbSA_LockPtrBtn */
 224     "SetPtrDflt",       /* XkbSA_SetPtrDflt */
 225     "ISOLock",          /* XkbSA_ISOLock */
 226     "Terminate",        /* XkbSA_Terminate */
 227     "SwitchScreen",     /* XkbSA_SwitchScreen */
 228     "SetControls",      /* XkbSA_SetControls */
 229     "LockControls",     /* XkbSA_LockControls */
 230     "ActionMessage",    /* XkbSA_ActionMessage */
 231     "RedirectKey",      /* XkbSA_RedirectKey */
 232     "DeviceBtn",        /* XkbSA_DeviceBtn */
 233     "LockDeviceBtn",    /* XkbSA_LockDeviceBtn */
 234     "DeviceValuator"    /* XkbSA_DeviceValuator */
 235 };
 236
 237 const char *
 238 XkbcActionTypeText(unsigned type)
 239 {
 240     if (type <= XkbSA_LastAction)
 241         return actionTypeNames[type];
 242     return "Private";
 243 }
 244
 245 const char *
 246 XkbcKeysymText(xkb_keysym_t sym)
 247 {
 248     static char buffer[64];
 249
 250     xkb_keysym_get_name(sym, buffer, sizeof buffer);
 251
 252     return buffer;
 253 }
 254
 255 const char *
 256 XkbcKeyNameText(char *name)
 257 {
 258     char *buf;
 259     int len;
 260
 261     buf = tbGetBuffer(7);
 262     buf[0] = '<';
 263     strncpy(&buf[1], name, 4);
 264     buf[5] = '\0';
 265     len = strlen(buf);
 266     buf[len++] = '>';
 267     buf[len] = '\0';
 268
 269     return buf;
 270 }
 271
 272 static const char *siMatchText[5] = {
 273     "NoneOf",       /* XkbSI_NoneOf */
 274     "AnyOfOrNone",  /* XkbSI_AnyOfOrNone */
 275     "AnyOf",        /* XkbSI_AnyOf */
 276     "AllOf",        /* XkbSI_AllOf */
 277     "Exactly"       /* XkbSI_Exactly */
 278 };
 279
 280 const char *
 281 XkbcSIMatchText(unsigned type)
 282 {
 283     char *buf;
 284
 285     switch (type & XkbSI_OpMask) {
 286     case XkbSI_NoneOf:
 287         return siMatchText[0];
 288     case XkbSI_AnyOfOrNone:
 289         return siMatchText[1];
 290     case XkbSI_AnyOf:
 291         return siMatchText[2];
 292     case XkbSI_AllOf:
 293         return siMatchText[3];
 294     case XkbSI_Exactly:
 295         return siMatchText[4];
 296     default:
 297         buf = tbGetBuffer(40);
 298         snprintf(buf, 40, "0x%x", type & XkbSI_OpMask);
 299         return buf;
 300     }
 301 }