Pileus Git - ~andy/gtk/blob - gtk/gtkkeyhash.c

   1 /* gtkkeyhash.c: Keymap aware matching of key bindings
   2  *
   3  * GTK - The GIMP Toolkit
   4  * Copyright (C) 2002, Red Hat Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21 #include "gtkdebug.h"
  22 #include "gtkkeyhash.h"
  23
  24 typedef struct _GtkKeyHashEntry GtkKeyHashEntry;
  25
  26 struct _GtkKeyHashEntry
  27 {
  28   guint keyval;
  29   GdkModifierType modifiers;
  30   gpointer value;
  31
  32   /* Set as a side effect of generating key_hash->keycode_hash
  33    */
  34   GdkKeymapKey *keys;
  35   gint n_keys;
  36 };
  37
  38 struct _GtkKeyHash
  39 {
  40   GdkKeymap *keymap;
  41   GHashTable *keycode_hash;
  42   GHashTable *reverse_hash;
  43   GList *entries_list;
  44   GDestroyNotify destroy_notify;
  45 };
  46
  47 static void
  48 key_hash_clear_keycode (gpointer key,
  49                         gpointer value,
  50                         gpointer data)
  51 {
  52   GSList *keys = value;
  53   g_slist_free (keys);
  54 }
  55
  56 static void
  57 key_hash_insert_entry (GtkKeyHash      *key_hash,
  58                        GtkKeyHashEntry *entry)
  59 {
  60   gint i;
  61
  62   g_free (entry->keys);
  63   gdk_keymap_get_entries_for_keyval (key_hash->keymap,
  64                                      entry->keyval,
  65                                      &entry->keys, &entry->n_keys);
  66
  67   for (i = 0; i < entry->n_keys; i++)
  68     {
  69       GSList *old_keys = g_hash_table_lookup (key_hash->keycode_hash,
  70                                               GUINT_TO_POINTER (entry->keys[i].keycode));
  71       old_keys = g_slist_prepend (old_keys, entry);
  72       g_hash_table_insert (key_hash->keycode_hash,
  73                            GUINT_TO_POINTER (entry->keys[i].keycode),
  74                            old_keys);
  75     }
  76 }
  77
  78 static GHashTable *
  79 key_hash_get_keycode_hash (GtkKeyHash *key_hash)
  80 {
  81   if (!key_hash->keycode_hash)
  82     {
  83       GList *tmp_list;
  84
  85       key_hash->keycode_hash = g_hash_table_new (g_direct_hash, NULL);
  86
  87       /* Preserve the original insertion order
  88        */
  89       for (tmp_list = g_list_last (key_hash->entries_list);
  90            tmp_list;
  91            tmp_list = tmp_list->prev)
  92         key_hash_insert_entry (key_hash, tmp_list->data);
  93     }
  94
  95   return key_hash->keycode_hash;
  96 }
  97
  98 static void
  99 key_hash_keys_changed (GdkKeymap  *keymap,
 100                        GtkKeyHash *key_hash)
 101 {
 102   /* The keymap changed, so we have to regenerate the keycode hash
 103    */
 104   if (key_hash->keycode_hash)
 105     {
 106       g_hash_table_foreach (key_hash->keycode_hash, key_hash_clear_keycode, NULL);
 107       g_hash_table_destroy (key_hash->keycode_hash);
 108       key_hash->keycode_hash = NULL;
 109     }
 110 }
 111
 112 /**
 113  * _gtk_key_hash_new:
 114  * @keymap: a #GdkKeymap
 115  * @item_destroy_notify: function to be called when items are removed
 116  *   from the hash or %NULL.
 117  *
 118  * Create a new key hash object for doing binding resolution.
 119  *
 120  * Return value: the newly created object. Free with _gtk_key_hash_free().
 121  **/
 122 GtkKeyHash *
 123 _gtk_key_hash_new (GdkKeymap      *keymap,
 124                    GDestroyNotify  item_destroy_notify)
 125 {
 126   GtkKeyHash *key_hash = g_new (GtkKeyHash, 1);
 127
 128   key_hash->keymap = keymap;
 129   g_signal_connect (keymap, "keys_changed",
 130                     G_CALLBACK (key_hash_keys_changed), key_hash);
 131
 132   key_hash->entries_list = NULL;
 133   key_hash->keycode_hash = NULL;
 134   key_hash->reverse_hash = g_hash_table_new (g_direct_hash, NULL);
 135   key_hash->destroy_notify = item_destroy_notify;
 136
 137   return key_hash;
 138 }
 139
 140 static void
 141 key_hash_free_entry (GtkKeyHash      *key_hash,
 142                      GtkKeyHashEntry *entry)
 143 {
 144   if (key_hash->destroy_notify)
 145     (*key_hash->destroy_notify) (entry->value);
 146
 147   g_free (entry->keys);
 148   g_free (entry);
 149 }
 150
 151 static void
 152 key_hash_free_entry_foreach (gpointer value,
 153                              gpointer data)
 154 {
 155   GtkKeyHashEntry *entry = value;
 156   GtkKeyHash *key_hash = data;
 157
 158   key_hash_free_entry (key_hash, entry);
 159 }
 160
 161 /**
 162  * gtk_key_hash_free:
 163  * @key_hash: a #GtkKeyHash
 164  *
 165  * Destroys a key hash created with gtk_key_hash_new()
 166  **/
 167 void
 168 _gtk_key_hash_free (GtkKeyHash *key_hash)
 169 {
 170   g_signal_handlers_disconnect_by_func (key_hash->keymap,
 171                                         key_hash_keys_changed,
 172                                         key_hash);
 173
 174   if (key_hash->keycode_hash)
 175     {
 176       g_hash_table_foreach (key_hash->keycode_hash, key_hash_clear_keycode, NULL);
 177       g_hash_table_destroy (key_hash->keycode_hash);
 178     }
 179
 180   g_hash_table_destroy (key_hash->reverse_hash);
 181
 182   g_list_foreach (key_hash->entries_list, key_hash_free_entry_foreach, key_hash);
 183   g_list_free (key_hash->entries_list);
 184
 185   g_free (key_hash);
 186 }
 187
 188 /**
 189  * _gtk_key_hash_add_entry:
 190  * @key_hash: a #GtkKeyHash
 191  * @keyval: key symbol for this binding
 192  * @modifiers: modifiers for this binding
 193  * @value: value to insert in the key hash
 194  *
 195  * Inserts a pair of key symbol and modifier mask into the key hash.
 196  **/
 197 void
 198 _gtk_key_hash_add_entry (GtkKeyHash      *key_hash,
 199                          guint            keyval,
 200                          GdkModifierType  modifiers,
 201                          gpointer         value)
 202 {
 203   GtkKeyHashEntry *entry = g_new (GtkKeyHashEntry, 1);
 204
 205   entry->value = value;
 206   entry->keyval = keyval;
 207   entry->modifiers = modifiers;
 208   entry->keys = NULL;
 209
 210   key_hash->entries_list = g_list_prepend (key_hash->entries_list, entry);
 211   g_hash_table_insert (key_hash->reverse_hash, value, key_hash->entries_list);
 212
 213   if (key_hash->keycode_hash)
 214     key_hash_insert_entry (key_hash, entry);
 215 }
 216
 217 /**
 218  * _gtk_key_hash_remove_entry:
 219  * @key_hash: a #GtkKeyHash
 220  * @value: value previously added with _gtk_key_hash_add_entry()
 221  *
 222  * Removes a value previously added to the key hash with
 223  * _gtk_key_hash_add_entry().
 224  **/
 225 void
 226 _gtk_key_hash_remove_entry (GtkKeyHash *key_hash,
 227                             gpointer    value)
 228 {
 229   GList *entry_node = g_hash_table_lookup (key_hash->reverse_hash, value);
 230
 231   if (entry_node)
 232     {
 233       GtkKeyHashEntry *entry = entry_node->data;
 234
 235       if (key_hash->keycode_hash)
 236         {
 237           gint i;
 238
 239           for (i = 0; i < entry->n_keys; i++)
 240             {
 241               GSList *old_keys = g_hash_table_lookup (key_hash->keycode_hash,
 242                                                       GUINT_TO_POINTER (entry->keys[i].keycode));
 243
 244               GSList *new_keys = g_slist_remove (old_keys, entry);
 245               if (new_keys != old_keys)
 246                 {
 247                   if (new_keys)
 248                     g_hash_table_insert (key_hash->keycode_hash,
 249                                          GUINT_TO_POINTER (entry->keys[i].keycode),
 250                                          new_keys);
 251                   else
 252                     g_hash_table_remove (key_hash->keycode_hash,
 253                                          GUINT_TO_POINTER (entry->keys[i].keycode));
 254                 }
 255             }
 256         }
 257
 258       g_hash_table_remove (key_hash->reverse_hash, entry_node);
 259       key_hash->entries_list = g_list_delete_link (key_hash->entries_list, entry_node);
 260
 261       key_hash_free_entry (key_hash, entry);
 262     }
 263 }
 264
 265 static gint
 266 lookup_result_compare (gconstpointer a,
 267                        gconstpointer b)
 268 {
 269   const GtkKeyHashEntry *entry_a = a;
 270   const GtkKeyHashEntry *entry_b = b;
 271   guint modifiers;
 272
 273   gint n_bits_a = 0;
 274   gint n_bits_b = 0;
 275
 276   modifiers = entry_a->modifiers;
 277   while (modifiers)
 278     {
 279       if (modifiers & 1)
 280         n_bits_a++;
 281       modifiers >>= 1;
 282     }
 283
 284   modifiers = entry_b->modifiers;
 285   while (modifiers)
 286     {
 287       if (modifiers & 1)
 288         n_bits_b++;
 289       modifiers >>= 1;
 290     }
 291
 292   return n_bits_a < n_bits_b ? -1 : (n_bits_a == n_bits_b ? 0 : 1);
 293
 294 }
 295
 296 /* Sort a list of results so that matches with less modifiers come
 297  * before matches with more modifiers
 298  */
 299 static GSList *
 300 sort_lookup_results (GSList *slist)
 301 {
 302   return g_slist_sort (slist, lookup_result_compare);
 303 }
 304
 305 /**
 306  * _gtk_key_hash_lookup:
 307  * @key_hash: a #GtkKeyHash
 308  * @hardware_keycode: hardware keycode field from a #GdkEventKey
 309  * @state: state field from a #GdkEventKey
 310  * @group: group field from a #GdkEventKey
 311  *
 312  * Looks up the best matching entry or entries in the hash table for
 313  * a given event. The results are sorted so that entries with less
 314  * modifiers come before entries with more modifiers.
 315  *
 316  * Return value: A #GSList of all matching entries. If there were exact
 317  *  matches, they are returned, otherwise all fuzzy matches are
 318  *  returned. (A fuzzy match is a match in keycode and level, but not
 319  *  in group.)
 320  **/
 321 GSList *
 322 _gtk_key_hash_lookup (GtkKeyHash      *key_hash,
 323                       guint16          hardware_keycode,
 324                       GdkModifierType  state,
 325                       gint             group)
 326 {
 327   GHashTable *keycode_hash = key_hash_get_keycode_hash (key_hash);
 328   GSList *keys = g_hash_table_lookup (keycode_hash, GUINT_TO_POINTER ((guint)hardware_keycode));
 329   GSList *results = NULL;
 330   gboolean have_exact = FALSE;
 331   guint keyval;
 332   gint effective_group;
 333   gint level;
 334   GdkModifierType consumed_modifiers;
 335
 336   gdk_keymap_translate_keyboard_state (key_hash->keymap,
 337                                        hardware_keycode, state, group,
 338                                        &keyval, &effective_group, &level, &consumed_modifiers);
 339
 340   GTK_NOTE (KEYBINDINGS,
 341             g_message ("Looking up keycode = %u, modifiers = 0x%04x,\n"
 342                        "    keyval = %u, group = %d, level = %d, consumed_modifiers = 0x%04x",
 343                        hardware_keycode, state, keyval, effective_group, level, consumed_modifiers));
 344
 345   if (keys)
 346     {
 347       GSList *tmp_list = keys;
 348       while (tmp_list)
 349         {
 350           GtkKeyHashEntry *entry = tmp_list->data;
 351
 352           if ((entry->modifiers & ~consumed_modifiers) == (state & ~consumed_modifiers))
 353             {
 354               gint i;
 355
 356               if (keyval == entry->keyval) /* Exact match */
 357                 {
 358                   GTK_NOTE (KEYBINDINGS,
 359                             g_message ("  found exact match, keyval = %u, modifiers = 0x%04x",
 360                                        entry->keyval, entry->modifiers));
 361
 362                   if (!have_exact)
 363                     {
 364                       g_slist_free (results);
 365                       results = NULL;
 366                     }
 367
 368                   have_exact = TRUE;
 369                   results = g_slist_prepend (results, entry->value);
 370                 }
 371
 372               if (!have_exact)
 373                 {
 374                   for (i = 0; i < entry->n_keys; i++)
 375                     {
 376                       if (entry->keys[i].keycode == hardware_keycode &&
 377                           entry->keys[i].level == level) /* Match for all but group */
 378                         {
 379                           GTK_NOTE (KEYBINDINGS,
 380                                     g_message ("  found group = %d, level = %d",
 381                                                entry->keys[i].group, entry->keys[i].level));
 382                           results = g_slist_prepend (results, entry->value);
 383                           break;
 384                         }
 385                     }
 386                 }
 387             }
 388
 389           tmp_list = tmp_list->next;
 390         }
 391     }
 392
 393   return sort_lookup_results (results);
 394 }
 395
 396 /**
 397  * _gtk_key_hash_lookup_keyval:
 398  * @key_hash: a #GtkKeyHash
 399  * @event: a #GtkEvent
 400  *
 401  * Looks up the best matching entry or entries in the hash table for a
 402  * given keyval/modifiers pair. It's better to use
 403  * _gtk_key_hash_lookup() if you have the original #GdkEventKey
 404  * available.  The results are sorted so that entries with less
 405  * modifiers come before entries with more modifiers.
 406  *
 407  * Return value: A #GSList of all matching entries.
 408  **/
 409 GSList *
 410 _gtk_key_hash_lookup_keyval (GtkKeyHash     *key_hash,
 411                              guint           keyval,
 412                              GdkModifierType modifiers)
 413 {
 414   GdkKeymapKey *keys;
 415   gint n_keys;
 416   GSList *results = NULL;
 417
 418   if (!keyval)                  /* Key without symbol */
 419     return NULL;
 420
 421   /* Find some random keycode for this keycode
 422    */
 423   gdk_keymap_get_entries_for_keyval (key_hash->keymap, keyval,
 424                                      &keys, &n_keys);
 425
 426   if (n_keys)
 427     {
 428       GHashTable *keycode_hash = key_hash_get_keycode_hash (key_hash);
 429       GSList *entries = g_hash_table_lookup (keycode_hash, GUINT_TO_POINTER (keys[0].keycode));
 430
 431       while (entries)
 432         {
 433           GtkKeyHashEntry *entry = entries->data;
 434
 435           if (entry->keyval == keyval && entry->modifiers == modifiers)
 436             results = g_slist_prepend (results, entry->value);
 437
 438           entries = entries->next;
 439         }
 440     }
 441
 442   g_free (keys);
 443
 444   return sort_lookup_results (results);
 445 }