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 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 }