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

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1998, 2001 Tim Janik
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include "config.h"
  21
  22 #include "gtkaccelmap.h"
  23
  24 #include "gtkwindow.h"  /* in lack of GtkAcceleratable */
  25
  26 #include <string.h>
  27 #include <fcntl.h>
  28 #ifdef HAVE_UNISTD_H
  29 #include <unistd.h>
  30 #endif
  31 #ifdef G_OS_WIN32
  32 #include <io.h>
  33 #endif
  34 #include <errno.h>
  35
  36
  37 /* --- structures --- */
  38 typedef struct {
  39   const gchar *accel_path;
  40   guint        accel_key;
  41   guint        accel_mods;
  42   guint        std_accel_key;
  43   guint        std_accel_mods;
  44   guint        changed : 1;
  45   GSList      *groups;
  46 } AccelEntry;
  47
  48
  49 /* --- variables --- */
  50 static GHashTable *accel_entry_ht = NULL;       /* accel_path -> AccelEntry */
  51 static GSList     *accel_filters = NULL;
  52
  53
  54 /* --- functions --- */
  55 static guint
  56 accel_entry_hash (gconstpointer key)
  57 {
  58   const AccelEntry *entry = key;
  59
  60   return g_str_hash (entry->accel_path);
  61 }
  62
  63 static gboolean
  64 accel_entry_equal (gconstpointer key1,
  65                    gconstpointer key2)
  66 {
  67   const AccelEntry *entry1 = key1;
  68   const AccelEntry *entry2 = key2;
  69
  70   return g_str_equal (entry1->accel_path, entry2->accel_path);
  71 }
  72
  73 static inline AccelEntry*
  74 accel_path_lookup (const gchar *accel_path)
  75 {
  76   AccelEntry ekey;
  77
  78   ekey.accel_path = accel_path;
  79
  80   /* safety NULL check for return_if_fail()s */
  81   return accel_path ? g_hash_table_lookup (accel_entry_ht, &ekey) : NULL;
  82 }
  83
  84 void
  85 _gtk_accel_map_init (void)
  86 {
  87   g_assert (accel_entry_ht == NULL);
  88
  89   accel_entry_ht = g_hash_table_new (accel_entry_hash, accel_entry_equal);
  90 }
  91
  92 gboolean
  93 _gtk_accel_path_is_valid (const gchar *accel_path)
  94 {
  95   gchar *p;
  96
  97   if (!accel_path || accel_path[0] != '<' ||
  98       accel_path[1] == '<' || accel_path[1] == '>' || !accel_path[1])
  99     return FALSE;
 100   p = strchr (accel_path, '>');
 101   if (!p || p[1] != '/')
 102     return FALSE;
 103   return TRUE;
 104 }
 105
 106 /**
 107  * gtk_accel_map_add_entry
 108  * @accel_path: valid accelerator path
 109  * @accel_key:  the accelerator key
 110  * @accel_mods: the accelerator modifiers
 111  *
 112  * Register a new accelerator with the global accelerator map.
 113  * This function should only be called once per @accel_path
 114  * with the canonical @accel_key and @accel_mods for this path.
 115  * To change the accelerator during runtime programatically, use
 116  * gtk_accel_map_change_entry().
 117  * The accelerator path must consist of "&lt;WINDOWTYPE&gt;/Category1/Category2/.../Action",
 118  * where WINDOWTYPE should be a unique application specifc identifier, that
 119  * corresponds to the kind of window the accelerator is being used in, e.g. "Gimp-Image",
 120  * "Abiword-Document" or "Gnumeric-Settings".
 121  * The Category1/.../Action portion is most apropriately choosen by the action the
 122  * accelerator triggers, i.e. for accelerators on menu items, choose the item's menu path,
 123  * e.g. "File/Save As", "Image/View/Zoom" or "Edit/Select All".
 124  * So a full valid accelerator path may look like:
 125  * "&lt;Gimp-Toolbox&gt;/File/Dialogs/Tool Options...".
 126  */
 127 void
 128 gtk_accel_map_add_entry (const gchar *accel_path,
 129                          guint        accel_key,
 130                          guint        accel_mods)
 131 {
 132   AccelEntry *entry;
 133
 134   g_return_if_fail (_gtk_accel_path_is_valid (accel_path));
 135
 136   if (!accel_key)
 137     accel_mods = 0;
 138   else
 139     accel_mods &= gtk_accelerator_get_default_mod_mask ();
 140
 141   entry = accel_path_lookup (accel_path);
 142   if (entry)
 143     {
 144       if (!entry->std_accel_key && !entry->std_accel_mods &&
 145           (accel_key || accel_mods))
 146         {
 147           entry->std_accel_key = accel_key;
 148           entry->std_accel_mods = accel_mods;
 149           if (!entry->changed)
 150             gtk_accel_map_change_entry (entry->accel_path, accel_key, accel_mods, TRUE);
 151         }
 152     }
 153   else
 154     {
 155       entry = g_new0 (AccelEntry, 1);
 156       entry->accel_path = g_quark_to_string (g_quark_from_string (accel_path));
 157       entry->std_accel_key = accel_key;
 158       entry->std_accel_mods = accel_mods;
 159       entry->accel_key = accel_key;
 160       entry->accel_mods = accel_mods;
 161       entry->changed = FALSE;
 162       g_hash_table_insert (accel_entry_ht, entry, entry);
 163     }
 164 }
 165
 166 /**
 167  * gtk_accel_map_lookup_entry
 168  * @accel_path:  valid accelerator path
 169  * @key:         accelerator key to be filled in (optional)
 170  * @returns:     %TRUE if @accel_path is known, %FALSE otherwise
 171  *
 172  * Looks up the accelerator entry for @accel_path and fills in @key.
 173  */
 174 gboolean
 175 gtk_accel_map_lookup_entry (const gchar *accel_path,
 176                             GtkAccelKey *key)
 177 {
 178   AccelEntry *entry;
 179
 180   g_return_val_if_fail (_gtk_accel_path_is_valid (accel_path), FALSE);
 181
 182   entry = accel_path_lookup (accel_path);
 183   if (entry && key)
 184     {
 185       key->accel_key = entry->accel_key;
 186       key->accel_mods = entry->accel_mods;
 187       key->accel_flags = 0;
 188     }
 189
 190   return entry ? TRUE : FALSE;
 191 }
 192
 193 static void
 194 hash2slist_foreach (gpointer  key,
 195                     gpointer  value,
 196                     gpointer  user_data)
 197 {
 198   GSList **slist_p = user_data;
 199
 200   *slist_p = g_slist_prepend (*slist_p, value);
 201 }
 202
 203 static GSList*
 204 g_hash_table_slist_values (GHashTable *hash_table)
 205 {
 206   GSList *slist = NULL;
 207
 208   g_return_val_if_fail (hash_table != NULL, NULL);
 209
 210   g_hash_table_foreach (hash_table, hash2slist_foreach, &slist);
 211
 212   return slist;
 213 }
 214
 215 static gboolean
 216 internal_change_entry (const gchar    *accel_path,
 217                        guint           accel_key,
 218                        GdkModifierType accel_mods,
 219                        gboolean        replace,
 220                        gboolean        simulate)
 221 {
 222   GSList *node, *slist, *win_list, *group_list, *replace_list = NULL;
 223   GHashTable *group_hm, *win_hm;
 224   gboolean change_accel, removable, can_change = TRUE, seen_accel = FALSE;
 225   GQuark entry_quark;
 226   AccelEntry *entry = accel_path_lookup (accel_path);
 227
 228   /* not much todo if there's no entry yet */
 229   if (!entry)
 230     {
 231       if (!simulate)
 232         {
 233           gtk_accel_map_add_entry (accel_path, 0, 0);
 234           entry = accel_path_lookup (accel_path);
 235           entry->accel_key = accel_key;
 236           entry->accel_mods = accel_mods;
 237           entry->changed = TRUE;
 238         }
 239       return TRUE;
 240     }
 241
 242   /* if there's nothing to change, not much todo either */
 243   if (entry->accel_key == accel_key && entry->accel_mods == accel_mods)
 244     return FALSE;
 245
 246   /* nobody's interested, easy going */
 247   if (!entry->groups)
 248     {
 249       if (!simulate)
 250         {
 251           entry->accel_key = accel_key;
 252           entry->accel_mods = accel_mods;
 253           entry->changed = TRUE;
 254         }
 255       return TRUE;
 256     }
 257
 258   /* 1) fetch all accel groups affected by this entry */
 259   entry_quark = g_quark_try_string (entry->accel_path);
 260   group_hm = g_hash_table_new (NULL, NULL);
 261   win_hm = g_hash_table_new (NULL, NULL);
 262   for (slist = entry->groups; slist; slist = slist->next)
 263     g_hash_table_insert (group_hm, slist->data, slist->data);
 264
 265   /* 2) collect acceleratables affected */
 266   group_list = g_hash_table_slist_values (group_hm);
 267   for (slist = group_list; slist; slist = slist->next)
 268     {
 269       GtkAccelGroup *group = slist->data;
 270
 271       for (node = group->acceleratables; node; node = node->next)
 272         g_hash_table_insert (win_hm, node->data, node->data);
 273     }
 274   g_slist_free (group_list);
 275
 276   /* 3) include all accel groups used by acceleratables */
 277   win_list = g_hash_table_slist_values (win_hm);
 278   g_hash_table_destroy (win_hm);
 279   for (slist = win_list; slist; slist = slist->next)
 280     for (node = gtk_accel_groups_from_object (slist->data); node; node = node->next)
 281       g_hash_table_insert (group_hm, node->data, node->data);
 282   group_list = g_hash_table_slist_values (group_hm);
 283   g_hash_table_destroy (group_hm);
 284
 285   /* 4) walk the acceleratables and figure whether they occupy accel_key&accel_mods */
 286   if (accel_key)
 287     for (slist = win_list; slist; slist = slist->next)
 288       if (GTK_IS_WINDOW (slist->data))  /* bad kludge in lack of a GtkAcceleratable */
 289         if (_gtk_window_query_nonaccels (slist->data, accel_key, accel_mods))
 290           {
 291             seen_accel = TRUE;
 292             break;
 293           }
 294   removable = !seen_accel;
 295
 296   /* 5) walk all accel groups and search for locks */
 297   if (removable)
 298     for (slist = group_list; slist; slist = slist->next)
 299       {
 300         GtkAccelGroup *group = slist->data;
 301         GtkAccelGroupEntry *ag_entry;
 302         guint i, n;
 303
 304         n = 0;
 305         ag_entry = entry->accel_key ? gtk_accel_group_query (group, entry->accel_key, entry->accel_mods, &n) : NULL;
 306         for (i = 0; i < n; i++)
 307           if (ag_entry[i].accel_path_quark == entry_quark)
 308             {
 309               can_change = !(ag_entry[i].key.accel_flags & GTK_ACCEL_LOCKED);
 310               if (!can_change)
 311                 goto break_loop_step5;
 312             }
 313
 314         n = 0;
 315         ag_entry = accel_key ? gtk_accel_group_query (group, accel_key, accel_mods, &n) : NULL;
 316         for (i = 0; i < n; i++)
 317           {
 318             seen_accel = TRUE;
 319             removable = !group->lock_count && !(ag_entry[i].key.accel_flags & GTK_ACCEL_LOCKED);
 320             if (!removable)
 321               goto break_loop_step5;
 322             if (ag_entry[i].accel_path_quark)
 323               replace_list = g_slist_prepend (replace_list, GUINT_TO_POINTER (ag_entry->accel_path_quark));
 324           }
 325       }
 326  break_loop_step5:
 327
 328   /* 6) check whether we can remove existing accelerators */
 329   if (removable && can_change)
 330     for (slist = replace_list; slist; slist = slist->next)
 331       if (!internal_change_entry (g_quark_to_string (GPOINTER_TO_UINT (slist->data)), 0, 0, FALSE, TRUE))
 332         {
 333           removable = FALSE;
 334           break;
 335         }
 336
 337   /* 7) check conditions and proceed if possible */
 338   change_accel = can_change && (!seen_accel || (removable && replace));
 339
 340   if (change_accel && !simulate)
 341     {
 342       guint old_accel_key, old_accel_mods;
 343
 344       /* ref accel groups */
 345       for (slist = group_list; slist; slist = slist->next)
 346         g_object_ref (slist->data);
 347
 348       /* 8) remove existing accelerators */
 349       for (slist = replace_list; slist; slist = slist->next)
 350         internal_change_entry (g_quark_to_string (GPOINTER_TO_UINT (slist->data)), 0, 0, FALSE, FALSE);
 351
 352       /* 9) install new accelerator */
 353       old_accel_key = entry->accel_key;
 354       old_accel_mods = entry->accel_mods;
 355       entry->accel_key = accel_key;
 356       entry->accel_mods = accel_mods;
 357       entry->changed = TRUE;
 358       for (slist = group_list; slist; slist = slist->next)
 359         _gtk_accel_group_reconnect (slist->data, g_quark_from_string (entry->accel_path));
 360
 361       /* unref accel groups */
 362       for (slist = group_list; slist; slist = slist->next)
 363         g_object_unref (slist->data);
 364     }
 365   g_slist_free (replace_list);
 366   g_slist_free (group_list);
 367   g_slist_free (win_list);
 368
 369   return change_accel;
 370 }
 371
 372 /**
 373  * gtk_accel_map_change_entry
 374  * @accel_path:  valid accelerator path
 375  * @accel_key:   new accelerator key
 376  * @accel_mods:  new accelerator modifiers
 377  * @replace:     %TRUE if other accelerators may be deleted upon conflicts
 378  * @returns:     %TRUE if the accelerator could be changed, %FALSE otherwise
 379  *
 380  * Change the @accel_key and @accel_mods currently associated with @accel_path.
 381  * Due to conflicts with other accelerators, a change may not alwys be possible,
 382  * @replace indicates whether other accelerators may be deleted to resolve such
 383  * conflicts. A change will only occur if all conflicts could be resolved (which
 384  * might not be the case if conflicting accelerators are locked). Succesful
 385  * changes are indicated by a %TRUE return value.
 386  */
 387 gboolean
 388 gtk_accel_map_change_entry (const gchar    *accel_path,
 389                             guint           accel_key,
 390                             GdkModifierType accel_mods,
 391                             gboolean        replace)
 392 {
 393   g_return_val_if_fail (_gtk_accel_path_is_valid (accel_path), FALSE);
 394
 395   return internal_change_entry (accel_path, accel_key, accel_key ? accel_mods : 0, replace, FALSE);
 396 }
 397
 398 static guint
 399 accel_map_parse_accel_path (GScanner *scanner)
 400 {
 401   guint accel_key = 0, accel_mods = 0;
 402   gchar *path, *accel;
 403
 404   /* parse accel path */
 405   g_scanner_get_next_token (scanner);
 406   if (scanner->token != G_TOKEN_STRING)
 407     return G_TOKEN_STRING;
 408
 409   /* test if the next token is an accelerator */
 410   g_scanner_peek_next_token (scanner);
 411   if (scanner->next_token != G_TOKEN_STRING)
 412     {
 413       /* if not so, eat that token and error out */
 414       g_scanner_get_next_token (scanner);
 415       return G_TOKEN_STRING;
 416     }
 417
 418   /* get the full accelerator specification */
 419   path = g_strdup (scanner->value.v_string);
 420   g_scanner_get_next_token (scanner);
 421   accel = g_strdup (scanner->value.v_string);
 422
 423   /* ensure the entry is present */
 424   gtk_accel_map_add_entry (path, 0, 0);
 425
 426   /* and propagate it */
 427   gtk_accelerator_parse (accel, &accel_key, &accel_mods);
 428   gtk_accel_map_change_entry (path, accel_key, accel_mods, TRUE);
 429
 430   g_free (accel);
 431   g_free (path);
 432
 433   /* check correct statement end */
 434   g_scanner_get_next_token (scanner);
 435   if (scanner->token != ')')
 436     return ')';
 437   else
 438     return G_TOKEN_NONE;
 439 }
 440
 441 static void
 442 accel_map_parse_statement (GScanner *scanner)
 443 {
 444   guint expected_token;
 445
 446   g_scanner_get_next_token (scanner);
 447
 448   if (scanner->token == G_TOKEN_SYMBOL)
 449     {
 450       guint (*parser_func) (GScanner*);
 451
 452       parser_func = scanner->value.v_symbol;
 453
 454       expected_token = parser_func (scanner);
 455     }
 456   else
 457     expected_token = G_TOKEN_SYMBOL;
 458
 459   /* skip rest of statement on errrors
 460    */
 461   if (expected_token != G_TOKEN_NONE)
 462     {
 463       register guint level;
 464
 465       level = 1;
 466       if (scanner->token == ')')
 467         level--;
 468       if (scanner->token == '(')
 469         level++;
 470
 471       while (!g_scanner_eof (scanner) && level > 0)
 472         {
 473           g_scanner_get_next_token (scanner);
 474
 475           if (scanner->token == '(')
 476             level++;
 477           else if (scanner->token == ')')
 478             level--;
 479         }
 480     }
 481 }
 482
 483 void
 484 gtk_accel_map_load_scanner (GScanner *scanner)
 485 {
 486   gboolean skip_comment_single;
 487   gboolean symbol_2_token;
 488   gchar *cpair_comment_single;
 489   gpointer saved_symbol;
 490
 491   g_return_if_fail (scanner != 0);
 492
 493   /* configure scanner */
 494   skip_comment_single = scanner->config->skip_comment_single;
 495   scanner->config->skip_comment_single = TRUE;
 496   cpair_comment_single = scanner->config->cpair_comment_single;
 497   scanner->config->cpair_comment_single = ";\n";
 498   symbol_2_token = scanner->config->symbol_2_token;
 499   scanner->config->symbol_2_token = FALSE;
 500   saved_symbol = g_scanner_lookup_symbol (scanner, "gtk_accel_path");
 501   g_scanner_scope_add_symbol (scanner, 0, "gtk_accel_path", accel_map_parse_accel_path);
 502
 503   /* outer parsing loop
 504    */
 505   g_scanner_peek_next_token (scanner);
 506   while (scanner->next_token == '(')
 507     {
 508       g_scanner_get_next_token (scanner);
 509
 510       accel_map_parse_statement (scanner);
 511
 512       g_scanner_peek_next_token (scanner);
 513     }
 514
 515   /* restore config */
 516   scanner->config->skip_comment_single = skip_comment_single;
 517   scanner->config->cpair_comment_single = cpair_comment_single;
 518   scanner->config->symbol_2_token = symbol_2_token;
 519   g_scanner_scope_remove_symbol (scanner, 0, "gtk_accel_path");
 520   if (saved_symbol)
 521     g_scanner_scope_add_symbol (scanner, 0, "gtk_accel_path", saved_symbol);
 522 }
 523
 524 /**
 525  * gtk_accel_map_load_fd
 526  * @fd: valid readable file descriptor
 527  *
 528  * Filedescriptor variant of gtk_accel_map_load().
 529  * Note that the file descriptor will not be closed by this function.
 530  */
 531 void
 532 gtk_accel_map_load_fd (gint fd)
 533 {
 534   GScanner *scanner;
 535
 536   g_return_if_fail (fd >= 0);
 537
 538   /* create and setup scanner */
 539   scanner = g_scanner_new (NULL);
 540   g_scanner_input_file (scanner, fd);
 541
 542   gtk_accel_map_load_scanner (scanner);
 543
 544   g_scanner_destroy (scanner);
 545 }
 546
 547 /**
 548  * gtk_accel_map_load
 549  * @file_name: a file containing accelerator specifications
 550  *
 551  * Parses a file previously saved with gtk_accel_map_save() for
 552  * accelerator specifications, and propagates them accordingly.
 553  */
 554 void
 555 gtk_accel_map_load (const gchar *file_name)
 556 {
 557   gint fd;
 558
 559   g_return_if_fail (file_name != NULL);
 560
 561   if (!g_file_test (file_name, G_FILE_TEST_IS_REGULAR))
 562     return;
 563
 564   fd = open (file_name, O_RDONLY);
 565   if (fd < 0)
 566     return;
 567
 568   gtk_accel_map_load_fd (fd);
 569
 570   close (fd);
 571 }
 572
 573 static void
 574 accel_map_print (gpointer        data,
 575                  const gchar    *accel_path,
 576                  guint           accel_key,
 577                  guint           accel_mods,
 578                  gboolean        changed)
 579 {
 580   GString *gstring = g_string_new (changed ? NULL : "; ");
 581   gint err, fd = GPOINTER_TO_INT (data);
 582   gchar *tmp, *name;
 583
 584   g_string_append (gstring, "(gtk_accel_path \"");
 585
 586   tmp = g_strescape (accel_path, NULL);
 587   g_string_append (gstring, tmp);
 588   g_free (tmp);
 589
 590   g_string_append (gstring, "\" \"");
 591
 592   name = gtk_accelerator_name (accel_key, accel_mods);
 593   tmp = g_strescape (name, NULL);
 594   g_free (name);
 595   g_string_append (gstring, tmp);
 596   g_free (tmp);
 597
 598   g_string_append (gstring, "\")\n");
 599
 600   do
 601     err = write (fd, gstring->str, gstring->len);
 602   while (err < 0 && errno == EINTR);
 603
 604   g_string_free (gstring, TRUE);
 605 }
 606
 607 /**
 608  * gtk_accel_map_save_fd
 609  * @fd: valid writable file descriptor
 610  *
 611  * Filedescriptor variant of gtk_accel_map_save().
 612  * Note that the file descriptor will not be closed by this function.
 613  */
 614 void
 615 gtk_accel_map_save_fd (gint fd)
 616 {
 617   GString *gstring;
 618   gint err;
 619
 620   g_return_if_fail (fd >= 0);
 621
 622   gstring = g_string_new ("; ");
 623   if (g_get_prgname ())
 624     g_string_append (gstring, g_get_prgname ());
 625   g_string_append (gstring, " GtkAccelMap rc-file         -*- scheme -*-\n");
 626   g_string_append (gstring, "; this file is an automated accelerator map dump\n");
 627   g_string_append (gstring, ";\n");
 628
 629   do
 630     err = write (fd, gstring->str, gstring->len);
 631   while (err < 0 && errno == EINTR);
 632
 633   gtk_accel_map_foreach (GINT_TO_POINTER (fd), accel_map_print);
 634 }
 635
 636 /**
 637  * gtk_accel_map_save
 638  * @file_name: the file to contain accelerator specifications
 639  *
 640  * Saves current accelerator specifications (accelerator path, key
 641  * and modifiers) to @file_name.
 642  * The file is written in a format suitable to be read back in by
 643  * gtk_accel_map_load().
 644  */
 645 void
 646 gtk_accel_map_save (const gchar *file_name)
 647 {
 648   gint fd;
 649
 650   g_return_if_fail (file_name != NULL);
 651
 652   fd = open (file_name, O_CREAT | O_TRUNC | O_WRONLY, 0644);
 653   if (fd < 0)
 654     return;
 655
 656   gtk_accel_map_save_fd (fd);
 657
 658   close (fd);
 659 }
 660
 661 /**
 662  * gtk_accel_map_foreach
 663  * @data:         data to be passed into @foreach_func
 664  * @foreach_func: function to be executed for each accel map entry
 665  *
 666  * Loop over the entries in the accelerator map, and execute
 667  * @foreach_func on each. The signature of @foreach_func is that of
 668  * #GtkAccelMapForeach, the @changed parameter indicates whether
 669  * this accelerator was changed during runtime (thus, would need
 670  * saving during an accelerator map dump).
 671  */
 672 void
 673 gtk_accel_map_foreach (gpointer           data,
 674                        GtkAccelMapForeach foreach_func)
 675 {
 676   GSList *entries, *slist, *node;
 677
 678   g_return_if_fail (foreach_func != NULL);
 679
 680   entries = g_hash_table_slist_values (accel_entry_ht);
 681   for (slist = entries; slist; slist = slist->next)
 682     {
 683       AccelEntry *entry = slist->data;
 684       gboolean changed = entry->accel_key != entry->std_accel_key || entry->accel_mods != entry->std_accel_mods;
 685
 686       for (node = accel_filters; node; node = node->next)
 687         if (g_pattern_match_string (node->data, entry->accel_path))
 688           goto skip_accel;
 689       foreach_func (data, entry->accel_path, entry->accel_key, entry->accel_mods, changed);
 690     skip_accel:
 691       /* noop */;
 692     }
 693   g_slist_free (entries);
 694 }
 695
 696 void
 697 gtk_accel_map_foreach_unfiltered (gpointer           data,
 698                                   GtkAccelMapForeach foreach_func)
 699 {
 700   GSList *entries, *slist;
 701
 702   g_return_if_fail (foreach_func != NULL);
 703
 704   entries = g_hash_table_slist_values (accel_entry_ht);
 705   for (slist = entries; slist; slist = slist->next)
 706     {
 707       AccelEntry *entry = slist->data;
 708       gboolean changed = entry->accel_key != entry->std_accel_key || entry->accel_mods != entry->std_accel_mods;
 709
 710       foreach_func (data, entry->accel_path, entry->accel_key, entry->accel_mods, changed);
 711     }
 712   g_slist_free (entries);
 713 }
 714
 715 void
 716 gtk_accel_map_add_filter (const gchar *filter_pattern)
 717 {
 718   GPatternSpec *pspec;
 719   GSList *slist;
 720
 721   g_return_if_fail (filter_pattern != NULL);
 722
 723   pspec = g_pattern_spec_new (filter_pattern);
 724   for (slist = accel_filters; slist; slist = slist->next)
 725     if (g_pattern_spec_equal (pspec, slist->data))
 726       {
 727         g_pattern_spec_free (pspec);
 728         return;
 729       }
 730   accel_filters = g_slist_prepend (accel_filters, pspec);
 731 }
 732
 733 void
 734 _gtk_accel_map_add_group (const gchar   *accel_path,
 735                           GtkAccelGroup *accel_group)
 736 {
 737   AccelEntry *entry;
 738
 739   g_return_if_fail (_gtk_accel_path_is_valid (accel_path));
 740   g_return_if_fail (GTK_IS_ACCEL_GROUP (accel_group));
 741
 742   entry = accel_path_lookup (accel_path);
 743   if (!entry)
 744     {
 745       gtk_accel_map_add_entry (accel_path, 0, 0);
 746       entry = accel_path_lookup (accel_path);
 747     }
 748   entry->groups = g_slist_prepend (entry->groups, accel_group);
 749 }
 750
 751 void
 752 _gtk_accel_map_remove_group (const gchar   *accel_path,
 753                              GtkAccelGroup *accel_group)
 754 {
 755   AccelEntry *entry;
 756
 757   entry = accel_path_lookup (accel_path);
 758   g_return_if_fail (entry != NULL);
 759   g_return_if_fail (g_slist_find (entry->groups, accel_group));
 760
 761   entry->groups = g_slist_remove (entry->groups, accel_group);
 762 }