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 <X11/keysym.h>
  28
  29 #include "xkb-priv.h"
  30 #include "alloc.h"
  31
  32 #define mapSize(m) (sizeof(m) / sizeof(struct xkb_kt_map_entry))
  33 static struct xkb_kt_map_entry map2Level[]= {
  34     { true, ShiftMask, {1, ShiftMask, 0} }
  35 };
  36
  37 static struct xkb_kt_map_entry mapAlpha[]= {
  38     { true, ShiftMask, { 1, ShiftMask, 0 } },
  39     { true, LockMask,  { 0, LockMask,  0 } }
  40 };
  41
  42 static struct xkb_mods preAlpha[]= {
  43     { 0,        0,        0 },
  44     { LockMask, LockMask, 0 }
  45 };
  46
  47 #define NL_VMOD_MASK 0
  48 static  struct xkb_kt_map_entry mapKeypad[]= {
  49     { true,  ShiftMask, { 1, ShiftMask, 0 } },
  50     { false, 0,         { 1, 0, NL_VMOD_MASK } }
  51 };
  52
  53 static struct xkb_key_type canonicalTypes[XkbNumRequiredTypes] = {
  54     { { 0, 0, 0 },
  55       1,        /* num_levels */
  56       0,        /* map_count */
  57       NULL, NULL,
  58       NULL, NULL
  59     },
  60     { { ShiftMask, ShiftMask, 0 },
  61       2,        /* num_levels */
  62       mapSize(map2Level),   /* map_count */
  63       map2Level, NULL,
  64       NULL,      NULL
  65     },
  66     { { ShiftMask|LockMask, ShiftMask|LockMask, 0 },
  67       2,        /* num_levels */
  68       mapSize(mapAlpha),    /* map_count */
  69       mapAlpha, preAlpha,
  70       NULL,     NULL
  71     },
  72     { { ShiftMask, ShiftMask, NL_VMOD_MASK },
  73       2,        /* num_levels */
  74       mapSize(mapKeypad),   /* map_count */
  75       mapKeypad, NULL,
  76       NULL,      NULL
  77     }
  78 };
  79
  80 int
  81 XkbcInitCanonicalKeyTypes(struct xkb_keymap *keymap, unsigned which,
  82                           int keypadVMod)
  83 {
  84     struct xkb_client_map * map;
  85     struct xkb_key_type *from, *to;
  86     int rtrn;
  87
  88     if (!keymap)
  89         return BadMatch;
  90
  91     rtrn = XkbcAllocClientMap(keymap, XkbKeyTypesMask, XkbNumRequiredTypes);
  92     if (rtrn != Success)
  93         return rtrn;
  94
  95     map = keymap->map;
  96     if ((which & XkbAllRequiredTypes) == 0)
  97         return Success;
  98
  99     rtrn = Success;
 100     from = canonicalTypes;
 101     to = map->types;
 102
 103     if (which & XkbOneLevelMask)
 104         rtrn = XkbcCopyKeyType(&from[XkbOneLevelIndex], &to[XkbOneLevelIndex]);
 105
 106     if ((which & XkbTwoLevelMask) && (rtrn == Success))
 107         rtrn = XkbcCopyKeyType(&from[XkbTwoLevelIndex], &to[XkbTwoLevelIndex]);
 108
 109     if ((which & XkbAlphabeticMask) && (rtrn == Success))
 110         rtrn = XkbcCopyKeyType(&from[XkbAlphabeticIndex],
 111                                &to[XkbAlphabeticIndex]);
 112
 113     if ((which & XkbKeypadMask) && (rtrn == Success)) {
 114         struct xkb_key_type * type;
 115
 116         rtrn = XkbcCopyKeyType(&from[XkbKeypadIndex], &to[XkbKeypadIndex]);
 117         type = &to[XkbKeypadIndex];
 118
 119         if ((keypadVMod >= 0) && (keypadVMod < XkbNumVirtualMods) &&
 120             (rtrn == Success)) {
 121             type->mods.vmods = (1 << keypadVMod);
 122             type->map[0].active = true;
 123             type->map[0].mods.mask = ShiftMask;
 124             type->map[0].mods.real_mods = ShiftMask;
 125             type->map[0].mods.vmods = 0;
 126             type->map[0].level = 1;
 127             type->map[1].active = false;
 128             type->map[1].mods.mask = 0;
 129             type->map[1].mods.real_mods = 0;
 130             type->map[1].mods.vmods = (1 << keypadVMod);
 131             type->map[1].level = 1;
 132         }
 133     }
 134
 135     return Success;
 136 }
 137
 138 unsigned
 139 _XkbcKSCheckCase(xkb_keysym_t ks)
 140 {
 141     unsigned set = (ks & (~0xff)) >> 8;
 142     unsigned rtrn = 0;
 143
 144     switch (set) {
 145     case 0: /* latin 1 */
 146         if ((ks >= XK_A && ks <= XK_Z) ||
 147             (ks >= XK_Agrave && ks <= XK_THORN && ks != XK_multiply))
 148             rtrn |= _XkbKSUpper;
 149         if ((ks >= XK_a && ks <= XK_z) ||
 150             (ks >= XK_agrave && ks <= XK_ydiaeresis))
 151             rtrn |= _XkbKSLower;
 152         break;
 153     case 1: /* latin 2 */
 154         if ((ks >= XK_Aogonek && ks <= XK_Zabovedot && ks != XK_breve) ||
 155             (ks >= XK_Racute && ks<=XK_Tcedilla))
 156             rtrn |= _XkbKSUpper;
 157         if ((ks >= XK_aogonek && ks <= XK_zabovedot && ks != XK_caron) ||
 158             (ks >= XK_racute && ks <= XK_tcedilla))
 159             rtrn |= _XkbKSLower;
 160         break;
 161     case 2: /* latin 3 */
 162         if ((ks >= XK_Hstroke && ks <= XK_Jcircumflex) ||
 163             (ks >= XK_Cabovedot && ks <= XK_Scircumflex))
 164             rtrn |= _XkbKSUpper;
 165         if ((ks >= XK_hstroke && ks <= XK_jcircumflex) ||
 166             (ks >= XK_cabovedot && ks <= XK_scircumflex))
 167             rtrn |= _XkbKSLower;
 168         break;
 169     case 3: /* latin 4 */
 170         if ((ks >= XK_Rcedilla && ks <= XK_Tslash) ||
 171             (ks == XK_ENG) ||
 172             (ks >= XK_Amacron && ks <= XK_Umacron))
 173             rtrn |= _XkbKSUpper;
 174         if ((ks >= XK_rcedilla && ks <= XK_tslash) ||
 175             (ks == XK_eng) ||
 176             (ks >= XK_amacron && ks <= XK_umacron))
 177             rtrn |= _XkbKSLower;
 178         break;
 179     case 18: /* latin 8 */
 180         if ((ks == XK_Wcircumflex) ||
 181             (ks == XK_Ycircumflex) ||
 182             (ks == XK_Babovedot) ||
 183             (ks == XK_Dabovedot) ||
 184             (ks == XK_Fabovedot) ||
 185             (ks == XK_Mabovedot) ||
 186             (ks == XK_Pabovedot) ||
 187             (ks == XK_Sabovedot) ||
 188             (ks == XK_Tabovedot) ||
 189             (ks == XK_Wdiaeresis) ||
 190             (ks == XK_Ygrave))
 191             rtrn |= _XkbKSUpper;
 192         if ((ks == XK_wcircumflex) ||
 193             (ks == XK_ycircumflex) ||
 194             (ks == XK_babovedot) ||
 195             (ks == XK_dabovedot) ||
 196             (ks == XK_fabovedot) ||
 197             (ks == XK_mabovedot) ||
 198             (ks == XK_pabovedot) ||
 199             (ks == XK_sabovedot) ||
 200             (ks == XK_tabovedot) ||
 201             (ks == XK_wdiaeresis) ||
 202             (ks == XK_ygrave))
 203             rtrn |= _XkbKSLower;
 204         break;
 205     case 19: /* latin 9 */
 206         if (ks == XK_OE || ks == XK_Ydiaeresis)
 207             rtrn |= _XkbKSUpper;
 208         if (ks == XK_oe)
 209             rtrn |= _XkbKSLower;
 210         break;
 211     }
 212
 213     return rtrn;
 214 }