src/xkbcomp/vmod.c

   1 /************************************************************
   2  * Copyright (c) 1994 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 "vmod.h"
  28
  29 void
  30 InitVModInfo(VModInfo *info, struct xkb_keymap *keymap)
  31 {
  32     ClearVModInfo(info, keymap);
  33 }
  34
  35 void
  36 ClearVModInfo(VModInfo *info, struct xkb_keymap *keymap)
  37 {
  38     xkb_mod_index_t i;
  39     xkb_mod_mask_t bit;
  40
  41     info->defined = info->available = 0;
  42
  43     for (i = 0; i < XkbNumVirtualMods; i++)
  44         keymap->vmods[i] = XkbNoModifierMask;
  45
  46     for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1)
  47         if (keymap->vmod_names[i])
  48             info->defined |= bit;
  49 }
  50
  51 /***====================================================================***/
  52
  53 /**
  54  * Handle one entry in the virtualModifiers line (e.g. NumLock).
  55  * If the entry is e.g. NumLock=Mod1, stmt->value is not NULL, and the
  56  * XkbServerMap's vmod is set to the given modifier. Otherwise, the vmod is 0.
  57  *
  58  * @param stmt The statement specifying the name and (if any the value).
  59  * @param mergeMode Merge strategy (e.g. MERGE_OVERRIDE)
  60  */
  61 bool
  62 HandleVModDef(VModDef *stmt, struct xkb_keymap *keymap,
  63               enum merge_mode mergeMode, VModInfo *info)
  64 {
  65     xkb_mod_index_t i;
  66     int nextFree;
  67     xkb_mod_mask_t bit;
  68     xkb_mod_mask_t mask;
  69
  70     nextFree = -1;
  71     for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
  72         const char *str1;
  73         const char *str2 = "";
  74
  75         if (!(info->defined & bit)) {
  76             if (nextFree < 0)
  77                 nextFree = i;
  78             continue;
  79         }
  80
  81         /* already defined */
  82         if (!keymap->vmod_names[i])
  83             continue;
  84
  85         if (!streq(keymap->vmod_names[i],
  86                    xkb_atom_text(keymap->ctx, stmt->name)))
  87             continue;
  88
  89         info->available |= bit;
  90
  91         if (!stmt->value)
  92             return true;
  93
  94         if (!ExprResolveModMask(keymap->ctx, stmt->value, &mask)) {
  95             log_err(keymap->ctx, "Declaration of %s ignored\n",
  96                     xkb_atom_text(keymap->ctx, stmt->name));
  97             return false;
  98         }
  99
 100         if (mask == keymap->vmods[i])
 101             return true;
 102
 103         str1 = ModMaskText(keymap->vmods[i]);
 104         if (mergeMode == MERGE_OVERRIDE) {
 105             str2 = str1;
 106             str1 = ModMaskText(mask);
 107         }
 108
 109         log_warn(keymap->ctx,
 110                  "Virtual modifier %s defined multiple times; "
 111                  "Using %s, ignoring %s\n",
 112                  xkb_atom_text(keymap->ctx, stmt->name), str1, str2);
 113
 114         if (mergeMode == MERGE_OVERRIDE)
 115             keymap->vmods[i] = mask;
 116
 117         return true;
 118     }
 119
 120     if (nextFree < 0) {
 121         log_err(keymap->ctx,
 122                 "Too many virtual modifiers defined (maximum %d)\n",
 123                 XkbNumVirtualMods);
 124         return false;
 125     }
 126
 127     info->defined |= (1 << nextFree);
 128     info->available |= (1 << nextFree);
 129
 130     keymap->vmod_names[nextFree] = xkb_atom_text(keymap->ctx, stmt->name);
 131
 132     if (!stmt->value)
 133         return true;
 134
 135     if (!ExprResolveModMask(keymap->ctx, stmt->value, &mask)) {
 136         log_err(keymap->ctx, "Declaration of %s ignored\n",
 137                 xkb_atom_text(keymap->ctx, stmt->name));
 138         return false;
 139     }
 140
 141     keymap->vmods[nextFree] = mask;
 142     return true;
 143 }
 144
 145 /**
 146  * Returns the index of the given modifier in the keymap->vmod_names array.
 147  *
 148  * @param keymap Pointer to the xkb data structure.
 149  * @param field The Atom of the modifier's name (e.g. Atom for LAlt)
 150  * @param type Must be EXPR_TYPE_INT, otherwise return false.
 151  * @param val_rtrn Set to the index of the modifier that matches.
 152  *
 153  * @return true on success, false otherwise. If false is returned, val_rtrn is
 154  * undefined.
 155  */
 156 static bool
 157 LookupVModIndex(const struct xkb_keymap *keymap, xkb_atom_t field,
 158                 enum expr_value_type type, xkb_mod_index_t *val_rtrn)
 159 {
 160     xkb_mod_index_t i;
 161     const char *name = xkb_atom_text(keymap->ctx, field);
 162
 163     if (type != EXPR_TYPE_INT)
 164         return false;
 165
 166     /* For each named modifier, get the name and compare it to the one passed
 167      * in. If we get a match, return the index of the modifier.
 168      * The order of modifiers is the same as in the virtual_modifiers line in
 169      * the xkb_types section.
 170      */
 171     for (i = 0; i < XkbNumVirtualMods; i++) {
 172         if (keymap->vmod_names[i] && streq(keymap->vmod_names[i], name)) {
 173             *val_rtrn = i;
 174             return true;
 175         }
 176     }
 177
 178     return false;
 179 }
 180
 181 /**
 182  * Get the mask for the given (virtual or core) modifier and set
 183  * val_rtrn.uval to the mask value.
 184  *
 185  * @param priv Pointer to xkb data structure.
 186  * @param val_rtrn Member uval is set to the mask returned.
 187  *
 188  * @return true on success, false otherwise. If false is returned, val_rtrn is
 189  * undefined.
 190  */
 191 bool
 192 LookupVModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
 193                enum expr_value_type type, xkb_mod_mask_t *val_rtrn)
 194 {
 195     xkb_mod_index_t ndx;
 196
 197     if (LookupModMask(ctx, NULL, field, type, val_rtrn)) {
 198         return true;
 199     }
 200     else if (LookupVModIndex(priv, field, type, &ndx)) {
 201         *val_rtrn = (1 << (XkbNumModifiers + ndx));
 202         return true;
 203     }
 204
 205     return false;
 206 }
 207
 208 bool
 209 ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap,
 210                        xkb_mod_index_t *ndx_rtrn, VModInfo *info)
 211 {
 212     int val;
 213
 214     if (def->op == EXPR_IDENT) {
 215         xkb_mod_index_t i;
 216         xkb_mod_mask_t bit;
 217         const char *name = xkb_atom_text(keymap->ctx, def->value.str);
 218
 219         for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
 220             if ((info->available & bit) && keymap->vmod_names[i] &&
 221                 streq(keymap->vmod_names[i], name)) {
 222                 *ndx_rtrn = i;
 223                 return true;
 224             }
 225         }
 226     }
 227
 228     if (!ExprResolveInteger(keymap->ctx, def, &val))
 229         return false;
 230
 231     if (val < 0 || val >= XkbNumVirtualMods) {
 232         log_err(keymap->ctx,
 233                 "Illegal virtual modifier %d (must be 0..%d inclusive)\n",
 234                 val, XkbNumVirtualMods - 1);
 235         return false;
 236     }
 237
 238     *ndx_rtrn = (xkb_mod_index_t) val;
 239     return true;
 240 }