********************************************************/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
+#include "xkb-priv.h"
+#include "alloc.h"
-#include "X11/extensions/XKBcommon.h"
-#include "XKBcommonint.h"
-
-#define mapSize(m) (sizeof(m) / sizeof(XkbKTMapEntryRec))
-static XkbKTMapEntryRec map2Level[]= {
- { True, ShiftMask, {1, ShiftMask, 0} }
+static struct xkb_kt_map_entry map2Level[]= {
+ {
+ .active = true,
+ .level = ShiftMask,
+ .mods = {.mask = 1, .vmods = ShiftMask, .real_mods = 0 }
+ }
};
-static XkbKTMapEntryRec mapAlpha[]= {
- { True, ShiftMask, { 1, ShiftMask, 0 } },
- { True, LockMask, { 0, LockMask, 0 } }
+static struct xkb_kt_map_entry mapAlpha[]= {
+ {
+ .active = true,
+ .level = ShiftMask,
+ .mods = { .mask = 1, .vmods = ShiftMask, .real_mods = 0 }
+ },
+ {
+ .active = true,
+ .level = LockMask,
+ .mods = { .mask = 0, .vmods = LockMask, .real_mods = 0 }
+ }
};
-static XkbModsRec preAlpha[]= {
- { 0, 0, 0 },
- { LockMask, LockMask, 0 }
+static struct xkb_mods preAlpha[]= {
+ { .mask = 0, .vmods = 0, .real_mods = 0 },
+ { .mask = LockMask, .vmods = LockMask, .real_mods = 0 }
};
#define NL_VMOD_MASK 0
-static XkbKTMapEntryRec mapKeypad[]= {
- { True, ShiftMask, { 1, ShiftMask, 0 } },
- { False, 0, { 1, 0, NL_VMOD_MASK } }
+static struct xkb_kt_map_entry mapKeypad[]= {
+ {
+ .active = true,
+ .level = ShiftMask,
+ .mods = { .mask = 1, .vmods = ShiftMask, .real_mods = 0 }
+ },
+ {
+ .active = false,
+ .level = 0,
+ .mods = { .mask = 1, .vmods = 0, .real_mods = NL_VMOD_MASK }
+ }
};
-static XkbKeyTypeRec canonicalTypes[XkbNumRequiredTypes] = {
- { { 0, 0, 0 },
- 1, /* num_levels */
- 0, /* map_count */
- NULL, NULL,
- None, NULL
+static const struct xkb_key_type canonicalTypes[XkbNumRequiredTypes] = {
+ {
+ .mods = { .mask = 0, .vmods = 0, .real_mods = 0 },
+ .num_levels = 1,
+ .preserve = NULL,
+ .name = NULL,
+ .level_names = NULL
},
- { { ShiftMask, ShiftMask, 0 },
- 2, /* num_levels */
- mapSize(map2Level), /* map_count */
- map2Level, NULL,
- None, NULL
+ {
+ .mods = { .mask = ShiftMask, .vmods = ShiftMask, .real_mods = 0 },
+ .num_levels = 2,
+ .map = darray_lit(map2Level),
+ .preserve = NULL,
+ .name = NULL,
+ .level_names = NULL
},
- { { ShiftMask|LockMask, ShiftMask|LockMask, 0 },
- 2, /* num_levels */
- mapSize(mapAlpha), /* map_count */
- mapAlpha, preAlpha,
- None, NULL
+ {
+ .mods = { .mask = ShiftMask|LockMask, .vmods = ShiftMask|LockMask, .real_mods = 0 },
+ .num_levels = 2,
+ .map = darray_lit(mapAlpha),
+ .preserve = preAlpha,
+ .name = NULL,
+ .level_names = NULL
},
- { { ShiftMask, ShiftMask, NL_VMOD_MASK },
- 2, /* num_levels */
- mapSize(mapKeypad), /* map_count */
- mapKeypad, NULL,
- None, NULL
+ {
+ .mods = { .mask = ShiftMask, .vmods = ShiftMask, .real_mods = NL_VMOD_MASK },
+ .num_levels = 2,
+ .map = darray_lit(mapKeypad),
+ .preserve = NULL,
+ .name = NULL,
+ .level_names = NULL
}
};
int
-XkbcInitCanonicalKeyTypes(XkbcDescPtr xkb, unsigned which, int keypadVMod)
+XkbcInitCanonicalKeyTypes(struct xkb_keymap *keymap, unsigned which,
+ int keypadVMod)
{
- XkbClientMapPtr map;
- XkbKeyTypePtr from,to;
+ struct xkb_client_map * map;
+ const struct xkb_key_type *from;
int rtrn;
- if (!xkb)
+ if (!keymap)
return BadMatch;
- rtrn= XkbcAllocClientMap(xkb, XkbKeyTypesMask, XkbNumRequiredTypes);
+ rtrn = XkbcAllocClientMap(keymap, XkbKeyTypesMask, XkbNumRequiredTypes);
if (rtrn != Success)
return rtrn;
- map= xkb->map;
+ map = keymap->map;
if ((which & XkbAllRequiredTypes) == 0)
return Success;
rtrn = Success;
from = canonicalTypes;
- to = map->types;
if (which & XkbOneLevelMask)
- rtrn = XkbcCopyKeyType(&from[XkbOneLevelIndex], &to[XkbOneLevelIndex]);
+ rtrn = XkbcCopyKeyType(&from[XkbOneLevelIndex],
+ &darray_item(map->types, XkbOneLevelIndex));
if ((which & XkbTwoLevelMask) && (rtrn == Success))
- rtrn = XkbcCopyKeyType(&from[XkbTwoLevelIndex], &to[XkbTwoLevelIndex]);
+ rtrn = XkbcCopyKeyType(&from[XkbTwoLevelIndex],
+ &darray_item(map->types, XkbTwoLevelIndex));
if ((which & XkbAlphabeticMask) && (rtrn == Success))
rtrn = XkbcCopyKeyType(&from[XkbAlphabeticIndex],
- &to[XkbAlphabeticIndex]);
+ &darray_item(map->types, XkbAlphabeticIndex));
if ((which & XkbKeypadMask) && (rtrn == Success)) {
- XkbKeyTypePtr type;
+ struct xkb_key_type * type;
- rtrn = XkbcCopyKeyType(&from[XkbKeypadIndex], &to[XkbKeypadIndex]);
- type = &to[XkbKeypadIndex];
+ rtrn = XkbcCopyKeyType(&from[XkbKeypadIndex],
+ &darray_item(map->types, XkbKeypadIndex));
+ type = &darray_item(map->types, XkbKeypadIndex);
if ((keypadVMod >= 0) && (keypadVMod < XkbNumVirtualMods) &&
(rtrn == Success)) {
+ struct xkb_kt_map_entry *entry;
type->mods.vmods = (1 << keypadVMod);
- type->map[0].active = True;
- type->map[0].mods.mask = ShiftMask;
- type->map[0].mods.real_mods = ShiftMask;
- type->map[0].mods.vmods = 0;
- type->map[0].level = 1;
- type->map[1].active = False;
- type->map[1].mods.mask = 0;
- type->map[1].mods.real_mods = 0;
- type->map[1].mods.vmods = (1 << keypadVMod);
- type->map[1].level = 1;
+
+ entry = &darray_item(type->map, 0);
+ entry->active = true;
+ entry->mods.mask = ShiftMask;
+ entry->mods.real_mods = ShiftMask;
+ entry->mods.vmods = 0;
+ entry->level = 1;
+
+ entry = &darray_item(type->map, 1);
+ entry->active = false;
+ entry->mods.mask = 0;
+ entry->mods.real_mods = 0;
+ entry->mods.vmods = (1 << keypadVMod);
+ entry->level = 1;
}
}
return Success;
}
-Bool
-XkbcVirtualModsToReal(XkbcDescPtr xkb, unsigned virtual_mask,
- unsigned *mask_rtrn)
+unsigned
+_XkbcKSCheckCase(xkb_keysym_t ks)
{
- int i, bit;
- unsigned mask;
-
- if (!xkb)
- return False;
- if (virtual_mask == 0) {
- *mask_rtrn = 0;
- return True;
- }
- if (!xkb->server)
- return False;
+ unsigned set = (ks & (~0xff)) >> 8;
+ unsigned rtrn = 0;
- for (i = mask = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
- if (virtual_mask & bit)
- mask |= xkb->server->vmods[i];
+ switch (set) {
+ case 0: /* latin 1 */
+ if ((ks >= XKB_KEY_A && ks <= XKB_KEY_Z) ||
+ (ks >= XKB_KEY_Agrave && ks <= XKB_KEY_THORN && ks != XKB_KEY_multiply))
+ rtrn |= _XkbKSUpper;
+ if ((ks >= XKB_KEY_a && ks <= XKB_KEY_z) ||
+ (ks >= XKB_KEY_agrave && ks <= XKB_KEY_ydiaeresis))
+ rtrn |= _XkbKSLower;
+ break;
+ case 1: /* latin 2 */
+ if ((ks >= XKB_KEY_Aogonek && ks <= XKB_KEY_Zabovedot && ks != XKB_KEY_breve) ||
+ (ks >= XKB_KEY_Racute && ks<=XKB_KEY_Tcedilla))
+ rtrn |= _XkbKSUpper;
+ if ((ks >= XKB_KEY_aogonek && ks <= XKB_KEY_zabovedot && ks != XKB_KEY_caron) ||
+ (ks >= XKB_KEY_racute && ks <= XKB_KEY_tcedilla))
+ rtrn |= _XkbKSLower;
+ break;
+ case 2: /* latin 3 */
+ if ((ks >= XKB_KEY_Hstroke && ks <= XKB_KEY_Jcircumflex) ||
+ (ks >= XKB_KEY_Cabovedot && ks <= XKB_KEY_Scircumflex))
+ rtrn |= _XkbKSUpper;
+ if ((ks >= XKB_KEY_hstroke && ks <= XKB_KEY_jcircumflex) ||
+ (ks >= XKB_KEY_cabovedot && ks <= XKB_KEY_scircumflex))
+ rtrn |= _XkbKSLower;
+ break;
+ case 3: /* latin 4 */
+ if ((ks >= XKB_KEY_Rcedilla && ks <= XKB_KEY_Tslash) ||
+ (ks == XKB_KEY_ENG) ||
+ (ks >= XKB_KEY_Amacron && ks <= XKB_KEY_Umacron))
+ rtrn |= _XkbKSUpper;
+ if ((ks >= XKB_KEY_rcedilla && ks <= XKB_KEY_tslash) ||
+ (ks == XKB_KEY_eng) ||
+ (ks >= XKB_KEY_amacron && ks <= XKB_KEY_umacron))
+ rtrn |= _XkbKSLower;
+ break;
+ case 18: /* latin 8 */
+ if ((ks == XKB_KEY_Wcircumflex) ||
+ (ks == XKB_KEY_Ycircumflex) ||
+ (ks == XKB_KEY_Babovedot) ||
+ (ks == XKB_KEY_Dabovedot) ||
+ (ks == XKB_KEY_Fabovedot) ||
+ (ks == XKB_KEY_Mabovedot) ||
+ (ks == XKB_KEY_Pabovedot) ||
+ (ks == XKB_KEY_Sabovedot) ||
+ (ks == XKB_KEY_Tabovedot) ||
+ (ks == XKB_KEY_Wdiaeresis) ||
+ (ks == XKB_KEY_Ygrave))
+ rtrn |= _XkbKSUpper;
+ if ((ks == XKB_KEY_wcircumflex) ||
+ (ks == XKB_KEY_ycircumflex) ||
+ (ks == XKB_KEY_babovedot) ||
+ (ks == XKB_KEY_dabovedot) ||
+ (ks == XKB_KEY_fabovedot) ||
+ (ks == XKB_KEY_mabovedot) ||
+ (ks == XKB_KEY_pabovedot) ||
+ (ks == XKB_KEY_sabovedot) ||
+ (ks == XKB_KEY_tabovedot) ||
+ (ks == XKB_KEY_wdiaeresis) ||
+ (ks == XKB_KEY_ygrave))
+ rtrn |= _XkbKSLower;
+ break;
+ case 19: /* latin 9 */
+ if (ks == XKB_KEY_OE || ks == XKB_KEY_Ydiaeresis)
+ rtrn |= _XkbKSUpper;
+ if (ks == XKB_KEY_oe)
+ rtrn |= _XkbKSLower;
+ break;
}
- *mask_rtrn = mask;
- return True;
+ return rtrn;
}
-/*
- * All latin-1 alphanumerics, plus parens, slash, minus, underscore and
- * wildcards.
- */
-static unsigned char componentSpecLegal[] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xa7, 0xff, 0x83,
- 0xfe, 0xff, 0xff, 0x87, 0xfe, 0xff, 0xff, 0x07,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff
-};
-
-void
-XkbcEnsureSafeMapName(char *name)
+xkb_keycode_t
+XkbcFindKeycodeByName(struct xkb_keymap *keymap, const char *name,
+ bool use_aliases)
{
- if (!name)
- return;
+ struct xkb_key_alias *alias;
+ xkb_keycode_t i;
- while (*name!='\0') {
- if ((componentSpecLegal[(*name) / 8] & (1 << ((*name) % 8))) == 0)
- *name= '_';
- name++;
+ for (i = keymap->min_key_code; i <= keymap->max_key_code; i++) {
+ if (strncmp(darray_item(keymap->names->keys, i).name, name,
+ XkbKeyNameLength) == 0)
+ return i;
}
-}
-unsigned
-_XkbcKSCheckCase(KeySym ks)
-{
-unsigned set,rtrn;
+ if (!use_aliases)
+ return 0;
- set= (ks & (~0xff)) >> 8;
- rtrn= 0;
- switch (set) {
- case 0: /* latin 1 */
- if (((ks>=XK_A)&&(ks<=XK_Z))||
- ((ks>=XK_Agrave)&&(ks<=XK_THORN)&&(ks!=XK_multiply))) {
- rtrn|= _XkbcKSUpper;
- }
- if (((ks>=XK_a)&&(ks<=XK_z))||
- ((ks>=XK_agrave)&&(ks<=XK_ydiaeresis))) {
- rtrn|= _XkbcKSLower;
- }
- break;
- case 1: /* latin 2 */
- if (((ks>=XK_Aogonek)&&(ks<=XK_Zabovedot)&&(ks!=XK_breve))||
- ((ks>=XK_Racute)&&(ks<=XK_Tcedilla))) {
- rtrn|= _XkbcKSUpper;
- }
- if (((ks>=XK_aogonek)&&(ks<=XK_zabovedot)&&(ks!=XK_caron))||
- ((ks>=XK_racute)&&(ks<=XK_tcedilla))) {
- rtrn|= _XkbcKSLower;
- }
- break;
- case 2: /* latin 3 */
- if (((ks>=XK_Hstroke)&&(ks<=XK_Jcircumflex))||
- ((ks>=XK_Cabovedot)&&(ks<=XK_Scircumflex))) {
- rtrn|= _XkbcKSUpper;
- }
- if (((ks>=XK_hstroke)&&(ks<=XK_jcircumflex))||
- ((ks>=XK_cabovedot)&&(ks<=XK_scircumflex))) {
- rtrn|= _XkbcKSLower;
- }
- break;
- case 3: /* latin 4 */
- if (((ks>=XK_Rcedilla)&&(ks<=XK_Tslash))||
- (ks==XK_ENG)||
- ((ks>=XK_Amacron)&&(ks<=XK_Umacron))) {
- rtrn|= _XkbcKSUpper;
- }
- if (((ks>=XK_rcedilla)&&(ks<=XK_tslash))||
- (ks==XK_eng)||
- ((ks>=XK_amacron)&&(ks<=XK_umacron))) {
- rtrn|= _XkbcKSLower;
- }
- break;
- case 18: /* latin 8 */
- if ((ks==XK_Babovedot)||
- ((ks>=XK_Dabovedot)&&(ks<=XK_Wacute))||
- ((ks>=XK_Ygrave)&&(ks<=XK_Fabovedot))||
- (ks==XK_Mabovedot)||
- (ks==XK_Pabovedot)||
- (ks==XK_Sabovedot)||
- (ks==XK_Wdiaeresis)||
- ((ks>=XK_Wcircumflex)&&(ks<=XK_Ycircumflex))) {
- rtrn|= _XkbcKSUpper;
- }
- if ((ks==XK_babovedot)||
- (ks==XK_dabovedot)||
- (ks==XK_fabovedot)||
- (ks==XK_mabovedot)||
- ((ks>=XK_wgrave)&&(ks<=XK_wacute))||
- (ks==XK_ygrave)||
- ((ks>=XK_wdiaeresis)&&(ks<=XK_ycircumflex))) {
- rtrn|= _XkbcKSLower;
- }
- break;
- case 19: /* latin 9 */
- if ((ks==XK_OE)||(ks==XK_Ydiaeresis)) {
- rtrn|= _XkbcKSUpper;
- }
- if (ks==XK_oe) {
- rtrn|= _XkbcKSLower;
- }
- break;
+
+ for (i = 0; i < darray_size(keymap->names->key_aliases); i++) {
+ alias = &darray_item(keymap->names->key_aliases, i);
+ if (strncmp(name, alias->alias, XkbKeyNameLength) == 0)
+ return XkbcFindKeycodeByName(keymap, alias->real, false);
}
- return rtrn;
+
+ return 0;
}
projects / profile / ivi / libxkbcommon.git / blobdiff