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