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  * Lookup the accelerator entry for @accel_path and fill in @key.
 173  * If the lookup revealed no results, (0) is returned, the entry's
 174  * #GQuark otherwise.
 175  */
 176 gboolean
 177 gtk_accel_map_lookup_entry (const gchar *accel_path,
 178                             GtkAccelKey *key)
 179 {
 180   AccelEntry *entry;
 181
 182   g_return_val_if_fail (_gtk_accel_path_is_valid (accel_path), FALSE);
 183
 184   entry = accel_path_lookup (accel_path);
 185   if (entry && key)
 186     {
 187       key->accel_key = entry->accel_key;
 188       key->accel_mods = entry->accel_mods;
 189       key->accel_flags = 0;
 190     }
 191
 192   return entry ? TRUE : FALSE;
 193 }
 194
 195 static void
 196 hash2slist_foreach (gpointer  key,
 197                     gpointer  value,
 198                     gpointer  user_data)
 199 {
 200   GSList **slist_p = user_data;
 201
 202   *slist_p = g_slist_prepend (*slist_p, value);
 203 }
 204
 205 static GSList*
 206 g_hash_table_slist_values (GHashTable *hash_table)
 207 {
 208   GSList *slist = NULL;
 209
 210   g_return_val_if_fail (hash_table != NULL, NULL);
 211
 212   g_hash_table_foreach (hash_table, hash2slist_foreach, &slist);
 213
 214   return slist;
 215 }
 216
 217 static gboolean
 218 internal_change_entry (const gchar    *accel_path,
 219                        guint           accel_key,
 220                        GdkModifierType accel_mods,
 221                        gboolean        replace,
 222                        gboolean        simulate)
 223 {
 224   GSList *node, *slist, *win_list, *group_list, *replace_list = NULL;
 225   GHashTable *group_hm, *win_hm;
 226   gboolean change_accel, removable, can_change = TRUE, seen_accel = FALSE;
 227   GQuark entry_quark;
 228   AccelEntry *entry = accel_path_lookup (accel_path);
 229
 230   /* not much todo if there's no entry yet */
 231   if (!entry)
 232     {
 233       if (!simulate)
 234         {
 235           gtk_accel_map_add_entry (accel_path, 0, 0);
 236           entry = accel_path_lookup (accel_path);
 237           entry->accel_key = accel_key;
 238           entry->accel_mods = accel_mods;
 239           entry->changed = TRUE;
 240         }
 241       return TRUE;
 242     }
 243
 244   /* if there's nothing to change, not much todo either */
 245   if (entry->accel_key == accel_key && entry->accel_mods == accel_mods)
 246     return FALSE;
 247
 248   /* nobody's interested, easy going */
 249   if (!entry->groups)
 250     {
 251       if (!simulate)
 252         {
 253           entry->accel_key = accel_key;
 254           entry->accel_mods = accel_mods;
 255           entry->changed = TRUE;
 256         }
 257       return TRUE;
 258     }
 259
 260   /* 1) fetch all accel groups affected by this entry */
 261   entry_quark = g_quark_try_string (entry->accel_path);
 262   group_hm = g_hash_table_new (NULL, NULL);
 263   win_hm = g_hash_table_new (NULL, NULL);
 264   for (slist = entry->groups; slist; slist = slist->next)
 265     g_hash_table_insert (group_hm, slist->data, slist->data);
 266
 267   /* 2) collect acceleratables affected */
 268   group_list = g_hash_table_slist_values (group_hm);
 269   for (slist = group_list; slist; slist = slist->next)
 270     {
 271       GtkAccelGroup *group = slist->data;
 272
 273       for (node = group->acceleratables; node; node = node->next)
 274         g_hash_table_insert (win_hm, node->data, node->data);
 275     }
 276   g_slist_free (group_list);
 277
 278   /* 3) include all accel groups used by acceleratables */
 279   win_list = g_hash_table_slist_values (win_hm);
 280   g_hash_table_destroy (win_hm);
 281   for (slist = win_list; slist; slist = slist->next)
 282     for (node = gtk_accel_groups_from_acceleratable (slist->data); node; node = node->next)
 283       g_hash_table_insert (group_hm, node->data, node->data);
 284   group_list = g_hash_table_slist_values (group_hm);
 285   g_hash_table_destroy (group_hm);
 286
 287   /* 4) walk the acceleratables and figure whether they occupy accel_key&accel_mods */
 288   if (accel_key)
 289     for (slist = win_list; slist; slist = slist->next)
 290       if (GTK_IS_WINDOW (slist->data))  /* bad kludge in lack of a GtkAcceleratable */
 291         if (_gtk_window_query_nonaccels (slist->data, accel_key, accel_mods))
 292           {
 293             seen_accel = TRUE;
 294             break;
 295           }
 296   removable = !seen_accel;
 297
 298   /* 5) walk all accel groups and search for locks */
 299   if (removable)
 300     for (slist = group_list; slist; slist = slist->next)
 301       {
 302         GtkAccelGroup *group = slist->data;
 303         GtkAccelGroupEntry *ag_entry;
 304         guint i, n;
 305
 306         n = 0;
 307         ag_entry = entry->accel_key ? gtk_accel_group_query (group, entry->accel_key, entry->accel_mods, &n) : NULL;
 308         for (i = 0; i < n; i++)
 309           if (ag_entry[i].accel_path_quark == entry_quark)
 310             {
 311               can_change = !(ag_entry[i].key.accel_flags & GTK_ACCEL_LOCKED);
 312               if (!can_change)
 313                 goto break_loop_step5;
 314             }
 315
 316         n = 0;
 317         ag_entry = accel_key ? gtk_accel_group_query (group, accel_key, accel_mods, &n) : NULL;
 318         for (i = 0; i < n; i++)
 319           {
 320             seen_accel = TRUE;
 321             removable = !group->lock_count && !(ag_entry[i].key.accel_flags & GTK_ACCEL_LOCKED);
 322             if (!removable)
 323               goto break_loop_step5;
 324             if (ag_entry[i].accel_path_quark)
 325               replace_list = g_slist_prepend (replace_list, GUINT_TO_POINTER (ag_entry->accel_path_quark));
 326           }
 327       }
 328  break_loop_step5:
 329
 330   /* 6) check whether we can remove existing accelerators */
 331   if (removable && can_change)
 332     for (slist = replace_list; slist; slist = slist->next)
 333       if (!internal_change_entry (g_quark_to_string (GPOINTER_TO_UINT (slist->data)), 0, 0, FALSE, TRUE))
 334         {
 335           removable = FALSE;
 336           break;
 337         }
 338
 339   /* 7) check conditions and proceed if possible */
 340   change_accel = can_change && (!seen_accel || (removable && replace));
 341
 342   if (change_accel && !simulate)
 343     {
 344       guint old_accel_key, old_accel_mods;
 345
 346       /* ref accel groups */
 347       for (slist = group_list; slist; slist = slist->next)
 348         g_object_ref (slist->data);
 349
 350       /* 8) remove existing accelerators */
 351       for (slist = replace_list; slist; slist = slist->next)
 352         internal_change_entry (g_quark_to_string (GPOINTER_TO_UINT (slist->data)), 0, 0, FALSE, FALSE);
 353
 354       /* 9) install new accelerator */
 355       old_accel_key = entry->accel_key;
 356       old_accel_mods = entry->accel_mods;
 357       entry->accel_key = accel_key;
 358       entry->accel_mods = accel_mods;
 359       entry->changed = TRUE;
 360       for (slist = group_list; slist; slist = slist->next)
 361         _gtk_accel_group_reconnect (slist->data, g_quark_from_string (entry->accel_path));
 362
 363       /* unref accel groups */
 364       for (slist = group_list; slist; slist = slist->next)
 365         g_object_unref (slist->data);
 366     }
 367   g_slist_free (replace_list);
 368   g_slist_free (group_list);
 369   g_slist_free (win_list);
 370
 371   return change_accel;
 372 }
 373
 374 /**
 375  * gtk_accel_map_change_entry
 376  * @accel_path:  valid accelerator path
 377  * @accel_key:   new accelerator key
 378  * @accel_mods:  new accelerator modifiers
 379  * @replace:     %TRUE if other accelerators may be deleted upon conflicts
 380  * @returns:     %TRUE if the accelerator could be changed, %FALSE otherwise
 381  *
 382  * Change the @accel_key and @accel_mods currently associated with @accel_path.
 383  * Due to conflicts with other accelerators, a change may not alwys be possible,
 384  * @replace indicates whether other accelerators may be deleted to resolve such
 385  * conflicts. A change will only occur if all conflicts could be resolved (which
 386  * might not be the case if conflicting accelerators are locked). Succesful
 387  * changes are indicated by a %TRUE return value.
 388  */
 389 gboolean
 390 gtk_accel_map_change_entry (const gchar    *accel_path,
 391                             guint           accel_key,
 392                             GdkModifierType accel_mods,
 393                             gboolean        replace)
 394 {
 395   g_return_val_if_fail (_gtk_accel_path_is_valid (accel_path), FALSE);
 396
 397   return internal_change_entry (accel_path, accel_key, accel_key ? accel_mods : 0, replace, FALSE);
 398 }
 399
 400 static guint
 401 accel_map_parse_accel_path (GScanner *scanner)
 402 {
 403   guint accel_key = 0, accel_mods = 0;
 404   gchar *path, *accel;
 405
 406   /* parse accel path */
 407   g_scanner_get_next_token (scanner);
 408   if (scanner->token != G_TOKEN_STRING)
 409     return G_TOKEN_STRING;
 410
 411   /* test if the next token is an accelerator */
 412   g_scanner_peek_next_token (scanner);
 413   if (scanner->next_token != G_TOKEN_STRING)
 414     {
 415       /* if not so, eat that token and error out */
 416       g_scanner_get_next_token (scanner);
 417       return G_TOKEN_STRING;
 418     }
 419
 420   /* get the full accelerator specification */
 421   path = g_strdup (scanner->value.v_string);
 422   g_scanner_get_next_token (scanner);
 423   accel = g_strdup (scanner->value.v_string);
 424
 425   /* ensure the entry is present */
 426   gtk_accel_map_add_entry (path, 0, 0);
 427
 428   /* and propagate it */
 429   gtk_accelerator_parse (accel, &accel_key, &accel_mods);
 430   gtk_accel_map_change_entry (path, accel_key, accel_mods, TRUE);
 431
 432   g_free (accel);
 433   g_free (path);
 434
 435   /* check correct statement end */
 436   g_scanner_get_next_token (scanner);
 437   if (scanner->token != ')')
 438     return ')';
 439   else
 440     return G_TOKEN_NONE;
 441 }
 442
 443 static void
 444 accel_map_parse_statement (GScanner *scanner)
 445 {
 446   guint expected_token;
 447
 448   g_scanner_get_next_token (scanner);
 449
 450   if (scanner->token == G_TOKEN_SYMBOL)
 451     {
 452       guint (*parser_func) (GScanner*);
 453
 454       parser_func = scanner->value.v_symbol;
 455
 456       expected_token = parser_func (scanner);
 457     }
 458   else
 459     expected_token = G_TOKEN_SYMBOL;
 460
 461   /* skip rest of statement on errrors
 462    */
 463   if (expected_token != G_TOKEN_NONE)
 464     {
 465       register guint level;
 466
 467       level = 1;
 468       if (scanner->token == ')')
 469         level--;
 470       if (scanner->token == '(')
 471         level++;
 472
 473       while (!g_scanner_eof (scanner) && level > 0)
 474         {
 475           g_scanner_get_next_token (scanner);
 476
 477           if (scanner->token == '(')
 478             level++;
 479           else if (scanner->token == ')')
 480             level--;
 481         }
 482     }
 483 }
 484
 485 void
 486 gtk_accel_map_load_scanner (GScanner *scanner)
 487 {
 488   gboolean skip_comment_single;
 489   gboolean symbol_2_token;
 490   gchar *cpair_comment_single;
 491   gpointer saved_symbol;
 492
 493   g_return_if_fail (scanner != 0);
 494
 495   /* configure scanner */
 496   skip_comment_single = scanner->config->skip_comment_single;
 497   scanner->config->skip_comment_single = TRUE;
 498   cpair_comment_single = scanner->config->cpair_comment_single;
 499   scanner->config->cpair_comment_single = ";\n";
 500   symbol_2_token = scanner->config->symbol_2_token;
 501   scanner->config->symbol_2_token = FALSE;
 502   saved_symbol = g_scanner_lookup_symbol (scanner, "gtk_accel_path");
 503   g_scanner_scope_add_symbol (scanner, 0, "gtk_accel_path", accel_map_parse_accel_path);
 504
 505   /* outer parsing loop
 506    */
 507   g_scanner_peek_next_token (scanner);
 508   while (scanner->next_token == '(')
 509     {
 510       g_scanner_get_next_token (scanner);
 511
 512       accel_map_parse_statement (scanner);
 513
 514       g_scanner_peek_next_token (scanner);
 515     }
 516
 517   /* restore config */
 518   scanner->config->skip_comment_single = skip_comment_single;
 519   scanner->config->cpair_comment_single = cpair_comment_single;
 520   scanner->config->symbol_2_token = symbol_2_token;
 521   g_scanner_scope_remove_symbol (scanner, 0, "gtk_accel_path");
 522   if (saved_symbol)
 523     g_scanner_scope_add_symbol (scanner, 0, "gtk_accel_path", saved_symbol);
 524 }
 525
 526 /**
 527  * gtk_accel_map_load_fd
 528  * @fd: valid readable file descriptor
 529  *
 530  * Filedescriptor variant of gtk_accel_map_load().
 531  * Note that the file descriptor will not be closed by this function.
 532  */
 533 void
 534 gtk_accel_map_load_fd (gint fd)
 535 {
 536   GScanner *scanner;
 537
 538   g_return_if_fail (fd >= 0);
 539
 540   /* create and setup scanner */
 541   scanner = g_scanner_new (NULL);
 542   g_scanner_input_file (scanner, fd);
 543
 544   gtk_accel_map_load_scanner (scanner);
 545
 546   g_scanner_destroy (scanner);
 547 }
 548
 549 /**
 550  * gtk_accel_map_load
 551  * @file_name: a file containing accelerator specifications
 552  *
 553  * Parses a file previously saved with gtk_accel_map_save() for
 554  * accelerator specifications, and propagates them accordingly.
 555  */
 556 void
 557 gtk_accel_map_load (const gchar *file_name)
 558 {
 559   gint fd;
 560
 561   g_return_if_fail (file_name != NULL);
 562
 563   if (!g_file_test (file_name, G_FILE_TEST_IS_REGULAR))
 564     return;
 565
 566   fd = open (file_name, O_RDONLY);
 567   if (fd < 0)
 568     return;
 569
 570   gtk_accel_map_load_fd (fd);
 571
 572   close (fd);
 573 }
 574
 575 static void
 576 accel_map_print (gpointer        data,
 577                  const gchar    *accel_path,
 578                  guint           accel_key,
 579                  guint           accel_mods,
 580                  gboolean        changed)
 581 {
 582   GString *gstring = g_string_new (changed ? NULL : "; ");
 583   gint err, fd = GPOINTER_TO_INT (data);
 584   gchar *tmp, *name;
 585
 586   g_string_append (gstring, "(gtk_accel_path \"");
 587
 588   tmp = g_strescape (accel_path, NULL);
 589   g_string_append (gstring, tmp);
 590   g_free (tmp);
 591
 592   g_string_append (gstring, "\" \"");
 593
 594   name = gtk_accelerator_name (accel_key, accel_mods);
 595   tmp = g_strescape (name, NULL);
 596   g_free (name);
 597   g_string_append (gstring, tmp);
 598   g_free (tmp);
 599
 600   g_string_append (gstring, "\")\n");
 601
 602   do
 603     err = write (fd, gstring->str, gstring->len);
 604   while (err < 0 && errno == EINTR);
 605
 606   g_string_free (gstring, TRUE);
 607 }
 608
 609 /**
 610  * gtk_accel_map_save_fd
 611  * @fd: valid writable file descriptor
 612  *
 613  * Filedescriptor variant of gtk_accel_map_save().
 614  * Note that the file descriptor will not be closed by this function.
 615  */
 616 void
 617 gtk_accel_map_save_fd (gint fd)
 618 {
 619   GString *gstring;
 620   gint err;
 621
 622   g_return_if_fail (fd >= 0);
 623
 624   gstring = g_string_new ("; ");
 625   if (g_get_prgname ())
 626     g_string_append (gstring, g_get_prgname ());
 627   g_string_append (gstring, " GtkAccelMap rc-file         -*- scheme -*-\n");
 628   g_string_append (gstring, "; this file is an automated accelerator map dump\n");
 629   g_string_append (gstring, ";\n");
 630
 631   do
 632     err = write (fd, gstring->str, gstring->len);
 633   while (err < 0 && errno == EINTR);
 634
 635   gtk_accel_map_foreach (GINT_TO_POINTER (fd), accel_map_print);
 636 }
 637
 638 /**
 639  * gtk_accel_map_save
 640  * @file_name: the file to contain accelerator specifications
 641  *
 642  * Saves current accelerator specifications (accelerator path, key
 643  * and modifiers) to @file_name.
 644  * The file is written in a format suitable to be read back in by
 645  * gtk_accel_map_load().
 646  */
 647 void
 648 gtk_accel_map_save (const gchar *file_name)
 649 {
 650   gint fd;
 651
 652   g_return_if_fail (file_name != NULL);
 653
 654   fd = open (file_name, O_CREAT | O_TRUNC | O_WRONLY, 0644);
 655   if (fd < 0)
 656     return;
 657
 658   gtk_accel_map_save_fd (fd);
 659
 660   close (fd);
 661 }
 662
 663 /**
 664  * gtk_accel_map_foreach
 665  * @data:         data to be passed into @foreach_func
 666  * @foreach_func: function to be executed for each accel map entry
 667  *
 668  * Loop over the entries in the accelerator map, and execute
 669  * @foreach_func on each. The signature of @foreach_func is that of
 670  * #GtkAccelMapForeach, the @changed parameter indicates whether
 671  * this accelerator was changed during runtime (thus, would need
 672  * saving during an accelerator map dump).
 673  */
 674 void
 675 gtk_accel_map_foreach (gpointer           data,
 676                        GtkAccelMapForeach foreach_func)
 677 {
 678   GSList *entries, *slist, *node;
 679
 680   g_return_if_fail (foreach_func != NULL);
 681
 682   entries = g_hash_table_slist_values (accel_entry_ht);
 683   for (slist = entries; slist; slist = slist->next)
 684     {
 685       AccelEntry *entry = slist->data;
 686       gboolean changed = entry->accel_key != entry->std_accel_key || entry->accel_mods != entry->std_accel_mods;
 687
 688       for (node = accel_filters; node; node = node->next)
 689         if (g_pattern_match_string (node->data, entry->accel_path))
 690           goto skip_accel;
 691       foreach_func (data, entry->accel_path, entry->accel_key, entry->accel_mods, changed);
 692     skip_accel:
 693       /* noop */;
 694     }
 695   g_slist_free (entries);
 696 }
 697
 698 void
 699 gtk_accel_map_foreach_unfiltered (gpointer           data,
 700                                   GtkAccelMapForeach foreach_func)
 701 {
 702   GSList *entries, *slist;
 703
 704   g_return_if_fail (foreach_func != NULL);
 705
 706   entries = g_hash_table_slist_values (accel_entry_ht);
 707   for (slist = entries; slist; slist = slist->next)
 708     {
 709       AccelEntry *entry = slist->data;
 710       gboolean changed = entry->accel_key != entry->std_accel_key || entry->accel_mods != entry->std_accel_mods;
 711
 712       foreach_func (data, entry->accel_path, entry->accel_key, entry->accel_mods, changed);
 713     }
 714   g_slist_free (entries);
 715 }
 716
 717 void
 718 gtk_accel_map_add_filter (const gchar *filter_pattern)
 719 {
 720   GPatternSpec *pspec;
 721   GSList *slist;
 722
 723   g_return_if_fail (filter_pattern != NULL);
 724
 725   pspec = g_pattern_spec_new (filter_pattern);
 726   for (slist = accel_filters; slist; slist = slist->next)
 727     if (g_pattern_spec_equal (pspec, slist->data))
 728       {
 729         g_pattern_spec_free (pspec);
 730         return;
 731       }
 732   accel_filters = g_slist_prepend (accel_filters, pspec);
 733 }
 734
 735 void
 736 _gtk_accel_map_add_group (const gchar   *accel_path,
 737                           GtkAccelGroup *accel_group)
 738 {
 739   AccelEntry *entry;
 740
 741   g_return_if_fail (_gtk_accel_path_is_valid (accel_path));
 742   g_return_if_fail (GTK_IS_ACCEL_GROUP (accel_group));
 743
 744   entry = accel_path_lookup (accel_path);
 745   if (!entry)
 746     {
 747       gtk_accel_map_add_entry (accel_path, 0, 0);
 748       entry = accel_path_lookup (accel_path);
 749     }
 750   entry->groups = g_slist_prepend (entry->groups, accel_group);
 751 }
 752
 753 void
 754 _gtk_accel_map_remove_group (const gchar   *accel_path,
 755                              GtkAccelGroup *accel_group)
 756 {
 757   AccelEntry *entry;
 758
 759   entry = accel_path_lookup (accel_path);
 760   g_return_if_fail (entry != NULL);
 761   g_return_if_fail (g_slist_find (entry->groups, accel_group));
 762
 763   entry->groups = g_slist_remove (entry->groups, accel_group);
 764 }