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_add (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, GtkType);
 915       switch (G_TYPE_FUNDAMENTAL (arg->arg_type))
 916         {
 917           /* for elaborated commenting about var args collection, take a look
 918            * at gtk_arg_collect_value() in gtkargcollector.c
 919            */
 920         case G_TYPE_CHAR:
 921         case G_TYPE_UCHAR:
 922         case G_TYPE_INT:
 923         case G_TYPE_UINT:
 924         case G_TYPE_BOOLEAN:
 925         case G_TYPE_ENUM:
 926         case G_TYPE_FLAGS:
 927           arg->arg_type = G_TYPE_LONG;
 928           arg->d.long_data = va_arg (args, gint);
 929           break;
 930         case G_TYPE_LONG:
 931         case G_TYPE_ULONG:
 932           arg->arg_type = G_TYPE_LONG;
 933           arg->d.long_data = va_arg (args, glong);
 934           break;
 935         case G_TYPE_FLOAT:
 936         case G_TYPE_DOUBLE:
 937           arg->arg_type = G_TYPE_DOUBLE;
 938           arg->d.double_data = va_arg (args, gdouble);
 939           break;
 940         case G_TYPE_STRING:
 941           if (arg->arg_type != GTK_TYPE_IDENTIFIER)
 942             arg->arg_type = G_TYPE_STRING;
 943           arg->d.string_data = va_arg (args, gchar*);
 944           if (!arg->d.string_data)
 945             {
 946               g_warning ("gtk_binding_entry_add_signal(): type `%s' arg[%u] is `NULL'",
 947                          g_type_name (arg->arg_type),
 948                          i);
 949               i += n_args + 1;
 950             }
 951           break;
 952         default:
 953           g_warning ("gtk_binding_entry_add_signal(): unsupported type `%s' for arg[%u]",
 954                      g_type_name (arg->arg_type), i);
 955           i += n_args + 1;
 956           break;
 957         }
 958     }
 959   va_end (args);
 960
 961   if (i == n_args || i == 0)
 962     {
 963       slist = g_slist_reverse (slist);
 964       gtk_binding_entry_add_signall (binding_set, keyval, modifiers, signal_name, slist);
 965     }
 966
 967   free_slist = slist;
 968   while (slist)
 969     {
 970       g_slice_free (GtkBindingArg, slist->data);
 971       slist = slist->next;
 972     }
 973   g_slist_free (free_slist);
 974 }
 975
 976 /**
 977  * gtk_binding_set_add_path:
 978  * @binding_set:  binding set to add a path to
 979  * @path_type:    path type the pattern applies to
 980  * @path_pattern: the actual match pattern
 981  * @priority:     binding priority
 982  *
 983  * This function is used internally by the GtkRC parsing mechanism to
 984  * assign match patterns to #GtkBindingSet structures.
 985  **/
 986 void
 987 gtk_binding_set_add_path (GtkBindingSet      *binding_set,
 988                           GtkPathType         path_type,
 989                           const gchar        *path_pattern,
 990                           GtkPathPriorityType priority)
 991 {
 992   PatternSpec *pspec;
 993   GSList **slist_p, *slist;
 994   static guint seq_id = 0;
 995
 996   g_return_if_fail (binding_set != NULL);
 997   g_return_if_fail (path_pattern != NULL);
 998   g_return_if_fail (priority <= GTK_PATH_PRIO_MASK);
 999
1000   priority &= GTK_PATH_PRIO_MASK;
1001
1002   switch (path_type)
1003     {
1004     case  GTK_PATH_WIDGET:
1005       slist_p = &binding_set->widget_path_pspecs;
1006       break;
1007     case  GTK_PATH_WIDGET_CLASS:
1008       slist_p = &binding_set->widget_class_pspecs;
1009       break;
1010     case  GTK_PATH_CLASS:
1011       slist_p = &binding_set->class_branch_pspecs;
1012       break;
1013     default:
1014       g_assert_not_reached ();
1015       slist_p = NULL;
1016       break;
1017     }
1018
1019   pspec = g_new (PatternSpec, 1);
1020   pspec->type = path_type;
1021   if (path_type == GTK_PATH_WIDGET_CLASS)
1022     {
1023       pspec->pspec = NULL;
1024       pspec->path = _gtk_rc_parse_widget_class_path (path_pattern);
1025     }
1026   else
1027     {
1028       pspec->pspec = g_pattern_spec_new (path_pattern);
1029       pspec->path = NULL;
1030     }
1031
1032   pspec->seq_id = priority << 28;
1033   pspec->user_data = binding_set;
1034
1035   slist = *slist_p;
1036   while (slist)
1037     {
1038       PatternSpec *tmp_pspec;
1039
1040       tmp_pspec = slist->data;
1041       slist = slist->next;
1042
1043       if (g_pattern_spec_equal (tmp_pspec->pspec, pspec->pspec))
1044         {
1045           GtkPathPriorityType lprio = tmp_pspec->seq_id >> 28;
1046
1047           pattern_spec_free (pspec);
1048           pspec = NULL;
1049           if (lprio < priority)
1050             {
1051               tmp_pspec->seq_id &= 0x0fffffff;
1052               tmp_pspec->seq_id |= priority << 28;
1053             }
1054           break;
1055         }
1056     }
1057   if (pspec)
1058     {
1059       pspec->seq_id |= seq_id++ & 0x0fffffff;
1060       *slist_p = g_slist_prepend (*slist_p, pspec);
1061     }
1062 }
1063
1064 static gboolean
1065 binding_match_activate (GSList          *pspec_list,
1066                         GtkObject       *object,
1067                         guint            path_length,
1068                         gchar           *path,
1069                         gchar           *path_reversed,
1070                         gboolean        *unbound)
1071 {
1072   GSList *slist;
1073
1074   *unbound = FALSE;
1075
1076   for (slist = pspec_list; slist; slist = slist->next)
1077     {
1078       PatternSpec *pspec;
1079       GtkBindingSet *binding_set;
1080
1081       binding_set = NULL;
1082       pspec = slist->data;
1083
1084       if (pspec->type == GTK_PATH_WIDGET_CLASS)
1085         {
1086           if (_gtk_rc_match_widget_class (pspec->path, path_length, path, path_reversed))
1087             binding_set = pspec->user_data;
1088         }
1089       else
1090         {
1091           if (g_pattern_match (pspec->pspec, path_length, path, path_reversed))
1092             binding_set = pspec->user_data;
1093         }
1094
1095       if (binding_set)
1096         {
1097           if (binding_set->current->marks_unbound)
1098             {
1099               *unbound = TRUE;
1100               return FALSE;
1101             }
1102
1103           if (gtk_binding_entry_activate (binding_set->current, object))
1104             return TRUE;
1105         }
1106     }
1107
1108   return FALSE;
1109 }
1110
1111 static gint
1112 gtk_binding_pattern_compare (gconstpointer new_pattern,
1113                              gconstpointer existing_pattern)
1114 {
1115   register const PatternSpec *np  = new_pattern;
1116   register const PatternSpec *ep  = existing_pattern;
1117
1118   /* walk the list as long as the existing patterns have
1119    * higher priorities.
1120    */
1121
1122   return np->seq_id < ep->seq_id;
1123 }
1124
1125 static GSList*
1126 gtk_binding_entries_sort_patterns (GSList      *entries,
1127                                    GtkPathType  path_id,
1128                                    gboolean     is_release)
1129 {
1130   GSList *patterns;
1131   GSList *tmp_list;
1132
1133   patterns = NULL;
1134   for (tmp_list = entries; tmp_list; tmp_list = tmp_list->next)
1135     {
1136       GtkBindingEntry *entry = tmp_list->data;
1137       GtkBindingSet *binding_set;
1138
1139       binding_set = entry->binding_set;
1140       binding_set->current = NULL;
1141     }
1142
1143   for (; entries; entries = entries->next)
1144     {
1145       GtkBindingEntry *entry = entries->data;
1146       GtkBindingSet *binding_set;
1147       GSList *slist = NULL;
1148
1149       if (is_release != ((entry->modifiers & GDK_RELEASE_MASK) != 0))
1150         continue;
1151
1152       binding_set = entry->binding_set;
1153
1154       if (binding_set->current)
1155         continue;
1156       binding_set->current = entry;
1157
1158       switch (path_id)
1159         {
1160         case GTK_PATH_WIDGET:
1161           slist = binding_set->widget_path_pspecs;
1162           break;
1163         case GTK_PATH_WIDGET_CLASS:
1164           slist = binding_set->widget_class_pspecs;
1165           break;
1166         case GTK_PATH_CLASS:
1167           slist = binding_set->class_branch_pspecs;
1168           break;
1169         }
1170
1171       for (; slist; slist = slist->next)
1172         {
1173           PatternSpec *pspec;
1174
1175           pspec = slist->data;
1176           patterns = g_slist_insert_sorted (patterns, pspec, gtk_binding_pattern_compare);
1177         }
1178     }
1179
1180   return patterns;
1181 }
1182
1183 static gboolean
1184 gtk_bindings_activate_list (GtkObject *object,
1185                             GSList    *entries,
1186                             gboolean   is_release)
1187 {
1188   GtkWidget *widget = GTK_WIDGET (object);
1189   gboolean handled = FALSE;
1190
1191   if (!entries)
1192     return FALSE;
1193
1194   if (!handled)
1195     {
1196       guint path_length;
1197       gchar *path, *path_reversed;
1198       GSList *patterns;
1199       gboolean unbound;
1200
1201       gtk_widget_path (widget, &path_length, &path, &path_reversed);
1202       patterns = gtk_binding_entries_sort_patterns (entries, GTK_PATH_WIDGET, is_release);
1203       handled = binding_match_activate (patterns, object, path_length, path, path_reversed, &unbound);
1204       g_slist_free (patterns);
1205       g_free (path);
1206       g_free (path_reversed);
1207
1208       if (unbound)
1209         return FALSE;
1210     }
1211
1212   if (!handled)
1213     {
1214       guint path_length;
1215       gchar *path, *path_reversed;
1216       GSList *patterns;
1217       gboolean unbound;
1218
1219       gtk_widget_class_path (widget, &path_length, &path, &path_reversed);
1220       patterns = gtk_binding_entries_sort_patterns (entries, GTK_PATH_WIDGET_CLASS, is_release);
1221       handled = binding_match_activate (patterns, object, path_length, path, path_reversed, &unbound);
1222       g_slist_free (patterns);
1223       g_free (path);
1224       g_free (path_reversed);
1225
1226       if (unbound)
1227         return FALSE;
1228     }
1229
1230   if (!handled)
1231     {
1232       GSList *patterns;
1233       GType class_type;
1234       gboolean unbound = FALSE;
1235
1236       patterns = gtk_binding_entries_sort_patterns (entries, GTK_PATH_CLASS, is_release);
1237       class_type = G_TYPE_FROM_INSTANCE (object);
1238       while (class_type && !handled)
1239         {
1240           guint path_length;
1241           gchar *path;
1242           gchar *path_reversed;
1243
1244           path = g_strdup (g_type_name (class_type));
1245           path_reversed = g_strdup (path);
1246           g_strreverse (path_reversed);
1247           path_length = strlen (path);
1248           handled = binding_match_activate (patterns, object, path_length, path, path_reversed, &unbound);
1249           g_free (path);
1250           g_free (path_reversed);
1251
1252           if (unbound)
1253             break;
1254
1255           class_type = g_type_parent (class_type);
1256         }
1257       g_slist_free (patterns);
1258
1259       if (unbound)
1260         return FALSE;
1261     }
1262
1263   return handled;
1264 }
1265
1266 /**
1267  * gtk_bindings_activate:
1268  * @object: object to activate when binding found
1269  * @keyval: key value of the binding
1270  * @modifiers: key modifier of the binding
1271  *
1272  * Find a key binding matching @keyval and @modifiers and activate the
1273  * binding on @object.
1274  *
1275  * Return value: %TRUE if a binding was found and activated
1276  **/
1277 gboolean
1278 gtk_bindings_activate (GtkObject      *object,
1279                        guint           keyval,
1280                        GdkModifierType modifiers)
1281 {
1282   GSList *entries = NULL;
1283   GdkDisplay *display;
1284   GtkKeyHash *key_hash;
1285   gboolean handled = FALSE;
1286   gboolean is_release;
1287
1288   g_return_val_if_fail (GTK_IS_OBJECT (object), FALSE);
1289
1290   if (!GTK_IS_WIDGET (object))
1291     return FALSE;
1292
1293   is_release = (modifiers & GDK_RELEASE_MASK) != 0;
1294   modifiers = modifiers & BINDING_MOD_MASK () & ~GDK_RELEASE_MASK;
1295
1296   display = gtk_widget_get_display (GTK_WIDGET (object));
1297   key_hash = binding_key_hash_for_keymap (gdk_keymap_get_for_display (display));
1298
1299   entries = _gtk_key_hash_lookup_keyval (key_hash, keyval, modifiers);
1300
1301   handled = gtk_bindings_activate_list (object, entries, is_release);
1302
1303   g_slist_free (entries);
1304
1305   return handled;
1306 }
1307
1308 /**
1309  * gtk_bindings_activate_event:
1310  * @object: a #GtkObject (generally must be a widget)
1311  * @event: a #GdkEventKey
1312  *
1313  * Looks up key bindings for @object to find one matching
1314  * @event, and if one was found, activate it.
1315  *
1316  * Return value: %TRUE if a matching key binding was found
1317  **/
1318 gboolean
1319 gtk_bindings_activate_event (GtkObject      *object,
1320                              GdkEventKey    *event)
1321 {
1322   GSList *entries = NULL;
1323   GdkDisplay *display;
1324   GtkKeyHash *key_hash;
1325   gboolean handled = FALSE;
1326
1327   g_return_val_if_fail (GTK_IS_OBJECT (object), FALSE);
1328
1329   if (!GTK_IS_WIDGET (object))
1330     return FALSE;
1331
1332   display = gtk_widget_get_display (GTK_WIDGET (object));
1333   key_hash = binding_key_hash_for_keymap (gdk_keymap_get_for_display (display));
1334
1335   entries = _gtk_key_hash_lookup (key_hash,
1336                                   event->hardware_keycode,
1337                                   event->state,
1338                                   BINDING_MOD_MASK () & ~GDK_RELEASE_MASK,
1339                                   event->group);
1340
1341   handled = gtk_bindings_activate_list (object, entries,
1342                                         event->type == GDK_KEY_RELEASE);
1343
1344   g_slist_free (entries);
1345
1346   return handled;
1347 }
1348
1349 static guint
1350 gtk_binding_parse_signal (GScanner       *scanner,
1351                           GtkBindingSet  *binding_set,
1352                           guint           keyval,
1353                           GdkModifierType modifiers)
1354 {
1355   gchar *signal;
1356   guint expected_token = 0;
1357   GSList *args;
1358   GSList *slist;
1359   gboolean done;
1360   gboolean negate;
1361   gboolean need_arg;
1362   gboolean seen_comma;
1363
1364   g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
1365
1366   g_scanner_get_next_token (scanner);
1367   if (scanner->token != G_TOKEN_STRING)
1368     return G_TOKEN_STRING;
1369   g_scanner_peek_next_token (scanner);
1370   if (scanner->next_token != '(')
1371     {
1372       g_scanner_get_next_token (scanner);
1373       return '(';
1374     }
1375   signal = g_strdup (scanner->value.v_string);
1376   g_scanner_get_next_token (scanner);
1377
1378   negate = FALSE;
1379   args = NULL;
1380   done = FALSE;
1381   need_arg = TRUE;
1382   seen_comma = FALSE;
1383   scanner->config->scan_symbols = FALSE;
1384   do
1385     {
1386       if (need_arg)
1387         expected_token = G_TOKEN_INT;
1388       else
1389         expected_token = ')';
1390       g_scanner_get_next_token (scanner);
1391       switch (scanner->token)
1392         {
1393           GtkBindingArg *arg;
1394
1395         case G_TOKEN_FLOAT:
1396           if (need_arg)
1397             {
1398               need_arg = FALSE;
1399               arg = g_new (GtkBindingArg, 1);
1400               arg->arg_type = G_TYPE_DOUBLE;
1401               arg->d.double_data = scanner->value.v_float;
1402               if (negate)
1403                 {
1404                   arg->d.double_data = - arg->d.double_data;
1405                   negate = FALSE;
1406                 }
1407               args = g_slist_prepend (args, arg);
1408             }
1409           else
1410             done = TRUE;
1411           break;
1412         case G_TOKEN_INT:
1413           if (need_arg)
1414             {
1415               need_arg = FALSE;
1416               arg = g_new (GtkBindingArg, 1);
1417               arg->arg_type = G_TYPE_LONG;
1418               arg->d.long_data = scanner->value.v_int;
1419               if (negate)
1420                 {
1421                   arg->d.long_data = - arg->d.long_data;
1422                   negate = FALSE;
1423                 }
1424               args = g_slist_prepend (args, arg);
1425             }
1426           else
1427             done = TRUE;
1428           break;
1429         case G_TOKEN_STRING:
1430           if (need_arg && !negate)
1431             {
1432               need_arg = FALSE;
1433               arg = g_new (GtkBindingArg, 1);
1434               arg->arg_type = G_TYPE_STRING;
1435               arg->d.string_data = g_strdup (scanner->value.v_string);
1436               args = g_slist_prepend (args, arg);
1437             }
1438           else
1439             done = TRUE;
1440           break;
1441         case G_TOKEN_IDENTIFIER:
1442           if (need_arg && !negate)
1443             {
1444               need_arg = FALSE;
1445               arg = g_new (GtkBindingArg, 1);
1446               arg->arg_type = GTK_TYPE_IDENTIFIER;
1447               arg->d.string_data = g_strdup (scanner->value.v_identifier);
1448               args = g_slist_prepend (args, arg);
1449             }
1450           else
1451             done = TRUE;
1452           break;
1453         case '-':
1454           if (!need_arg)
1455             done = TRUE;
1456           else if (negate)
1457             {
1458               expected_token = G_TOKEN_INT;
1459               done = TRUE;
1460             }
1461           else
1462             negate = TRUE;
1463           break;
1464         case ',':
1465           seen_comma = TRUE;
1466           if (need_arg)
1467             done = TRUE;
1468           else
1469             need_arg = TRUE;
1470           break;
1471         case ')':
1472           if (!(need_arg && seen_comma) && !negate)
1473             {
1474               args = g_slist_reverse (args);
1475               gtk_binding_entry_add_signall (binding_set,
1476                                              keyval,
1477                                              modifiers,
1478                                              signal,
1479                                              args);
1480               expected_token = G_TOKEN_NONE;
1481             }
1482           done = TRUE;
1483           break;
1484         default:
1485           done = TRUE;
1486           break;
1487         }
1488     }
1489   while (!done);
1490   scanner->config->scan_symbols = TRUE;
1491
1492   for (slist = args; slist; slist = slist->next)
1493     {
1494       GtkBindingArg *arg;
1495
1496       arg = slist->data;
1497       if (G_TYPE_FUNDAMENTAL (arg->arg_type) == G_TYPE_STRING)
1498         g_free (arg->d.string_data);
1499       g_free (arg);
1500     }
1501   g_slist_free (args);
1502   g_free (signal);
1503
1504   return expected_token;
1505 }
1506
1507 static inline guint
1508 gtk_binding_parse_bind (GScanner       *scanner,
1509                         GtkBindingSet  *binding_set)
1510 {
1511   guint keyval = 0;
1512   GdkModifierType modifiers = 0;
1513   gboolean unbind = FALSE;
1514
1515   g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
1516
1517   g_scanner_get_next_token (scanner);
1518   if (scanner->token != GTK_RC_TOKEN_BIND &&
1519       scanner->token != GTK_RC_TOKEN_UNBIND)
1520     return GTK_RC_TOKEN_BIND;
1521   unbind = scanner->token == GTK_RC_TOKEN_UNBIND;
1522   g_scanner_get_next_token (scanner);
1523   if (scanner->token != G_TOKEN_STRING)
1524     return G_TOKEN_STRING;
1525   gtk_accelerator_parse (scanner->value.v_string, &keyval, &modifiers);
1526   modifiers &= BINDING_MOD_MASK ();
1527   if (keyval == 0)
1528     return G_TOKEN_STRING;
1529
1530   if (unbind)
1531     {
1532       gtk_binding_entry_skip (binding_set, keyval, modifiers);
1533       return G_TOKEN_NONE;
1534     }
1535
1536   g_scanner_get_next_token (scanner);
1537
1538   if (scanner->token != '{')
1539     return '{';
1540
1541   gtk_binding_entry_clear (binding_set, keyval, modifiers);
1542
1543   g_scanner_peek_next_token (scanner);
1544   while (scanner->next_token != '}')
1545     {
1546       switch (scanner->next_token)
1547         {
1548           guint expected_token;
1549
1550         case G_TOKEN_STRING:
1551           expected_token = gtk_binding_parse_signal (scanner,
1552                                                      binding_set,
1553                                                      keyval,
1554                                                      modifiers);
1555           if (expected_token != G_TOKEN_NONE)
1556             return expected_token;
1557           break;
1558         default:
1559           g_scanner_get_next_token (scanner);
1560           return '}';
1561         }
1562       g_scanner_peek_next_token (scanner);
1563     }
1564   g_scanner_get_next_token (scanner);
1565
1566   return G_TOKEN_NONE;
1567 }
1568
1569 /**
1570  * gtk_binding_parse_binding:
1571  * @scanner: GtkRC scanner
1572  *
1573  * Deprecated as public API, used only internally.
1574  *
1575  * Return value: expected token upon errors, %G_TOKEN_NONE on success.
1576  **/
1577 guint
1578 gtk_binding_parse_binding (GScanner *scanner)
1579 {
1580   return _gtk_binding_parse_binding (scanner);
1581 }
1582
1583 guint
1584 _gtk_binding_parse_binding (GScanner *scanner)
1585 {
1586   gchar *name;
1587   GtkBindingSet *binding_set;
1588
1589   g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
1590
1591   g_scanner_get_next_token (scanner);
1592   if (scanner->token != GTK_RC_TOKEN_BINDING)
1593     return GTK_RC_TOKEN_BINDING;
1594   g_scanner_get_next_token (scanner);
1595   if (scanner->token != G_TOKEN_STRING)
1596     return G_TOKEN_STRING;
1597   name = g_strdup (scanner->value.v_string);
1598
1599   g_scanner_get_next_token (scanner);
1600   if (scanner->token != '{')
1601     {
1602       g_free (name);
1603       return G_TOKEN_STRING;
1604     }
1605
1606   binding_set = gtk_binding_set_find (name);
1607   if (!binding_set)
1608     {
1609       binding_set = gtk_binding_set_new (name);
1610       binding_set->parsed = 1;
1611     }
1612   g_free (name);
1613
1614   g_scanner_peek_next_token (scanner);
1615   while (scanner->next_token != '}')
1616     {
1617       switch (scanner->next_token)
1618         {
1619           guint expected_token;
1620
1621         case GTK_RC_TOKEN_BIND:
1622         case GTK_RC_TOKEN_UNBIND:
1623           expected_token = gtk_binding_parse_bind (scanner, binding_set);
1624           if (expected_token != G_TOKEN_NONE)
1625             return expected_token;
1626           break;
1627         default:
1628           g_scanner_get_next_token (scanner);
1629           return '}';
1630         }
1631       g_scanner_peek_next_token (scanner);
1632     }
1633   g_scanner_get_next_token (scanner);
1634
1635   return G_TOKEN_NONE;
1636 }
1637
1638 static void
1639 free_pattern_specs (GSList *pattern_specs)
1640 {
1641   GSList *slist;
1642
1643   for (slist = pattern_specs; slist; slist = slist->next)
1644     {
1645       PatternSpec *pspec;
1646
1647       pspec = slist->data;
1648
1649       pattern_spec_free (pspec);
1650     }
1651
1652   g_slist_free (pattern_specs);
1653 }
1654
1655 static void
1656 binding_set_delete (GtkBindingSet *binding_set)
1657 {
1658   GtkBindingEntry *entry, *next;
1659
1660   entry = binding_set->entries;
1661   while (entry)
1662     {
1663       next = entry->set_next;
1664       binding_entry_destroy (entry);
1665       entry = next;
1666     }
1667
1668   free_pattern_specs (binding_set->widget_path_pspecs);
1669   free_pattern_specs (binding_set->widget_class_pspecs);
1670   free_pattern_specs (binding_set->class_branch_pspecs);
1671
1672   g_free (binding_set);
1673 }
1674
1675 /**
1676  * _gtk_binding_reset_parsed:
1677  *
1678  * Removing all binding sets that were added by
1679  * gtk_binding_parse_binding()
1680  **/
1681 void
1682 _gtk_binding_reset_parsed (void)
1683 {
1684   GSList *slist, *next;
1685
1686   slist = binding_set_list;
1687   while (slist)
1688     {
1689       GtkBindingSet *binding_set;
1690
1691       binding_set = slist->data;
1692       next = slist->next;
1693
1694       if (binding_set->parsed)
1695         {
1696           binding_set_list = g_slist_delete_link (binding_set_list, slist);
1697           binding_set_delete (binding_set);
1698         }
1699
1700       slist = next;
1701     }
1702 }
1703
1704 guint
1705 _gtk_binding_signal_new (const gchar        *signal_name,
1706                          GType               itype,
1707                          GSignalFlags        signal_flags,
1708                          GCallback           handler,
1709                          GSignalAccumulator  accumulator,
1710                          gpointer            accu_data,
1711                          GSignalCMarshaller  c_marshaller,
1712                          GType               return_type,
1713                          guint               n_params,
1714                          ...)
1715 {
1716   va_list args;
1717   guint signal_id;
1718
1719   g_return_val_if_fail (signal_name != NULL, 0);
1720
1721   va_start (args, n_params);
1722
1723   signal_id = g_signal_new_valist (signal_name, itype, signal_flags,
1724                                    g_cclosure_new (handler, NULL, NULL),
1725                                    accumulator, accu_data, c_marshaller,
1726                                    return_type, n_params, args);
1727
1728   va_end (args);
1729
1730   return signal_id;
1731 }
1732
1733 #define __GTK_BINDINGS_C__
1734 #include "gtkaliasdef.c"