/* GTK - The GIMP Toolkit * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald * * GtkAccelLabel: GtkLabel with accelerator monitoring facilities. * Copyright (C) 1998 Tim Janik * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ /* * Modified by the GTK+ Team and others 1997-2001. See the AUTHORS * file for a list of people on the GTK+ Team. See the ChangeLog * files for a list of changes. These files are distributed with * GTK+ at ftp://ftp.gtk.org/pub/gtk/. */ #include "config.h" #include #include "gtkaccellabel.h" #include "gtkaccelmap.h" #include "gtkmain.h" #include "gtkprivate.h" #include "gtkintl.h" #include "gtkalias.h" #include /** * SECTION:gtkaccellabel * @Short_description: A label which displays an accelerator key on the right of the text * @Title: GtkAccelLabel * @See_also: #GtkItemFactory, #GtkAccelGroup * * The #GtkAccelLabel widget is a subclass of #GtkLabel that also displays an * accelerator key on the right of the label text, e.g. 'Ctl+S'. * It is commonly used in menus to show the keyboard short-cuts for commands. * * The accelerator key to display is not set explicitly. * Instead, the #GtkAccelLabel displays the accelerators which have been added to * a particular widget. This widget is set by calling * gtk_accel_label_set_accel_widget(). * * For example, a #GtkMenuItem widget may have an accelerator added to emit the * "activate" signal when the 'Ctl+S' key combination is pressed. * A #GtkAccelLabel is created and added to the #GtkMenuItem, and * gtk_accel_label_set_accel_widget() is called with the #GtkMenuItem as the * second argument. The #GtkAccelLabel will now display 'Ctl+S' after its label. * * Note that creating a #GtkMenuItem with gtk_menu_item_new_with_label() (or * one of the similar functions for #GtkCheckMenuItem and #GtkRadioMenuItem) * automatically adds a #GtkAccelLabel to the #GtkMenuItem and calls * gtk_accel_label_set_accel_widget() to set it up for you. * * A #GtkAccelLabel will only display accelerators which have %GTK_ACCEL_VISIBLE * set (see #GtkAccelFlags). * A #GtkAccelLabel can display multiple accelerators and even signal names, * though it is almost always used to display just one accelerator key. * * Creating a simple menu item with an accelerator key. * * GtkWidget *save_item; * GtkAccelGroup *accel_group; * * /* Create a GtkAccelGroup and add it to the window. */ * accel_group = gtk_accel_group_new (); * gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); * * /* Create the menu item using the convenience function. */ * save_item = gtk_menu_item_new_with_label ("Save"); * gtk_widget_show (save_item); * gtk_container_add (GTK_CONTAINER (menu), save_item); * * /* Now add the accelerator to the GtkMenuItem. Note that since we called * gtk_menu_item_new_with_label() to create the GtkMenuItem the * GtkAccelLabel is automatically set up to display the GtkMenuItem * accelerators. We just need to make sure we use GTK_ACCEL_VISIBLE here. */ * gtk_widget_add_accelerator (save_item, "activate", accel_group, * GDK_s, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); * * */ enum { PROP_0, PROP_ACCEL_CLOSURE, PROP_ACCEL_WIDGET }; static void gtk_accel_label_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec); static void gtk_accel_label_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec); static void gtk_accel_label_destroy (GtkObject *object); static void gtk_accel_label_finalize (GObject *object); static void gtk_accel_label_size_request (GtkWidget *widget, GtkRequisition *requisition); static gboolean gtk_accel_label_expose_event (GtkWidget *widget, GdkEventExpose *event); static const gchar *gtk_accel_label_get_string (GtkAccelLabel *accel_label); G_DEFINE_TYPE (GtkAccelLabel, gtk_accel_label, GTK_TYPE_LABEL) static void gtk_accel_label_class_init (GtkAccelLabelClass *class) { GObjectClass *gobject_class = G_OBJECT_CLASS (class); GtkObjectClass *object_class = GTK_OBJECT_CLASS (class); GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class); gobject_class->finalize = gtk_accel_label_finalize; gobject_class->set_property = gtk_accel_label_set_property; gobject_class->get_property = gtk_accel_label_get_property; object_class->destroy = gtk_accel_label_destroy; widget_class->size_request = gtk_accel_label_size_request; widget_class->expose_event = gtk_accel_label_expose_event; class->signal_quote1 = g_strdup ("<:"); class->signal_quote2 = g_strdup (":>"); #ifndef GDK_WINDOWING_QUARTZ /* This is the text that should appear next to menu accelerators * that use the shift key. If the text on this key isn't typically * translated on keyboards used for your language, don't translate * this. */ class->mod_name_shift = g_strdup (C_("keyboard label", "Shift")); /* This is the text that should appear next to menu accelerators * that use the control key. If the text on this key isn't typically * translated on keyboards used for your language, don't translate * this. */ class->mod_name_control = g_strdup (C_("keyboard label", "Ctrl")); /* This is the text that should appear next to menu accelerators * that use the alt key. If the text on this key isn't typically * translated on keyboards used for your language, don't translate * this. */ class->mod_name_alt = g_strdup (C_("keyboard label", "Alt")); class->mod_separator = g_strdup ("+"); #else /* GDK_WINDOWING_QUARTZ */ /* U+21E7 UPWARDS WHITE ARROW */ class->mod_name_shift = g_strdup ("\xe2\x87\xa7"); /* U+2303 UP ARROWHEAD */ class->mod_name_control = g_strdup ("\xe2\x8c\x83"); /* U+2325 OPTION KEY */ class->mod_name_alt = g_strdup ("\xe2\x8c\xa5"); class->mod_separator = g_strdup (""); #endif /* GDK_WINDOWING_QUARTZ */ class->accel_seperator = g_strdup (" / "); class->latin1_to_char = TRUE; g_object_class_install_property (gobject_class, PROP_ACCEL_CLOSURE, g_param_spec_boxed ("accel-closure", P_("Accelerator Closure"), P_("The closure to be monitored for accelerator changes"), G_TYPE_CLOSURE, GTK_PARAM_READWRITE)); g_object_class_install_property (gobject_class, PROP_ACCEL_WIDGET, g_param_spec_object ("accel-widget", P_("Accelerator Widget"), P_("The widget to be monitored for accelerator changes"), GTK_TYPE_WIDGET, GTK_PARAM_READWRITE)); } static void gtk_accel_label_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GtkAccelLabel *accel_label; accel_label = GTK_ACCEL_LABEL (object); switch (prop_id) { case PROP_ACCEL_CLOSURE: gtk_accel_label_set_accel_closure (accel_label, g_value_get_boxed (value)); break; case PROP_ACCEL_WIDGET: gtk_accel_label_set_accel_widget (accel_label, g_value_get_object (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void gtk_accel_label_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { GtkAccelLabel *accel_label; accel_label = GTK_ACCEL_LABEL (object); switch (prop_id) { case PROP_ACCEL_CLOSURE: g_value_set_boxed (value, accel_label->accel_closure); break; case PROP_ACCEL_WIDGET: g_value_set_object (value, accel_label->accel_widget); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void gtk_accel_label_init (GtkAccelLabel *accel_label) { accel_label->accel_padding = 3; accel_label->accel_widget = NULL; accel_label->accel_closure = NULL; accel_label->accel_group = NULL; accel_label->accel_string = NULL; } /** * gtk_accel_label_new: * @string: the label string. Must be non-%NULL. * * Creates a new #GtkAccelLabel. * * Returns: a new #GtkAccelLabel. */ GtkWidget* gtk_accel_label_new (const gchar *string) { GtkAccelLabel *accel_label; g_return_val_if_fail (string != NULL, NULL); accel_label = g_object_new (GTK_TYPE_ACCEL_LABEL, NULL); gtk_label_set_text (GTK_LABEL (accel_label), string); return GTK_WIDGET (accel_label); } static void gtk_accel_label_destroy (GtkObject *object) { GtkAccelLabel *accel_label = GTK_ACCEL_LABEL (object); gtk_accel_label_set_accel_widget (accel_label, NULL); gtk_accel_label_set_accel_closure (accel_label, NULL); GTK_OBJECT_CLASS (gtk_accel_label_parent_class)->destroy (object); } static void gtk_accel_label_finalize (GObject *object) { GtkAccelLabel *accel_label = GTK_ACCEL_LABEL (object); g_free (accel_label->accel_string); G_OBJECT_CLASS (gtk_accel_label_parent_class)->finalize (object); } /** * gtk_accel_label_get_accel_widget: * @accel_label: a #GtkAccelLabel * * Fetches the widget monitored by this accelerator label. See * gtk_accel_label_set_accel_widget(). * * Returns: (transfer none): the object monitored by the accelerator label, or %NULL. **/ GtkWidget* gtk_accel_label_get_accel_widget (GtkAccelLabel *accel_label) { g_return_val_if_fail (GTK_IS_ACCEL_LABEL (accel_label), NULL); return accel_label->accel_widget; } /** * gtk_accel_label_get_accel_width: * @accel_label: a #GtkAccelLabel. * * Returns the width needed to display the accelerator key(s). * This is used by menus to align all of the #GtkMenuItem widgets, and shouldn't * be needed by applications. * * Returns: the width needed to display the accelerator key(s). */ guint gtk_accel_label_get_accel_width (GtkAccelLabel *accel_label) { g_return_val_if_fail (GTK_IS_ACCEL_LABEL (accel_label), 0); return (accel_label->accel_string_width + (accel_label->accel_string_width ? accel_label->accel_padding : 0)); } static void gtk_accel_label_size_request (GtkWidget *widget, GtkRequisition *requisition) { GtkAccelLabel *accel_label = GTK_ACCEL_LABEL (widget); PangoLayout *layout; gint width; GTK_WIDGET_CLASS (gtk_accel_label_parent_class)->size_request (widget, requisition); layout = gtk_widget_create_pango_layout (widget, gtk_accel_label_get_string (accel_label)); pango_layout_get_pixel_size (layout, &width, NULL); accel_label->accel_string_width = width; g_object_unref (layout); } static gint get_first_baseline (PangoLayout *layout) { PangoLayoutIter *iter; gint result; iter = pango_layout_get_iter (layout); result = pango_layout_iter_get_baseline (iter); pango_layout_iter_free (iter); return PANGO_PIXELS (result); } static gboolean gtk_accel_label_expose_event (GtkWidget *widget, GdkEventExpose *event) { GtkAccelLabel *accel_label = GTK_ACCEL_LABEL (widget); GtkMisc *misc = GTK_MISC (accel_label); GtkTextDirection direction; direction = gtk_widget_get_direction (widget); if (gtk_widget_is_drawable (widget)) { guint ac_width; ac_width = gtk_accel_label_get_accel_width (accel_label); if (widget->allocation.width >= widget->requisition.width + ac_width) { PangoLayout *label_layout; PangoLayout *accel_layout; GtkLabel *label = GTK_LABEL (widget); gint x; gint y; label_layout = gtk_label_get_layout (GTK_LABEL (accel_label)); if (direction == GTK_TEXT_DIR_RTL) widget->allocation.x += ac_width; widget->allocation.width -= ac_width; if (gtk_label_get_ellipsize (label)) pango_layout_set_width (label_layout, pango_layout_get_width (label_layout) - ac_width * PANGO_SCALE); if (GTK_WIDGET_CLASS (gtk_accel_label_parent_class)->expose_event) GTK_WIDGET_CLASS (gtk_accel_label_parent_class)->expose_event (widget, event); if (direction == GTK_TEXT_DIR_RTL) widget->allocation.x -= ac_width; widget->allocation.width += ac_width; if (gtk_label_get_ellipsize (label)) pango_layout_set_width (label_layout, pango_layout_get_width (label_layout) + ac_width * PANGO_SCALE); if (direction == GTK_TEXT_DIR_RTL) x = widget->allocation.x + misc->xpad; else x = widget->allocation.x + widget->allocation.width - misc->xpad - ac_width; gtk_label_get_layout_offsets (GTK_LABEL (accel_label), NULL, &y); accel_layout = gtk_widget_create_pango_layout (widget, gtk_accel_label_get_string (accel_label)); y += get_first_baseline (label_layout) - get_first_baseline (accel_layout); gtk_paint_layout (widget->style, widget->window, gtk_widget_get_state (widget), FALSE, &event->area, widget, "accellabel", x, y, accel_layout); g_object_unref (accel_layout); } else { if (GTK_WIDGET_CLASS (gtk_accel_label_parent_class)->expose_event) GTK_WIDGET_CLASS (gtk_accel_label_parent_class)->expose_event (widget, event); } } return FALSE; } static void refetch_widget_accel_closure (GtkAccelLabel *accel_label) { GClosure *closure = NULL; GList *clist, *list; g_return_if_fail (GTK_IS_ACCEL_LABEL (accel_label)); g_return_if_fail (GTK_IS_WIDGET (accel_label->accel_widget)); clist = gtk_widget_list_accel_closures (accel_label->accel_widget); for (list = clist; list; list = list->next) { /* we just take the first closure used */ closure = list->data; break; } g_list_free (clist); gtk_accel_label_set_accel_closure (accel_label, closure); } /** * gtk_accel_label_set_accel_widget: * @accel_label: a #GtkAccelLabel * @accel_widget: the widget to be monitored. * * Sets the widget to be monitored by this accelerator label. **/ void gtk_accel_label_set_accel_widget (GtkAccelLabel *accel_label, GtkWidget *accel_widget) { g_return_if_fail (GTK_IS_ACCEL_LABEL (accel_label)); if (accel_widget) g_return_if_fail (GTK_IS_WIDGET (accel_widget)); if (accel_widget != accel_label->accel_widget) { if (accel_label->accel_widget) { gtk_accel_label_set_accel_closure (accel_label, NULL); g_signal_handlers_disconnect_by_func (accel_label->accel_widget, refetch_widget_accel_closure, accel_label); g_object_unref (accel_label->accel_widget); } accel_label->accel_widget = accel_widget; if (accel_label->accel_widget) { g_object_ref (accel_label->accel_widget); g_signal_connect_object (accel_label->accel_widget, "accel-closures-changed", G_CALLBACK (refetch_widget_accel_closure), accel_label, G_CONNECT_SWAPPED); refetch_widget_accel_closure (accel_label); } g_object_notify (G_OBJECT (accel_label), "accel-widget"); } } static void gtk_accel_label_reset (GtkAccelLabel *accel_label) { if (accel_label->accel_string) { g_free (accel_label->accel_string); accel_label->accel_string = NULL; } gtk_widget_queue_resize (GTK_WIDGET (accel_label)); } static void check_accel_changed (GtkAccelGroup *accel_group, guint keyval, GdkModifierType modifier, GClosure *accel_closure, GtkAccelLabel *accel_label) { if (accel_closure == accel_label->accel_closure) gtk_accel_label_reset (accel_label); } /** * gtk_accel_label_set_accel_closure: * @accel_label: a #GtkAccelLabel * @accel_closure: the closure to monitor for accelerator changes. * * Sets the closure to be monitored by this accelerator label. The closure * must be connected to an accelerator group; see gtk_accel_group_connect(). **/ void gtk_accel_label_set_accel_closure (GtkAccelLabel *accel_label, GClosure *accel_closure) { g_return_if_fail (GTK_IS_ACCEL_LABEL (accel_label)); if (accel_closure) g_return_if_fail (gtk_accel_group_from_accel_closure (accel_closure) != NULL); if (accel_closure != accel_label->accel_closure) { if (accel_label->accel_closure) { g_signal_handlers_disconnect_by_func (accel_label->accel_group, check_accel_changed, accel_label); accel_label->accel_group = NULL; g_closure_unref (accel_label->accel_closure); } accel_label->accel_closure = accel_closure; if (accel_label->accel_closure) { g_closure_ref (accel_label->accel_closure); accel_label->accel_group = gtk_accel_group_from_accel_closure (accel_closure); g_signal_connect_object (accel_label->accel_group, "accel-changed", G_CALLBACK (check_accel_changed), accel_label, 0); } gtk_accel_label_reset (accel_label); g_object_notify (G_OBJECT (accel_label), "accel-closure"); } } static gboolean find_accel (GtkAccelKey *key, GClosure *closure, gpointer data) { return data == (gpointer) closure; } static const gchar * gtk_accel_label_get_string (GtkAccelLabel *accel_label) { if (!accel_label->accel_string) gtk_accel_label_refetch (accel_label); return accel_label->accel_string; } /* Underscores in key names are better displayed as spaces * E.g., Page_Up should be "Page Up" */ static void substitute_underscores (char *str) { char *p; for (p = str; *p; p++) if (*p == '_') *p = ' '; } /* On Mac, if the key has symbolic representation (e.g. arrow keys), * append it to gstring and return TRUE; otherwise return FALSE. * See http://docs.info.apple.com/article.html?path=Mac/10.5/en/cdb_symbs.html * for the list of special keys. */ static gboolean append_keyval_symbol (guint accelerator_key, GString *gstring) { #ifdef GDK_WINDOWING_QUARTZ switch (accelerator_key) { case GDK_Return: /* U+21A9 LEFTWARDS ARROW WITH HOOK */ g_string_append (gstring, "\xe2\x86\xa9"); return TRUE; case GDK_ISO_Enter: /* U+2324 UP ARROWHEAD BETWEEN TWO HORIZONTAL BARS */ g_string_append (gstring, "\xe2\x8c\xa4"); return TRUE; case GDK_Left: /* U+2190 LEFTWARDS ARROW */ g_string_append (gstring, "\xe2\x86\x90"); return TRUE; case GDK_Up: /* U+2191 UPWARDS ARROW */ g_string_append (gstring, "\xe2\x86\x91"); return TRUE; case GDK_Right: /* U+2192 RIGHTWARDS ARROW */ g_string_append (gstring, "\xe2\x86\x92"); return TRUE; case GDK_Down: /* U+2193 DOWNWARDS ARROW */ g_string_append (gstring, "\xe2\x86\x93"); return TRUE; case GDK_Page_Up: /* U+21DE UPWARDS ARROW WITH DOUBLE STROKE */ g_string_append (gstring, "\xe2\x87\x9e"); return TRUE; case GDK_Page_Down: /* U+21DF DOWNWARDS ARROW WITH DOUBLE STROKE */ g_string_append (gstring, "\xe2\x87\x9f"); return TRUE; case GDK_Home: /* U+2196 NORTH WEST ARROW */ g_string_append (gstring, "\xe2\x86\x96"); return TRUE; case GDK_End: /* U+2198 SOUTH EAST ARROW */ g_string_append (gstring, "\xe2\x86\x98"); return TRUE; case GDK_Escape: /* U+238B BROKEN CIRCLE WITH NORTHWEST ARROW */ g_string_append (gstring, "\xe2\x8e\x8b"); return TRUE; case GDK_BackSpace: /* U+232B ERASE TO THE LEFT */ g_string_append (gstring, "\xe2\x8c\xab"); return TRUE; case GDK_Delete: /* U+2326 ERASE TO THE RIGHT */ g_string_append (gstring, "\xe2\x8c\xa6"); return TRUE; default: return FALSE; } #else /* !GDK_WINDOWING_QUARTZ */ return FALSE; #endif } gchar * _gtk_accel_label_class_get_accelerator_label (GtkAccelLabelClass *klass, guint accelerator_key, GdkModifierType accelerator_mods) { GString *gstring; gboolean seen_mod = FALSE; gunichar ch; gstring = g_string_new (""); if (accelerator_mods & GDK_SHIFT_MASK) { g_string_append (gstring, klass->mod_name_shift); seen_mod = TRUE; } if (accelerator_mods & GDK_CONTROL_MASK) { if (seen_mod) g_string_append (gstring, klass->mod_separator); g_string_append (gstring, klass->mod_name_control); seen_mod = TRUE; } if (accelerator_mods & GDK_MOD1_MASK) { if (seen_mod) g_string_append (gstring, klass->mod_separator); g_string_append (gstring, klass->mod_name_alt); seen_mod = TRUE; } if (accelerator_mods & GDK_MOD2_MASK) { if (seen_mod) g_string_append (gstring, klass->mod_separator); g_string_append (gstring, "Mod2"); seen_mod = TRUE; } if (accelerator_mods & GDK_MOD3_MASK) { if (seen_mod) g_string_append (gstring, klass->mod_separator); g_string_append (gstring, "Mod3"); seen_mod = TRUE; } if (accelerator_mods & GDK_MOD4_MASK) { if (seen_mod) g_string_append (gstring, klass->mod_separator); g_string_append (gstring, "Mod4"); seen_mod = TRUE; } if (accelerator_mods & GDK_MOD5_MASK) { if (seen_mod) g_string_append (gstring, klass->mod_separator); g_string_append (gstring, "Mod5"); seen_mod = TRUE; } if (accelerator_mods & GDK_SUPER_MASK) { if (seen_mod) g_string_append (gstring, klass->mod_separator); /* This is the text that should appear next to menu accelerators * that use the super key. If the text on this key isn't typically * translated on keyboards used for your language, don't translate * this. */ g_string_append (gstring, C_("keyboard label", "Super")); seen_mod = TRUE; } if (accelerator_mods & GDK_HYPER_MASK) { if (seen_mod) g_string_append (gstring, klass->mod_separator); /* This is the text that should appear next to menu accelerators * that use the hyper key. If the text on this key isn't typically * translated on keyboards used for your language, don't translate * this. */ g_string_append (gstring, C_("keyboard label", "Hyper")); seen_mod = TRUE; } if (accelerator_mods & GDK_META_MASK) { if (seen_mod) g_string_append (gstring, klass->mod_separator); #ifndef GDK_WINDOWING_QUARTZ /* This is the text that should appear next to menu accelerators * that use the meta key. If the text on this key isn't typically * translated on keyboards used for your language, don't translate * this. */ g_string_append (gstring, C_("keyboard label", "Meta")); #else /* Command key symbol U+2318 PLACE OF INTEREST SIGN */ g_string_append (gstring, "\xe2\x8c\x98"); #endif seen_mod = TRUE; } if (seen_mod) g_string_append (gstring, klass->mod_separator); ch = gdk_keyval_to_unicode (accelerator_key); if (ch && (g_unichar_isgraph (ch) || ch == ' ') && (ch < 0x80 || klass->latin1_to_char)) { switch (ch) { case ' ': g_string_append (gstring, C_("keyboard label", "Space")); break; case '\\': g_string_append (gstring, C_("keyboard label", "Backslash")); break; default: g_string_append_unichar (gstring, g_unichar_toupper (ch)); break; } } else if (!append_keyval_symbol (accelerator_key, gstring)) { gchar *tmp; tmp = gdk_keyval_name (gdk_keyval_to_lower (accelerator_key)); if (tmp != NULL) { if (tmp[0] != 0 && tmp[1] == 0) g_string_append_c (gstring, g_ascii_toupper (tmp[0])); else { const gchar *str; str = g_dpgettext2 (GETTEXT_PACKAGE, "keyboard label", tmp); if (str == tmp) { g_string_append (gstring, tmp); substitute_underscores (gstring->str); } else g_string_append (gstring, str); } } } return g_string_free (gstring, FALSE); } /** * gtk_accel_label_refetch: * @accel_label: a #GtkAccelLabel. * * Recreates the string representing the accelerator keys. * This should not be needed since the string is automatically updated whenever * accelerators are added or removed from the associated widget. * * Returns: always returns %FALSE. */ gboolean gtk_accel_label_refetch (GtkAccelLabel *accel_label) { gboolean enable_accels; g_return_val_if_fail (GTK_IS_ACCEL_LABEL (accel_label), FALSE); if (accel_label->accel_string) { g_free (accel_label->accel_string); accel_label->accel_string = NULL; } g_object_get (gtk_widget_get_settings (GTK_WIDGET (accel_label)), "gtk-enable-accels", &enable_accels, NULL); if (enable_accels && accel_label->accel_closure) { GtkAccelKey *key = gtk_accel_group_find (accel_label->accel_group, find_accel, accel_label->accel_closure); if (key && key->accel_flags & GTK_ACCEL_VISIBLE) { GtkAccelLabelClass *klass; gchar *tmp; klass = GTK_ACCEL_LABEL_GET_CLASS (accel_label); tmp = _gtk_accel_label_class_get_accelerator_label (klass, key->accel_key, key->accel_mods); accel_label->accel_string = g_strconcat (" ", tmp, NULL); g_free (tmp); } if (!accel_label->accel_string) accel_label->accel_string = g_strdup ("-/-"); } if (!accel_label->accel_string) accel_label->accel_string = g_strdup (""); gtk_widget_queue_resize (GTK_WIDGET (accel_label)); return FALSE; } #define __GTK_ACCEL_LABEL_C__ #include "gtkaliasdef.c"