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