src/map.c

   1 /**
   2  * Copyright © 2012 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  * Author: Daniel Stone <daniel@fooishbar.org>
  24  */
  25
  26 /************************************************************
  27  * Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
  28  *
  29  * Permission to use, copy, modify, and distribute this
  30  * software and its documentation for any purpose and without
  31  * fee is hereby granted, provided that the above copyright
  32  * notice appear in all copies and that both that copyright
  33  * notice and this permission notice appear in supporting
  34  * documentation, and that the name of Silicon Graphics not be
  35  * used in advertising or publicity pertaining to distribution
  36  * of the software without specific prior written permission.
  37  * Silicon Graphics makes no representation about the suitability
  38  * of this software for any purpose. It is provided "as is"
  39  * without any express or implied warranty.
  40  *
  41  * SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  42  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  43  * AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
  44  * GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  45  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  46  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  47  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
  48  * THE USE OR PERFORMANCE OF THIS SOFTWARE.
  49  *
  50  * ********************************************************/
  51
  52 #ifdef HAVE_CONFIG_H
  53 #include <config.h>
  54 #endif
  55
  56 #include "xkbcommon/xkbcommon.h"
  57 #include "XKBcommonint.h"
  58 #include "xkballoc.h"
  59 #include <X11/X.h>
  60
  61 /**
  62  * Returns the level to use for the given key and state, or -1 if invalid.
  63  */
  64 static int
  65 xkb_key_get_level(struct xkb_desc *xkb, struct xkb_state *state,
  66                   xkb_keycode_t key, unsigned int group)
  67 {
  68     struct xkb_key_type *type = XkbKeyType(xkb, key, group);
  69     unsigned int active_mods = state->mods & type->mods.mask;
  70     int i;
  71
  72     fprintf(stderr, "get_level: %s, %d entries, mods %x, mask %x (v%x r%x)\n",
  73             type->name, type->map_count, state->mods, type->mods.mask,
  74             type->mods.vmods, type->mods.real_mods);
  75
  76     for (i = 0; i < type->map_count; i++) {
  77         if (!type->map[i].active)
  78             continue;
  79         fprintf(stderr, "    type active, level %d (%s), mask %x (v%x r%x), active %x\n",
  80                 type->map[i].level, type->level_names[i], type->map[i].mods.mask,
  81                 type->map[i].mods.real_mods, type->map[i].mods.vmods, active_mods);
  82         if (type->map[i].mods.mask == active_mods)
  83             return type->map[i].level;
  84     }
  85
  86     return 0;
  87 }
  88
  89 /**
  90  * Returns the group to use for the given key and state, or -1 if invalid,
  91  * taking wrapping/clamping/etc into account.
  92  */
  93 static int
  94 xkb_key_get_group(struct xkb_desc *xkb, struct xkb_state *state,
  95                   xkb_keycode_t key)
  96 {
  97     unsigned int info = XkbKeyGroupInfo(xkb, key);
  98     unsigned int num_groups = XkbKeyNumGroups(xkb, key);
  99     int ret = state->group;
 100
 101     if (ret < XkbKeyNumGroups(xkb, key))
 102         return ret;
 103
 104     switch (XkbOutOfRangeGroupAction(info)) {
 105     case XkbRedirectIntoRange:
 106         ret = XkbOutOfRangeGroupInfo(info);
 107         if (ret >= num_groups)
 108             ret = 0;
 109         break;
 110     case XkbClampIntoRange:
 111         ret = num_groups - 1;
 112         break;
 113     case XkbWrapIntoRange:
 114     default:
 115         ret %= num_groups;
 116         break;
 117     }
 118
 119     return ret;
 120 }
 121
 122 /**
 123  * As below, but takes an explicit group/level rather than state.
 124  */
 125 unsigned int
 126 xkb_key_get_syms_by_level(struct xkb_desc *xkb, xkb_keycode_t key, unsigned int group,
 127                           unsigned int level, xkb_keysym_t **syms_out)
 128 {
 129     *syms_out = &(XkbKeySymEntry(xkb, key, level, group));
 130     if (**syms_out == NoSymbol)
 131         goto err;
 132
 133     return 1;
 134
 135 err:
 136     *syms_out = NULL;
 137     return 0;
 138 }
 139
 140 /**
 141  * Provides the symbols to use for the given key and state.  Returns the
 142  * number of symbols pointed to in syms_out.
 143  */
 144 unsigned int
 145 xkb_key_get_syms(struct xkb_desc *xkb, struct xkb_state *state,
 146                  xkb_keycode_t key, xkb_keysym_t **syms_out)
 147 {
 148     int group;
 149     int level;
 150
 151     if (!xkb || !state || key < xkb->min_key_code || key > xkb->max_key_code)
 152         return -1;
 153
 154     group = xkb_key_get_group(xkb, state, key);
 155     if (group == -1)
 156         goto err;
 157     level = xkb_key_get_level(xkb, state, key, group);
 158     if (level == -1)
 159         goto err;
 160
 161     return xkb_key_get_syms_by_level(xkb, key, group, level, syms_out);
 162
 163 err:
 164     *syms_out = NULL;
 165     return 0;
 166 }