X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftext.c;h=290a5ae24e0fec78227b2468f6c74daf917522cc;hb=990262cb4558f6eb0fbb936b83c9cc72daa585a6;hp=9db34d54f69ca65843b0a1e22a12905e83424153;hpb=1f492901314baae0172c19414fac6829089f97a4;p=platform%2Fupstream%2Flibxkbcommon.git diff --git a/src/text.c b/src/text.c index 9db34d5..290a5ae 100644 --- a/src/text.c +++ b/src/text.c @@ -1,297 +1,351 @@ /************************************************************ - Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc. - - Permission to use, copy, modify, and distribute this - software and its documentation for any purpose and without - fee is hereby granted, provided that the above copyright - notice appear in all copies and that both that copyright - notice and this permission notice appear in supporting - documentation, and that the name of Silicon Graphics not be - used in advertising or publicity pertaining to distribution - of the software without specific prior written permission. - Silicon Graphics makes no representation about the suitability - of this software for any purpose. It is provided "as is" - without any express or implied warranty. - - SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS - SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON - GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL - DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, - DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE - OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH - THE USE OR PERFORMANCE OF THIS SOFTWARE. - + * Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, and distribute this + * software and its documentation for any purpose and without + * fee is hereby granted, provided that the above copyright + * notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting + * documentation, and that the name of Silicon Graphics not be + * used in advertising or publicity pertaining to distribution + * of the software without specific prior written permission. + * Silicon Graphics makes no representation about the suitability + * of this software for any purpose. It is provided "as is" + * without any express or implied warranty. + * + * SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS + * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON + * GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE + * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH + * THE USE OR PERFORMANCE OF THIS SOFTWARE. + * ********************************************************/ -#include "text.h" +#include "config.h" -#define BUFFER_SIZE 1024 -static char textBuffer[BUFFER_SIZE]; -static unsigned int tbNext = 0; +#include "keymap.h" +#include "text.h" -static char * -tbGetBuffer(unsigned int size) +bool +LookupString(const LookupEntry tab[], const char *string, + unsigned int *value_rtrn) { - char *rtrn; - - if (size >= BUFFER_SIZE) - return NULL; - - if ((BUFFER_SIZE - tbNext) <= size) - tbNext = 0; - - rtrn = &textBuffer[tbNext]; - tbNext += size; - - return rtrn; -} + if (!string) + return false; -static const char * -XkbcVModIndexText(struct xkb_keymap *keymap, unsigned ndx) -{ - int len; - char *rtrn; - const char *tmp = NULL; - char buf[20]; - - if (ndx >= XkbNumVirtualMods) - tmp = "illegal"; - else if (keymap && keymap->names) - tmp = keymap->names->vmods[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 = tbGetBuffer(len); - strncpy(rtrn, tmp, len); - - return rtrn; + return false; } const char * -XkbcVModMaskText(struct xkb_keymap *keymap, unsigned modMask, unsigned mask) +LookupValue(const LookupEntry tab[], unsigned int value) { - int i, bit, 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; - if ((modMask == 0) && (mask == 0)) - return "none"; + return NULL; +} - if (modMask != 0) - mm = XkbcModMaskText(modMask, false); +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 (mask) { - for (i = 0, bit = 1; i < XkbNumVirtualMods && rem > 1; i++, bit <<= 1) - { - if (!(mask & 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) ? "+" : "", - XkbcVModIndexText(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 = tbGetBuffer(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 }, +}; -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 }, }; const char * -XkbcModIndexText(unsigned ndx) +ModIndexText(struct xkb_context *ctx, const struct xkb_mod_set *mods, + xkb_mod_index_t ndx) { - char *buf; - - if (ndx < XkbNumModifiers) - return modNames[ndx]; - else if (ndx == XkbNoModifier) + if (ndx == XKB_MOD_INVALID) return "none"; - buf = tbGetBuffer(32); - snprintf(buf, 32, "ILLEGAL_%02x", ndx); + if (ndx == XKB_MOD_NONE) + return "None"; + + if (ndx >= mods->num_mods) + return NULL; + + return xkb_atom_text(ctx, mods->mods[ndx].name); +} + +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; } const char * -XkbcModMaskText(unsigned mask, bool cFormat) +SIMatchText(enum xkb_match_operation type) +{ + return LookupValue(symInterpretMatchMaskNames, type); +} + +const char * +ModMaskText(struct xkb_context *ctx, const struct xkb_mod_set *mods, + xkb_mod_mask_t mask) { - int i, rem, bit; - char *str, *buf; + char buf[1024] = {0}; + size_t pos = 0; + xkb_mod_index_t i; + const struct xkb_mod *mod; - if ((mask & 0xff) == 0xff) - return (cFormat ? "0xff" : "all"); + if (mask == 0) + return "none"; - if ((mask & 0xff) == 0) - return (cFormat ? "0" : "none"); + if (mask == MOD_REAL_MASK_ALL) + return "all"; - rem = 64; - buf = tbGetBuffer(rem); - str = buf; - buf[0] = '\0'; - for (i = 0, bit = 1; i < XkbNumModifiers && rem > 1; i++, bit <<= 1) { - int len; + xkb_mods_enumerate(i, mod, mods) { + int ret; - if (!(mask & bit)) + if (!(mask & (1u << i))) continue; - len = snprintf(str, rem, "%s%s%s", - (str != buf) ? (cFormat ? "|" : "+") : "", - modNames[i], - cFormat ? "Mask" : ""); - 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 strcpy(xkb_context_get_buffer(ctx, pos + 1), buf); } const char * -XkbcFileTypeText(enum xkb_file_type type) +LedStateMaskText(struct xkb_context *ctx, enum xkb_state_component mask) { - switch (type) { - case FILE_TYPE_KEYMAP: - return "Keymap"; - case FILE_TYPE_TYPES: - return "Types"; - case FILE_TYPE_COMPAT: - return "CompatMap"; - case FILE_TYPE_SYMBOLS: - return "Symbols"; - case FILE_TYPE_KEYCODES: - return "KeyNames"; - case FILE_TYPE_RULES: - return "Rules"; - default: - return "unknown"; - } -} + char buf[1024]; + size_t pos = 0; -static const char *actionTypeNames[XkbSA_NumActions]= { - "NoAction", /* XkbSA_NoAction */ - "SetMods", /* XkbSA_SetMods */ - "LatchMods", /* XkbSA_LatchMods */ - "LockMods", /* XkbSA_LockMods */ - "SetGroup", /* XkbSA_SetGroup */ - "LatchGroup", /* XkbSA_LatchGroup */ - "LockGroup", /* XkbSA_LockGroup */ - "MovePtr", /* XkbSA_MovePtr */ - "PtrBtn", /* XkbSA_PtrBtn */ - "LockPtrBtn", /* XkbSA_LockPtrBtn */ - "SetPtrDflt", /* XkbSA_SetPtrDflt */ - "ISOLock", /* XkbSA_ISOLock */ - "Terminate", /* XkbSA_Terminate */ - "SwitchScreen", /* XkbSA_SwitchScreen */ - "SetControls", /* XkbSA_SetControls */ - "LockControls", /* XkbSA_LockControls */ - "ActionMessage", /* XkbSA_ActionMessage */ - "RedirectKey", /* XkbSA_RedirectKey */ - "DeviceBtn", /* XkbSA_DeviceBtn */ - "LockDeviceBtn", /* XkbSA_LockDeviceBtn */ - "DeviceValuator" /* XkbSA_DeviceValuator */ -}; + if (mask == 0) + return "0"; -const char * -XkbcActionTypeText(unsigned type) -{ - if (type <= XkbSA_LastAction) - return actionTypeNames[type]; - return "Private"; -} + for (unsigned i = 0; mask; i++) { + int ret; -const char * -XkbcKeysymText(xkb_keysym_t sym) -{ - static char buffer[64]; + if (!(mask & (1u << i))) + continue; - xkb_keysym_get_name(sym, buffer, sizeof buffer); + mask &= ~(1u << i); - return buffer; + 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 strcpy(xkb_context_get_buffer(ctx, pos + 1), buf); } const char * -XkbcKeyNameText(char *name) +ControlMaskText(struct xkb_context *ctx, enum xkb_action_controls mask) { - char *buf; - int len; + char buf[1024]; + size_t pos = 0; - buf = tbGetBuffer(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 * -XkbcSIMatchText(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 = tbGetBuffer(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 strcpy(xkb_context_get_buffer(ctx, pos + 1), buf); }