From ceaa2df6e9f96245a0e99edeb29a8b28c39c79b1 Mon Sep 17 00:00:00 2001 From: Sergey Chupligin Date: Tue, 14 Jun 2022 15:35:59 +0300 Subject: src/gtk Update gtk part to version 3.24.8 Fixes https://github.com/AyatanaIndicators/qmenumodel/issues/22 --- libqmenumodel/src/ayatanamenumodel.cpp | 23 +- libqmenumodel/src/gtk/gtkactionmuxer.c | 211 ++++++++++++++-- libqmenumodel/src/gtk/gtkactionmuxer.h | 17 ++ libqmenumodel/src/gtk/gtkactionobserver.c | 40 +++- libqmenumodel/src/gtk/gtkactionobserver.h | 8 + libqmenumodel/src/gtk/gtkmenutracker.c | 245 ++++++++++++++----- libqmenumodel/src/gtk/gtkmenutracker.h | 12 +- libqmenumodel/src/gtk/gtkmenutrackeritem.c | 370 +++++++++++++++++++++-------- libqmenumodel/src/gtk/gtkmenutrackeritem.h | 28 ++- 9 files changed, 748 insertions(+), 206 deletions(-) diff --git a/libqmenumodel/src/ayatanamenumodel.cpp b/libqmenumodel/src/ayatanamenumodel.cpp index 9ab0ff4..265309d 100644 --- a/libqmenumodel/src/ayatanamenumodel.cpp +++ b/libqmenumodel/src/ayatanamenumodel.cpp @@ -210,9 +210,16 @@ void AyatanaMenuModelPrivate::updateMenuModel() GDBusMenuModel *menu; menu = g_dbus_menu_model_get (this->connection, this->nameOwner, this->menuObjectPath.constData()); - this->menutracker = gtk_menu_tracker_new (GTK_ACTION_OBSERVABLE (this->muxer), - G_MENU_MODEL (menu), TRUE, NULL, - menuItemInserted, menuItemRemoved, this); + this->menutracker = gtk_menu_tracker_new(GTK_ACTION_OBSERVABLE (this->muxer), + G_MENU_MODEL (menu), + TRUE, + FALSE, + FALSE, + NULL, + NULL, + menuItemInserted, + menuItemRemoved, + this); g_object_unref (menu); } @@ -499,7 +506,7 @@ QVariant AyatanaMenuModel::data(const QModelIndex &index, int role) const return QKeySequence(gtk_menu_tracker_item_get_accel (item), QKeySequence::NativeText); case HasSubmenuRole: - return gtk_menu_tracker_item_get_has_submenu (item) != FALSE; + return gtk_menu_tracker_item_get_has_link (item, G_MENU_LINK_SUBMENU) != FALSE; default: return QVariant(); @@ -549,7 +556,7 @@ QObject * AyatanaMenuModel::submenu(int position, QQmlComponent* actionStatePars } item = (GtkMenuTrackerItem *) g_sequence_get (it); - if (!item || !gtk_menu_tracker_item_get_has_submenu (item)) { + if (!item || !gtk_menu_tracker_item_get_has_link (item, G_MENU_LINK_SUBMENU)) { return NULL; } @@ -564,10 +571,14 @@ QObject * AyatanaMenuModel::submenu(int position, QQmlComponent* actionStatePars } } - model->priv->menutracker = gtk_menu_tracker_new_for_item_submenu (item, + model->priv->menutracker = gtk_menu_tracker_new_for_item_link (item, + G_MENU_LINK_SUBMENU, + FALSE, + FALSE, AyatanaMenuModelPrivate::menuItemInserted, AyatanaMenuModelPrivate::menuItemRemoved, model->priv); + g_object_set_qdata (G_OBJECT (item), ayatana_submenu_model_quark (), model); } diff --git a/libqmenumodel/src/gtk/gtkactionmuxer.c b/libqmenumodel/src/gtk/gtkactionmuxer.c index 4618564..3080b4b 100644 --- a/libqmenumodel/src/gtk/gtkactionmuxer.c +++ b/libqmenumodel/src/gtk/gtkactionmuxer.c @@ -26,7 +26,7 @@ #include -/** +/*< private > * SECTION:gtkactionmuxer * @short_description: Aggregate and monitor several action groups * @@ -37,19 +37,19 @@ * particular context into a single action group, with namespacing. * * Consider the case of two action groups -- one containing actions - * applicable to an entire application (such as 'quit') and one + * applicable to an entire application (such as “quit”) and one * containing actions applicable to a particular window in the - * application (such as 'fullscreen'). + * application (such as “fullscreen”). * * In this case, each of these action groups could be added to a - * #GtkActionMuxer with the prefixes "app" and "win", respectively. This - * would expose the actions as "app.quit" and "win.fullscreen" on the + * #GtkActionMuxer with the prefixes “app” and “win”, respectively. This + * would expose the actions as “app.quit” and “win.fullscreen” on the * #GActionGroup interface presented by the #GtkActionMuxer. * * Activations and state change requests on the #GtkActionMuxer are wired * through to the underlying action group in the expected way. * - * This class is typically only used at the site of "consumption" of + * This class is typically only used at the site of “consumption” of * actions (eg: when displaying a menu that contains many actions on * different objects). */ @@ -65,6 +65,7 @@ struct _GtkActionMuxer GHashTable *observed_actions; GHashTable *groups; + GHashTable *primary_accels; GtkActionMuxer *parent; }; @@ -81,6 +82,8 @@ enum static GParamSpec *properties[NUM_PROPERTIES]; +guint accel_signal; + typedef struct { GtkActionMuxer *muxer; @@ -134,7 +137,7 @@ gtk_action_muxer_list_actions (GActionGroup *action_group) actions); } - return (gchar **) g_array_free (actions, FALSE); + return (gchar **)(void *) g_array_free (actions, FALSE); } static Group * @@ -333,6 +336,39 @@ gtk_action_muxer_action_removed_from_parent (GActionGroup *action_group, gtk_action_muxer_action_removed (muxer, action_name); } +static void +gtk_action_muxer_primary_accel_changed (GtkActionMuxer *muxer, + const gchar *action_name, + const gchar *action_and_target) +{ + Action *action; + GSList *node; + + if (!action_name) + action_name = strrchr (action_and_target, '|') + 1; + + action = g_hash_table_lookup (muxer->observed_actions, action_name); + for (node = action ? action->watchers : NULL; node; node = node->next) + gtk_action_observer_primary_accel_changed (node->data, GTK_ACTION_OBSERVABLE (muxer), + action_name, action_and_target); + g_signal_emit (muxer, accel_signal, 0, action_name, action_and_target); +} + +static void +gtk_action_muxer_parent_primary_accel_changed (GtkActionMuxer *parent, + const gchar *action_name, + const gchar *action_and_target, + gpointer user_data) +{ + GtkActionMuxer *muxer = user_data; + + /* If it's in our table then don't let the parent one filter through */ + if (muxer->primary_accels && g_hash_table_lookup (muxer->primary_accels, action_and_target)) + return; + + gtk_action_muxer_primary_accel_changed (muxer, action_name, action_and_target); +} + static gboolean gtk_action_muxer_query_action (GActionGroup *action_group, const gchar *action_name, @@ -498,6 +534,8 @@ gtk_action_muxer_finalize (GObject *object) g_assert_cmpint (g_hash_table_size (muxer->observed_actions), ==, 0); g_hash_table_unref (muxer->observed_actions); g_hash_table_unref (muxer->groups); + if (muxer->primary_accels) + g_hash_table_unref (muxer->primary_accels); G_OBJECT_CLASS (gtk_action_muxer_parent_class) ->finalize (object); @@ -514,6 +552,7 @@ gtk_action_muxer_dispose (GObject *object) g_signal_handlers_disconnect_by_func (muxer->parent, gtk_action_muxer_action_removed_from_parent, muxer); g_signal_handlers_disconnect_by_func (muxer->parent, gtk_action_muxer_parent_action_enabled_changed, muxer); g_signal_handlers_disconnect_by_func (muxer->parent, gtk_action_muxer_parent_action_state_changed, muxer); + g_signal_handlers_disconnect_by_func (muxer->parent, gtk_action_muxer_parent_primary_accel_changed, muxer); g_clear_object (&muxer->parent); } @@ -593,6 +632,9 @@ gtk_action_muxer_class_init (GObjectClass *class) class->finalize = gtk_action_muxer_finalize; class->dispose = gtk_action_muxer_dispose; + accel_signal = g_signal_new ("primary-accel-changed", GTK_TYPE_ACTION_MUXER, G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING); + properties[PROP_PARENT] = g_param_spec_object ("parent", "Parent", "The parent muxer", GTK_TYPE_ACTION_MUXER, @@ -602,7 +644,7 @@ gtk_action_muxer_class_init (GObjectClass *class) g_object_class_install_properties (class, NUM_PROPERTIES, properties); } -/** +/*< private > * gtk_action_muxer_insert: * @muxer: a #GtkActionMuxer * @prefix: the prefix string for the action group @@ -610,15 +652,15 @@ gtk_action_muxer_class_init (GObjectClass *class) * * Adds the actions in @action_group to the list of actions provided by * @muxer. @prefix is prefixed to each action name, such that for each - * action x in @action_group, there is an equivalent - * action @prefix.x in @muxer. + * action `x` in @action_group, there is an equivalent + * action @prefix`.x` in @muxer. * - * For example, if @prefix is "app" and @action_group - * contains an action called "quit", then @muxer will - * now contain an action called "app.quit". + * For example, if @prefix is “`app`” and @action_group + * contains an action called “`quit`”, then @muxer will + * now contain an action called “`app.quit`”. * * If any #GtkActionObservers are registered for actions in the group, - * "action_added" notifications will be emitted, as appropriate. + * “action_added” notifications will be emitted, as appropriate. * * @prefix must not contain a dot ('.'). */ @@ -656,7 +698,7 @@ gtk_action_muxer_insert (GtkActionMuxer *muxer, G_CALLBACK (gtk_action_muxer_group_action_state_changed), group); } -/** +/*< private > * gtk_action_muxer_remove: * @muxer: a #GtkActionMuxer * @prefix: the prefix of the action group to remove @@ -664,7 +706,7 @@ gtk_action_muxer_insert (GtkActionMuxer *muxer, * Removes a #GActionGroup from the #GtkActionMuxer. * * If any #GtkActionObservers are registered for actions in the group, - * "action_removed" notifications will be emitted, as appropriate. + * “action_removed” notifications will be emitted, as appropriate. */ void gtk_action_muxer_remove (GtkActionMuxer *muxer, @@ -690,7 +732,27 @@ gtk_action_muxer_remove (GtkActionMuxer *muxer, } } -/** +const gchar ** +gtk_action_muxer_list_prefixes (GtkActionMuxer *muxer) +{ + return (const gchar **) g_hash_table_get_keys_as_array (muxer->groups, NULL); +} + +GActionGroup * +gtk_action_muxer_lookup (GtkActionMuxer *muxer, + const gchar *prefix) +{ + Group *group; + + group = g_hash_table_lookup (muxer->groups, prefix); + + if (group != NULL) + return group->group; + + return NULL; +} + +/*< private > * gtk_action_muxer_new: * * Creates a new #GtkActionMuxer. @@ -701,7 +763,7 @@ gtk_action_muxer_new (void) return g_object_new (GTK_TYPE_ACTION_MUXER, NULL); } -/** +/*< private > * gtk_action_muxer_get_parent: * @muxer: a #GtkActionMuxer * @@ -715,7 +777,27 @@ gtk_action_muxer_get_parent (GtkActionMuxer *muxer) return muxer->parent; } -/** +static void +emit_changed_accels (GtkActionMuxer *muxer, + GtkActionMuxer *parent) +{ + while (parent) + { + if (parent->primary_accels) + { + GHashTableIter iter; + gpointer key; + + g_hash_table_iter_init (&iter, parent->primary_accels); + while (g_hash_table_iter_next (&iter, &key, NULL)) + gtk_action_muxer_primary_accel_changed (muxer, NULL, key); + } + + parent = parent->parent; + } +} + +/*< private > * gtk_action_muxer_set_parent: * @muxer: a #GtkActionMuxer * @parent: (allow-none): the new parent #GtkActionMuxer @@ -742,10 +824,13 @@ gtk_action_muxer_set_parent (GtkActionMuxer *muxer, gtk_action_muxer_action_removed (muxer, *it); g_strfreev (actions); + emit_changed_accels (muxer, muxer->parent); + g_signal_handlers_disconnect_by_func (muxer->parent, gtk_action_muxer_action_added_to_parent, muxer); g_signal_handlers_disconnect_by_func (muxer->parent, gtk_action_muxer_action_removed_from_parent, muxer); g_signal_handlers_disconnect_by_func (muxer->parent, gtk_action_muxer_parent_action_enabled_changed, muxer); g_signal_handlers_disconnect_by_func (muxer->parent, gtk_action_muxer_parent_action_state_changed, muxer); + g_signal_handlers_disconnect_by_func (muxer->parent, gtk_action_muxer_parent_primary_accel_changed, muxer); g_object_unref (muxer->parent); } @@ -764,6 +849,8 @@ gtk_action_muxer_set_parent (GtkActionMuxer *muxer, gtk_action_muxer_action_added (muxer, *it, G_ACTION_GROUP (muxer->parent), *it); g_strfreev (actions); + emit_changed_accels (muxer, muxer->parent); + g_signal_connect (muxer->parent, "action-added", G_CALLBACK (gtk_action_muxer_action_added_to_parent), muxer); g_signal_connect (muxer->parent, "action-removed", @@ -772,7 +859,93 @@ gtk_action_muxer_set_parent (GtkActionMuxer *muxer, G_CALLBACK (gtk_action_muxer_parent_action_enabled_changed), muxer); g_signal_connect (muxer->parent, "action-state-changed", G_CALLBACK (gtk_action_muxer_parent_action_state_changed), muxer); + g_signal_connect (muxer->parent, "primary-accel-changed", + G_CALLBACK (gtk_action_muxer_parent_primary_accel_changed), muxer); } g_object_notify_by_pspec (G_OBJECT (muxer), properties[PROP_PARENT]); } + +void +gtk_action_muxer_set_primary_accel (GtkActionMuxer *muxer, + const gchar *action_and_target, + const gchar *primary_accel) +{ + if (!muxer->primary_accels) + muxer->primary_accels = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); + + if (primary_accel) + g_hash_table_insert (muxer->primary_accels, g_strdup (action_and_target), g_strdup (primary_accel)); + else + g_hash_table_remove (muxer->primary_accels, action_and_target); + + gtk_action_muxer_primary_accel_changed (muxer, NULL, action_and_target); +} + +const gchar * +gtk_action_muxer_get_primary_accel (GtkActionMuxer *muxer, + const gchar *action_and_target) +{ + if (muxer->primary_accels) + { + const gchar *primary_accel; + + primary_accel = g_hash_table_lookup (muxer->primary_accels, action_and_target); + + if (primary_accel) + return primary_accel; + } + + if (!muxer->parent) + return NULL; + + return gtk_action_muxer_get_primary_accel (muxer->parent, action_and_target); +} + +gchar * +gtk_print_action_and_target (const gchar *action_namespace, + const gchar *action_name, + GVariant *target) +{ + GString *result; + + g_return_val_if_fail (strchr (action_name, '|') == NULL, NULL); + g_return_val_if_fail (action_namespace == NULL || strchr (action_namespace, '|') == NULL, NULL); + + result = g_string_new (NULL); + + if (target) + g_variant_print_string (target, result, TRUE); + g_string_append_c (result, '|'); + + if (action_namespace) + { + g_string_append (result, action_namespace); + g_string_append_c (result, '.'); + } + + g_string_append (result, action_name); + + return g_string_free (result, FALSE); +} + +gchar * +gtk_normalise_detailed_action_name (const gchar *detailed_action_name) +{ + GError *error = NULL; + gchar *action_and_target; + gchar *action_name; + GVariant *target; + + g_action_parse_detailed_name (detailed_action_name, &action_name, &target, &error); + g_assert_no_error (error); + + action_and_target = gtk_print_action_and_target (NULL, action_name, target); + + if (target) + g_variant_unref (target); + + g_free (action_name); + + return action_and_target; +} diff --git a/libqmenumodel/src/gtk/gtkactionmuxer.h b/libqmenumodel/src/gtk/gtkactionmuxer.h index 4014830..8d6e347 100644 --- a/libqmenumodel/src/gtk/gtkactionmuxer.h +++ b/libqmenumodel/src/gtk/gtkactionmuxer.h @@ -42,11 +42,28 @@ void gtk_action_muxer_insert (GtkActi void gtk_action_muxer_remove (GtkActionMuxer *muxer, const gchar *prefix); +const gchar ** gtk_action_muxer_list_prefixes (GtkActionMuxer *muxer); +GActionGroup * gtk_action_muxer_lookup (GtkActionMuxer *muxer, + const gchar *prefix); GtkActionMuxer * gtk_action_muxer_get_parent (GtkActionMuxer *muxer); void gtk_action_muxer_set_parent (GtkActionMuxer *muxer, GtkActionMuxer *parent); +void gtk_action_muxer_set_primary_accel (GtkActionMuxer *muxer, + const gchar *action_and_target, + const gchar *primary_accel); + +const gchar * gtk_action_muxer_get_primary_accel (GtkActionMuxer *muxer, + const gchar *action_and_target); + +/* No better place for these... */ +gchar * gtk_print_action_and_target (const gchar *action_namespace, + const gchar *action_name, + GVariant *target); + +gchar * gtk_normalise_detailed_action_name (const gchar *detailed_action_name); + G_END_DECLS #endif /* __GTK_ACTION_MUXER_H__ */ diff --git a/libqmenumodel/src/gtk/gtkactionobserver.c b/libqmenumodel/src/gtk/gtkactionobserver.c index cf70b20..fda0ae7 100644 --- a/libqmenumodel/src/gtk/gtkactionobserver.c +++ b/libqmenumodel/src/gtk/gtkactionobserver.c @@ -23,7 +23,7 @@ G_DEFINE_INTERFACE (GtkActionObserver, gtk_action_observer, G_TYPE_OBJECT) -/** +/*< private > * SECTION:gtkactionobserver * @short_description: an interface implemented by objects that are * interested in monitoring actions for changes @@ -54,7 +54,7 @@ gtk_action_observer_default_init (GtkActionObserverInterface *class) { } -/** +/*< private > * gtk_action_observer_action_added: * @observer: a #GtkActionObserver * @observable: the source of the event @@ -85,7 +85,7 @@ gtk_action_observer_action_added (GtkActionObserver *observer, ->action_added (observer, observable, action_name, parameter_type, enabled, state); } -/** +/*< private > * gtk_action_observer_action_enabled_changed: * @observer: a #GtkActionObserver * @observable: the source of the event @@ -110,7 +110,7 @@ gtk_action_observer_action_enabled_changed (GtkActionObserver *observer, ->action_enabled_changed (observer, observable, action_name, enabled); } -/** +/*< private > * gtk_action_observer_action_state_changed: * @observer: a #GtkActionObserver * @observable: the source of the event @@ -135,7 +135,7 @@ gtk_action_observer_action_state_changed (GtkActionObserver *observer, ->action_state_changed (observer, observable, action_name, state); } -/** +/*< private > * gtk_action_observer_action_removed: * @observer: a #GtkActionObserver * @observable: the source of the event @@ -157,3 +157,33 @@ gtk_action_observer_action_removed (GtkActionObserver *observer, GTK_ACTION_OBSERVER_GET_IFACE (observer) ->action_removed (observer, observable, action_name); } + +/*< private > + * gtk_action_observer_primary_accel_changed: + * @observer: a #GtkActionObserver + * @observable: the source of the event + * @action_name: the name of the action + * @action_and_target: detailed action of the changed accel, in “action and target” format + * + * This function is called when an action that the observer is + * registered to receive events for has one of its accelerators changed. + * + * Accelerator changes are reported for all targets associated with the + * action. The @action_and_target string should be used to check if the + * reported target is the one that the observer is interested in. + */ +void +gtk_action_observer_primary_accel_changed (GtkActionObserver *observer, + GtkActionObservable *observable, + const gchar *action_name, + const gchar *action_and_target) +{ + GtkActionObserverInterface *iface; + + g_return_if_fail (GTK_IS_ACTION_OBSERVER (observer)); + + iface = GTK_ACTION_OBSERVER_GET_IFACE (observer); + + if (iface->primary_accel_changed) + iface->primary_accel_changed (observer, observable, action_name, action_and_target); +} diff --git a/libqmenumodel/src/gtk/gtkactionobserver.h b/libqmenumodel/src/gtk/gtkactionobserver.h index 83629a7..a4e9659 100644 --- a/libqmenumodel/src/gtk/gtkactionobserver.h +++ b/libqmenumodel/src/gtk/gtkactionobserver.h @@ -57,6 +57,10 @@ struct _GtkActionObserverInterface void (* action_removed) (GtkActionObserver *observer, GtkActionObservable *observable, const gchar *action_name); + void (* primary_accel_changed) (GtkActionObserver *observer, + GtkActionObservable *observable, + const gchar *action_name, + const gchar *action_and_target); }; GType gtk_action_observer_get_type (void); @@ -77,6 +81,10 @@ void gtk_action_observer_action_state_changed (GtkActi void gtk_action_observer_action_removed (GtkActionObserver *observer, GtkActionObservable *observable, const gchar *action_name); +void gtk_action_observer_primary_accel_changed (GtkActionObserver *observer, + GtkActionObservable *observable, + const gchar *action_name, + const gchar *action_and_target); G_END_DECLS diff --git a/libqmenumodel/src/gtk/gtkmenutracker.c b/libqmenumodel/src/gtk/gtkmenutracker.c index 8b72965..95e08bc 100644 --- a/libqmenumodel/src/gtk/gtkmenutracker.c +++ b/libqmenumodel/src/gtk/gtkmenutracker.c @@ -12,9 +12,7 @@ * 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. + * License along with this library; if not, see . * * Author: Ryan Lortie */ @@ -23,7 +21,7 @@ #include "gtkmenutracker.h" -/** +/*< private > * SECTION:gtkmenutracker * @Title: GtkMenuTracker * @Short_description: A helper class for interpreting #GMenuModel @@ -48,11 +46,11 @@ * * Certain properties on the #GtkMenuTrackerItem are mutable, and you must * listen for changes in the item. For more details, see the documentation - * for #GtkMenuTrackerItem along with https://live.gnome.org/GApplication/GMenuModel. + * for #GtkMenuTrackerItem along with https://wiki.gnome.org/Projects/GLib/GApplication/GMenuModel. * * The idea of @with_separators is for special cases where menu models may * be tracked in places where separators are not available, like in toplevel - * "File", "Edit" menu bars. Ignoring separator items is wrong, as #GtkMenuTracker + * "File", “Edit” menu bars. Ignoring separator items is wrong, as #GtkMenuTracker * expects the position to change, so we must tell #GtkMenuTracker to ignore * separators itself. */ @@ -62,6 +60,8 @@ typedef struct _GtkMenuTrackerSection GtkMenuTrackerSection; struct _GtkMenuTracker { GtkActionObservable *observable; + guint merge_sections : 1; + guint mac_os_mode : 1; GtkMenuTrackerInsertFunc insert_func; GtkMenuTrackerRemoveFunc remove_func; gpointer user_data; @@ -71,12 +71,14 @@ struct _GtkMenuTracker struct _GtkMenuTrackerSection { - GMenuModel *model; + gpointer model; /* may be a GtkMenuTrackerItem or a GMenuModel */ GSList *items; gchar *action_namespace; + guint separator_label : 1; guint with_separators : 1; guint has_separator : 1; + guint is_fake : 1; gulong handler; }; @@ -84,6 +86,7 @@ struct _GtkMenuTrackerSection static GtkMenuTrackerSection * gtk_menu_tracker_section_new (GtkMenuTracker *tracker, GMenuModel *model, gboolean with_separators, + gboolean separator_label, gint offset, const gchar *action_namespace, GPtrArray *items_already_created); @@ -91,7 +94,7 @@ static void gtk_menu_tracker_section_free (GtkMenuTrackerS static GtkMenuTrackerSection * gtk_menu_tracker_section_find_model (GtkMenuTrackerSection *section, - GMenuModel *model, + gpointer model, gint *offset) { GSList *item; @@ -119,7 +122,7 @@ gtk_menu_tracker_section_find_model (GtkMenuTrackerSection *section, (*offset)++; } - return FALSE; + return NULL; } /* this is responsible for syncing the showing of a separator for a @@ -127,7 +130,7 @@ gtk_menu_tracker_section_find_model (GtkMenuTrackerSection *section, * * we only ever show separators if we have _actual_ children (ie: we do * not show a separator if the section contains only empty child - * sections). it's difficult to determine this on-the-fly, so we have + * sections). it’s difficult to determine this on-the-fly, so we have * this separate function to come back later and figure it out. * * 'section' is that section. @@ -142,11 +145,11 @@ gtk_menu_tracker_section_find_model (GtkMenuTrackerSection *section, * * could_have_separator is true in two situations: * - * - our parent section had with_separators defined and we are not the - * first section (ie: we should add a separator if we have content in + * - our parent section had with_separators defined and there are items + * before us (ie: we should add a separator if we have content in * order to divide us from the items above) * - * - if we had a 'label' attribute set for this section + * - if we had a “label” attribute set for this section * * parent_model and parent_index are passed in so that we can give them * to the insertion callback so that it can see the label (and anything @@ -168,6 +171,7 @@ gtk_menu_tracker_section_sync_separators (GtkMenuTrackerSection *section, gboolean should_have_separator; gint n_items = 0; GSList *item; + GPtrArray *items = g_ptr_array_new (); gint i = 0; for (item = section->items; item; item = item->next) @@ -176,13 +180,15 @@ gtk_menu_tracker_section_sync_separators (GtkMenuTrackerSection *section, if (subsection) { - gboolean could_have_separator; + gboolean separator; - could_have_separator = (section->with_separators && i > 0) || - g_menu_model_get_item_attribute (section->model, i, "label", "s", NULL); + separator = (section->with_separators && n_items > 0) || subsection->separator_label; + /* Only pass the parent_model and parent_index in case they may be used to create the separator. */ n_items += gtk_menu_tracker_section_sync_separators (subsection, tracker, offset + n_items, - could_have_separator, section->model, i); + separator, + separator ? section->model : NULL, + separator ? i : 0); } else n_items++; @@ -190,19 +196,18 @@ gtk_menu_tracker_section_sync_separators (GtkMenuTrackerSection *section, i++; } - should_have_separator = could_have_separator && n_items != 0; + should_have_separator = !section->is_fake && could_have_separator && n_items != 0; if (should_have_separator > section->has_separator) { /* Add a separator */ - GtkMenuTrackerItem *item; - GPtrArray *items = g_ptr_array_new (); + GtkMenuTrackerItem *separator; - item = _gtk_menu_tracker_item_new (tracker->observable, parent_model, parent_index, NULL, TRUE); - g_ptr_array_add (items, (gpointer) item); + separator = _gtk_menu_tracker_item_new (tracker->observable, parent_model, parent_index, FALSE, NULL, TRUE); + g_ptr_array_add (items, (gpointer) separator); (* tracker->insert_func) (items, offset, tracker->user_data); g_ptr_array_unref (items); - g_object_unref (item); + g_object_unref (separator); section->has_separator = TRUE; } @@ -218,6 +223,41 @@ gtk_menu_tracker_section_sync_separators (GtkMenuTrackerSection *section, return n_items; } +static void +gtk_menu_tracker_item_visibility_changed (GtkMenuTrackerItem *item, + GParamSpec *pspec, + gpointer user_data) +{ + GtkMenuTracker *tracker = user_data; + GtkMenuTrackerSection *section; + gboolean is_now_visible; + gboolean was_visible; + gint offset = 0; + + is_now_visible = gtk_menu_tracker_item_get_is_visible (item); + + /* remember: the item is our model */ + section = gtk_menu_tracker_section_find_model (tracker->toplevel, item, &offset); + + was_visible = section->items != NULL; + + if (is_now_visible == was_visible) + return; + + if (is_now_visible) + { + section->items = g_slist_prepend (NULL, NULL); + (* tracker->insert_func) (section->model, offset, tracker->user_data); + } + else + { + section->items = g_slist_delete_link (section->items, section->items); + (* tracker->remove_func) (offset, 1, tracker->user_data); + } + + gtk_menu_tracker_section_sync_separators (tracker->toplevel, tracker, 0, FALSE, NULL, 0); +} + static gint gtk_menu_tracker_section_measure (GtkMenuTrackerSection *section) { @@ -258,6 +298,7 @@ gtk_menu_tracker_remove_items (GtkMenuTracker *tracker, n = gtk_menu_tracker_section_measure (subsection); gtk_menu_tracker_section_free (subsection); + while (n--) n_total_items += n; } @@ -275,28 +316,32 @@ gtk_menu_tracker_add_items (GtkMenuTracker *tracker, GMenuModel *model, gint position, gint n_items, - GPtrArray *items_already_created - ) + GPtrArray *items_already_created) { - GPtrArray *items; - if (items_already_created) - { - items = items_already_created; - } - else - { - items = g_ptr_array_new (); - } + GPtrArray *items; + if (items_already_created) + { + items = items_already_created; + } + else + { + items = g_ptr_array_new (); + } while (n_items--) { GMenuModel *submenu; submenu = g_menu_model_get_item_link (model, position + n_items, G_MENU_LINK_SECTION); g_assert (submenu != model); - if (submenu != NULL) + + if (submenu != NULL && tracker->merge_sections) { GtkMenuTrackerSection *subsection; gchar *action_namespace = NULL; + gboolean has_label; + + has_label = g_menu_model_get_item_attribute (model, position + n_items, + G_MENU_ATTRIBUTE_LABEL, "s", NULL); g_menu_model_get_item_attribute (model, position + n_items, G_MENU_ATTRIBUTE_ACTION_NAMESPACE, "s", &action_namespace); @@ -306,11 +351,11 @@ gtk_menu_tracker_add_items (GtkMenuTracker *tracker, gchar *namespace; namespace = g_strjoin (".", section->action_namespace, action_namespace, NULL); - subsection = gtk_menu_tracker_section_new (tracker, submenu, FALSE, offset, namespace, items_already_created); + subsection = gtk_menu_tracker_section_new (tracker, submenu, FALSE, has_label, offset, namespace, items_already_created); g_free (namespace); } else - subsection = gtk_menu_tracker_section_new (tracker, submenu, FALSE, offset, section->action_namespace, items_already_created); + subsection = gtk_menu_tracker_section_new (tracker, submenu, FALSE, has_label, offset, action_namespace, items_already_created); *change_point = g_slist_prepend (*change_point, subsection); g_free (action_namespace); @@ -321,22 +366,76 @@ gtk_menu_tracker_add_items (GtkMenuTracker *tracker, GtkMenuTrackerItem *item; item = _gtk_menu_tracker_item_new (tracker->observable, model, position + n_items, - section->action_namespace, FALSE); - g_ptr_array_insert (items, 0, (gpointer) item); + tracker->mac_os_mode, + section->action_namespace, submenu != NULL); + + /* In the case that the item may disappear we handle that by + * treating the item that we just created as being its own + * subsection. This happens as so: + * + * - the subsection is created without the possibility of + * showing a separator + * + * - the subsection will have either 0 or 1 item in it at all + * times: either the shown item or not (in the case it is + * hidden) + * + * - the created item acts as the "model" for this section + * and we use its "visiblity-changed" signal in the same + * way that we use the "items-changed" signal from a real + * GMenuModel + * + * We almost never use the '->model' stored in the section for + * anything other than lookups and for dropped the ref and + * disconnecting the signal when we destroy the menu, and we + * need to do exactly those things in this case as well. + * + * The only other thing that '->model' is used for is in the + * case that we want to show a separator, but we will never do + * that because separators are not shown for this fake section. + */ + if (gtk_menu_tracker_item_may_disappear (item)) + { + GtkMenuTrackerSection *fake_section; + + fake_section = g_slice_new0 (GtkMenuTrackerSection); + fake_section->is_fake = TRUE; + fake_section->model = g_object_ref (item); + fake_section->handler = g_signal_connect (item, "notify::is-visible", + G_CALLBACK (gtk_menu_tracker_item_visibility_changed), + tracker); + *change_point = g_slist_prepend (*change_point, fake_section); + + if (gtk_menu_tracker_item_get_is_visible (item)) + { + (* tracker->insert_func) (items, offset, tracker->user_data); + fake_section->items = g_slist_prepend (NULL, NULL); + } + } + else + { + /* In the normal case, we store NULL in the linked list. + * The measurement and lookup code count NULL always as + * exactly 1: an item that will always be there. + */ + g_ptr_array_insert (items, 0, (gpointer) item); + *change_point = g_slist_prepend (*change_point, NULL); + } - *change_point = g_slist_prepend (*change_point, NULL); + g_object_unref (item); } } + if (!items_already_created) - { - if (items->len) - { - (* tracker->insert_func) (items, offset, tracker->user_data); - for (gint i = 0; i < items->len; ++i) - g_object_unref(g_ptr_array_index(items, i)); - } - g_ptr_array_unref (items); - } + { + if (items->len) + { + (* tracker->insert_func) (items, offset, tracker->user_data); + for (gint i = 0; i < items->len; ++i) + g_object_unref(g_ptr_array_index(items, i)); + } + g_ptr_array_unref (items); + } } static void @@ -406,6 +505,7 @@ static GtkMenuTrackerSection * gtk_menu_tracker_section_new (GtkMenuTracker *tracker, GMenuModel *model, gboolean with_separators, + gboolean separator_label, gint offset, const gchar *action_namespace, GPtrArray *items_already_created) @@ -416,6 +516,7 @@ gtk_menu_tracker_section_new (GtkMenuTracker *tracker, section->model = g_object_ref (model); section->with_separators = with_separators; section->action_namespace = g_strdup (action_namespace); + section->separator_label = separator_label; gtk_menu_tracker_add_items (tracker, section, §ion->items, offset, model, 0, g_menu_model_get_n_items (model), items_already_created); section->handler = g_signal_connect (model, "items-changed", G_CALLBACK (gtk_menu_tracker_model_changed), tracker); @@ -428,6 +529,10 @@ gtk_menu_tracker_section_new (GtkMenuTracker *tracker, * @model: the model to flatten * @with_separators: if the toplevel should have separators (ie: TRUE * for menus, FALSE for menubars) + * @merge_sections: if sections should have their items merged in the + * usual way or reported only as separators (which can be queried to + * manually handle the items) + * @mac_os_mode: if this is on behalf of the Mac OS menubar * @action_namespace: the passed-in action namespace * @insert_func: insert callback * @remove_func: remove callback @@ -458,7 +563,7 @@ gtk_menu_tracker_section_new (GtkMenuTracker *tracker, * information about the menu item to insert. @action_namespace is the * action namespace that actions referred to from that item should place * themselves in. Note that if the item is a submenu and the - * "action-namespace" attribute is defined on the item, it will _not_ be + * “action-namespace” attribute is defined on the item, it will _not_ be * applied to the @action_namespace argument as it is meant for the * items inside of the submenu, not the submenu item itself. * @@ -466,7 +571,7 @@ gtk_menu_tracker_section_new (GtkMenuTracker *tracker, * separator. @model and @item_index will still be meaningfully set in * this case -- to the section menu item corresponding to the separator. * This is useful if the section specifies a label, for example. If - * there is an "action-namespace" attribute on this menu item then it + * there is an “action-namespace” attribute on this menu item then it * should be ignored by the consumer because #GtkMenuTracker has already * handled it. * @@ -478,7 +583,10 @@ GtkMenuTracker * gtk_menu_tracker_new (GtkActionObservable *observable, GMenuModel *model, gboolean with_separators, + gboolean merge_sections, + gboolean mac_os_mode, const gchar *action_namespace, + GPtrArray *items_already_created, GtkMenuTrackerInsertFunc insert_func, GtkMenuTrackerRemoveFunc remove_func, gpointer user_data) @@ -486,28 +594,43 @@ gtk_menu_tracker_new (GtkActionObservable *observable, GtkMenuTracker *tracker; tracker = g_slice_new (GtkMenuTracker); + tracker->merge_sections = merge_sections; + tracker->mac_os_mode = mac_os_mode; tracker->observable = g_object_ref (observable); tracker->insert_func = insert_func; tracker->remove_func = remove_func; tracker->user_data = user_data; - tracker->toplevel = gtk_menu_tracker_section_new (tracker, model, with_separators, 0, action_namespace, NULL); + tracker->toplevel = gtk_menu_tracker_section_new (tracker, model, with_separators, FALSE, 0, action_namespace, NULL); gtk_menu_tracker_section_sync_separators (tracker->toplevel, tracker, 0, FALSE, NULL, 0); return tracker; } GtkMenuTracker * -gtk_menu_tracker_new_for_item_submenu (GtkMenuTrackerItem *item, - GtkMenuTrackerInsertFunc insert_func, - GtkMenuTrackerRemoveFunc remove_func, - gpointer user_data) +gtk_menu_tracker_new_for_item_link (GtkMenuTrackerItem *item, + const gchar *link_name, + gboolean merge_sections, + gboolean mac_os_mode, + GtkMenuTrackerInsertFunc insert_func, + GtkMenuTrackerRemoveFunc remove_func, + gpointer user_data) { - return gtk_menu_tracker_new (_gtk_menu_tracker_item_get_observable (item), - _gtk_menu_tracker_item_get_submenu (item), - TRUE, - _gtk_menu_tracker_item_get_submenu_namespace (item), - insert_func, remove_func, user_data); + GtkMenuTracker *tracker; + GMenuModel *submenu; + gchar *namespace; + + submenu = _gtk_menu_tracker_item_get_link (item, link_name); + namespace = _gtk_menu_tracker_item_get_link_namespace (item); + + tracker = gtk_menu_tracker_new (_gtk_menu_tracker_item_get_observable (item), submenu, + TRUE, merge_sections, mac_os_mode, + namespace, NULL, insert_func, remove_func, user_data); + + g_object_unref (submenu); + g_free (namespace); + + return tracker; } /*< private > diff --git a/libqmenumodel/src/gtk/gtkmenutracker.h b/libqmenumodel/src/gtk/gtkmenutracker.h index 1ade63f..2ff0455 100644 --- a/libqmenumodel/src/gtk/gtkmenutracker.h +++ b/libqmenumodel/src/gtk/gtkmenutracker.h @@ -12,9 +12,7 @@ * 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. + * License along with this library; if not, see . * * Author: Ryan Lortie */ @@ -38,12 +36,18 @@ typedef void (* GtkMenuTrackerRemoveFunc) (gint GtkMenuTracker * gtk_menu_tracker_new (GtkActionObservable *observer, GMenuModel *model, gboolean with_separators, + gboolean merge_sections, + gboolean mac_os_mode, const gchar *action_namespace, + GPtrArray *items_already_created, GtkMenuTrackerInsertFunc insert_func, GtkMenuTrackerRemoveFunc remove_func, gpointer user_data); -GtkMenuTracker * gtk_menu_tracker_new_for_item_submenu (GtkMenuTrackerItem *item, +GtkMenuTracker * gtk_menu_tracker_new_for_item_link (GtkMenuTrackerItem *item, + const gchar *link_name, + gboolean merge_sections, + gboolean mac_os_mode, GtkMenuTrackerInsertFunc insert_func, GtkMenuTrackerRemoveFunc remove_func, gpointer user_data); diff --git a/libqmenumodel/src/gtk/gtkmenutrackeritem.c b/libqmenumodel/src/gtk/gtkmenutrackeritem.c index 650e719..d05f1ba 100644 --- a/libqmenumodel/src/gtk/gtkmenutrackeritem.c +++ b/libqmenumodel/src/gtk/gtkmenutrackeritem.c @@ -12,9 +12,7 @@ * 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. + * License along with this library; if not, see . * * Author: Ryan Lortie */ @@ -22,8 +20,13 @@ #include "config.h" #include "gtkmenutrackeritem.h" +#include "gtkactionmuxer.h" -/** +#include "gtkactionmuxer.h" + +#include + +/*< private > * SECTION:gtkmenutrackeritem * @Title: GtkMenuTrackerItem * @Short_description: Small helper for model menu items @@ -34,7 +37,7 @@ * * If an item is one of the non-normal classes (submenu, separator), only the * label of the item needs to be respected. Otherwise, all the properties - * of the item contribute to the item's appearance and state. + * of the item contribute to the item’s appearance and state. * * Implementing the appearance of the menu item is up to toolkits, and certain * toolkits may choose to ignore certain properties, like icon or accel. The @@ -63,7 +66,7 @@ * Applications using submenus may want to lazily build their submenus in * response to the user clicking on it, as building a submenu may be expensive. * - * Thus, the submenu has two special controls -- the submenu's visibility + * Thus, the submenu has two special controls -- the submenu’s visibility * should be controlled by the GtkMenuTrackerItem::submenu-shown property, * and if a user clicks on the submenu, do not immediately show the menu, * but call gtk_menu_tracker_item_request_submenu_shown() and wait for the @@ -83,6 +86,7 @@ struct _GtkMenuTrackerItem GtkActionObservable *observable; gchar *action_namespace; + gchar *action_and_target; GMenuItem *item; GtkMenuTrackerItemRole role : 4; guint is_separator : 1; @@ -91,23 +95,30 @@ struct _GtkMenuTrackerItem guint toggled : 1; guint submenu_shown : 1; guint submenu_requested : 1; + guint hidden_when : 2; + guint is_visible : 1; GVariant *action_state; }; +#define HIDDEN_NEVER 0 +#define HIDDEN_WHEN_MISSING 1 +#define HIDDEN_WHEN_DISABLED 2 +#define HIDDEN_WHEN_ALWAYS 3 + enum { PROP_0, PROP_IS_SEPARATOR, - PROP_HAS_SUBMENU, PROP_LABEL, PROP_ICON, + PROP_VERB_ICON, PROP_SENSITIVE, - PROP_VISIBLE, PROP_ROLE, PROP_TOGGLED, PROP_ACCEL, PROP_SUBMENU_SHOWN, PROP_ACTION_NAME, PROP_ACTION_STATE, + PROP_IS_VISIBLE, N_PROPS }; @@ -153,21 +164,18 @@ gtk_menu_tracker_item_get_property (GObject *object, case PROP_IS_SEPARATOR: g_value_set_boolean (value, gtk_menu_tracker_item_get_is_separator (self)); break; - case PROP_HAS_SUBMENU: - g_value_set_boolean (value, gtk_menu_tracker_item_get_has_submenu (self)); - break; case PROP_LABEL: g_value_set_string (value, gtk_menu_tracker_item_get_label (self)); break; case PROP_ICON: - g_value_set_object (value, gtk_menu_tracker_item_get_icon (self)); + g_value_take_object (value, gtk_menu_tracker_item_get_icon (self)); + break; + case PROP_VERB_ICON: + g_value_take_object (value, gtk_menu_tracker_item_get_verb_icon (self)); break; case PROP_SENSITIVE: g_value_set_boolean (value, gtk_menu_tracker_item_get_sensitive (self)); break; - case PROP_VISIBLE: - g_value_set_boolean (value, gtk_menu_tracker_item_get_visible (self)); - break; case PROP_ROLE: g_value_set_enum (value, gtk_menu_tracker_item_get_role (self)); break; @@ -180,10 +188,12 @@ gtk_menu_tracker_item_get_property (GObject *object, case PROP_SUBMENU_SHOWN: g_value_set_boolean (value, gtk_menu_tracker_item_get_submenu_shown (self)); break; - case PROP_ACTION_NAME: - g_value_take_string (value, gtk_menu_tracker_item_get_action_name (self)); case PROP_ACTION_STATE: g_value_set_variant (value, self->action_state); + case PROP_ACTION_NAME: + g_value_take_string (value, gtk_menu_tracker_item_get_action_name (self)); + case PROP_IS_VISIBLE: + g_value_set_boolean (value, gtk_menu_tracker_item_get_is_visible (self)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); @@ -197,6 +207,7 @@ gtk_menu_tracker_item_finalize (GObject *object) GtkMenuTrackerItem *self = GTK_MENU_TRACKER_ITEM (object); g_free (self->action_namespace); + g_free (self->action_and_target); if (self->observable) g_object_unref (self->observable); @@ -222,16 +233,14 @@ gtk_menu_tracker_item_class_init (GtkMenuTrackerItemClass *class) gtk_menu_tracker_item_pspecs[PROP_IS_SEPARATOR] = g_param_spec_boolean ("is-separator", "", "", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE); - gtk_menu_tracker_item_pspecs[PROP_HAS_SUBMENU] = - g_param_spec_boolean ("has-submenu", "", "", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE); gtk_menu_tracker_item_pspecs[PROP_LABEL] = g_param_spec_string ("label", "", "", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE); gtk_menu_tracker_item_pspecs[PROP_ICON] = g_param_spec_object ("icon", "", "", G_TYPE_ICON, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE); + gtk_menu_tracker_item_pspecs[PROP_VERB_ICON] = + g_param_spec_object ("verb-icon", "", "", G_TYPE_ICON, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE); gtk_menu_tracker_item_pspecs[PROP_SENSITIVE] = g_param_spec_boolean ("sensitive", "", "", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE); - gtk_menu_tracker_item_pspecs[PROP_VISIBLE] = - g_param_spec_boolean ("visible", "", "", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE); gtk_menu_tracker_item_pspecs[PROP_ROLE] = g_param_spec_enum ("role", "", "", GTK_TYPE_MENU_TRACKER_ITEM_ROLE, GTK_MENU_TRACKER_ITEM_ROLE_NORMAL, @@ -246,10 +255,51 @@ gtk_menu_tracker_item_class_init (GtkMenuTrackerItemClass *class) g_param_spec_boolean ("action-name", "", "", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE); gtk_menu_tracker_item_pspecs[PROP_ACTION_STATE] = g_param_spec_boolean ("action-state", "", "", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE); + gtk_menu_tracker_item_pspecs[PROP_IS_VISIBLE] = + g_param_spec_boolean ("is-visible", "", "", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE); g_object_class_install_properties (class, N_PROPS, gtk_menu_tracker_item_pspecs); } +/* This syncs up the visibility for the hidden-when='' case. We call it + * from the action observer functions on changes to the action group and + * on initialisation (via the action observer functions that are invoked + * at that time). + */ +static void +gtk_menu_tracker_item_update_visibility (GtkMenuTrackerItem *self) +{ + gboolean visible; + + switch (self->hidden_when) + { + case HIDDEN_NEVER: + visible = TRUE; + break; + + case HIDDEN_WHEN_MISSING: + visible = self->can_activate; + break; + + case HIDDEN_WHEN_DISABLED: + visible = self->sensitive; + break; + + case HIDDEN_WHEN_ALWAYS: + visible = FALSE; + break; + + default: + g_assert_not_reached (); + } + + if (visible != self->is_visible) + { + self->is_visible = visible; + g_object_notify (G_OBJECT (self), "is-visible"); + } +} + static void gtk_menu_tracker_item_action_added (GtkActionObserver *observer, GtkActionObservable *observable, @@ -309,6 +359,12 @@ gtk_menu_tracker_item_action_added (GtkActionObserver *observer, if (action_target) g_variant_unref (action_target); + + /* In case of hidden-when='', we want to Wait until after refreshing + * all of the properties to emit the signal that will cause the + * tracker to expose us (to prevent too much thrashing). + */ + gtk_menu_tracker_item_update_visibility (self); } static void @@ -328,6 +384,8 @@ gtk_menu_tracker_item_action_enabled_changed (GtkActionObserver *observer, self->sensitive = enabled; g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_SENSITIVE]); + + gtk_menu_tracker_item_update_visibility (self); } static void @@ -373,40 +431,53 @@ gtk_menu_tracker_item_action_removed (GtkActionObserver *observer, const gchar *action_name) { GtkMenuTrackerItem *self = GTK_MENU_TRACKER_ITEM (observer); + gboolean was_sensitive, was_toggled; + GtkMenuTrackerItemRole old_role; if (!self->can_activate) return; - g_object_freeze_notify (G_OBJECT (self)); + was_sensitive = self->sensitive; + was_toggled = self->toggled; + old_role = self->role; - if (self->sensitive) - { - self->sensitive = FALSE; - g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_SENSITIVE]); - } + self->can_activate = FALSE; + self->sensitive = FALSE; + self->toggled = FALSE; + self->role = GTK_MENU_TRACKER_ITEM_ROLE_NORMAL; + self->action_state = NULL; - if (self->toggled) - { - self->toggled = FALSE; - g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_TOGGLED]); - } + /* Backwards from adding: we want to remove ourselves from the menu + * -before- thrashing the properties. + */ + gtk_menu_tracker_item_update_visibility (self); - if (self->role != GTK_MENU_TRACKER_ITEM_ROLE_NORMAL) - { - self->role = GTK_MENU_TRACKER_ITEM_ROLE_NORMAL; - g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_ROLE]); - } + g_object_freeze_notify (G_OBJECT (self)); - if (self->action_state != NULL) - { - g_variant_unref (self->action_state); - self->action_state = NULL; - g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_ACTION_STATE]); - } + if (was_sensitive) + g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_SENSITIVE]); + + if (was_toggled) + g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_TOGGLED]); + + if (old_role != GTK_MENU_TRACKER_ITEM_ROLE_NORMAL) + g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_ROLE]); g_object_thaw_notify (G_OBJECT (self)); } +static void +gtk_menu_tracker_item_primary_accel_changed (GtkActionObserver *observer, + GtkActionObservable *observable, + const gchar *action_name, + const gchar *action_and_target) +{ + GtkMenuTrackerItem *self = GTK_MENU_TRACKER_ITEM (observer); + + if (g_str_equal (action_and_target, self->action_and_target)) + g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_ACCEL]); +} + static void gtk_menu_tracker_item_init_observer_iface (GtkActionObserverInterface *iface) { @@ -414,17 +485,20 @@ gtk_menu_tracker_item_init_observer_iface (GtkActionObserverInterface *iface) iface->action_enabled_changed = gtk_menu_tracker_item_action_enabled_changed; iface->action_state_changed = gtk_menu_tracker_item_action_state_changed; iface->action_removed = gtk_menu_tracker_item_action_removed; + iface->primary_accel_changed = gtk_menu_tracker_item_primary_accel_changed; } GtkMenuTrackerItem * _gtk_menu_tracker_item_new (GtkActionObservable *observable, GMenuModel *model, gint item_index, + gboolean mac_os_mode, const gchar *action_namespace, gboolean is_separator) { GtkMenuTrackerItem *self; const gchar *action_name; + const gchar *hidden_when; g_return_val_if_fail (GTK_IS_ACTION_OBSERVABLE (observable), NULL); g_return_val_if_fail (G_IS_MENU_MODEL (model), NULL); @@ -435,50 +509,72 @@ _gtk_menu_tracker_item_new (GtkActionObservable *observable, self->observable = g_object_ref (observable); self->is_separator = is_separator; + if (!is_separator && g_menu_item_get_attribute (self->item, "hidden-when", "&s", &hidden_when)) + { + if (g_str_equal (hidden_when, "action-disabled")) + self->hidden_when = HIDDEN_WHEN_DISABLED; + else if (g_str_equal (hidden_when, "action-missing")) + self->hidden_when = HIDDEN_WHEN_MISSING; + else if (mac_os_mode && g_str_equal (hidden_when, "macos-menubar")) + self->hidden_when = HIDDEN_WHEN_ALWAYS; + + /* Ignore other values -- this code may be running in context of a + * desktop shell or the like and should not spew criticals due to + * application bugs... + * + * Note: if we just set a hidden-when state, but don't get the + * action_name below then our visibility will be FALSE forever. + * That's to be expected since the action is missing... + */ + } + if (!is_separator && g_menu_item_get_attribute (self->item, "action", "&s", &action_name)) { GActionGroup *group = G_ACTION_GROUP (observable); const GVariantType *parameter_type; + GVariant *target; gboolean enabled; GVariant *state; gboolean found; + target = g_menu_item_get_attribute_value (self->item, "target", NULL); + + self->action_and_target = gtk_print_action_and_target (action_namespace, action_name, target); + + if (target) + g_variant_unref (target); + + action_name = strrchr (self->action_and_target, '|') + 1; + state = NULL; - if (action_namespace) - { - gchar *full_action; + gtk_action_observable_register_observer (self->observable, action_name, GTK_ACTION_OBSERVER (self)); + found = g_action_group_query_action (group, action_name, &enabled, ¶meter_type, NULL, NULL, &state); - full_action = g_strjoin (".", action_namespace, action_name, NULL); - gtk_action_observable_register_observer (self->observable, full_action, GTK_ACTION_OBSERVER (self)); - found = g_action_group_query_action (group, full_action, &enabled, ¶meter_type, NULL, NULL, &state); - g_free (full_action); + if (found) + { + gtk_menu_tracker_item_action_added (GTK_ACTION_OBSERVER (self), observable, NULL, parameter_type, enabled, state); } else { - gtk_action_observable_register_observer (self->observable, action_name, GTK_ACTION_OBSERVER (self)); - found = g_action_group_query_action (group, action_name, &enabled, ¶meter_type, NULL, NULL, &state); + gtk_menu_tracker_item_update_visibility (self); } - if (found) - gtk_menu_tracker_item_action_added (GTK_ACTION_OBSERVER (self), observable, NULL, parameter_type, enabled, state); - else - gtk_menu_tracker_item_action_removed (GTK_ACTION_OBSERVER (self), observable, NULL); - if (state) g_variant_unref (state); } else { + gtk_menu_tracker_item_update_visibility (self); gboolean submenu_enabled; - if (g_menu_item_get_attribute (self->item, "submenu-enabled", "b", &submenu_enabled)) - { - self->sensitive = submenu_enabled; - } - else - { - self->sensitive = TRUE; - } + if (g_menu_item_get_attribute (self->item, "submenu-enabled", "b", &submenu_enabled)) + { + self->sensitive = submenu_enabled; + } + else + { + self->sensitive = TRUE; + } } return self; @@ -490,11 +586,11 @@ _gtk_menu_tracker_item_get_observable (GtkMenuTrackerItem *self) return self->observable; } -/** +/*< private > * gtk_menu_tracker_item_get_is_separator: * @self: A #GtkMenuTrackerItem instance * - * Returns whether the menu item is a separator. If so, only + * Returns: whether the menu item is a separator. If so, only * certain properties may need to be obeyed. See the documentation * for #GtkMenuTrackerItem. */ @@ -504,20 +600,21 @@ gtk_menu_tracker_item_get_is_separator (GtkMenuTrackerItem *self) return self->is_separator; } -/** +/*< private > * gtk_menu_tracker_item_get_has_submenu: * @self: A #GtkMenuTrackerItem instance * - * Returns whether the menu item has a submenu. If so, only + * Returns: whether the menu item has a submenu. If so, only * certain properties may need to be obeyed. See the documentation * for #GtkMenuTrackerItem. */ gboolean -gtk_menu_tracker_item_get_has_submenu (GtkMenuTrackerItem *self) +gtk_menu_tracker_item_get_has_link (GtkMenuTrackerItem *self, + const gchar *link_name) { GMenuModel *link; - link = g_menu_item_get_link (self->item, G_MENU_LINK_SUBMENU); + link = g_menu_item_get_link (self->item, link_name); if (link) { @@ -538,7 +635,7 @@ gtk_menu_tracker_item_get_label (GtkMenuTrackerItem *self) return label; } -/** +/*< private > * gtk_menu_tracker_item_get_icon: * * Returns: (transfer full): @@ -560,16 +657,32 @@ gtk_menu_tracker_item_get_icon (GtkMenuTrackerItem *self) return icon; } -gboolean -gtk_menu_tracker_item_get_sensitive (GtkMenuTrackerItem *self) +/*< private > + * gtk_menu_tracker_item_get_verb_icon: + * + * Returns: (transfer full): + */ +GIcon * +gtk_menu_tracker_item_get_verb_icon (GtkMenuTrackerItem *self) { - return self->sensitive; + GVariant *icon_data; + GIcon *icon; + + icon_data = g_menu_item_get_attribute_value (self->item, "verb-icon", NULL); + + if (icon_data == NULL) + return NULL; + + icon = g_icon_deserialize (icon_data); + g_variant_unref (icon_data); + + return icon; } gboolean -gtk_menu_tracker_item_get_visible (GtkMenuTrackerItem *self) +gtk_menu_tracker_item_get_sensitive (GtkMenuTrackerItem *self) { - return TRUE; + return self->sensitive; } GtkMenuTrackerItemRole @@ -587,21 +700,59 @@ gtk_menu_tracker_item_get_toggled (GtkMenuTrackerItem *self) const gchar * gtk_menu_tracker_item_get_accel (GtkMenuTrackerItem *self) { - const gchar *accel = NULL; + const gchar *accel; + + if (!self->action_and_target) + return NULL; - g_menu_item_get_attribute (self->item, "accel", "&s", &accel); + if (g_menu_item_get_attribute (self->item, "accel", "&s", &accel)) + return accel; + + if (!GTK_IS_ACTION_MUXER (self->observable)) + return NULL; - return accel; + return gtk_action_muxer_get_primary_accel (GTK_ACTION_MUXER (self->observable), self->action_and_target); +} + +const gchar * +gtk_menu_tracker_item_get_special (GtkMenuTrackerItem *self) +{ + const gchar *special = NULL; + + g_menu_item_get_attribute (self->item, "x-gtk-private-special", "&s", &special); + + return special; +} + +const gchar * +gtk_menu_tracker_item_get_display_hint (GtkMenuTrackerItem *self) +{ + const gchar *display_hint = NULL; + + g_menu_item_get_attribute (self->item, "display-hint", "&s", &display_hint); + + return display_hint; +} + +const gchar * +gtk_menu_tracker_item_get_text_direction (GtkMenuTrackerItem *self) +{ + const gchar *text_direction = NULL; + + g_menu_item_get_attribute (self->item, "text-direction", "&s", &text_direction); + + return text_direction; } GMenuModel * -_gtk_menu_tracker_item_get_submenu (GtkMenuTrackerItem *self) +_gtk_menu_tracker_item_get_link (GtkMenuTrackerItem *self, + const gchar *link_name) { - return g_menu_item_get_link (self->item, "submenu"); + return g_menu_item_get_link (self->item, link_name); } gchar * -_gtk_menu_tracker_item_get_submenu_namespace (GtkMenuTrackerItem *self) +_gtk_menu_tracker_item_get_link_namespace (GtkMenuTrackerItem *self) { const gchar *namespace; @@ -632,10 +783,7 @@ gtk_menu_tracker_item_get_submenu_shown (GtkMenuTrackerItem *self) * gtk_menu_tracker_item_get_action_name: * @self: A #GtkMenuTrackerItem instance * - * Returns a newly-allocated string containing the name of the action - * associated with this menu item. - * - * Returns: (transfer full): the action name, free it with g_free() + * Returns the action name */ gchar * gtk_menu_tracker_item_get_action_name (GtkMenuTrackerItem *self) @@ -643,12 +791,12 @@ gtk_menu_tracker_item_get_action_name (GtkMenuTrackerItem *self) const gchar *action_name; if (!g_menu_item_get_attribute (self->item, G_MENU_ATTRIBUTE_ACTION, "&s", &action_name)) - return NULL; + return NULL; if (self->action_namespace) - return g_strjoin (".", self->action_namespace, action_name, NULL); - else - return g_strdup (action_name); + return g_strjoin (".", self->action_namespace, action_name, NULL); + else + return g_strdup (action_name); } GVariant * @@ -688,19 +836,10 @@ gtk_menu_tracker_item_activated (GtkMenuTrackerItem *self) if (!self->can_activate) return; - g_menu_item_get_attribute (self->item, G_MENU_ATTRIBUTE_ACTION, "&s", &action_name); + action_name = strrchr (self->action_and_target, '|') + 1; action_target = g_menu_item_get_attribute_value (self->item, G_MENU_ATTRIBUTE_TARGET, NULL); - if (self->action_namespace) - { - gchar *full_action; - - full_action = g_strjoin (".", self->action_namespace, action_name, NULL); - g_action_group_activate_action (G_ACTION_GROUP (self->observable), full_action, action_target); - g_free (full_action); - } - else - g_action_group_activate_action (G_ACTION_GROUP (self->observable), action_name, action_target); + g_action_group_activate_action (G_ACTION_GROUP (self->observable), action_name, action_target); if (action_target) g_variant_unref (action_target); @@ -930,3 +1069,30 @@ gtk_menu_tracker_item_get_attribute_value (GtkMenuTrackerItem *self, { return g_menu_item_get_attribute_value (self->item, attribute, expected_type); } + +/** + * gtk_menu_tracker_item_get_is_visible: + * @self: A #GtkMenuTrackerItem instance + * + * Don't use this unless you're tracking items for yourself -- normally + * the tracker will emit add/remove automatically when this changes. + * + * Returns: if the item should currently be shown + */ +gboolean +gtk_menu_tracker_item_get_is_visible (GtkMenuTrackerItem *self) +{ + return self->is_visible; +} + +/** + * gtk_menu_tracker_item_may_disappear: + * @self: A #GtkMenuTrackerItem instance + * + * Returns: if the item may disappear (ie: is-visible property may change) + */ +gboolean +gtk_menu_tracker_item_may_disappear (GtkMenuTrackerItem *self) +{ + return self->hidden_when != HIDDEN_NEVER; +} diff --git a/libqmenumodel/src/gtk/gtkmenutrackeritem.h b/libqmenumodel/src/gtk/gtkmenutrackeritem.h index dc62bf1..3fbec27 100644 --- a/libqmenumodel/src/gtk/gtkmenutrackeritem.h +++ b/libqmenumodel/src/gtk/gtkmenutrackeritem.h @@ -45,22 +45,30 @@ GType gtk_menu_tracker_item_role_get_type (void) G GtkMenuTrackerItem * _gtk_menu_tracker_item_new (GtkActionObservable *observable, GMenuModel *model, gint item_index, + gboolean mac_os_mode, const gchar *action_namespace, gboolean is_separator); +const gchar * gtk_menu_tracker_item_get_special (GtkMenuTrackerItem *self); + +const gchar * gtk_menu_tracker_item_get_display_hint (GtkMenuTrackerItem *self); + +const gchar * gtk_menu_tracker_item_get_text_direction (GtkMenuTrackerItem *self); + GtkActionObservable * _gtk_menu_tracker_item_get_observable (GtkMenuTrackerItem *self); gboolean gtk_menu_tracker_item_get_is_separator (GtkMenuTrackerItem *self); -gboolean gtk_menu_tracker_item_get_has_submenu (GtkMenuTrackerItem *self); +gboolean gtk_menu_tracker_item_get_has_link (GtkMenuTrackerItem *self, + const gchar *link_name); const gchar * gtk_menu_tracker_item_get_label (GtkMenuTrackerItem *self); GIcon * gtk_menu_tracker_item_get_icon (GtkMenuTrackerItem *self); -gboolean gtk_menu_tracker_item_get_sensitive (GtkMenuTrackerItem *self); +GIcon * gtk_menu_tracker_item_get_verb_icon (GtkMenuTrackerItem *self); -gboolean gtk_menu_tracker_item_get_visible (GtkMenuTrackerItem *self); +gboolean gtk_menu_tracker_item_get_sensitive (GtkMenuTrackerItem *self); GtkMenuTrackerItemRole gtk_menu_tracker_item_get_role (GtkMenuTrackerItem *self); @@ -68,9 +76,14 @@ gboolean gtk_menu_tracker_item_get_toggled (GtkMenu const gchar * gtk_menu_tracker_item_get_accel (GtkMenuTrackerItem *self); -GMenuModel * _gtk_menu_tracker_item_get_submenu (GtkMenuTrackerItem *self); +GMenuModel * _gtk_menu_tracker_item_get_link (GtkMenuTrackerItem *self, + const gchar *link_name); -gchar * _gtk_menu_tracker_item_get_submenu_namespace (GtkMenuTrackerItem *self); +gchar * _gtk_menu_tracker_item_get_link_namespace (GtkMenuTrackerItem *self); + +gboolean gtk_menu_tracker_item_may_disappear (GtkMenuTrackerItem *self); + +gboolean gtk_menu_tracker_item_get_is_visible (GtkMenuTrackerItem *self); gboolean gtk_menu_tracker_item_get_should_request_show (GtkMenuTrackerItem *self); @@ -79,15 +92,12 @@ void gtk_menu_tracker_item_activated (GtkMenu void gtk_menu_tracker_item_change_state (GtkMenuTrackerItem *self, GVariant *value); - - - void gtk_menu_tracker_item_request_submenu_shown (GtkMenuTrackerItem *self, gboolean shown); gboolean gtk_menu_tracker_item_get_submenu_shown (GtkMenuTrackerItem *self); -gchar * gtk_menu_tracker_item_get_action_name (GtkMenuTrackerItem *self); +gchar * gtk_menu_tracker_item_get_action_name (GtkMenuTrackerItem *self); GVariant * gtk_menu_tracker_item_get_action_state (GtkMenuTrackerItem *self); -- cgit v1.2.3