X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftext.c;h=290a5ae24e0fec78227b2468f6c74daf917522cc;hb=b900faf77b5d07805f10a1160cd1c6842cc46b11;hp=6b96b72a6e0858c20bf15f00ad76120a450b693d;hpb=6d74e66e3f92344ed817b88f21ac7a47863ed26b;p=platform%2Fupstream%2Flibxkbcommon.git diff --git a/src/text.c b/src/text.c index 6b96b72..290a5ae 100644 --- a/src/text.c +++ b/src/text.c @@ -24,6 +24,8 @@ * ********************************************************/ +#include "config.h" + #include "keymap.h" #include "text.h" @@ -31,12 +33,10 @@ bool LookupString(const LookupEntry tab[], const char *string, unsigned int *value_rtrn) { - const LookupEntry *entry; - if (!string) return false; - for (entry = tab; entry->name; entry++) { + for (const LookupEntry *entry = tab; entry->name; entry++) { if (istreq(entry->name, string)) { *value_rtrn = entry->value; return true; @@ -49,9 +49,7 @@ LookupString(const LookupEntry tab[], const char *string, const char * LookupValue(const LookupEntry tab[], unsigned int value) { - const LookupEntry *entry; - - for (entry = tab; entry->name; entry++) + for (const LookupEntry *entry = tab; entry->name; entry++) if (entry->value == value) return entry->name; @@ -80,78 +78,78 @@ const LookupEntry ctrlMaskNames[] = { }; const LookupEntry modComponentMaskNames[] = { - {"base", XKB_STATE_DEPRESSED}, - {"latched", XKB_STATE_LATCHED}, - {"locked", XKB_STATE_LOCKED}, - {"effective", XKB_STATE_EFFECTIVE}, - {"compat", XKB_STATE_EFFECTIVE}, - {"any", XKB_STATE_EFFECTIVE}, - {"none", 0}, - {NULL, 0} + { "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 } }; const LookupEntry groupComponentMaskNames[] = { - {"base", XKB_STATE_DEPRESSED}, - {"latched", XKB_STATE_LATCHED}, - {"locked", XKB_STATE_LOCKED}, - {"effective", XKB_STATE_EFFECTIVE}, - {"any", XKB_STATE_EFFECTIVE}, - {"none", 0}, - {NULL, 0} + { "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 } }; 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} + { "Group1", 0x01 }, + { "Group2", 0x02 }, + { "Group3", 0x04 }, + { "Group4", 0x08 }, + { "Group5", 0x10 }, + { "Group6", 0x20 }, + { "Group7", 0x40 }, + { "Group8", 0x80 }, + { "none", 0x00 }, + { "all", 0xff }, + { NULL, 0 } }; const LookupEntry groupNames[] = { - {"group1", 1}, - {"group2", 2}, - {"group3", 3}, - {"group4", 4}, - {"group5", 5}, - {"group6", 6}, - {"group7", 7}, - {"group8", 8}, - {NULL, 0} + { "Group1", 1 }, + { "Group2", 2 }, + { "Group3", 3 }, + { "Group4", 4 }, + { "Group5", 5 }, + { "Group6", 6 }, + { "Group7", 7 }, + { "Group8", 8 }, + { NULL, 0 } }; const LookupEntry levelNames[] = { - { "level1", 1 }, - { "level2", 2 }, - { "level3", 3 }, - { "level4", 4 }, - { "level5", 5 }, - { "level6", 6 }, - { "level7", 7 }, - { "level8", 8 }, + { "Level1", 1 }, + { "Level2", 2 }, + { "Level3", 3 }, + { "Level4", 4 }, + { "Level5", 5 }, + { "Level6", 6 }, + { "Level7", 7 }, + { "Level8", 8 }, { NULL, 0 } }; const LookupEntry buttonNames[] = { - { "button1", 1 }, - { "button2", 2 }, - { "button3", 3 }, - { "button4", 4 }, - { "button5", 5 }, + { "Button1", 1 }, + { "Button2", 2 }, + { "Button3", 3 }, + { "Button4", 4 }, + { "Button5", 5 }, { "default", 0 }, { NULL, 0 } }; const LookupEntry useModMapValueNames[] = { - { "levelone", 1 }, - { "level1", 1 }, - { "anylevel", 0 }, + { "LevelOne", 1 }, + { "Level1", 1 }, + { "AnyLevel", 0 }, { "any", 0 }, { NULL, 0 } }; @@ -179,10 +177,10 @@ const LookupEntry actionTypeNames[] = { { "SwitchScreen", ACTION_TYPE_SWITCH_VT }, { "SetControls", ACTION_TYPE_CTRL_SET }, { "LockControls", ACTION_TYPE_CTRL_LOCK }, - { "RedirectKey", ACTION_TYPE_KEY_REDIRECT }, - { "Redirect", ACTION_TYPE_KEY_REDIRECT }, { "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 }, @@ -208,37 +206,63 @@ const LookupEntry symInterpretMatchMaskNames[] = { { "AnyOf", MATCH_ANY }, { "AllOf", MATCH_ALL }, { "Exactly", MATCH_EXACTLY }, + { NULL, 0 }, }; -#define BUFFER_SIZE 1024 - -static char * -GetBuffer(size_t size) +const char * +ModIndexText(struct xkb_context *ctx, const struct xkb_mod_set *mods, + xkb_mod_index_t ndx) { - static char buffer[BUFFER_SIZE]; - static size_t next; - char *rtrn; + if (ndx == XKB_MOD_INVALID) + return "none"; + + if (ndx == XKB_MOD_NONE) + return "None"; - if (size >= BUFFER_SIZE) + if (ndx >= mods->num_mods) return NULL; - if (BUFFER_SIZE - next <= size) - next = 0; + return xkb_atom_text(ctx, mods->mods[ndx].name); +} - rtrn = &buffer[next]; - next += size; +const char * +ActionTypeText(enum xkb_action_type type) +{ + const char *name = LookupValue(actionTypeNames, type); + return name ? name : "Private"; +} + +const char * +KeysymText(struct xkb_context *ctx, xkb_keysym_t sym) +{ + 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; +} - return rtrn; +const char * +SIMatchText(enum xkb_match_operation type) +{ + return LookupValue(symInterpretMatchMaskNames, type); } const char * -ModMaskText(const struct xkb_keymap *keymap, xkb_mod_mask_t mask) +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; - size_t len; - ssize_t rem; - char *str; - char buf[BUFFER_SIZE]; const struct xkb_mod *mod; if (mask == 0) @@ -247,98 +271,81 @@ ModMaskText(const struct xkb_keymap *keymap, xkb_mod_mask_t mask) if (mask == MOD_REAL_MASK_ALL) return "all"; - str = buf; - buf[0] = '\0'; - rem = BUFFER_SIZE; - darray_enumerate(i, mod, keymap->mods) { - if (!(mask & (1 << i))) - continue; + xkb_mods_enumerate(i, mod, mods) { + int ret; - len = snprintf(str, rem, "%s%s", - (str != buf) ? "+" : "", - xkb_atom_text(keymap->ctx, mod->name)); - rem -= len; - str += len; + if (!(mask & (1u << i))) + continue; - if (rem <= 1) + 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; } - str = buf; - - len = strlen(str); - if (len >= BUFFER_SIZE) - len = BUFFER_SIZE - 1; - - return strcpy(GetBuffer(len + 1), str); + return strcpy(xkb_context_get_buffer(ctx, pos + 1), buf); } const char * -ModIndexText(const struct xkb_keymap *keymap, xkb_mod_index_t ndx) +LedStateMaskText(struct xkb_context *ctx, enum xkb_state_component mask) { - if (ndx == XKB_MOD_INVALID) - return "none"; + char buf[1024]; + size_t pos = 0; - if (ndx >= darray_size(keymap->mods)) - return NULL; + if (mask == 0) + return "0"; - return xkb_atom_text(keymap->ctx, darray_item(keymap->mods, ndx).name); -} + for (unsigned i = 0; mask; i++) { + int ret; -xkb_mod_index_t -ModNameToIndex(const struct xkb_keymap *keymap, xkb_atom_t name, - enum mod_type type) -{ - xkb_mod_index_t i; - const struct xkb_mod *mod; + if (!(mask & (1u << i))) + continue; - darray_enumerate(i, mod, keymap->mods) - if ((mod->type & type) && name == mod->name) - return i; + mask &= ~(1u << i); - return XKB_MOD_INVALID; -} + 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; + } -const char * -ActionTypeText(unsigned type) -{ - const char *name = LookupValue(actionTypeNames, type); - return name ? name : "Private"; + return strcpy(xkb_context_get_buffer(ctx, pos + 1), buf); } const char * -KeysymText(xkb_keysym_t sym) +ControlMaskText(struct xkb_context *ctx, enum xkb_action_controls mask) { - static char buffer[64]; + char buf[1024]; + size_t pos = 0; - xkb_keysym_get_name(sym, buffer, sizeof buffer); + if (mask == 0) + return "none"; - return buffer; -} + if (mask == CONTROL_ALL) + return "all"; -const char * -KeyNameText(struct xkb_context *ctx, xkb_atom_t name) -{ - const char *sname = xkb_atom_text(ctx, name); - size_t len = strlen(sname) + 3; - char *buf = GetBuffer(len); - snprintf(buf, len, "<%s>", sname); - return buf; -} + for (unsigned i = 0; mask; i++) { + int ret; -const char * -SIMatchText(enum xkb_match_operation type) -{ - const char *name; - char *buf; + if (!(mask & (1u << i))) + continue; - type &= MATCH_OP_MASK; + mask &= ~(1u << i); - name = LookupValue(symInterpretMatchMaskNames, type); - if (name) - return name; + 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; + } - buf = GetBuffer(40); - snprintf(buf, 40, "0x%x", type); - return buf; + return strcpy(xkb_context_get_buffer(ctx, pos + 1), buf); }