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, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "config.h"
  19
  20 #include "gtkaccelmapprivate.h"
  21
  22 #include "gtkmarshalers.h"
  23 #include "gtkwindowprivate.h"
  24 #include "gtkintl.h"
  25
  26 #include <glib/gstdio.h>
  27
  28 #include <string.h>
  29 #include <errno.h>
  30 #include <fcntl.h>
  31 #ifdef HAVE_UNISTD_H
  32 #include <unistd.h>
  33 #endif
  34 #ifdef G_OS_WIN32
  35 #include <io.h>
  36 #endif
  37
  38
  39 /**
  40  * SECTION:gtkaccelmap
  41  * @Short_description: Loadable keyboard accelerator specifications
  42  * @Title: Accelerator Maps
  43  * @See_also: #GtkAccelGroup, #GtkAccelKey, #GtkUIManager, gtk_widget_set_accel_path(), gtk_menu_item_set_accel_path(), #GtkSettings:gtk-can-change-accels
  44  *
  45  * Accelerator maps are used to define runtime configurable accelerators.
  46  * Functions for manipulating them are are usually used by higher level
  47  * convenience mechanisms like #GtkUIManager and are thus considered
  48  * "low-level". You'll want to use them if you're manually creating menus that
  49  * should have user-configurable accelerators.
  50  *
  51  * Accelerator is uniquely defined by:
  52  *
  53  * <itemizedlist>
  54  *   <listitem><para>accelerator path</para></listitem>
  55  *   <listitem><para>accelerator key</para></listitem>
  56  *   <listitem><para>accelerator modifiers</para></listitem>
  57  * </itemizedlist>
  58  *
  59  * The accelerator path must consist of
  60  * "&lt;WINDOWTYPE&gt;/Category1/Category2/.../Action", where WINDOWTYPE
  61  * should be a unique application-specific identifier that corresponds to the
  62  * kind of window the accelerator is being used in, e.g. "Gimp-Image",
  63  * "Abiword-Document" or "Gnumeric-Settings".
  64  * The "Category1/.../Action" portion is most appropriately chosen by the action
  65  * the accelerator triggers, i.e. for accelerators on menu items, choose the
  66  * item's menu path, e.g. "File/Save As", "Image/View/Zoom" or
  67  * "Edit/Select All". So a full valid accelerator path may look like:
  68  * "&lt;Gimp-Toolbox&gt;/File/Dialogs/Tool Options...".
  69  *
  70  * All accelerators are stored inside one global #GtkAccelMap that can be
  71  * obtained using gtk_accel_map_get(). See <link
  72  * linkend="monitoring-changes">Monitoring changes</link> for additional
  73  * details.
  74  *
  75  * <refsect2 id="manipulating-accelerators">
  76  * <title>Manipulating accelerators</title>
  77  * <para>
  78  * New accelerators can be added using gtk_accel_map_add_entry(). To search for
  79  * specific accelerator, use gtk_accel_map_lookup_entry(). Modifications of
  80  * existing accelerators should be done using gtk_accel_map_change_entry().
  81  *
  82  * In order to avoid having some accelerators changed, they can be locked using
  83  * gtk_accel_map_lock_path(). Unlocking is done using
  84  * gtk_accel_map_unlock_path().
  85  * </para>
  86  * </refsect2>
  87  * <refsect2 id="saving-and-loading">
  88  * <title>Saving and loading accelerator maps</title>
  89  * <para>
  90  * Accelerator maps can be saved to and loaded from some external resource. For
  91  * simple saving and loading from file, gtk_accel_map_save() and
  92  * gtk_accel_map_load() are provided. Saving and loading can also be done by
  93  * providing file descriptor to gtk_accel_map_save_fd() and
  94  * gtk_accel_map_load_fd().
  95  * </para>
  96  * </refsect2>
  97  * <refsect2 id="monitoring-changes">
  98  * <title>Monitoring changes</title>
  99  * <para>
 100  * #GtkAccelMap object is only useful for monitoring changes of accelerators. By
 101  * connecting to #GtkAccelMap::changed signal, one can monitor changes of all
 102  * accelerators. It is also possible to monitor only single accelerator path by
 103  * using it as a detail of the #GtkAccelMap::changed signal.
 104  * </para>
 105  * </refsect2>
 106  */
 107
 108
 109 /* --- structures --- */
 110 struct _GtkAccelMap
 111 {
 112   GObject parent_instance;
 113 };
 114
 115 struct _GtkAccelMapClass
 116 {
 117   GObjectClass parent_class;
 118 };
 119
 120 typedef struct {
 121   const gchar *accel_path;
 122   guint        accel_key;
 123   guint        accel_mods;
 124   guint        std_accel_key;
 125   guint        std_accel_mods;
 126   guint        changed    :  1;
 127   guint        lock_count : 15;
 128   GSList      *groups;
 129 } AccelEntry;
 130
 131 /* --- signals --- */
 132 enum {
 133   CHANGED,
 134   LAST_SIGNAL
 135 };
 136
 137 /* --- variables --- */
 138
 139 static GHashTable  *accel_entry_ht = NULL;      /* accel_path -> AccelEntry */
 140 static GSList      *accel_filters = NULL;
 141 static gulong       accel_map_signals[LAST_SIGNAL] = { 0, };
 142 static GtkAccelMap *accel_map;
 143
 144 /* --- prototypes --- */
 145 static void do_accel_map_changed (AccelEntry *entry);
 146
 147 /* --- functions --- */
 148 static guint
 149 accel_entry_hash (gconstpointer key)
 150 {
 151   const AccelEntry *entry = key;
 152
 153   return g_str_hash (entry->accel_path);
 154 }
 155
 156 static gboolean
 157 accel_entry_equal (gconstpointer key1,
 158                    gconstpointer key2)
 159 {
 160   const AccelEntry *entry1 = key1;
 161   const AccelEntry *entry2 = key2;
 162
 163   return g_str_equal (entry1->accel_path, entry2->accel_path);
 164 }
 165
 166 static inline AccelEntry*
 167 accel_path_lookup (const gchar *accel_path)
 168 {
 169   AccelEntry ekey;
 170
 171   ekey.accel_path = accel_path;
 172
 173   /* safety NULL check for return_if_fail()s */
 174   return accel_path ? g_hash_table_lookup (accel_entry_ht, &ekey) : NULL;
 175 }
 176
 177 void
 178 _gtk_accel_map_init (void)
 179 {
 180   if (accel_entry_ht == NULL)
 181     accel_entry_ht = g_hash_table_new (accel_entry_hash, accel_entry_equal);
 182 }
 183
 184 gboolean
 185 _gtk_accel_path_is_valid (const gchar *accel_path)
 186 {
 187   gchar *p;
 188
 189   if (!accel_path || accel_path[0] != '<' ||
 190       accel_path[1] == '<' || accel_path[1] == '>' || !accel_path[1])
 191     return FALSE;
 192   p = strchr (accel_path, '>');
 193   if (!p || (p[1] != 0 && p[1] != '/'))
 194     return FALSE;
 195   return TRUE;
 196 }
 197
 198 /**
 199  * gtk_accel_map_add_entry:
 200  * @accel_path: valid accelerator path
 201  * @accel_key:  the accelerator key
 202  * @accel_mods: the accelerator modifiers
 203  *
 204  * Registers a new accelerator with the global accelerator map.
 205  * This function should only be called once per @accel_path
 206  * with the canonical @accel_key and @accel_mods for this path.
 207  * To change the accelerator during runtime programatically, use
 208  * gtk_accel_map_change_entry().
 209  *
 210  * Set @accel_key and @accel_mods to 0 to request a removal of
 211  * the accelerator.
 212  *
 213  * Note that @accel_path string will be stored in a #GQuark. Therefore, if you
 214  * pass a static string, you can save some memory by interning it first with
 215  * g_intern_static_string().
 216  */
 217 void
 218 gtk_accel_map_add_entry (const gchar    *accel_path,
 219                          guint           accel_key,
 220                          GdkModifierType accel_mods)
 221 {
 222   AccelEntry *entry;
 223
 224   g_return_if_fail (_gtk_accel_path_is_valid (accel_path));
 225
 226   if (!accel_key)
 227     accel_mods = 0;
 228   else
 229     accel_mods &= gtk_accelerator_get_default_mod_mask ();
 230
 231   entry = accel_path_lookup (accel_path);
 232   if (entry)
 233     {
 234       if (!entry->std_accel_key && !entry->std_accel_mods &&
 235           (accel_key || accel_mods))
 236         {
 237           entry->std_accel_key = accel_key;
 238           entry->std_accel_mods = accel_mods;
 239           if (!entry->changed)
 240             gtk_accel_map_change_entry (entry->accel_path, accel_key, accel_mods, TRUE);
 241         }
 242     }
 243   else
 244     {
 245       entry = g_slice_new0 (AccelEntry);
 246       entry->accel_path = g_intern_string (accel_path);
 247       entry->std_accel_key = accel_key;
 248       entry->std_accel_mods = accel_mods;
 249       entry->accel_key = accel_key;
 250       entry->accel_mods = accel_mods;
 251       entry->changed = FALSE;
 252       entry->lock_count = 0;
 253       g_hash_table_insert (accel_entry_ht, entry, entry);
 254
 255       do_accel_map_changed (entry);
 256     }
 257 }
 258
 259 /**
 260  * gtk_accel_map_lookup_entry:
 261  * @accel_path: a valid accelerator path
 262  * @key: (allow-none) (out): the accelerator key to be filled in (optional)
 263  *
 264  * Looks up the accelerator entry for @accel_path and fills in @key.
 265  *
 266  * Returns: %TRUE if @accel_path is known, %FALSE otherwise
 267  */
 268 gboolean
 269 gtk_accel_map_lookup_entry (const gchar *accel_path,
 270                             GtkAccelKey *key)
 271 {
 272   AccelEntry *entry;
 273
 274   g_return_val_if_fail (_gtk_accel_path_is_valid (accel_path), FALSE);
 275
 276   entry = accel_path_lookup (accel_path);
 277   if (entry && key)
 278     {
 279       key->accel_key = entry->accel_key;
 280       key->accel_mods = entry->accel_mods;
 281       key->accel_flags = 0;
 282     }
 283
 284   return entry ? TRUE : FALSE;
 285 }
 286
 287 static void
 288 hash2slist_foreach (gpointer  key,
 289                     gpointer  value,
 290                     gpointer  user_data)
 291 {
 292   GSList **slist_p = user_data;
 293
 294   *slist_p = g_slist_prepend (*slist_p, value);
 295 }
 296
 297 static GSList*
 298 g_hash_table_slist_values (GHashTable *hash_table)
 299 {
 300   GSList *slist = NULL;
 301
 302   g_return_val_if_fail (hash_table != NULL, NULL);
 303
 304   g_hash_table_foreach (hash_table, hash2slist_foreach, &slist);
 305
 306   return slist;
 307 }
 308
 309 /* if simulate==TRUE, return whether accel_path can be changed to
 310  * accel_key && accel_mods. otherwise, return whether accel_path
 311  * was actually changed.
 312  */
 313 static gboolean
 314 internal_change_entry (const gchar    *accel_path,
 315                        guint           accel_key,
 316                        GdkModifierType accel_mods,
 317                        gboolean        replace,
 318                        gboolean        simulate)
 319 {
 320   GSList *node, *slist, *win_list, *group_list, *replace_list = NULL;
 321   GHashTable *group_hm, *window_hm;
 322   gboolean change_accel, removable, can_change = TRUE, seen_accel = FALSE;
 323   GQuark entry_quark;
 324   AccelEntry *entry = accel_path_lookup (accel_path);
 325
 326   /* not much todo if there's no entry yet */
 327   if (!entry)
 328     {
 329       if (!simulate)
 330         {
 331           gtk_accel_map_add_entry (accel_path, 0, 0);
 332           entry = accel_path_lookup (accel_path);
 333           entry->accel_key = accel_key;
 334           entry->accel_mods = accel_mods;
 335           entry->changed = TRUE;
 336
 337           do_accel_map_changed (entry);
 338         }
 339       return TRUE;
 340     }
 341
 342   /* if there's nothing to change, not much todo either */
 343   if (entry->accel_key == accel_key && entry->accel_mods == accel_mods)
 344     {
 345       if (!simulate)
 346         entry->changed = TRUE;
 347       return simulate ? TRUE : FALSE;
 348     }
 349
 350   /* The no-change case has already been handled, so
 351    * simulate doesn't make a difference here.
 352    */
 353   if (entry->lock_count > 0)
 354     return FALSE;
 355
 356   /* nobody's interested, easy going */
 357   if (!entry->groups)
 358     {
 359       if (!simulate)
 360         {
 361           entry->accel_key = accel_key;
 362           entry->accel_mods = accel_mods;
 363           entry->changed = TRUE;
 364
 365           do_accel_map_changed (entry);
 366         }
 367       return TRUE;
 368     }
 369
 370   /* 1) fetch all accel groups affected by this entry */
 371   entry_quark = g_quark_try_string (entry->accel_path);
 372   group_hm = g_hash_table_new (NULL, NULL);
 373   window_hm = g_hash_table_new (NULL, NULL);
 374   for (slist = entry->groups; slist; slist = slist->next)
 375     g_hash_table_insert (group_hm, slist->data, slist->data);
 376
 377   /* 2) collect acceleratables affected */
 378   group_list = g_hash_table_slist_values (group_hm);
 379   for (slist = group_list; slist; slist = slist->next)
 380     {
 381       GtkAccelGroup *group = slist->data;
 382
 383       for (node = _gtk_accel_group_get_accelerables (group); node; node = node->next)
 384         g_hash_table_insert (window_hm, node->data, node->data);
 385     }
 386   g_slist_free (group_list);
 387
 388   /* 3) include all accel groups used by acceleratables */
 389   win_list = g_hash_table_slist_values (window_hm);
 390   g_hash_table_destroy (window_hm);
 391   for (slist = win_list; slist; slist = slist->next)
 392     for (node = gtk_accel_groups_from_object (slist->data); node; node = node->next)
 393       g_hash_table_insert (group_hm, node->data, node->data);
 394   group_list = g_hash_table_slist_values (group_hm);
 395   g_hash_table_destroy (group_hm);
 396
 397   /* 4) walk the acceleratables and figure whether they occupy accel_key&accel_mods */
 398   if (accel_key)
 399     for (slist = win_list; slist; slist = slist->next)
 400       if (GTK_IS_WINDOW (slist->data))  /* bad kludge in lack of a GtkAcceleratable */
 401         if (_gtk_window_query_nonaccels (slist->data, accel_key, accel_mods))
 402           {
 403             seen_accel = TRUE;
 404             break;
 405           }
 406   removable = !seen_accel;
 407
 408   /* 5) walk all accel groups and search for locks */
 409   if (removable)
 410     for (slist = group_list; slist; slist = slist->next)
 411       {
 412         GtkAccelGroup *group = slist->data;
 413         GtkAccelGroupEntry *ag_entry;
 414         guint i, n;
 415
 416         n = 0;
 417         ag_entry = entry->accel_key ? gtk_accel_group_query (group, entry->accel_key, entry->accel_mods, &n) : NULL;
 418         for (i = 0; i < n; i++)
 419           if (ag_entry[i].accel_path_quark == entry_quark)
 420             {
 421               can_change = !(ag_entry[i].key.accel_flags & GTK_ACCEL_LOCKED);
 422               if (!can_change)
 423                 goto break_loop_step5;
 424             }
 425
 426         n = 0;
 427         ag_entry = accel_key ? gtk_accel_group_query (group, accel_key, accel_mods, &n) : NULL;
 428         for (i = 0; i < n; i++)
 429           {
 430             seen_accel = TRUE;
 431             removable = !gtk_accel_group_get_is_locked (group) && !(ag_entry[i].key.accel_flags & GTK_ACCEL_LOCKED);
 432             if (!removable)
 433               goto break_loop_step5;
 434             if (ag_entry[i].accel_path_quark)
 435               replace_list = g_slist_prepend (replace_list, GUINT_TO_POINTER (ag_entry[i].accel_path_quark));
 436           }
 437       }
 438  break_loop_step5:
 439
 440   /* 6) check whether we can remove existing accelerators */
 441   if (removable && can_change)
 442     for (slist = replace_list; slist; slist = slist->next)
 443       if (!internal_change_entry (g_quark_to_string (GPOINTER_TO_UINT (slist->data)), 0, 0, FALSE, TRUE))
 444         {
 445           removable = FALSE;
 446           break;
 447         }
 448
 449   /* 7) check conditions and proceed if possible */
 450   change_accel = can_change && (!seen_accel || (removable && replace));
 451
 452   if (change_accel && !simulate)
 453     {
 454       /* ref accel groups */
 455       for (slist = group_list; slist; slist = slist->next)
 456         g_object_ref (slist->data);
 457
 458       /* 8) remove existing accelerators */
 459       for (slist = replace_list; slist; slist = slist->next)
 460         internal_change_entry (g_quark_to_string (GPOINTER_TO_UINT (slist->data)), 0, 0, FALSE, FALSE);
 461
 462       /* 9) install new accelerator */
 463       entry->accel_key = accel_key;
 464       entry->accel_mods = accel_mods;
 465       entry->changed = TRUE;
 466
 467       for (slist = group_list; slist; slist = slist->next)
 468         _gtk_accel_group_reconnect (slist->data, g_quark_from_string (entry->accel_path));
 469
 470       /* unref accel groups */
 471       for (slist = group_list; slist; slist = slist->next)
 472         g_object_unref (slist->data);
 473
 474       do_accel_map_changed (entry);
 475     }
 476   g_slist_free (replace_list);
 477   g_slist_free (group_list);
 478   g_slist_free (win_list);
 479
 480   return change_accel;
 481 }
 482
 483 /**
 484  * gtk_accel_map_change_entry:
 485  * @accel_path:  a valid accelerator path
 486  * @accel_key:   the new accelerator key
 487  * @accel_mods:  the new accelerator modifiers
 488  * @replace:     %TRUE if other accelerators may be deleted upon conflicts
 489  *
 490  * Changes the @accel_key and @accel_mods currently associated with @accel_path.
 491  * Due to conflicts with other accelerators, a change may not always be possible,
 492  * @replace indicates whether other accelerators may be deleted to resolve such
 493  * conflicts. A change will only occur if all conflicts could be resolved (which
 494  * might not be the case if conflicting accelerators are locked). Successful
 495  * changes are indicated by a %TRUE return value.
 496  *
 497  * Note that @accel_path string will be stored in a #GQuark. Therefore, if you
 498  * pass a static string, you can save some memory by interning it first with
 499  * g_intern_static_string().
 500  *
 501  * Returns: %TRUE if the accelerator could be changed, %FALSE otherwise
 502  */
 503 gboolean
 504 gtk_accel_map_change_entry (const gchar    *accel_path,
 505                             guint           accel_key,
 506                             GdkModifierType accel_mods,
 507                             gboolean        replace)
 508 {
 509   g_return_val_if_fail (_gtk_accel_path_is_valid (accel_path), FALSE);
 510
 511   return internal_change_entry (accel_path, accel_key, accel_key ? accel_mods : 0, replace, FALSE);
 512 }
 513
 514 static guint
 515 accel_map_parse_accel_path (GScanner *scanner)
 516 {
 517   guint accel_key = 0;
 518   GdkModifierType accel_mods = 0;
 519   gchar *path, *accel;
 520
 521   /* parse accel path */
 522   g_scanner_get_next_token (scanner);
 523   if (scanner->token != G_TOKEN_STRING)
 524     return G_TOKEN_STRING;
 525
 526   /* test if the next token is an accelerator */
 527   g_scanner_peek_next_token (scanner);
 528   if (scanner->next_token != G_TOKEN_STRING)
 529     {
 530       /* if not so, eat that token and error out */
 531       g_scanner_get_next_token (scanner);
 532       return G_TOKEN_STRING;
 533     }
 534
 535   /* get the full accelerator specification */
 536   path = g_strdup (scanner->value.v_string);
 537   g_scanner_get_next_token (scanner);
 538   accel = g_strdup (scanner->value.v_string);
 539
 540   /* ensure the entry is present */
 541   gtk_accel_map_add_entry (path, 0, 0);
 542
 543   /* and propagate it */
 544   gtk_accelerator_parse (accel, &accel_key, &accel_mods);
 545   gtk_accel_map_change_entry (path, accel_key, accel_mods, TRUE);
 546
 547   g_free (accel);
 548   g_free (path);
 549
 550   /* check correct statement end */
 551   g_scanner_get_next_token (scanner);
 552   if (scanner->token != ')')
 553     return ')';
 554   else
 555     return G_TOKEN_NONE;
 556 }
 557
 558 static void
 559 accel_map_parse_statement (GScanner *scanner)
 560 {
 561   guint expected_token;
 562
 563   g_scanner_get_next_token (scanner);
 564
 565   if (scanner->token == G_TOKEN_SYMBOL)
 566     {
 567       guint (*parser_func) (GScanner*);
 568
 569       parser_func = (guint (*) (GScanner *))scanner->value.v_symbol;
 570
 571       expected_token = parser_func (scanner);
 572     }
 573   else
 574     expected_token = G_TOKEN_SYMBOL;
 575
 576   /* skip rest of statement on errrors
 577    */
 578   if (expected_token != G_TOKEN_NONE)
 579     {
 580       register guint level;
 581
 582       level = 1;
 583       if (scanner->token == ')')
 584         level--;
 585       if (scanner->token == '(')
 586         level++;
 587
 588       while (!g_scanner_eof (scanner) && level > 0)
 589         {
 590           g_scanner_get_next_token (scanner);
 591
 592           if (scanner->token == '(')
 593             level++;
 594           else if (scanner->token == ')')
 595             level--;
 596         }
 597     }
 598 }
 599
 600 /**
 601  * gtk_accel_map_load_scanner:
 602  * @scanner: a #GScanner which has already been provided with an input file
 603  *
 604  * #GScanner variant of gtk_accel_map_load().
 605  */
 606 void
 607 gtk_accel_map_load_scanner (GScanner *scanner)
 608 {
 609   gboolean skip_comment_single;
 610   gboolean symbol_2_token;
 611   gchar *cpair_comment_single;
 612   gpointer saved_symbol;
 613
 614   g_return_if_fail (scanner != NULL);
 615
 616   /* configure scanner */
 617   skip_comment_single = scanner->config->skip_comment_single;
 618   scanner->config->skip_comment_single = TRUE;
 619   cpair_comment_single = scanner->config->cpair_comment_single;
 620   scanner->config->cpair_comment_single = ";\n";
 621   symbol_2_token = scanner->config->symbol_2_token;
 622   scanner->config->symbol_2_token = FALSE;
 623   saved_symbol = g_scanner_lookup_symbol (scanner, "gtk_accel_path");
 624   g_scanner_scope_add_symbol (scanner, 0, "gtk_accel_path",
 625                               accel_map_parse_accel_path);
 626
 627   /* outer parsing loop
 628    */
 629   g_scanner_peek_next_token (scanner);
 630   while (scanner->next_token == '(')
 631     {
 632       g_scanner_get_next_token (scanner);
 633
 634       accel_map_parse_statement (scanner);
 635
 636       g_scanner_peek_next_token (scanner);
 637     }
 638
 639   /* restore config */
 640   scanner->config->skip_comment_single = skip_comment_single;
 641   scanner->config->cpair_comment_single = cpair_comment_single;
 642   scanner->config->symbol_2_token = symbol_2_token;
 643   g_scanner_scope_remove_symbol (scanner, 0, "gtk_accel_path");
 644   if (saved_symbol)
 645     g_scanner_scope_add_symbol (scanner, 0, "gtk_accel_path", saved_symbol);
 646 }
 647
 648 /**
 649  * gtk_accel_map_load_fd:
 650  * @fd: a valid readable file descriptor
 651  *
 652  * Filedescriptor variant of gtk_accel_map_load().
 653  *
 654  * Note that the file descriptor will not be closed by this function.
 655  */
 656 void
 657 gtk_accel_map_load_fd (gint fd)
 658 {
 659   GScanner *scanner;
 660
 661   g_return_if_fail (fd >= 0);
 662
 663   /* create and setup scanner */
 664   scanner = g_scanner_new (NULL);
 665   g_scanner_input_file (scanner, fd);
 666
 667   gtk_accel_map_load_scanner (scanner);
 668
 669   g_scanner_destroy (scanner);
 670 }
 671
 672 /**
 673  * gtk_accel_map_load:
 674  * @file_name: (type filename): a file containing accelerator specifications,
 675  *   in the GLib file name encoding
 676  *
 677  * Parses a file previously saved with gtk_accel_map_save() for
 678  * accelerator specifications, and propagates them accordingly.
 679  */
 680 void
 681 gtk_accel_map_load (const gchar *file_name)
 682 {
 683   gint fd;
 684
 685   g_return_if_fail (file_name != NULL);
 686
 687   if (!g_file_test (file_name, G_FILE_TEST_IS_REGULAR))
 688     return;
 689
 690   fd = g_open (file_name, O_RDONLY, 0);
 691   if (fd < 0)
 692     return;
 693
 694   gtk_accel_map_load_fd (fd);
 695
 696   close (fd);
 697 }
 698
 699 static gboolean
 700 write_all (gint   fd,
 701            gchar *buf,
 702            gsize  to_write)
 703 {
 704   while (to_write > 0)
 705     {
 706       gssize count = write (fd, buf, to_write);
 707       if (count < 0)
 708         {
 709           if (errno != EINTR)
 710             return FALSE;
 711         }
 712       else
 713         {
 714           to_write -= count;
 715           buf += count;
 716         }
 717     }
 718
 719   return TRUE;
 720 }
 721
 722 static void
 723 accel_map_print (gpointer        data,
 724                  const gchar    *accel_path,
 725                  guint           accel_key,
 726                  GdkModifierType accel_mods,
 727                  gboolean        changed)
 728 {
 729   GString *gstring = g_string_new (changed ? NULL : "; ");
 730   gint fd = GPOINTER_TO_INT (data);
 731   gchar *tmp, *name;
 732
 733   g_string_append (gstring, "(gtk_accel_path \"");
 734
 735   tmp = g_strescape (accel_path, NULL);
 736   g_string_append (gstring, tmp);
 737   g_free (tmp);
 738
 739   g_string_append (gstring, "\" \"");
 740
 741   name = gtk_accelerator_name (accel_key, accel_mods);
 742   tmp = g_strescape (name, NULL);
 743   g_free (name);
 744   g_string_append (gstring, tmp);
 745   g_free (tmp);
 746
 747   g_string_append (gstring, "\")\n");
 748
 749   write_all (fd, gstring->str, gstring->len);
 750
 751   g_string_free (gstring, TRUE);
 752 }
 753
 754 /**
 755  * gtk_accel_map_save_fd:
 756  * @fd: a valid writable file descriptor
 757  *
 758  * Filedescriptor variant of gtk_accel_map_save().
 759  *
 760  * Note that the file descriptor will not be closed by this function.
 761  */
 762 void
 763 gtk_accel_map_save_fd (gint fd)
 764 {
 765   GString *gstring;
 766
 767   g_return_if_fail (fd >= 0);
 768
 769   gstring = g_string_new ("; ");
 770   if (g_get_prgname ())
 771     g_string_append (gstring, g_get_prgname ());
 772   g_string_append (gstring, " GtkAccelMap rc-file         -*- scheme -*-\n");
 773   g_string_append (gstring, "; this file is an automated accelerator map dump\n");
 774   g_string_append (gstring, ";\n");
 775
 776   write_all (fd, gstring->str, gstring->len);
 777
 778   g_string_free (gstring, TRUE);
 779
 780   gtk_accel_map_foreach (GINT_TO_POINTER (fd), accel_map_print);
 781 }
 782
 783 /**
 784  * gtk_accel_map_save:
 785  * @file_name: (type filename): the name of the file to contain
 786  *   accelerator specifications, in the GLib file name encoding
 787  *
 788  * Saves current accelerator specifications (accelerator path, key
 789  * and modifiers) to @file_name.
 790  * The file is written in a format suitable to be read back in by
 791  * gtk_accel_map_load().
 792  */
 793 void
 794 gtk_accel_map_save (const gchar *file_name)
 795 {
 796   gint fd;
 797
 798   g_return_if_fail (file_name != NULL);
 799
 800   fd = g_open (file_name, O_CREAT | O_TRUNC | O_WRONLY, 0644);
 801   if (fd < 0)
 802     return;
 803
 804   gtk_accel_map_save_fd (fd);
 805
 806   close (fd);
 807 }
 808
 809 /**
 810  * gtk_accel_map_foreach:
 811  * @data: (allow-none): data to be passed into @foreach_func
 812  * @foreach_func: (scope call): function to be executed for each accel
 813  *                map entry which is not filtered out
 814  *
 815  * Loops over the entries in the accelerator map whose accel path
 816  * doesn't match any of the filters added with gtk_accel_map_add_filter(),
 817  * and execute @foreach_func on each. The signature of @foreach_func is
 818  * that of #GtkAccelMapForeach, the @changed parameter indicates whether
 819  * this accelerator was changed during runtime (thus, would need
 820  * saving during an accelerator map dump).
 821  */
 822 void
 823 gtk_accel_map_foreach (gpointer           data,
 824                        GtkAccelMapForeach foreach_func)
 825 {
 826   GSList *entries, *slist, *node;
 827
 828   g_return_if_fail (foreach_func != NULL);
 829
 830   entries = g_hash_table_slist_values (accel_entry_ht);
 831   for (slist = entries; slist; slist = slist->next)
 832     {
 833       AccelEntry *entry = slist->data;
 834       gboolean changed = entry->accel_key != entry->std_accel_key || entry->accel_mods != entry->std_accel_mods;
 835
 836       for (node = accel_filters; node; node = node->next)
 837         if (g_pattern_match_string (node->data, entry->accel_path))
 838           goto skip_accel;
 839       foreach_func (data, entry->accel_path, entry->accel_key, entry->accel_mods, changed);
 840     skip_accel:
 841       /* noop */;
 842     }
 843   g_slist_free (entries);
 844 }
 845
 846 /**
 847  * gtk_accel_map_foreach_unfiltered:
 848  * @data:         data to be passed into @foreach_func
 849  * @foreach_func: (scope call): function to be executed for each accel
 850  *                map entry
 851  *
 852  * Loops over all entries in the accelerator map, and execute
 853  * @foreach_func on each. The signature of @foreach_func is that of
 854  * #GtkAccelMapForeach, the @changed parameter indicates whether
 855  * this accelerator was changed during runtime (thus, would need
 856  * saving during an accelerator map dump).
 857  */
 858 void
 859 gtk_accel_map_foreach_unfiltered (gpointer           data,
 860                                   GtkAccelMapForeach foreach_func)
 861 {
 862   GSList *entries, *slist;
 863
 864   g_return_if_fail (foreach_func != NULL);
 865
 866   entries = g_hash_table_slist_values (accel_entry_ht);
 867   for (slist = entries; slist; slist = slist->next)
 868     {
 869       AccelEntry *entry = slist->data;
 870       gboolean changed = entry->accel_key != entry->std_accel_key || entry->accel_mods != entry->std_accel_mods;
 871
 872       foreach_func (data, entry->accel_path, entry->accel_key, entry->accel_mods, changed);
 873     }
 874   g_slist_free (entries);
 875 }
 876
 877 /**
 878  * gtk_accel_map_add_filter:
 879  * @filter_pattern: a pattern (see #GPatternSpec)
 880  *
 881  * Adds a filter to the global list of accel path filters.
 882  *
 883  * Accel map entries whose accel path matches one of the filters
 884  * are skipped by gtk_accel_map_foreach().
 885  *
 886  * This function is intended for GTK+ modules that create their own
 887  * menus, but don't want them to be saved into the applications accelerator
 888  * map dump.
 889  */
 890 void
 891 gtk_accel_map_add_filter (const gchar *filter_pattern)
 892 {
 893   GPatternSpec *pspec;
 894   GSList *slist;
 895
 896   g_return_if_fail (filter_pattern != NULL);
 897
 898   pspec = g_pattern_spec_new (filter_pattern);
 899   for (slist = accel_filters; slist; slist = slist->next)
 900     if (g_pattern_spec_equal (pspec, slist->data))
 901       {
 902         g_pattern_spec_free (pspec);
 903         return;
 904       }
 905   accel_filters = g_slist_prepend (accel_filters, pspec);
 906 }
 907
 908 void
 909 _gtk_accel_map_add_group (const gchar   *accel_path,
 910                           GtkAccelGroup *accel_group)
 911 {
 912   AccelEntry *entry;
 913
 914   g_return_if_fail (_gtk_accel_path_is_valid (accel_path));
 915   g_return_if_fail (GTK_IS_ACCEL_GROUP (accel_group));
 916
 917   entry = accel_path_lookup (accel_path);
 918   if (!entry)
 919     {
 920       gtk_accel_map_add_entry (accel_path, 0, 0);
 921       entry = accel_path_lookup (accel_path);
 922     }
 923   entry->groups = g_slist_prepend (entry->groups, accel_group);
 924 }
 925
 926 void
 927 _gtk_accel_map_remove_group (const gchar   *accel_path,
 928                              GtkAccelGroup *accel_group)
 929 {
 930   AccelEntry *entry;
 931
 932   entry = accel_path_lookup (accel_path);
 933   g_return_if_fail (entry != NULL);
 934   g_return_if_fail (g_slist_find (entry->groups, accel_group));
 935
 936   entry->groups = g_slist_remove (entry->groups, accel_group);
 937 }
 938
 939
 940 /**
 941  * gtk_accel_map_lock_path:
 942  * @accel_path: a valid accelerator path
 943  *
 944  * Locks the given accelerator path. If the accelerator map doesn't yet contain
 945  * an entry for @accel_path, a new one is created.
 946  *
 947  * Locking an accelerator path prevents its accelerator from being changed
 948  * during runtime. A locked accelerator path can be unlocked by
 949  * gtk_accel_map_unlock_path(). Refer to gtk_accel_map_change_entry()
 950  * for information about runtime accelerator changes.
 951  *
 952  * If called more than once, @accel_path remains locked until
 953  * gtk_accel_map_unlock_path() has been called an equivalent number
 954  * of times.
 955  *
 956  * Note that locking of individual accelerator paths is independent from
 957  * locking the #GtkAccelGroup containing them. For runtime accelerator
 958  * changes to be possible, both the accelerator path and its #GtkAccelGroup
 959  * have to be unlocked.
 960  *
 961  * Since: 2.4
 962  **/
 963 void
 964 gtk_accel_map_lock_path (const gchar *accel_path)
 965 {
 966   AccelEntry *entry;
 967
 968   g_return_if_fail (_gtk_accel_path_is_valid (accel_path));
 969
 970   entry = accel_path_lookup (accel_path);
 971
 972   if (!entry)
 973     {
 974       gtk_accel_map_add_entry (accel_path, 0, 0);
 975       entry = accel_path_lookup (accel_path);
 976     }
 977
 978   entry->lock_count += 1;
 979 }
 980
 981 /**
 982  * gtk_accel_map_unlock_path:
 983  * @accel_path: a valid accelerator path
 984  *
 985  * Undoes the last call to gtk_accel_map_lock_path() on this @accel_path.
 986  * Refer to gtk_accel_map_lock_path() for information about accelerator path locking.
 987  *
 988  * Since: 2.4
 989  **/
 990 void
 991 gtk_accel_map_unlock_path (const gchar *accel_path)
 992 {
 993   AccelEntry *entry;
 994
 995   g_return_if_fail (_gtk_accel_path_is_valid (accel_path));
 996
 997   entry = accel_path_lookup (accel_path);
 998
 999   g_return_if_fail (entry != NULL && entry->lock_count > 0);
1000
1001   entry->lock_count -= 1;
1002 }
1003
1004 G_DEFINE_TYPE (GtkAccelMap, gtk_accel_map, G_TYPE_OBJECT)
1005
1006 static void
1007 gtk_accel_map_class_init (GtkAccelMapClass *accel_map_class)
1008 {
1009   /**
1010    * GtkAccelMap::changed:
1011    * @object: the global accel map object
1012    * @accel_path: the path of the accelerator that changed
1013    * @accel_key: the key value for the new accelerator
1014    * @accel_mods: the modifier mask for the new accelerator
1015    *
1016    * Notifies of a change in the global accelerator map.
1017    * The path is also used as the detail for the signal,
1018    * so it is possible to connect to
1019    * changed::<replaceable>accel_path</replaceable>.
1020    *
1021    * Since: 2.4
1022    */
1023   accel_map_signals[CHANGED] = g_signal_new (I_("changed"),
1024                                              G_TYPE_FROM_CLASS (accel_map_class),
1025                                              G_SIGNAL_DETAILED|G_SIGNAL_RUN_LAST,
1026                                              0,
1027                                              NULL, NULL,
1028                                              _gtk_marshal_VOID__STRING_UINT_FLAGS,
1029                                              G_TYPE_NONE, 3,
1030                                              G_TYPE_STRING, G_TYPE_UINT, GDK_TYPE_MODIFIER_TYPE);
1031 }
1032
1033 static void
1034 gtk_accel_map_init (GtkAccelMap *accel_map)
1035 {
1036 }
1037
1038 /**
1039  * gtk_accel_map_get:
1040  *
1041  * Gets the singleton global #GtkAccelMap object. This object
1042  * is useful only for notification of changes to the accelerator
1043  * map via the ::changed signal; it isn't a parameter to the
1044  * other accelerator map functions.
1045  *
1046  * Return value: (transfer none): the global #GtkAccelMap object
1047  *
1048  * Since: 2.4
1049  **/
1050 GtkAccelMap *
1051 gtk_accel_map_get (void)
1052 {
1053   if (!accel_map)
1054     accel_map = g_object_new (GTK_TYPE_ACCEL_MAP, NULL);
1055
1056   return accel_map;
1057 }
1058
1059 static void
1060 do_accel_map_changed (AccelEntry *entry)
1061 {
1062   if (accel_map)
1063     g_signal_emit (accel_map,
1064                    accel_map_signals[CHANGED],
1065                    g_quark_from_string (entry->accel_path),
1066                    entry->accel_path,
1067                    entry->accel_key,
1068                    entry->accel_mods);
1069 }
1070
1071 gchar *
1072 _gtk_accel_path_for_action (const gchar *action_name,
1073                             GVariant    *parameter)
1074 {
1075   GString *s;
1076
1077   s = g_string_new ("<GAction>/");
1078   g_string_append (s, action_name);
1079   if (parameter)
1080     {
1081       g_string_append_c (s, '/');
1082       g_variant_print_string (parameter, s, FALSE);
1083     }
1084   return g_string_free (s, FALSE);
1085 }
1086