X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftext.c;h=e85b0eb3c1a1b4d66fa400dc894a7e32442be3a8;hb=f00e4d030c9dd49e40a8fa08fcae0c1a1be5cf14;hp=38c2322494809a4a14ebcc1a55330512c5e588e1;hpb=7ae0c6bac4759e9b56c4a5115c321b66012ce9dc;p=platform%2Fupstream%2Flibxkbcommon.git

diff --git a/src/text.c b/src/text.c
index 38c2322..e85b0eb 100644
--- a/src/text.c
+++ b/src/text.c
@@ -24,294 +24,325 @@
  *
  ********************************************************/
 
-#include "text.h"
+#include "config.h"
 
-#define BUFFER_SIZE 1024
+#include "keymap.h"
+#include "text.h"
 
-static char *
-GetBuffer(size_t size)
+bool
+LookupString(const LookupEntry tab[], const char *string,
+              unsigned int *value_rtrn)
 {
-    static char buffer[BUFFER_SIZE];
-    static size_t next;
-    char *rtrn;
-
-    if (size >= BUFFER_SIZE)
-        return NULL;
-
-    if (BUFFER_SIZE - next <= size)
-        next = 0;
+    if (!string)
+        return false;
 
-    rtrn = &buffer[next];
-    next += size;
-
-    return rtrn;
-}
-
-/*
- * Get a vmod name's text, where the vmod index is zero based
- * (0..XkbNumVirtualMods-1).
- */
-static const char *
-VModIndexText(struct xkb_keymap *keymap, xkb_mod_index_t ndx)
-{
-    int len;
-    char *rtrn;
-    const char *tmp = NULL;
-    char buf[20];
-
-    if (ndx >= XkbNumVirtualMods)
-         tmp = "illegal";
-    else
-         tmp = xkb_atom_text(keymap->ctx, keymap->vmod_names[ndx]);
-
-    if (!tmp) {
-        snprintf(buf, sizeof(buf) - 1, "%d", ndx);
-        tmp = buf;
+    for (const LookupEntry *entry = tab; entry->name; entry++) {
+        if (istreq(entry->name, string)) {
+            *value_rtrn = entry->value;
+            return true;
+        }
     }
 
-    len = strlen(tmp) + 1;
-    if (len >= BUFFER_SIZE)
-        len = BUFFER_SIZE - 1;
-
-    rtrn = GetBuffer(len);
-    strncpy(rtrn, tmp, len);
-
-    return rtrn;
+    return false;
 }
 
-/* Get a mod mask's text, where the mask is in rmods+vmods format. */
 const char *
-VModMaskText(struct xkb_keymap *keymap, xkb_mod_mask_t cmask)
+LookupValue(const LookupEntry tab[], unsigned int value)
 {
-    xkb_mod_index_t i;
-    xkb_mod_mask_t bit;
-    xkb_mod_mask_t rmask, vmask;
-    int len, rem;
-    const char *mm = NULL;
-    char *rtrn, *str;
-    char buf[BUFFER_SIZE];
+    for (const LookupEntry *entry = tab; entry->name; entry++)
+        if (entry->value == value)
+            return entry->name;
 
-    rmask = cmask & 0xff;
-    vmask = cmask >> XkbNumModifiers;
-
-    if (rmask == 0 && vmask == 0)
-        return "none";
+    return NULL;
+}
 
-    if (rmask != 0)
-        mm = ModMaskText(rmask);
+const LookupEntry ctrlMaskNames[] = {
+    { "RepeatKeys", CONTROL_REPEAT },
+    { "Repeat", CONTROL_REPEAT },
+    { "AutoRepeat", CONTROL_REPEAT },
+    { "SlowKeys", CONTROL_SLOW },
+    { "BounceKeys", CONTROL_DEBOUNCE },
+    { "StickyKeys", CONTROL_STICKY },
+    { "MouseKeys", CONTROL_MOUSEKEYS },
+    { "MouseKeysAccel", CONTROL_MOUSEKEYS_ACCEL },
+    { "AccessXKeys", CONTROL_AX },
+    { "AccessXTimeout", CONTROL_AX_TIMEOUT },
+    { "AccessXFeedback", CONTROL_AX_FEEDBACK },
+    { "AudibleBell", CONTROL_BELL },
+    { "IgnoreGroupLock", CONTROL_IGNORE_GROUP_LOCK },
+    { "all", CONTROL_ALL },
+    { "none", 0 },
+    { "Overlay1", 0 },
+    { "Overlay2", 0 },
+    { NULL, 0 }
+};
 
-    str = buf;
-    buf[0] = '\0';
-    rem = BUFFER_SIZE;
+const LookupEntry modComponentMaskNames[] = {
+    { "base", XKB_STATE_MODS_DEPRESSED },
+    { "latched", XKB_STATE_MODS_LATCHED },
+    { "locked", XKB_STATE_MODS_LOCKED },
+    { "effective", XKB_STATE_MODS_EFFECTIVE },
+    { "compat", XKB_STATE_MODS_EFFECTIVE },
+    { "any", XKB_STATE_MODS_EFFECTIVE },
+    { "none", 0 },
+    { NULL, 0 }
+};
 
-    if (vmask != 0) {
-        for (i = 0, bit = 1; i < XkbNumVirtualMods && rem > 1; i++, bit <<=
-                 1) {
-            if (!(vmask & bit))
-                continue;
+const LookupEntry groupComponentMaskNames[] = {
+    { "base", XKB_STATE_LAYOUT_DEPRESSED },
+    { "latched", XKB_STATE_LAYOUT_LATCHED },
+    { "locked", XKB_STATE_LAYOUT_LOCKED },
+    { "effective", XKB_STATE_LAYOUT_EFFECTIVE },
+    { "any", XKB_STATE_LAYOUT_EFFECTIVE },
+    { "none", 0 },
+    { NULL, 0 }
+};
 
-            len = snprintf(str, rem, "%s%s",
-                           (str != buf) ? "+" : "",
-                           VModIndexText(keymap, i));
-            rem -= len;
-            str += len;
-        }
+const LookupEntry groupMaskNames[] = {
+    { "Group1", 0x01 },
+    { "Group2", 0x02 },
+    { "Group3", 0x04 },
+    { "Group4", 0x08 },
+    { "Group5", 0x10 },
+    { "Group6", 0x20 },
+    { "Group7", 0x40 },
+    { "Group8", 0x80 },
+    { "none", 0x00 },
+    { "all", 0xff },
+    { NULL, 0 }
+};
 
-        str = buf;
-    }
-    else
-        str = NULL;
+const LookupEntry groupNames[] = {
+    { "Group1", 1 },
+    { "Group2", 2 },
+    { "Group3", 3 },
+    { "Group4", 4 },
+    { "Group5", 5 },
+    { "Group6", 6 },
+    { "Group7", 7 },
+    { "Group8", 8 },
+    { NULL, 0 }
+};
 
-    len = (str ? strlen(str) : 0) + (mm ? strlen(mm) : 0) +
-          (str && mm ? 1 : 0);
-    if (len >= BUFFER_SIZE)
-        len = BUFFER_SIZE - 1;
+const LookupEntry levelNames[] = {
+    { "Level1", 1 },
+    { "Level2", 2 },
+    { "Level3", 3 },
+    { "Level4", 4 },
+    { "Level5", 5 },
+    { "Level6", 6 },
+    { "Level7", 7 },
+    { "Level8", 8 },
+    { NULL, 0 }
+};
 
-    rtrn = GetBuffer(len + 1);
-    rtrn[0] = '\0';
+const LookupEntry buttonNames[] = {
+    { "Button1", 1 },
+    { "Button2", 2 },
+    { "Button3", 3 },
+    { "Button4", 4 },
+    { "Button5", 5 },
+    { "default", 0 },
+    { NULL, 0 }
+};
 
-    snprintf(rtrn, len + 1, "%s%s%s", (mm ? mm : ""),
-             (mm && str ? "+" : ""), (str ? str : ""));
+const LookupEntry useModMapValueNames[] = {
+    { "LevelOne", 1 },
+    { "Level1", 1 },
+    { "AnyLevel", 0 },
+    { "any", 0 },
+    { NULL, 0 }
+};
 
-    return rtrn;
-}
+const LookupEntry actionTypeNames[] = {
+    { "NoAction", ACTION_TYPE_NONE },
+    { "SetMods", ACTION_TYPE_MOD_SET },
+    { "LatchMods", ACTION_TYPE_MOD_LATCH },
+    { "LockMods", ACTION_TYPE_MOD_LOCK },
+    { "SetGroup", ACTION_TYPE_GROUP_SET },
+    { "LatchGroup", ACTION_TYPE_GROUP_LATCH },
+    { "LockGroup", ACTION_TYPE_GROUP_LOCK },
+    { "MovePtr", ACTION_TYPE_PTR_MOVE },
+    { "MovePointer", ACTION_TYPE_PTR_MOVE },
+    { "PtrBtn", ACTION_TYPE_PTR_BUTTON },
+    { "PointerButton", ACTION_TYPE_PTR_BUTTON },
+    { "LockPtrBtn", ACTION_TYPE_PTR_LOCK },
+    { "LockPtrButton", ACTION_TYPE_PTR_LOCK },
+    { "LockPointerButton", ACTION_TYPE_PTR_LOCK },
+    { "LockPointerBtn", ACTION_TYPE_PTR_LOCK },
+    { "SetPtrDflt", ACTION_TYPE_PTR_DEFAULT },
+    { "SetPointerDefault", ACTION_TYPE_PTR_DEFAULT },
+    { "Terminate", ACTION_TYPE_TERMINATE },
+    { "TerminateServer", ACTION_TYPE_TERMINATE },
+    { "SwitchScreen", ACTION_TYPE_SWITCH_VT },
+    { "SetControls", ACTION_TYPE_CTRL_SET },
+    { "LockControls", ACTION_TYPE_CTRL_LOCK },
+    { "Private", ACTION_TYPE_PRIVATE },
+    /* deprecated actions below here - unused */
+    { "RedirectKey", ACTION_TYPE_NONE },
+    { "Redirect", ACTION_TYPE_NONE },
+    { "ISOLock", ACTION_TYPE_NONE },
+    { "ActionMessage", ACTION_TYPE_NONE },
+    { "MessageAction", ACTION_TYPE_NONE },
+    { "Message", ACTION_TYPE_NONE },
+    { "DeviceBtn", ACTION_TYPE_NONE },
+    { "DevBtn", ACTION_TYPE_NONE },
+    { "DevButton", ACTION_TYPE_NONE },
+    { "DeviceButton", ACTION_TYPE_NONE },
+    { "LockDeviceBtn", ACTION_TYPE_NONE },
+    { "LockDevBtn", ACTION_TYPE_NONE },
+    { "LockDevButton", ACTION_TYPE_NONE },
+    { "LockDeviceButton", ACTION_TYPE_NONE },
+    { "DeviceValuator", ACTION_TYPE_NONE },
+    { "DevVal", ACTION_TYPE_NONE },
+    { "DeviceVal", ACTION_TYPE_NONE },
+    { "DevValuator", ACTION_TYPE_NONE },
+    { NULL, 0 },
+};
 
