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

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * GtkBindingSet: Keybinding manager for GObjects.
   5  * Copyright (C) 1998 Tim Janik
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 /*
  22  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  23  * file for a list of people on the GTK+ Team.  See the ChangeLog
  24  * files for a list of changes.  These files are distributed with
  25  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  26  */
  27
  28 #include "config.h"
  29 #include <string.h>
  30 #include <stdarg.h>
  31
  32 #include "gtkbindingsprivate.h"
  33 #include "gtkkeyhash.h"
  34 #include "gtkstylecontext.h"
  35 #include "gtkwidget.h"
  36 #include "gtkintl.h"
  37
  38 /**
  39  * SECTION:gtkbindings
  40  * @Title: Bindings
  41  * @Short_description: Key bindings for individual widgets
  42  * @See_also: Keyboard Accelerators, Mnemonics, #GtkCssProvider
  43  *
  44  * #GtkBindingSet provides a mechanism for configuring GTK+ key bindings
  45  * through CSS files. This eases key binding adjustments for application
  46  * developers as well as users and provides GTK+ users or administrators
  47  * with high key  binding configurability which requires no application
  48  * or toolkit side changes.
  49  *
  50  * <refsect2 id="gtk-bindings-install">
  51  * <title>Installing a key binding</title>
  52  * <para>
  53  * A CSS file binding consists of a 'binding-set' definition and a match
  54  * statement to apply the binding set to specific widget types. Details
  55  * on the matching mechanism are described under
  56  * <link linkend="gtkcssprovider-selectors">Selectors</link>
  57  * in the #GtkCssProvider documentation. Inside the binding set definition,
  58  * key combinations are bound to one or more specific signal emissions on
  59  * the target widget. Key combinations are strings consisting of an optional
  60  * #GdkModifierType name and <link linkend="gdk-Keyboard-Handling">key names</link>
  61  * such as those defined in <filename>&lt;gdk/gdkkeysyms.h&gt;</filename>
  62  * or returned from gdk_keyval_name(), they have to be parsable by
  63  * gtk_accelerator_parse(). Specifications of signal emissions consist
  64  * of a string identifying the signal name, and a list of signal specific
  65  * arguments in parenthesis.
  66  * </para>
  67  * <para>
  68  * For example for binding Control and the left or right cursor keys
  69  * of a #GtkEntry widget to the #GtkEntry::move-cursor signal (so movement
  70  * occurs in 3-character steps), the following binding can be used:
  71  * <informalexample><programlisting>
  72  * @binding-set MoveCursor3
  73  * {
  74  *   bind "&lt;Control&gt;Right" { "move-cursor" (visual-positions, 3, 0) };
  75  *   bind "&lt;Control&gt;Left" { "move-cursor" (visual-positions, -3, 0) };
  76  * };
  77  * GtkEntry
  78  * {
  79  *   gtk-key-bindings: MoveCursor3
  80  * }
  81  * </programlisting></informalexample>
  82  * </para>
  83  * </refsect2>
  84  * <refsect2 id="gtk-bindings-unbind">
  85  * <title>Unbinding existing key bindings</title>
  86  * <para>
  87  * GTK+ already defines a number of useful bindings for the widgets
  88  * it provides. Because custom bindings set up in CSS files take
  89  * precedence over the default bindings shipped with GTK+, overriding
  90  * existing bindings as demonstrated in
  91  * <link linkend="gtk-bindings-install">Installing a key binding</link>
  92  * works as expected. The same mechanism can not be used to "unbind"
  93  * existing bindings, however.
  94  * <informalexample><programlisting>
  95  * @binding-set MoveCursor3
  96  * {
  97  *   bind "&lt;Control&gt;Right" {  };
  98  *   bind "&lt;Control&gt;Left" {  };
  99  * };
 100  * GtkEntry
 101  * {
 102  *   gtk-key-bindings: MoveCursor3
 103  * }
 104  * </programlisting></informalexample>
 105  * The above example will not have the desired effect of causing
 106  * "&lt;Control&gt;Right" and "&lt;Control&gt;Left" key presses to
 107  * be ignored by GTK+. Instead, it just causes any existing bindings
 108  * from the bindings set "MoveCursor3" to be deleted, so when
 109  * "&lt;Control&gt;Right" or "&lt;Control&gt;Left" are pressed, no
 110  * binding for these keys is found in binding set "MoveCursor3".
 111  * GTK+ will thus continue to search for matching key bindings, and will
 112  * eventually lookup and find the default GTK+ bindings for entries which
 113  * implement word movement. To keep GTK+ from activating its default
 114  * bindings, the "unbind" keyword can be used like this:
 115  * <informalexample><programlisting>
 116  * @binding-set MoveCursor3
 117  * {
 118  *   unbind "&lt;Control&gt;Right";
 119  *   unbind "&lt;Control&gt;Left";
 120  * };
 121  * GtkEntry
 122  * {
 123  *   gtk-key-bindings: MoveCursor3
 124  * }
 125  * </programlisting></informalexample>
 126  * Now, GTK+ will find a match when looking up "&lt;Control&gt;Right"
 127  * and "&lt;Control&gt;Left" key presses before it resorts to its default
 128  * bindings, and the match instructs it to abort ("unbind") the search,
 129  * so the key presses are not consumed by this widget. As usual, further
 130  * processing of the key presses, e.g. by an entry's parent widget, is
 131  * now possible.
 132  * </para>
 133  * </refsect2>
 134  */
 135
 136 /* --- defines --- */
 137 #define BINDING_MOD_MASK() (gtk_accelerator_get_default_mod_mask () | GDK_RELEASE_MASK)
 138
 139
 140 #define GTK_TYPE_IDENTIFIER (gtk_identifier_get_type ())
 141 GType gtk_identifier_get_type (void) G_GNUC_CONST;
 142
 143
 144 /* --- structures --- */
 145 typedef struct {
 146   GtkPathType   type;
 147   GPatternSpec *pspec;
 148   gpointer      user_data;
 149   guint         seq_id;
 150 } PatternSpec;
 151
 152 typedef enum {
 153   GTK_BINDING_TOKEN_BIND,
 154   GTK_BINDING_TOKEN_UNBIND
 155 } GtkBindingTokens;
 156
 157 /* --- variables --- */
 158 static GHashTable       *binding_entry_hash_table = NULL;
 159 static GSList           *binding_key_hashes = NULL;
 160 static GSList           *binding_set_list = NULL;
 161 static const gchar       key_class_binding_set[] = "gtk-class-binding-set";
 162 static GQuark            key_id_class_binding_set = 0;
 163
 164
 165 /* --- functions --- */
 166 GType
 167 gtk_identifier_get_type (void)
 168 {
 169   static GType our_type = 0;
 170
 171   if (our_type == 0)
 172     {
 173       GTypeInfo tinfo = { 0, };
 174       our_type = g_type_register_static (G_TYPE_STRING, I_("GtkIdentifier"), &tinfo, 0);
 175     }
 176
 177   return our_type;
 178 }
 179
 180 static void
 181 pattern_spec_free (PatternSpec *pspec)
 182 {
 183   if (pspec->pspec)
 184     g_pattern_spec_free (pspec->pspec);
 185   g_free (pspec);
 186 }
 187
 188 static GtkBindingSignal*
 189 binding_signal_new (const gchar *signal_name,
 190                     guint        n_args)
 191 {
 192   GtkBindingSignal *signal;
 193
 194   signal = (GtkBindingSignal *) g_slice_alloc0 (sizeof (GtkBindingSignal) + n_args * sizeof (GtkBindingArg));
 195   signal->next = NULL;
 196   signal->signal_name = (gchar *)g_intern_string (signal_name);
 197   signal->n_args = n_args;
 198   signal->args = (GtkBindingArg *)(signal + 1);
 199
 200   return signal;
 201 }
 202
 203 static void
 204 binding_signal_free (GtkBindingSignal *sig)
 205 {
 206   guint i;
 207
 208   for (i = 0; i < sig->n_args; i++)
 209     {
 210       if (G_TYPE_FUNDAMENTAL (sig->args[i].arg_type) == G_TYPE_STRING)
 211         g_free (sig->args[i].d.string_data);
 212     }
 213   g_slice_free1 (sizeof (GtkBindingSignal) + sig->n_args * sizeof (GtkBindingArg), sig);
 214 }
 215
 216 static guint
 217 binding_entry_hash (gconstpointer  key)
 218 {
 219   register const GtkBindingEntry *e = key;
 220   register guint h;
 221
 222   h = e->keyval;
 223   h ^= e->modifiers;
 224
 225   return h;
 226 }
 227
 228 static gint
 229 binding_entries_compare (gconstpointer  a,
 230                          gconstpointer  b)
 231 {
 232   register const GtkBindingEntry *ea = a;
 233   register const GtkBindingEntry *eb = b;
 234
 235   return (ea->keyval == eb->keyval && ea->modifiers == eb->modifiers);
 236 }
 237
 238 static void
 239 binding_key_hash_insert_entry (GtkKeyHash      *key_hash,
 240                                GtkBindingEntry *entry)
 241 {
 242   guint keyval = entry->keyval;
 243
 244   /* We store lowercased accelerators. To deal with this, if <Shift>
 245    * was specified, uppercase.
 246    */
 247   if (entry->modifiers & GDK_SHIFT_MASK)
 248     {
 249       if (keyval == GDK_KEY_Tab)
 250         keyval = GDK_KEY_ISO_Left_Tab;
 251       else
 252         keyval = gdk_keyval_to_upper (keyval);
 253     }
 254
 255   _gtk_key_hash_add_entry (key_hash, keyval, entry->modifiers & ~GDK_RELEASE_MASK, entry);
 256 }
 257
 258 static void
 259 binding_key_hash_destroy (gpointer data)
 260 {
 261   GtkKeyHash *key_hash = data;
 262
 263   binding_key_hashes = g_slist_remove (binding_key_hashes, key_hash);
 264   _gtk_key_hash_free (key_hash);
 265 }
 266
 267 static void
 268 insert_entries_into_key_hash (gpointer key,
 269                               gpointer value,
 270                               gpointer data)
 271 {
 272   GtkKeyHash *key_hash = data;
 273   GtkBindingEntry *entry = value;
 274
 275   for (; entry; entry = entry->hash_next)
 276     binding_key_hash_insert_entry (key_hash, entry);
 277 }
 278
 279 static GtkKeyHash *
 280 binding_key_hash_for_keymap (GdkKeymap *keymap)
 281 {
 282   static GQuark key_hash_quark = 0;
 283   GtkKeyHash *key_hash;
 284
 285   if (!key_hash_quark)
 286     key_hash_quark = g_quark_from_static_string ("gtk-binding-key-hash");
 287
 288   key_hash = g_object_get_qdata (G_OBJECT (keymap), key_hash_quark);
 289
 290   if (!key_hash)
 291     {
 292       key_hash = _gtk_key_hash_new (keymap, NULL);
 293       g_object_set_qdata_full (G_OBJECT (keymap), key_hash_quark, key_hash, binding_key_hash_destroy);
 294
 295       if (binding_entry_hash_table)
 296         g_hash_table_foreach (binding_entry_hash_table,
 297                               insert_entries_into_key_hash,
 298                               key_hash);
 299
 300       binding_key_hashes = g_slist_prepend (binding_key_hashes, key_hash);
 301     }
 302
 303   return key_hash;
 304 }
 305
 306
 307 static GtkBindingEntry*
 308 binding_entry_new (GtkBindingSet  *binding_set,
 309                    guint           keyval,
 310                    GdkModifierType modifiers)
 311 {
 312   GSList *tmp_list;
 313   GtkBindingEntry *entry;
 314
 315   if (!binding_entry_hash_table)
 316     binding_entry_hash_table = g_hash_table_new (binding_entry_hash, binding_entries_compare);
 317
 318   entry = g_new (GtkBindingEntry, 1);
 319   entry->keyval = keyval;
 320   entry->modifiers = modifiers;
 321   entry->binding_set = binding_set,
 322   entry->destroyed = FALSE;
 323   entry->in_emission = FALSE;
 324   entry->marks_unbound = FALSE;
 325   entry->signals = NULL;
 326
 327   entry->set_next = binding_set->entries;
 328   binding_set->entries = entry;
 329
 330   entry->hash_next = g_hash_table_lookup (binding_entry_hash_table, entry);
 331   if (entry->hash_next)
 332     g_hash_table_remove (binding_entry_hash_table, entry->hash_next);
 333   g_hash_table_insert (binding_entry_hash_table, entry, entry);
 334
 335   for (tmp_list = binding_key_hashes; tmp_list; tmp_list = tmp_list->next)
 336     {
 337       GtkKeyHash *key_hash = tmp_list->data;
 338       binding_key_hash_insert_entry (key_hash, entry);
 339     }
 340
 341   return entry;
 342 }
 343
 344 static void
 345 binding_entry_free (GtkBindingEntry *entry)
 346 {
 347   GtkBindingSignal *sig;
 348
 349   g_assert (entry->set_next == NULL &&
 350             entry->hash_next == NULL &&
 351             entry->in_emission == FALSE &&
 352             entry->destroyed == TRUE);
 353
 354   entry->destroyed = FALSE;
 355
 356   sig = entry->signals;
 357   while (sig)
 358     {
 359       GtkBindingSignal *prev;
 360
 361       prev = sig;
 362       sig = prev->next;
 363       binding_signal_free (prev);
 364     }
 365   g_free (entry);
 366 }
 367
 368 static void
 369 binding_entry_destroy (GtkBindingEntry *entry)
 370 {
 371   GtkBindingEntry *o_entry;
 372   register GtkBindingEntry *tmp;
 373   GtkBindingEntry *begin;
 374   register GtkBindingEntry *last;
 375   GSList *tmp_list;
 376
 377   /* unlink from binding set
 378    */
 379   last = NULL;
 380   tmp = entry->binding_set->entries;
 381   while (tmp)
 382     {
 383       if (tmp == entry)
 384         {
 385           if (last)
 386             last->set_next = entry->set_next;
 387           else
 388             entry->binding_set->entries = entry->set_next;
 389           break;
 390         }
 391       last = tmp;
 392       tmp = last->set_next;
 393     }
 394   entry->set_next = NULL;
 395
 396   o_entry = g_hash_table_lookup (binding_entry_hash_table, entry);
 397   begin = o_entry;
 398   last = NULL;
 399   tmp = begin;
 400   while (tmp)
 401     {
 402       if (tmp == entry)
 403         {
 404           if (last)
 405             last->hash_next = entry->hash_next;
 406           else
 407             begin = entry->hash_next;
 408           break;
 409         }
 410       last = tmp;
 411       tmp = last->hash_next;
 412     }
 413   entry->hash_next = NULL;
 414
 415   if (!begin)
 416     g_hash_table_remove (binding_entry_hash_table, entry);
 417   else if (begin != o_entry)
 418     {
 419       g_hash_table_remove (binding_entry_hash_table, entry);
 420       g_hash_table_insert (binding_entry_hash_table, begin, begin);
 421     }
 422
 423   for (tmp_list = binding_key_hashes; tmp_list; tmp_list = tmp_list->next)
 424     {
 425       GtkKeyHash *key_hash = tmp_list->data;
 426       _gtk_key_hash_remove_entry (key_hash, entry);
 427     }
 428
 429   entry->destroyed = TRUE;
 430
 431   if (!entry->in_emission)
 432     binding_entry_free (entry);
 433 }
 434
 435 static GtkBindingEntry*
 436 binding_ht_lookup_entry (GtkBindingSet  *set,
 437                          guint           keyval,
 438                          GdkModifierType modifiers)
 439 {
 440   GtkBindingEntry lookup_entry = { 0 };
 441   GtkBindingEntry *entry;
 442
 443   if (!binding_entry_hash_table)
 444     return NULL;
 445
 446   lookup_entry.keyval = keyval;
 447   lookup_entry.modifiers = modifiers;
 448
 449   entry = g_hash_table_lookup (binding_entry_hash_table, &lookup_entry);
 450   for (; entry; entry = entry->hash_next)
 451     if (entry->binding_set == set)
 452       return entry;
 453
 454   return NULL;
 455 }
 456
 457 static gboolean
 458 binding_compose_params (GObject         *object,
 459                         GtkBindingArg   *args,
 460                         GSignalQuery    *query,
 461                         GValue         **params_p)
 462 {
 463   GValue *params;
 464   const GType *types;
 465   guint i;
 466   gboolean valid;
 467
 468   params = g_new0 (GValue, query->n_params + 1);
 469   *params_p = params;
 470
 471   /* The instance we emit on is the first object in the array
 472    */
 473   g_value_init (params, G_TYPE_OBJECT);
 474   g_value_set_object (params, G_OBJECT (object));
 475   params++;
 476
 477   types = query->param_types;
 478   valid = TRUE;
 479   for (i = 1; i < query->n_params + 1 && valid; i++)
 480     {
 481       GValue tmp_value = G_VALUE_INIT;
 482
 483       g_value_init (params, *types);
 484
 485       switch (G_TYPE_FUNDAMENTAL (args->arg_type))
 486         {
 487         case G_TYPE_DOUBLE:
 488           g_value_init (&tmp_value, G_TYPE_DOUBLE);
 489           g_value_set_double (&tmp_value, args->d.double_data);
 490           break;
 491         case G_TYPE_LONG:
 492           g_value_init (&tmp_value, G_TYPE_LONG);
 493           g_value_set_long (&tmp_value, args->d.long_data);
 494           break;
 495         case G_TYPE_STRING:
 496           /* gtk_rc_parse_flags/enum() has fancier parsing for this; we can't call
 497            * that since we don't have a GParamSpec, so just do something simple
 498            */
 499           if (G_TYPE_FUNDAMENTAL (*types) == G_TYPE_ENUM)
 500             {
 501               GEnumClass *class = G_ENUM_CLASS (g_type_class_ref (*types));
 502
 503               valid = FALSE;
 504
 505               if (args->arg_type == GTK_TYPE_IDENTIFIER)
 506                 {
 507                   GEnumValue *enum_value = NULL;
 508                   enum_value = g_enum_get_value_by_name (class, args->d.string_data);
 509                   if (!enum_value)
 510                     enum_value = g_enum_get_value_by_nick (class, args->d.string_data);
 511                   if (enum_value)
 512                     {
 513                       g_value_init (&tmp_value, *types);
 514                       g_value_set_enum (&tmp_value, enum_value->value);
 515                       valid = TRUE;
 516                     }
 517                 }
 518
 519               g_type_class_unref (class);
 520             }
 521           /* This is just a hack for compatibility with GTK+-1.2 where a string
 522            * could be used for a single flag value / without the support for multiple
 523            * values in gtk_rc_parse_flags(), this isn't very useful.
 524            */
 525           else if (G_TYPE_FUNDAMENTAL (*types) == G_TYPE_FLAGS)
 526             {
 527               GFlagsClass *class = G_FLAGS_CLASS (g_type_class_ref (*types));
 528
 529               valid = FALSE;
 530
 531               if (args->arg_type == GTK_TYPE_IDENTIFIER)
 532                 {
 533                   GFlagsValue *flags_value = NULL;
 534                   flags_value = g_flags_get_value_by_name (class, args->d.string_data);
 535                   if (!flags_value)
 536                     flags_value = g_flags_get_value_by_nick (class, args->d.string_data);
 537                   if (flags_value)
 538                     {
 539                       g_value_init (&tmp_value, *types);
 540                       g_value_set_flags (&tmp_value, flags_value->value);
 541                       valid = TRUE;
 542                     }
 543                 }
 544
 545               g_type_class_unref (class);
 546             }
 547           else
 548             {
 549               g_value_init (&tmp_value, G_TYPE_STRING);
 550               g_value_set_static_string (&tmp_value, args->d.string_data);
 551             }
 552           break;
 553         default:
 554           valid = FALSE;
 555           break;
 556         }
 557
 558       if (valid)
 559         {
 560           if (!g_value_transform (&tmp_value, params))
 561             valid = FALSE;
 562
 563           g_value_unset (&tmp_value);
 564         }
 565
 566       types++;
 567       params++;
 568       args++;
 569     }
 570
 571   if (!valid)
 572     {
 573       guint j;
 574
 575       for (j = 0; j < i; j++)
 576         g_value_unset (&(*params_p)[j]);
 577
 578       g_free (*params_p);
 579       *params_p = NULL;
 580     }
 581
 582   return valid;
 583 }
 584
 585 static gboolean
 586 gtk_binding_entry_activate (GtkBindingEntry *entry,
 587                             GObject         *object)
 588 {
 589   GtkBindingSignal *sig;
 590   gboolean old_emission;
 591   gboolean handled = FALSE;
 592   gint i;
 593
 594   old_emission = entry->in_emission;
 595   entry->in_emission = TRUE;
 596
 597   g_object_ref (object);
 598
 599   for (sig = entry->signals; sig; sig = sig->next)
 600     {
 601       GSignalQuery query;
 602       guint signal_id;
 603       GValue *params = NULL;
 604       GValue return_val = G_VALUE_INIT;
 605       gchar *accelerator = NULL;
 606
 607       signal_id = g_signal_lookup (sig->signal_name, G_OBJECT_TYPE (object));
 608       if (!signal_id)
 609         {
 610           accelerator = gtk_accelerator_name (entry->keyval, entry->modifiers);
 611           g_warning ("gtk_binding_entry_activate(): binding \"%s::%s\": "
 612                      "could not find signal \"%s\" in the `%s' class ancestry",
 613                      entry->binding_set->set_name,
 614                      accelerator,
 615                      sig->signal_name,
 616                      g_type_name (G_OBJECT_TYPE (object)));
 617           g_free (accelerator);
 618           continue;
 619         }
 620
 621       g_signal_query (signal_id, &query);
 622       if (query.n_params != sig->n_args ||
 623           (query.return_type != G_TYPE_NONE && query.return_type != G_TYPE_BOOLEAN) ||
 624           !binding_compose_params (object, sig->args, &query, &params))
 625         {
 626           accelerator = gtk_accelerator_name (entry->keyval, entry->modifiers);
 627           g_warning ("gtk_binding_entry_activate(): binding \"%s::%s\": "
 628                      "signature mismatch for signal \"%s\" in the `%s' class ancestry",
 629                      entry->binding_set->set_name,
 630                      accelerator,
 631                      sig->signal_name,
 632                      g_type_name (G_OBJECT_TYPE (object)));
 633         }
 634       else if (!(query.signal_flags & G_SIGNAL_ACTION))
 635         {
 636           accelerator = gtk_accelerator_name (entry->keyval, entry->modifiers);
 637           g_warning ("gtk_binding_entry_activate(): binding \"%s::%s\": "
 638                      "signal \"%s\" in the `%s' class ancestry cannot be used for action emissions",
 639                      entry->binding_set->set_name,
 640                      accelerator,
 641                      sig->signal_name,
 642                      g_type_name (G_OBJECT_TYPE (object)));
 643         }
 644       g_free (accelerator);
 645       if (accelerator)
 646         continue;
 647
 648       if (query.return_type == G_TYPE_BOOLEAN)
 649         g_value_init (&return_val, G_TYPE_BOOLEAN);
 650
 651       g_signal_emitv (params, signal_id, 0, &return_val);
 652
 653       if (query.return_type == G_TYPE_BOOLEAN)
 654         {
 655           if (g_value_get_boolean (&return_val))
 656             handled = TRUE;
 657           g_value_unset (&return_val);
 658         }
 659       else
 660         handled = TRUE;
 661
 662       for (i = 0; i < query.n_params + 1; i++)
 663         g_value_unset (&params[i]);
 664       g_free (params);
 665
 666       if (entry->destroyed)
 667         break;
 668     }
 669
 670   g_object_unref (object);
 671
 672   entry->in_emission = old_emission;
 673   if (entry->destroyed && !entry->in_emission)
 674     binding_entry_free (entry);
 675
 676   return handled;
 677 }
 678
 679 /**
 680  * gtk_binding_set_new: (skip)
 681  * @set_name: unique name of this binding set
 682  *
 683  * GTK+ maintains a global list of binding sets. Each binding set has
 684  * a unique name which needs to be specified upon creation.
 685  *
 686  * Return value: (transfer full): new binding set
 687  */
 688 GtkBindingSet*
 689 gtk_binding_set_new (const gchar *set_name)
 690 {
 691   GtkBindingSet *binding_set;
 692
 693   g_return_val_if_fail (set_name != NULL, NULL);
 694
 695   binding_set = g_new (GtkBindingSet, 1);
 696   binding_set->set_name = (gchar *) g_intern_string (set_name);
 697   binding_set->widget_path_pspecs = NULL;
 698   binding_set->widget_class_pspecs = NULL;
 699   binding_set->class_branch_pspecs = NULL;
 700   binding_set->entries = NULL;
 701   binding_set->current = NULL;
 702   binding_set->parsed = FALSE;
 703
 704   binding_set_list = g_slist_prepend (binding_set_list, binding_set);
 705
 706   return binding_set;
 707 }
 708
 709 /**
 710  * gtk_binding_set_by_class: (skip)
 711  * @object_class: a valid #GObject class
 712  *
 713  * This function returns the binding set named after the type name of
 714  * the passed in class structure. New binding sets are created on
 715  * demand by this function.
 716  *
 717  * Return value: (transfer full): the binding set corresponding to
 718  *     @object_class
 719  */
 720 GtkBindingSet*
 721 gtk_binding_set_by_class (gpointer object_class)
 722 {
 723   GObjectClass *class = object_class;
 724   GtkBindingSet* binding_set;
 725
 726   g_return_val_if_fail (G_IS_OBJECT_CLASS (class), NULL);
 727
 728   if (!key_id_class_binding_set)
 729     key_id_class_binding_set = g_quark_from_static_string (key_class_binding_set);
 730
 731   binding_set = g_dataset_id_get_data (class, key_id_class_binding_set);
 732
 733   if (binding_set)
 734     return binding_set;
 735
 736   binding_set = gtk_binding_set_new (g_type_name (G_OBJECT_CLASS_TYPE (class)));
 737   g_dataset_id_set_data (class, key_id_class_binding_set, binding_set);
 738
 739   return binding_set;
 740 }
 741
 742 static GtkBindingSet*
 743 gtk_binding_set_find_interned (const gchar *set_name)
 744 {
 745   GSList *slist;
 746
 747   for (slist = binding_set_list; slist; slist = slist->next)
 748     {
 749       GtkBindingSet *binding_set;
 750
 751       binding_set = slist->data;
 752       if (binding_set->set_name == set_name)
 753         return binding_set;
 754     }
 755
 756   return NULL;
 757 }
 758
 759 /**
 760  * gtk_binding_set_find:
 761  * @set_name: unique binding set name
 762  *
 763  * Find a binding set by its globally unique name.
 764  *
 765  * The @set_name can either be a name used for gtk_binding_set_new()
 766  * or the type name of a class used in gtk_binding_set_by_class().
 767  *
 768  * Return value: (transfer none): %NULL or the specified binding set
 769  */
 770 GtkBindingSet*
 771 gtk_binding_set_find (const gchar *set_name)
 772 {
 773   g_return_val_if_fail (set_name != NULL, NULL);
 774
 775   return gtk_binding_set_find_interned (g_intern_string (set_name));
 776 }
 777
 778 /**
 779  * gtk_binding_set_activate:
 780  * @binding_set: a #GtkBindingSet set to activate
 781  * @keyval:      key value of the binding
 782  * @modifiers:   key modifier of the binding
 783  * @object:      object to activate when binding found
 784  *
 785  * Find a key binding matching @keyval and @modifiers within
 786  * @binding_set and activate the binding on @object.
 787  *
 788  * Return value: %TRUE if a binding was found and activated
 789  */
 790 gboolean
 791 gtk_binding_set_activate (GtkBindingSet  *binding_set,
 792                           guint           keyval,
 793                           GdkModifierType modifiers,
 794                           GObject        *object)
 795 {
 796   GtkBindingEntry *entry;
 797
 798   g_return_val_if_fail (binding_set != NULL, FALSE);
 799   g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
 800
 801   keyval = gdk_keyval_to_lower (keyval);
 802   modifiers = modifiers & BINDING_MOD_MASK ();
 803
 804   entry = binding_ht_lookup_entry (binding_set, keyval, modifiers);
 805   if (entry)
 806     return gtk_binding_entry_activate (entry, object);
 807
 808   return FALSE;
 809 }
 810
 811 static void
 812 gtk_binding_entry_clear_internal (GtkBindingSet  *binding_set,
 813                                   guint           keyval,
 814                                   GdkModifierType modifiers)
 815 {
 816   GtkBindingEntry *entry;
 817
 818   keyval = gdk_keyval_to_lower (keyval);
 819   modifiers = modifiers & BINDING_MOD_MASK ();
 820
 821   entry = binding_ht_lookup_entry (binding_set, keyval, modifiers);
 822   if (entry)
 823     binding_entry_destroy (entry);
 824
 825   entry = binding_entry_new (binding_set, keyval, modifiers);
 826 }
 827
 828 /**
 829  * gtk_binding_entry_skip:
 830  * @binding_set: a #GtkBindingSet to skip an entry of
 831  * @keyval:      key value of binding to skip
 832  * @modifiers:   key modifier of binding to skip
 833  *
 834  * Install a binding on @binding_set which causes key lookups
 835  * to be aborted, to prevent bindings from lower priority sets
 836  * to be activated.
 837  *
 838  * Since: 2.12
 839  */
 840 void
 841 gtk_binding_entry_skip (GtkBindingSet  *binding_set,
 842                         guint           keyval,
 843                         GdkModifierType modifiers)
 844 {
 845   GtkBindingEntry *entry;
 846
 847   g_return_if_fail (binding_set != NULL);
 848
 849   keyval = gdk_keyval_to_lower (keyval);
 850   modifiers = modifiers & BINDING_MOD_MASK ();
 851
 852   entry = binding_ht_lookup_entry (binding_set, keyval, modifiers);
 853   if (entry)
 854     binding_entry_destroy (entry);
 855
 856   entry = binding_entry_new (binding_set, keyval, modifiers);
 857   entry->marks_unbound = TRUE;
 858 }
 859
 860 /**
 861  * gtk_binding_entry_remove:
 862  * @binding_set: a #GtkBindingSet to remove an entry of
 863  * @keyval:      key value of binding to remove
 864  * @modifiers:   key modifier of binding to remove
 865  *
 866  * Remove a binding previously installed via
 867  * gtk_binding_entry_add_signal() on @binding_set.
 868  */
 869 void
 870 gtk_binding_entry_remove (GtkBindingSet  *binding_set,
 871                           guint           keyval,
 872                           GdkModifierType modifiers)
 873 {
 874   GtkBindingEntry *entry;
 875
 876   g_return_if_fail (binding_set != NULL);
 877
 878   keyval = gdk_keyval_to_lower (keyval);
 879   modifiers = modifiers & BINDING_MOD_MASK ();
 880
 881   entry = binding_ht_lookup_entry (binding_set, keyval, modifiers);
 882   if (entry)
 883     binding_entry_destroy (entry);
 884 }
 885
 886 /**
 887  * gtk_binding_entry_add_signall:
 888  * @binding_set:  a #GtkBindingSet to add a signal to
 889  * @keyval:       key value
 890  * @modifiers:    key modifier
 891  * @signal_name:  signal name to be bound
 892  * @binding_args: (transfer none) (element-type GtkBindingArg):
 893  *     list of #GtkBindingArg signal arguments
 894  *
 895  * Override or install a new key binding for @keyval with @modifiers on
 896  * @binding_set.
 897  */
 898 void
 899 gtk_binding_entry_add_signall (GtkBindingSet  *binding_set,
 900                                guint           keyval,
 901                                GdkModifierType modifiers,
 902                                const gchar    *signal_name,
 903                                GSList         *binding_args)
 904 {
 905   _gtk_binding_entry_add_signall (binding_set,
 906                                   keyval, modifiers,
 907                                   signal_name, binding_args);
 908 }
 909
 910 void
 911 _gtk_binding_entry_add_signall (GtkBindingSet  *binding_set,
 912                                 guint          keyval,
 913                                 GdkModifierType modifiers,
 914                                 const gchar    *signal_name,
 915                                 GSList        *binding_args)
 916 {
 917   GtkBindingEntry *entry;
 918   GtkBindingSignal *signal, **signal_p;
 919   GSList *slist;
 920   guint n = 0;
 921   GtkBindingArg *arg;
 922
 923   g_return_if_fail (binding_set != NULL);
 924   g_return_if_fail (signal_name != NULL);
 925
 926   keyval = gdk_keyval_to_lower (keyval);
 927   modifiers = modifiers & BINDING_MOD_MASK ();
 928
 929   signal = binding_signal_new (signal_name, g_slist_length (binding_args));
 930
 931   arg = signal->args;
 932   for (slist = binding_args; slist; slist = slist->next)
 933     {
 934       GtkBindingArg *tmp_arg;
 935
 936       tmp_arg = slist->data;
 937       if (!tmp_arg)
 938         {
 939           g_warning ("gtk_binding_entry_add_signall(): arg[%u] is `NULL'", n);
 940           binding_signal_free (signal);
 941           return;
 942         }
 943       switch (G_TYPE_FUNDAMENTAL (tmp_arg->arg_type))
 944         {
 945         case  G_TYPE_LONG:
 946           arg->arg_type = G_TYPE_LONG;
 947           arg->d.long_data = tmp_arg->d.long_data;
 948           break;
 949         case  G_TYPE_DOUBLE:
 950           arg->arg_type = G_TYPE_DOUBLE;
 951           arg->d.double_data = tmp_arg->d.double_data;
 952           break;
 953         case  G_TYPE_STRING:
 954           if (tmp_arg->arg_type != GTK_TYPE_IDENTIFIER)
 955             arg->arg_type = G_TYPE_STRING;
 956           else
 957             arg->arg_type = GTK_TYPE_IDENTIFIER;
 958           arg->d.string_data = g_strdup (tmp_arg->d.string_data);
 959           if (!arg->d.string_data)
 960             {
 961               g_warning ("gtk_binding_entry_add_signall(): value of `string' arg[%u] is `NULL'", n);
 962               binding_signal_free (signal);
 963               return;
 964             }
 965           break;
 966         default:
 967           g_warning ("gtk_binding_entry_add_signall(): unsupported type `%s' for arg[%u]",
 968                      g_type_name (arg->arg_type), n);
 969           binding_signal_free (signal);
 970           return;
 971         }
 972       arg++;
 973       n++;
 974     }
 975
 976   entry = binding_ht_lookup_entry (binding_set, keyval, modifiers);
 977   if (!entry)
 978     {
 979       gtk_binding_entry_clear_internal (binding_set, keyval, modifiers);
 980       entry = binding_ht_lookup_entry (binding_set, keyval, modifiers);
 981     }
 982   signal_p = &entry->signals;
 983   while (*signal_p)
 984     signal_p = &(*signal_p)->next;
 985   *signal_p = signal;
 986 }
 987
 988 /**
 989  * gtk_binding_entry_add_signal:
 990  * @binding_set: a #GtkBindingSet to install an entry for
 991  * @keyval:      key value of binding to install
 992  * @modifiers:   key modifier of binding to install
 993  * @signal_name: signal to execute upon activation
 994  * @n_args:      number of arguments to @signal_name
 995  * @...:         arguments to @signal_name
 996  *
 997  * Override or install a new key binding for @keyval with @modifiers on
 998  * @binding_set. When the binding is activated, @signal_name will be
 999  * emitted on the target widget, with @n_args @Varargs used as
1000  * arguments.
1001  */
1002 void
1003 gtk_binding_entry_add_signal (GtkBindingSet  *binding_set,
1004                               guint           keyval,
1005                               GdkModifierType modifiers,
1006                               const gchar    *signal_name,
1007                               guint           n_args,
1008                               ...)
1009 {
1010   GSList *slist, *free_slist;
1011   va_list args;
1012   guint i;
1013
1014   g_return_if_fail (binding_set != NULL);
1015   g_return_if_fail (signal_name != NULL);
1016
1017   va_start (args, n_args);
1018   slist = NULL;
1019   for (i = 0; i < n_args; i++)
1020     {
1021       GtkBindingArg *arg;
1022
1023       arg = g_slice_new0 (GtkBindingArg);
1024       slist = g_slist_prepend (slist, arg);
1025
1026       arg->arg_type = va_arg (args, GType);
1027       switch (G_TYPE_FUNDAMENTAL (arg->arg_type))
1028         {
1029         case G_TYPE_CHAR:
1030         case G_TYPE_UCHAR:
1031         case G_TYPE_INT:
1032         case G_TYPE_UINT:
1033         case G_TYPE_BOOLEAN:
1034         case G_TYPE_ENUM:
1035         case G_TYPE_FLAGS:
1036           arg->arg_type = G_TYPE_LONG;
1037           arg->d.long_data = va_arg (args, gint);
1038           break;
1039         case G_TYPE_LONG:
1040         case G_TYPE_ULONG:
1041           arg->arg_type = G_TYPE_LONG;
1042           arg->d.long_data = va_arg (args, glong);
1043           break;
1044         case G_TYPE_FLOAT:
1045         case G_TYPE_DOUBLE:
1046           arg->arg_type = G_TYPE_DOUBLE;
1047           arg->d.double_data = va_arg (args, gdouble);
1048           break;
1049         case G_TYPE_STRING:
1050           if (arg->arg_type != GTK_TYPE_IDENTIFIER)
1051             arg->arg_type = G_TYPE_STRING;
1052           arg->d.string_data = va_arg (args, gchar*);
1053           if (!arg->d.string_data)
1054             {
1055               g_warning ("gtk_binding_entry_add_signal(): type `%s' arg[%u] is `NULL'",
1056                          g_type_name (arg->arg_type),
1057                          i);
1058               i += n_args + 1;
1059             }
1060           break;
1061         default:
1062           g_warning ("gtk_binding_entry_add_signal(): unsupported type `%s' for arg[%u]",
1063                      g_type_name (arg->arg_type), i);
1064           i += n_args + 1;
1065           break;
1066         }
1067     }
1068   va_end (args);
1069
1070   if (i == n_args || i == 0)
1071     {
1072       slist = g_slist_reverse (slist);
1073       _gtk_binding_entry_add_signall (binding_set, keyval, modifiers, signal_name, slist);
1074     }
1075
1076   free_slist = slist;
1077   while (slist)
1078     {
1079       g_slice_free (GtkBindingArg, slist->data);
1080       slist = slist->next;
1081     }
1082   g_slist_free (free_slist);
1083 }
1084
1085 static guint
1086 gtk_binding_parse_signal (GScanner       *scanner,
1087                           GtkBindingSet  *binding_set,
1088                           guint           keyval,
1089                           GdkModifierType modifiers)
1090 {
1091   gchar *signal;
1092   guint expected_token = 0;
1093   GSList *args;
1094   GSList *slist;
1095   gboolean done;
1096   gboolean negate;
1097   gboolean need_arg;
1098   gboolean seen_comma;
1099
1100   g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
1101
1102   g_scanner_get_next_token (scanner);
1103
1104   if (scanner->token != G_TOKEN_STRING)
1105     return G_TOKEN_STRING;
1106
1107   g_scanner_peek_next_token (scanner);
1108
1109   if (scanner->next_token != '(')
1110     {
1111       g_scanner_get_next_token (scanner);
1112       return '(';
1113     }
1114
1115   signal = g_strdup (scanner->value.v_string);
1116   g_scanner_get_next_token (scanner);
1117
1118   negate = FALSE;
1119   args = NULL;
1120   done = FALSE;
1121   need_arg = TRUE;
1122   seen_comma = FALSE;
1123   scanner->config->scan_symbols = FALSE;
1124
1125   do
1126     {
1127       GtkBindingArg *arg;
1128
1129       if (need_arg)
1130         expected_token = G_TOKEN_INT;
1131       else
1132         expected_token = ')';
1133
1134       g_scanner_get_next_token (scanner);
1135
1136       switch ((guint) scanner->token)
1137         {
1138         case G_TOKEN_FLOAT:
1139           if (need_arg)
1140             {
1141               need_arg = FALSE;
1142               arg = g_new (GtkBindingArg, 1);
1143               arg->arg_type = G_TYPE_DOUBLE;
1144               arg->d.double_data = scanner->value.v_float;
1145
1146               if (negate)
1147                 {
1148                   arg->d.double_data = - arg->d.double_data;
1149                   negate = FALSE;
1150                 }
1151               args = g_slist_prepend (args, arg);
1152             }
1153           else
1154             done = TRUE;
1155
1156           break;
1157         case G_TOKEN_INT:
1158           if (need_arg)
1159             {
1160               need_arg = FALSE;
1161               arg = g_new (GtkBindingArg, 1);
1162               arg->arg_type = G_TYPE_LONG;
1163               arg->d.long_data = scanner->value.v_int;
1164
1165               if (negate)
1166                 {
1167                   arg->d.long_data = - arg->d.long_data;
1168                   negate = FALSE;
1169                 }
1170               args = g_slist_prepend (args, arg);
1171             }
1172           else
1173             done = TRUE;
1174           break;
1175         case G_TOKEN_STRING:
1176           if (need_arg && !negate)
1177             {
1178               need_arg = FALSE;
1179               arg = g_new (GtkBindingArg, 1);
1180               arg->arg_type = G_TYPE_STRING;
1181               arg->d.string_data = g_strdup (scanner->value.v_string);
1182               args = g_slist_prepend (args, arg);
1183             }
1184           else
1185             done = TRUE;
1186
1187           break;
1188         case G_TOKEN_IDENTIFIER:
1189           if (need_arg && !negate)
1190             {
1191               need_arg = FALSE;
1192               arg = g_new (GtkBindingArg, 1);
1193               arg->arg_type = GTK_TYPE_IDENTIFIER;
1194               arg->d.string_data = g_strdup (scanner->value.v_identifier);
1195               args = g_slist_prepend (args, arg);
1196             }
1197           else
1198             done = TRUE;
1199
1200           break;
1201         case '-':
1202           if (!need_arg)
1203             done = TRUE;
1204           else if (negate)
1205             {
1206               expected_token = G_TOKEN_INT;
1207               done = TRUE;
1208             }
1209           else
1210             negate = TRUE;
1211
1212           break;
1213         case ',':
1214           seen_comma = TRUE;
1215           if (need_arg)
1216             done = TRUE;
1217           else
1218             need_arg = TRUE;
1219
1220           break;
1221         case ')':
1222           if (!(need_arg && seen_comma) && !negate)
1223             {
1224               args = g_slist_reverse (args);
1225               _gtk_binding_entry_add_signall (binding_set,
1226                                               keyval,
1227                                               modifiers,
1228                                               signal,
1229                                               args);
1230               expected_token = G_TOKEN_NONE;
1231             }
1232
1233           done = TRUE;
1234           break;
1235         default:
1236           done = TRUE;
1237           break;
1238         }
1239     }
1240   while (!done);
1241
1242   scanner->config->scan_symbols = TRUE;
1243
1244   for (slist = args; slist; slist = slist->next)
1245     {
1246       GtkBindingArg *arg;
1247
1248       arg = slist->data;
1249
1250       if (G_TYPE_FUNDAMENTAL (arg->arg_type) == G_TYPE_STRING)
1251         g_free (arg->d.string_data);
1252       g_free (arg);
1253     }
1254
1255   g_slist_free (args);
1256   g_free (signal);
1257
1258   return expected_token;
1259 }
1260
1261 static inline guint
1262 gtk_binding_parse_bind (GScanner       *scanner,
1263                         GtkBindingSet  *binding_set)
1264 {
1265   guint keyval = 0;
1266   GdkModifierType modifiers = 0;
1267   gboolean unbind = FALSE;
1268
1269   g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
1270
1271   g_scanner_get_next_token (scanner);
1272
1273   if (scanner->token != G_TOKEN_SYMBOL)
1274     return G_TOKEN_SYMBOL;
1275
1276   if (scanner->value.v_symbol != GUINT_TO_POINTER (GTK_BINDING_TOKEN_BIND) &&
1277       scanner->value.v_symbol != GUINT_TO_POINTER (GTK_BINDING_TOKEN_UNBIND))
1278     return G_TOKEN_SYMBOL;
1279
1280   unbind = (scanner->value.v_symbol == GUINT_TO_POINTER (GTK_BINDING_TOKEN_UNBIND));
1281   g_scanner_get_next_token (scanner);
1282
1283   if (scanner->token != (guint) G_TOKEN_STRING)
1284     return G_TOKEN_STRING;
1285
1286   gtk_accelerator_parse (scanner->value.v_string, &keyval, &modifiers);
1287   modifiers &= BINDING_MOD_MASK ();
1288
1289   if (keyval == 0)
1290     return G_TOKEN_STRING;
1291
1292   if (unbind)
1293     {
1294       gtk_binding_entry_skip (binding_set, keyval, modifiers);
1295       return G_TOKEN_NONE;
1296     }
1297
1298   g_scanner_get_next_token (scanner);
1299
1300   if (scanner->token != '{')
1301     return '{';
1302
1303   gtk_binding_entry_clear_internal (binding_set, keyval, modifiers);
1304   g_scanner_peek_next_token (scanner);
1305
1306   while (scanner->next_token != '}')
1307     {
1308       guint expected_token;
1309
1310       switch (scanner->next_token)
1311         {
1312         case G_TOKEN_STRING:
1313           expected_token = gtk_binding_parse_signal (scanner,
1314                                                      binding_set,
1315                                                      keyval,
1316                                                      modifiers);
1317           if (expected_token != G_TOKEN_NONE)
1318             return expected_token;
1319           break;
1320         default:
1321           g_scanner_get_next_token (scanner);
1322           return '}';
1323         }
1324
1325       g_scanner_peek_next_token (scanner);
1326     }
1327
1328   g_scanner_get_next_token (scanner);
1329
1330   return G_TOKEN_NONE;
1331 }
1332
1333 static GScanner *
1334 create_signal_scanner (void)
1335 {
1336   GScanner *scanner;
1337
1338   scanner = g_scanner_new (NULL);
1339   scanner->config->cset_identifier_nth = G_CSET_a_2_z G_CSET_A_2_Z G_CSET_DIGITS "-_";
1340
1341   g_scanner_scope_add_symbol (scanner, 0, "bind", GUINT_TO_POINTER (GTK_BINDING_TOKEN_BIND));
1342   g_scanner_scope_add_symbol (scanner, 0, "unbind", GUINT_TO_POINTER (GTK_BINDING_TOKEN_UNBIND));
1343
1344   g_scanner_set_scope (scanner, 0);
1345
1346   return scanner;
1347 }
1348
1349 /**
1350  * gtk_binding_entry_add_signal_from_string:
1351  * @binding_set: a #GtkBindingSet
1352  * @signal_desc: a signal description
1353  *
1354  * Parses a signal description from @signal_desc and incorporates
1355  * it into @binding_set.
1356  *
1357  * Signal descriptions may either bind a key combination to
1358  * one or more signals:
1359  * <informalexample><programlisting>
1360  *   bind "key" {
1361  *     "signalname" (param, ...)
1362  *     ...
1363  *   }
1364  * </programlisting></informalexample>
1365  *
1366  * Or they may also unbind a key combination:
1367  * <informalexample><programlisting>
1368  *   unbind "key"
1369  * </programlisting></informalexample>
1370  *
1371  * Key combinations must be in a format that can be parsed by
1372  * gtk_accelerator_parse().
1373  *
1374  * Returns: %G_TOKEN_NONE if the signal was successfully parsed and added,
1375  *     the expected token otherwise
1376  *
1377  * Since: 3.0
1378  */
1379 GTokenType
1380 gtk_binding_entry_add_signal_from_string (GtkBindingSet *binding_set,
1381                                           const gchar   *signal_desc)
1382 {
1383   static GScanner *scanner = NULL;
1384   GTokenType ret;
1385
1386   g_return_val_if_fail (binding_set != NULL, G_TOKEN_NONE);
1387   g_return_val_if_fail (signal_desc != NULL, G_TOKEN_NONE);
1388
1389   if (G_UNLIKELY (!scanner))
1390     scanner = create_signal_scanner ();
1391
1392   g_scanner_input_text (scanner, signal_desc,
1393                         (guint) strlen (signal_desc));
1394
1395   ret = gtk_binding_parse_bind (scanner, binding_set);
1396
1397   /* Reset for next use */
1398   g_scanner_set_scope (scanner, 0);
1399
1400   return ret;
1401 }
1402
1403 /**
1404  * gtk_binding_set_add_path:
1405  * @binding_set: a #GtkBindingSet to add a path to
1406  * @path_type: path type the pattern applies to
1407  * @path_pattern: the actual match pattern
1408  * @priority: binding priority
1409  *
1410  * This function was used internally by the GtkRC parsing mechanism
1411  * to assign match patterns to #GtkBindingSet structures.
1412  *
1413  * In GTK+ 3, these match patterns are unused.
1414  *
1415  * Deprecated: 3.0
1416  */
1417 void
1418 gtk_binding_set_add_path (GtkBindingSet       *binding_set,
1419                           GtkPathType          path_type,
1420                           const gchar         *path_pattern,
1421                           GtkPathPriorityType  priority)
1422 {
1423   PatternSpec *pspec;
1424   GSList **slist_p, *slist;
1425   static guint seq_id = 0;
1426
1427   g_return_if_fail (binding_set != NULL);
1428   g_return_if_fail (path_pattern != NULL);
1429   g_return_if_fail (priority <= GTK_PATH_PRIO_MASK);
1430
1431   priority &= GTK_PATH_PRIO_MASK;
1432
1433   switch (path_type)
1434     {
1435     case  GTK_PATH_WIDGET:
1436       slist_p = &binding_set->widget_path_pspecs;
1437       break;
1438     case  GTK_PATH_WIDGET_CLASS:
1439       slist_p = &binding_set->widget_class_pspecs;
1440       break;
1441     case  GTK_PATH_CLASS:
1442       slist_p = &binding_set->class_branch_pspecs;
1443       break;
1444     default:
1445       g_assert_not_reached ();
1446       slist_p = NULL;
1447       break;
1448     }
1449
1450   pspec = g_new (PatternSpec, 1);
1451   pspec->type = path_type;
1452   if (path_type == GTK_PATH_WIDGET_CLASS)
1453     pspec->pspec = NULL;
1454   else
1455     pspec->pspec = g_pattern_spec_new (path_pattern);
1456
1457   pspec->seq_id = priority << 28;
1458   pspec->user_data = binding_set;
1459
1460   slist = *slist_p;
1461   while (slist)
1462     {
1463       PatternSpec *tmp_pspec;
1464
1465       tmp_pspec = slist->data;
1466       slist = slist->next;
1467
1468       if (g_pattern_spec_equal (tmp_pspec->pspec, pspec->pspec))
1469         {
1470           GtkPathPriorityType lprio = tmp_pspec->seq_id >> 28;
1471
1472           pattern_spec_free (pspec);
1473           pspec = NULL;
1474           if (lprio < priority)
1475             {
1476               tmp_pspec->seq_id &= 0x0fffffff;
1477               tmp_pspec->seq_id |= priority << 28;
1478             }
1479           break;
1480         }
1481     }
1482   if (pspec)
1483     {
1484       pspec->seq_id |= seq_id++ & 0x0fffffff;
1485       *slist_p = g_slist_prepend (*slist_p, pspec);
1486     }
1487 }
1488
1489 static gint
1490 find_entry_with_binding (GtkBindingEntry *entry,
1491                          GtkBindingSet   *binding_set)
1492 {
1493   return (entry->binding_set == binding_set) ? 0 : 1;
1494 }
1495
1496 static gboolean
1497 binding_activate (GtkBindingSet *binding_set,
1498                   GSList        *entries,
1499                   GObject       *object,
1500                   gboolean       is_release,
1501                   gboolean      *unbound)
1502 {
1503   GtkBindingEntry *entry;
1504   GSList *elem;
1505
1506   elem = g_slist_find_custom (entries, binding_set,
1507                               (GCompareFunc) find_entry_with_binding);
1508
1509   if (!elem)
1510     return FALSE;
1511
1512   entry = elem->data;
1513
1514   if (is_release != ((entry->modifiers & GDK_RELEASE_MASK) != 0))
1515     return FALSE;
1516
1517   if (entry->marks_unbound)
1518     {
1519       *unbound = TRUE;
1520       return FALSE;
1521     }
1522
1523   if (gtk_binding_entry_activate (entry, object))
1524     return TRUE;
1525
1526   return FALSE;
1527 }
1528
1529 static gboolean
1530 gtk_bindings_activate_list (GObject  *object,
1531                             GSList   *entries,
1532                             gboolean  is_release)
1533 {
1534   GtkStyleContext *context;
1535   GtkBindingSet *binding_set;
1536   GtkStateFlags state;
1537   gboolean handled = FALSE;
1538   gboolean unbound = FALSE;
1539   GPtrArray *array;
1540
1541   if (!entries)
1542     return FALSE;
1543
1544   context = gtk_widget_get_style_context (GTK_WIDGET (object));
1545   state = gtk_widget_get_state_flags (GTK_WIDGET (object));
1546
1547   gtk_style_context_get (context, state,
1548                          "gtk-key-bindings", &array,
1549                          NULL);
1550   if (array)
1551     {
1552       gint i;
1553
1554       for (i = 0; i < array->len; i++)
1555         {
1556           binding_set = g_ptr_array_index (array, i);
1557           handled = binding_activate (binding_set, entries,
1558                                       object, is_release,
1559                                       &unbound);
1560           if (handled)
1561             break;
1562         }
1563
1564       g_ptr_array_unref (array);
1565
1566       if (unbound)
1567         return FALSE;
1568     }
1569
1570   if (!handled)
1571     {
1572       GType class_type;
1573
1574       class_type = G_TYPE_FROM_INSTANCE (object);
1575
1576       while (class_type && !handled)
1577         {
1578           binding_set = gtk_binding_set_find_interned (g_type_name (class_type));
1579           class_type = g_type_parent (class_type);
1580
1581           if (!binding_set)
1582             continue;
1583
1584           handled = binding_activate (binding_set, entries,
1585                                       object, is_release,
1586                                       &unbound);
1587         }
1588
1589       if (unbound)
1590         return FALSE;
1591     }
1592
1593   return handled;
1594 }
1595
1596 /**
1597  * gtk_bindings_activate:
1598  * @object: object to activate when binding found
1599  * @keyval: key value of the binding
1600  * @modifiers: key modifier of the binding
1601  *
1602  * Find a key binding matching @keyval and @modifiers and activate the
1603  * binding on @object.
1604  *
1605  * Return value: %TRUE if a binding was found and activated
1606  */
1607 gboolean
1608 gtk_bindings_activate (GObject         *object,
1609                        guint            keyval,
1610                        GdkModifierType  modifiers)
1611 {
1612   GSList *entries = NULL;
1613   GdkDisplay *display;
1614   GtkKeyHash *key_hash;
1615   gboolean handled = FALSE;
1616   gboolean is_release;
1617
1618   if (!GTK_IS_WIDGET (object))
1619     return FALSE;
1620
1621   is_release = (modifiers & GDK_RELEASE_MASK) != 0;
1622   modifiers = modifiers & BINDING_MOD_MASK () & ~GDK_RELEASE_MASK;
1623
1624   display = gtk_widget_get_display (GTK_WIDGET (object));
1625   key_hash = binding_key_hash_for_keymap (gdk_keymap_get_for_display (display));
1626
1627   entries = _gtk_key_hash_lookup_keyval (key_hash, keyval, modifiers);
1628
1629   handled = gtk_bindings_activate_list (object, entries, is_release);
1630
1631   g_slist_free (entries);
1632
1633   return handled;
1634 }
1635
1636 /**
1637  * gtk_bindings_activate_event:
1638  * @object: a #GObject (generally must be a widget)
1639  * @event: a #GdkEventKey
1640  *
1641  * Looks up key bindings for @object to find one matching
1642  * @event, and if one was found, activate it.
1643  *
1644  * Return value: %TRUE if a matching key binding was found
1645  *
1646  * Since: 2.4
1647  */
1648 gboolean
1649 gtk_bindings_activate_event (GObject     *object,
1650                              GdkEventKey *event)
1651 {
1652   GSList *entries = NULL;
1653   GdkDisplay *display;
1654   GtkKeyHash *key_hash;
1655   gboolean handled = FALSE;
1656
1657   if (!GTK_IS_WIDGET (object))
1658     return FALSE;
1659
1660   display = gtk_widget_get_display (GTK_WIDGET (object));
1661   key_hash = binding_key_hash_for_keymap (gdk_keymap_get_for_display (display));
1662
1663   entries = _gtk_key_hash_lookup (key_hash,
1664                                   event->hardware_keycode,
1665                                   event->state,
1666                                   BINDING_MOD_MASK () & ~GDK_RELEASE_MASK,
1667                                   event->group);
1668
1669   handled = gtk_bindings_activate_list (object, entries,
1670                                         event->type == GDK_KEY_RELEASE);
1671
1672   g_slist_free (entries);
1673
1674   return handled;
1675 }