src/misc.c

   1 /************************************************************
   2 Copyright (c) 1993 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 "xkb-priv.h"
  28 #include "alloc.h"
  29
  30 #define mapSize(m) (sizeof(m) / sizeof(struct xkb_kt_map_entry))
  31 static struct xkb_kt_map_entry map2Level[]= {
  32     { true, ShiftMask, {1, ShiftMask, 0} }
  33 };
  34
  35 static struct xkb_kt_map_entry mapAlpha[]= {
  36     { true, ShiftMask, { 1, ShiftMask, 0 } },
  37     { true, LockMask,  { 0, LockMask,  0 } }
  38 };
  39
  40 static struct xkb_mods preAlpha[]= {
  41     { 0,        0,        0 },
  42     { LockMask, LockMask, 0 }
  43 };
  44
  45 #define NL_VMOD_MASK 0
  46 static  struct xkb_kt_map_entry mapKeypad[]= {
  47     { true,  ShiftMask, { 1, ShiftMask, 0 } },
  48     { false, 0,         { 1, 0, NL_VMOD_MASK } }
  49 };
  50
  51 static struct xkb_key_type canonicalTypes[XkbNumRequiredTypes] = {
  52     { { 0, 0, 0 },
  53       1,        /* num_levels */
  54       0,        /* map_count */
  55       NULL, NULL,
  56       NULL, NULL
  57     },
  58     { { ShiftMask, ShiftMask, 0 },
  59       2,        /* num_levels */
  60       mapSize(map2Level),   /* map_count */
  61       map2Level, NULL,
  62       NULL,      NULL
  63     },
  64     { { ShiftMask|LockMask, ShiftMask|LockMask, 0 },
  65       2,        /* num_levels */
  66       mapSize(mapAlpha),    /* map_count */
  67       mapAlpha, preAlpha,
  68       NULL,     NULL
  69     },
  70     { { ShiftMask, ShiftMask, NL_VMOD_MASK },
  71       2,        /* num_levels */
  72       mapSize(mapKeypad),   /* map_count */
  73       mapKeypad, NULL,
  74       NULL,      NULL
  75     }
  76 };
  77
  78 int
  79 XkbcInitCanonicalKeyTypes(struct xkb_keymap *keymap, unsigned which,
  80                           int keypadVMod)
  81 {
  82     struct xkb_client_map * map;
  83     struct xkb_key_type *from, *to;
  84     int rtrn;
  85
  86     if (!keymap)
  87         return BadMatch;
  88
  89     rtrn = XkbcAllocClientMap(keymap, XkbKeyTypesMask, XkbNumRequiredTypes);
  90     if (rtrn != Success)
  91         return rtrn;
  92
  93     map = keymap->map;
  94     if ((which & XkbAllRequiredTypes) == 0)
  95         return Success;
  96
  97     rtrn = Success;
  98     from = canonicalTypes;
  99     to = map->types;
 100
 101     if (which & XkbOneLevelMask)
 102         rtrn = XkbcCopyKeyType(&from[XkbOneLevelIndex], &to[XkbOneLevelIndex]);
 103
 104     if ((which & XkbTwoLevelMask) && (rtrn == Success))
 105         rtrn = XkbcCopyKeyType(&from[XkbTwoLevelIndex], &to[XkbTwoLevelIndex]);
 106
 107     if ((which & XkbAlphabeticMask) && (rtrn == Success))
 108         rtrn = XkbcCopyKeyType(&from[XkbAlphabeticIndex],
 109                                &to[XkbAlphabeticIndex]);
 110
 111     if ((which & XkbKeypadMask) && (rtrn == Success)) {
 112         struct xkb_key_type * type;
 113
 114         rtrn = XkbcCopyKeyType(&from[XkbKeypadIndex], &to[XkbKeypadIndex]);
 115         type = &to[XkbKeypadIndex];
 116
 117         if ((keypadVMod >= 0) && (keypadVMod < XkbNumVirtualMods) &&
 118             (rtrn == Success)) {
 119             type->mods.vmods = (1 << keypadVMod);
 120             type->map[0].active = true;
 121             type->map[0].mods.mask = ShiftMask;
 122             type->map[0].mods.real_mods = ShiftMask;
 123             type->map[0].mods.vmods = 0;
 124             type->map[0].level = 1;
 125             type->map[1].active = false;
 126             type->map[1].mods.mask = 0;
 127             type->map[1].mods.real_mods = 0;
 128             type->map[1].mods.vmods = (1 << keypadVMod);
 129             type->map[1].level = 1;
 130         }
 131     }
 132
 133     return Success;
 134 }
 135
 136 unsigned
 137 _XkbcKSCheckCase(xkb_keysym_t ks)
 138 {
 139     unsigned set = (ks & (~0xff)) >> 8;
 140     unsigned rtrn = 0;
 141
 142     switch (set) {
 143     case 0: /* latin 1 */
 144         if ((ks >= XKB_KEY_A && ks <= XKB_KEY_Z) ||
 145             (ks >= XKB_KEY_Agrave && ks <= XKB_KEY_THORN && ks != XKB_KEY_multiply))
 146             rtrn |= _XkbKSUpper;
 147         if ((ks >= XKB_KEY_a && ks <= XKB_KEY_z) ||
 148             (ks >= XKB_KEY_agrave && ks <= XKB_KEY_ydiaeresis))
 149             rtrn |= _XkbKSLower;
 150         break;
 151     case 1: /* latin 2 */
 152         if ((ks >= XKB_KEY_Aogonek && ks <= XKB_KEY_Zabovedot && ks != XKB_KEY_breve) ||
 153             (ks >= XKB_KEY_Racute && ks<=XKB_KEY_Tcedilla))
 154             rtrn |= _XkbKSUpper;
 155         if ((ks >= XKB_KEY_aogonek && ks <= XKB_KEY_zabovedot && ks != XKB_KEY_caron) ||
 156             (ks >= XKB_KEY_racute && ks <= XKB_KEY_tcedilla))
 157             rtrn |= _XkbKSLower;
 158         break;
 159     case 2: /* latin 3 */
 160         if ((ks >= XKB_KEY_Hstroke && ks <= XKB_KEY_Jcircumflex) ||
 161             (ks >= XKB_KEY_Cabovedot && ks <= XKB_KEY_Scircumflex))
 162             rtrn |= _XkbKSUpper;
 163         if ((ks >= XKB_KEY_hstroke && ks <= XKB_KEY_jcircumflex) ||
 164             (ks >= XKB_KEY_cabovedot && ks <= XKB_KEY_scircumflex))
 165             rtrn |= _XkbKSLower;
 166         break;
 167     case 3: /* latin 4 */
 168         if ((ks >= XKB_KEY_Rcedilla && ks <= XKB_KEY_Tslash) ||
 169             (ks == XKB_KEY_ENG) ||
 170             (ks >= XKB_KEY_Amacron && ks <= XKB_KEY_Umacron))
 171             rtrn |= _XkbKSUpper;
 172         if ((ks >= XKB_KEY_rcedilla && ks <= XKB_KEY_tslash) ||
 173             (ks == XKB_KEY_eng) ||
 174             (ks >= XKB_KEY_amacron && ks <= XKB_KEY_umacron))
 175             rtrn |= _XkbKSLower;
 176         break;
 177     case 18: /* latin 8 */
 178         if ((ks == XKB_KEY_Wcircumflex) ||
 179             (ks == XKB_KEY_Ycircumflex) ||
 180             (ks == XKB_KEY_Babovedot) ||
 181             (ks == XKB_KEY_Dabovedot) ||
 182             (ks == XKB_KEY_Fabovedot) ||
 183             (ks == XKB_KEY_Mabovedot) ||
 184             (ks == XKB_KEY_Pabovedot) ||
 185             (ks == XKB_KEY_Sabovedot) ||
 186             (ks == XKB_KEY_Tabovedot) ||
 187             (ks == XKB_KEY_Wdiaeresis) ||
 188             (ks == XKB_KEY_Ygrave))
 189             rtrn |= _XkbKSUpper;
 190         if ((ks == XKB_KEY_wcircumflex) ||
 191             (ks == XKB_KEY_ycircumflex) ||
 192             (ks == XKB_KEY_babovedot) ||
 193             (ks == XKB_KEY_dabovedot) ||
 194             (ks == XKB_KEY_fabovedot) ||
 195             (ks == XKB_KEY_mabovedot) ||
 196             (ks == XKB_KEY_pabovedot) ||
 197             (ks == XKB_KEY_sabovedot) ||
 198             (ks == XKB_KEY_tabovedot) ||
 199             (ks == XKB_KEY_wdiaeresis) ||
 200             (ks == XKB_KEY_ygrave))
 201             rtrn |= _XkbKSLower;
 202         break;
 203     case 19: /* latin 9 */
 204         if (ks == XKB_KEY_OE || ks == XKB_KEY_Ydiaeresis)
 205             rtrn |= _XkbKSUpper;
 206         if (ks == XKB_KEY_oe)
 207             rtrn |= _XkbKSLower;
 208         break;
 209     }
 210
 211     return rtrn;
 212 }