-/*
- * IMPORTATNT
- * The indices used for the legacy core modifiers is derived from
- * the order of the names in this table. It matches the values
- * ShiftMapIndex, LockMapIndex, etc. from X11/X.h. Take note before
- * changing.
- */
-static const char *modNames[XkbNumModifiers] = {
-    "Shift",
-    "Lock",
-    "Control",
-    "Mod1",
-    "Mod2",
-    "Mod3",
-    "Mod4",
-    "Mod5",
+const LookupEntry symInterpretMatchMaskNames[] = {
+    { "NoneOf", MATCH_NONE },
+    { "AnyOfOrNone", MATCH_ANY_OR_NONE },
+    { "AnyOf", MATCH_ANY },
+    { "AllOf", MATCH_ALL },
+    { "Exactly", MATCH_EXACTLY },
+    { NULL, 0 },
 };
 
-xkb_mod_index_t
-ModNameToIndex(const char *name)
+const char *
+ModIndexText(struct xkb_context *ctx, const struct xkb_mod_set *mods,
+             xkb_mod_index_t ndx)
 {
-    xkb_mod_index_t i;
+    if (ndx == XKB_MOD_INVALID)
+        return "none";
 
-    for (i = 0; i < XkbNumModifiers; i++)
-        if (istreq(name, modNames[i]))
-            return i;
+    if (ndx >= mods->num_mods)
+        return NULL;
 
-    return XKB_MOD_INVALID;
+    return xkb_atom_text(ctx, mods->mods[ndx].name);
 }
 
 const char *
-ModIndexToName(xkb_mod_index_t ndx)
+ActionTypeText(enum xkb_action_type type)
 {
-    if (ndx < XkbNumModifiers)
-        return modNames[ndx];
-    return NULL;
+    const char *name = LookupValue(actionTypeNames, type);
+    return name ? name : "Private";
 }
 
 const char *
-ModIndexText(xkb_mod_index_t ndx)
+KeysymText(struct xkb_context *ctx, xkb_keysym_t sym)
 {
-    const char *name;
-    char *buf;
-
-    name = ModIndexToName(ndx);
-    if (name)
-        return name;
-
-    if (ndx == XKB_MOD_INVALID)
-        return "none";
-
-    buf = GetBuffer(32);
-    snprintf(buf, 32, "ILLEGAL_%02x", ndx);
+    char *buffer = xkb_context_get_buffer(ctx, 64);
+    xkb_keysym_get_name(sym, buffer, 64);
+    return buffer;
+}
 
+const char *
+KeyNameText(struct xkb_context *ctx, xkb_atom_t name)
+{
+    const char *sname = xkb_atom_text(ctx, name);
+    size_t len = strlen_safe(sname) + 3;
+    char *buf = xkb_context_get_buffer(ctx, len);
+    snprintf(buf, len, "<%s>", strempty(sname));
     return buf;
 }
 
-/* Gets the text for the real modifiers only. */
 const char *
-ModMaskText(xkb_mod_mask_t mask)
+SIMatchText(enum xkb_match_operation type)
 {
-    int i, rem;
-    xkb_mod_index_t bit;
-    char *str, *buf;
+    return LookupValue(symInterpretMatchMaskNames, type);
+}
 
-    if ((mask & 0xff) == 0xff)
-        return "all";
+const char *
+ModMaskText(struct xkb_context *ctx, const struct xkb_mod_set *mods,
+            xkb_mod_mask_t mask)
+{
+    char buf[1024] = {0};
+    size_t pos = 0;
+    xkb_mod_index_t i;
+    const struct xkb_mod *mod;
 
-    if ((mask & 0xff) == 0)
+    if (mask == 0)
         return "none";
 
-    rem = 64;
-    buf = GetBuffer(rem);
-    str = buf;
-    buf[0] = '\0';
-    for (i = 0, bit = 1; i < XkbNumModifiers && rem > 1; i++, bit <<= 1) {
-        int len;
+    if (mask == MOD_REAL_MASK_ALL)
+        return "all";
 
-        if (!(mask & bit))
+    xkb_mods_enumerate(i, mod, mods) {
+        int ret;
+
+        if (!(mask & (1u << i)))
             continue;
 
-        len = snprintf(str, rem, "%s%s",
-                       (str != buf ?  "+" : ""), modNames[i]);
-        rem -= len;
-        str += len;
+        ret = snprintf(buf + pos, sizeof(buf) - pos, "%s%s",
+                       pos == 0 ? "" : "+",
+                       xkb_atom_text(ctx, mod->name));
+        if (ret <= 0 || pos + ret >= sizeof(buf))
+            break;
+        else
+            pos += ret;
     }
 
-    return buf;
+    return strncpy(xkb_context_get_buffer(ctx, pos + 1), buf, pos + 1);
 }
 
-static const char *actionTypeNames[XkbSA_NumActions] = {
-    [XkbSA_NoAction]       = "NoAction",
-    [XkbSA_SetMods]        = "SetMods",
-    [XkbSA_LatchMods]      = "LatchMods",
-    [XkbSA_LockMods]       = "LockMods",
-    [XkbSA_SetGroup]       = "SetGroup",
-    [XkbSA_LatchGroup]     = "LatchGroup",
-    [XkbSA_LockGroup]      = "LockGroup",
-    [XkbSA_MovePtr]        = "MovePtr",
-    [XkbSA_PtrBtn]         = "PtrBtn",
-    [XkbSA_LockPtrBtn]     = "LockPtrBtn",
-    [XkbSA_SetPtrDflt]     = "SetPtrDflt",
-    [XkbSA_ISOLock]        = "ISOLock",
-    [XkbSA_Terminate]      = "Terminate",
-    [XkbSA_SwitchScreen]   = "SwitchScreen",
-    [XkbSA_SetControls]    = "SetControls",
-    [XkbSA_LockControls]   = "LockControls",
-    [XkbSA_ActionMessage]  = "ActionMessage",
-    [XkbSA_RedirectKey]    = "RedirectKey",
-    [XkbSA_DeviceBtn]      = "DeviceBtn",
-    [XkbSA_LockDeviceBtn]  = "LockDeviceBtn",
-    [XkbSA_DeviceValuator] = "DeviceValuator"
-};
-
 const char *
-ActionTypeText(unsigned type)
+LedStateMaskText(struct xkb_context *ctx, enum xkb_state_component mask)
 {
-    if (type <= XkbSA_LastAction)
-        return actionTypeNames[type];
-    return "Private";
-}
+    char buf[1024] = {0};
+    size_t pos = 0;
 
-const char *
-KeysymText(xkb_keysym_t sym)
-{
-    static char buffer[64];
+    if (mask == 0)
+        return "0";
 
-    xkb_keysym_get_name(sym, buffer, sizeof buffer);
+    for (unsigned i = 0; mask; i++) {
+        int ret;
 
-    return buffer;
+        if (!(mask & (1u << i)))
+            continue;
+
+        mask &= ~(1u << i);
+
+        ret = snprintf(buf + pos, sizeof(buf) - pos, "%s%s",
+                       pos == 0 ? "" : "+",
+                       LookupValue(modComponentMaskNames, 1u << i));
+        if (ret <= 0 || pos + ret >= sizeof(buf))
+            break;
+        else
+            pos += ret;
+    }
+
+    return strncpy(xkb_context_get_buffer(ctx, pos + 1), buf, pos + 1);
 }
 
 const char *
-KeyNameText(const char name[XkbKeyNameLength])
+ControlMaskText(struct xkb_context *ctx, enum xkb_action_controls mask)
 {
-    char *buf;
-    int len;
+    char buf[1024] = {0};
+    size_t pos = 0;
 
-    buf = GetBuffer(7);
-    buf[0] = '<';
-    strncpy(&buf[1], name, 4);
-    buf[5] = '\0';
-    len = strlen(buf);
-    buf[len++] = '>';
-    buf[len] = '\0';
+    if (mask == 0)
+        return "none";
 
-    return buf;
-}
+    if (mask == CONTROL_ALL)
+        return "all";
 
-static const char *siMatchText[5] = {
-    "NoneOf",       /* XkbSI_NoneOf */
-    "AnyOfOrNone",  /* XkbSI_AnyOfOrNone */
-    "AnyOf",        /* XkbSI_AnyOf */
-    "AllOf",        /* XkbSI_AllOf */
-    "Exactly"       /* XkbSI_Exactly */
-};
+    for (unsigned i = 0; mask; i++) {
+        int ret;
 
-const char *
-SIMatchText(unsigned type)
-{
-    char *buf;
-
-    switch (type & XkbSI_OpMask) {
-    case XkbSI_NoneOf:
-        return siMatchText[0];
-    case XkbSI_AnyOfOrNone:
-        return siMatchText[1];
-    case XkbSI_AnyOf:
-        return siMatchText[2];
-    case XkbSI_AllOf:
-        return siMatchText[3];
-    case XkbSI_Exactly:
-        return siMatchText[4];
-    default:
-        buf = GetBuffer(40);
-        snprintf(buf, 40, "0x%x", type & XkbSI_OpMask);
-        return buf;
+        if (!(mask & (1u << i)))
+            continue;
+
+        mask &= ~(1u << i);
+
+        ret = snprintf(buf + pos, sizeof(buf) - pos, "%s%s",
+                       pos == 0 ? "" : "+",
+                       LookupValue(ctrlMaskNames, 1u << i));
+        if (ret <= 0 || pos + ret >= sizeof(buf))
+            break;
+        else
+            pos += ret;
     }
+
+    return strncpy(xkb_context_get_buffer(ctx, pos + 1), buf, pos + 1);
 }