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