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