jean
/
Learning_GTK4_tree
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Learning_GTK4_tree/gtk/gtkactionmuxer.c

1485 lines
45 KiB
C
Raw Normal View History

initial
2023-12-12 11:36:42 +01:00
/*
* Copyright © 2011 Canonical Limited
*
* 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 licence, 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, see <http://www.gnu.org/licenses/>.
*
* Author: Ryan Lortie <desrt@desrt.ca>
*/
#include "config.h"
#include "gtkactionmuxerprivate.h"
#include "gtkactionobservableprivate.h"
#include "gtkactionobserverprivate.h"
#include "gtkbitmaskprivate.h"
#include "gtkmarshalers.h"
#include "gtkwidgetprivate.h"
#include "gsettings-mapping.h"
#include "gtkdebug.h"
#include "gtkprivate.h"
#include <string.h>
typedef struct
{
char *action_and_target;
char *accel;
} GtkAccel;
static void
gtk_accel_clear (GtkAccel *accel)
{
g_free (accel->action_and_target);
g_free (accel->accel);
}
#define GDK_ARRAY_NAME gtk_accels
#define GDK_ARRAY_TYPE_NAME GtkAccels
#define GDK_ARRAY_ELEMENT_TYPE GtkAccel
#define GDK_ARRAY_FREE_FUNC gtk_accel_clear
#define GDK_ARRAY_BY_VALUE 1
#define GDK_ARRAY_PREALLOC 2
#include "gdk/gdkarrayimpl.c"
static guint
gtk_accels_find (GtkAccels *accels,
const char *action_and_target)
{
guint i;
for (i = 0; i < gtk_accels_get_size (accels); i++)
{
GtkAccel *accel = gtk_accels_index (accels, i);
if (strcmp (accel->action_and_target, action_and_target) == 0)
return i;
}
return G_MAXUINT;
}
static void
gtk_accels_replace (GtkAccels *accels,
const char *action_and_target,
const char *primary_accel)
{
guint position;
position = gtk_accels_find (accels, action_and_target);
if (position < gtk_accels_get_size (accels))
{
GtkAccel *accel = gtk_accels_index (accels, position);
g_free (accel->accel);
accel->accel = g_strdup (primary_accel);
}
else
{
GtkAccel accel;
accel.action_and_target = g_strdup (action_and_target);
accel.accel = g_strdup (primary_accel);
gtk_accels_append (accels, &accel);
}
}
static void
gtk_accels_remove (GtkAccels *accels,
const char *action_and_target)
{
guint position;
position = gtk_accels_find (accels, action_and_target);
if (position < gtk_accels_get_size (accels))
gtk_accels_splice (accels, position, 1, FALSE, NULL, 0);
}
/*< private >
* GtkActionMuxer:
*
* GtkActionMuxer aggregates and monitors actions from multiple sources.
*
* `GtkActionMuxer` is `GtkActionObservable` and `GtkActionObserver` that
* offers a `GActionGroup`-like api and is capable of containing other
* `GActionGroup` instances. `GtkActionMuxer` does not implement the
* `GActionGroup` interface because it requires excessive signal emissions
* and has poor scalability. We use the `GtkActionObserver` machinery
* instead to propagate changes between action muxer instances and
* to other users.
*
* Beyond action groups, `GtkActionMuxer` can incorporate actions that
* are associated with widget classes (*class actions*) and actions
* that are associated with the parent widget, allowing for recursive
* lookup.
*
* In addition to the action attributes provided by `GActionGroup`,
* `GtkActionMuxer` maintains a *primary accelerator* string for
* actions that can be shown in menuitems.
*
* The typical use is aggregating all of the actions applicable to a
* 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
* containing actions applicable to a particular window in the
* 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 `GActionGroup`-like interface presented by the `GtkActionMuxer`.
*
* Activations and state change requests on the `GtkActionMuxer` are
* wired through to the underlying actions in the expected way.
*
* 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).
*/
static void gtk_action_muxer_observable_iface_init (GtkActionObservableInterface *iface);
static void gtk_action_muxer_observer_iface_init (GtkActionObserverInterface *iface);
typedef GObjectClass GtkActionMuxerClass;
struct _GtkActionMuxer
{
GObject parent_instance;
GtkActionMuxer *parent;
GtkWidget *widget;
GHashTable *observed_actions;
GHashTable *groups;
GtkAccels primary_accels;
GtkBitmask *widget_actions_disabled;
};
G_DEFINE_TYPE_WITH_CODE (GtkActionMuxer, gtk_action_muxer, G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTION_OBSERVER, gtk_action_muxer_observer_iface_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTION_OBSERVABLE, gtk_action_muxer_observable_iface_init))
enum
{
PROP_0,
PROP_PARENT,
PROP_WIDGET,
NUM_PROPERTIES
};
static GParamSpec *properties[NUM_PROPERTIES];
typedef struct
{
GtkActionMuxer *muxer;
GSList *watchers;
char *fullname;
} Action;
typedef struct
{
GtkActionMuxer *muxer;
GActionGroup *group;
char *prefix;
gulong handler_ids[4];
} Group;
static inline guint
get_action_position (GtkWidgetAction *action)
{
guint slot;
/* We use the length of @action to the end of the chain as the slot so that
* we have stable positions for any class or it's subclasses. Doing so helps
* us avoid having mutable arrays in the class data as we will not have
* access to the ClassPrivate data during instance _init() functions.
*/
for (slot = 0; action->next != NULL; slot++, action = action->next) {}
return slot;
}
static void
gtk_action_muxer_append_group_actions (const char *prefix,
Group *group,
GHashTable *actions)
{
char **group_actions;
char **action;
group_actions = g_action_group_list_actions (group->group);
for (action = group_actions; *action; action++)
{
char *name = g_strconcat (prefix, ".", *action, NULL);
g_hash_table_add (actions, name);
}
g_strfreev (group_actions);
}
char **
gtk_action_muxer_list_actions (GtkActionMuxer *muxer,
gboolean local_only)
{
GHashTable *actions;
char **keys;
g_return_val_if_fail (GTK_IS_ACTION_MUXER (muxer), NULL);
actions = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
for ( ; muxer != NULL; muxer = muxer->parent)
{
GHashTableIter iter;
const char *prefix;
Group *group;
if (muxer->widget)
{
GtkWidgetClass *klass = GTK_WIDGET_GET_CLASS (muxer->widget);
GtkWidgetClassPrivate *priv = klass->priv;
GtkWidgetAction *action;
for (action = priv->actions; action; action = action->next)
g_hash_table_add (actions, g_strdup (action->name));
}
if (muxer->groups)
{
g_hash_table_iter_init (&iter, muxer->groups);
while (g_hash_table_iter_next (&iter, (gpointer *)&prefix, (gpointer *)&group))
gtk_action_muxer_append_group_actions (prefix, group, actions);
}
if (local_only)
break;
}
keys = (char **)g_hash_table_get_keys_as_array (actions, NULL);
g_hash_table_steal_all (actions);
g_hash_table_unref (actions);
return (char **)keys;
}
static Group *
gtk_action_muxer_find_group (GtkActionMuxer *muxer,
const char *full_name,
const char **action_name)
{
const char *dot;
char *prefix;
const char *name;
Group *group;
if (!muxer->groups)
return NULL;
dot = strchr (full_name, '.');
if (!dot)
return NULL;
name = dot + 1;
prefix = g_strndup (full_name, dot - full_name);
group = g_hash_table_lookup (muxer->groups, prefix);
g_free (prefix);
if (action_name)
*action_name = name;
if (group &&
g_action_group_has_action (group->group, name))
return group;
return NULL;
}
GActionGroup *
gtk_action_muxer_find (GtkActionMuxer *muxer,
const char *action_name,
const char **unprefixed_name)
{
Group *group;
group = gtk_action_muxer_find_group (muxer, action_name, unprefixed_name);
if (group)
return group->group;
return NULL;
}
GActionGroup *
gtk_action_muxer_get_group (GtkActionMuxer *muxer,
const char *group_name)
{
Group *group;
if (!muxer->groups)
return NULL;
group = g_hash_table_lookup (muxer->groups, group_name);
if (group)
return group->group;
return NULL;
}
static inline Action *
find_observers (GtkActionMuxer *muxer,
const char *action_name)
{
if (muxer->observed_actions)
return g_hash_table_lookup (muxer->observed_actions, action_name);
return NULL;
}
void
gtk_action_muxer_action_enabled_changed (GtkActionMuxer *muxer,
const char *action_name,
gboolean enabled)
{
GtkWidgetAction *iter;
Action *action;
GSList *node;
if (muxer->widget)
{
GtkWidgetClass *klass = GTK_WIDGET_GET_CLASS (muxer->widget);
GtkWidgetClassPrivate *priv = klass->priv;
for (iter = priv->actions; iter; iter = iter->next)
{
if (strcmp (action_name, iter->name) == 0)
{
guint position = get_action_position (iter);
muxer->widget_actions_disabled =
_gtk_bitmask_set (muxer->widget_actions_disabled, position, !enabled);
break;
}
}
}
action = find_observers (muxer, action_name);
for (node = action ? action->watchers : NULL; node; node = node->next)
gtk_action_observer_action_enabled_changed (node->data, GTK_ACTION_OBSERVABLE (muxer), action_name, enabled);
}
static void
gtk_action_muxer_group_action_enabled_changed (GActionGroup *action_group,
const char *action_name,
gboolean enabled,
gpointer user_data)
{
Group *group = user_data;
char *fullname;
fullname = g_strconcat (group->prefix, ".", action_name, NULL);
gtk_action_muxer_action_enabled_changed (group->muxer, fullname, enabled);
g_free (fullname);
}
void
gtk_action_muxer_action_state_changed (GtkActionMuxer *muxer,
const char *action_name,
GVariant *state)
{
Action *action;
GSList *node;
action = find_observers (muxer, action_name);
for (node = action ? action->watchers : NULL; node; node = node->next)
gtk_action_observer_action_state_changed (node->data, GTK_ACTION_OBSERVABLE (muxer), action_name, state);
}
static void
gtk_action_muxer_group_action_state_changed (GActionGroup *action_group,
const char *action_name,
GVariant *state,
gpointer user_data)
{
Group *group = user_data;
char *fullname;
fullname = g_strconcat (group->prefix, ".", action_name, NULL);
gtk_action_muxer_action_state_changed (group->muxer, fullname, state);
g_free (fullname);
}
static gboolean action_muxer_query_action (GtkActionMuxer *muxer,
const char *action_name,
gboolean *enabled,
const GVariantType **parameter_type,
const GVariantType **state_type,
GVariant **state_hint,
GVariant **state,
gboolean recurse);
static void
notify_observers_added (GtkActionMuxer *muxer,
GtkActionMuxer *parent)
{
GHashTableIter iter;
const char *action_name;
Action *action;
if (!muxer->observed_actions)
return;
g_hash_table_iter_init (&iter, muxer->observed_actions);
while (g_hash_table_iter_next (&iter, (gpointer *)&action_name, (gpointer *)&action))
{
const GVariantType *parameter_type;
gboolean enabled;
GVariant *state;
GSList *node;
GSList *action_watchers;
action_watchers = action ? action->watchers : NULL;
if (!action_watchers)
continue;
for (node = action_watchers; node; node = node->next)
gtk_action_observer_primary_accel_changed (node->data, GTK_ACTION_OBSERVABLE (muxer),
action_name, NULL);
gtk_action_observable_register_observer (GTK_ACTION_OBSERVABLE (parent), action_name, GTK_ACTION_OBSERVER (muxer));
if (!action_muxer_query_action (muxer, action_name,
&enabled, &parameter_type,
NULL, NULL, &state,
TRUE))
continue;
for (node = action_watchers; node; node = node->next)
{
gtk_action_observer_action_added (node->data,
GTK_ACTION_OBSERVABLE (muxer),
action_name, parameter_type, enabled, state);
}
if (state)
g_variant_unref (state);
}
}
static void
notify_observers_removed (GtkActionMuxer *muxer,
GtkActionMuxer *parent)
{
GHashTableIter iter;
const char *action_name;
Action *action;
if (!muxer->observed_actions)
return;
g_hash_table_iter_init (&iter, muxer->observed_actions);
while (g_hash_table_iter_next (&iter, (gpointer *)&action_name, (gpointer *)&action))
{
GSList *node;
gtk_action_observable_unregister_observer (GTK_ACTION_OBSERVABLE (parent), action_name, GTK_ACTION_OBSERVER (muxer));
for (node = action->watchers; node; node = node->next)
{
gtk_action_observer_action_removed (node->data,
GTK_ACTION_OBSERVABLE (muxer),
action_name);
}
}
}
static void
gtk_action_muxer_action_added (GtkActionMuxer *muxer,
const char *action_name,
const GVariantType *parameter_type,
gboolean enabled,
GVariant *state)
{
Action *action;
GSList *node;
action = find_observers (muxer, action_name);
for (node = action ? action->watchers : NULL; node; node = node->next)
gtk_action_observer_action_added (node->data,
GTK_ACTION_OBSERVABLE (muxer),
action_name, parameter_type, enabled, state);
}
static void
gtk_action_muxer_action_added_to_group (GActionGroup *action_group,
const char *action_name,
gpointer user_data)
{
Group *group = user_data;
GtkActionMuxer *muxer = group->muxer;
Action *action;
const GVariantType *parameter_type;
gboolean enabled;
GVariant *state;
char *fullname;
fullname = g_strconcat (group->prefix, ".", action_name, NULL);
if (muxer->parent)
gtk_action_observable_unregister_observer (GTK_ACTION_OBSERVABLE (muxer->parent),
fullname,
GTK_ACTION_OBSERVER (muxer));
action = find_observers (muxer, fullname);
if (action && action->watchers &&
g_action_group_query_action (action_group, action_name,
&enabled, &parameter_type, NULL, NULL, &state))
{
gtk_action_muxer_action_added (muxer, fullname, parameter_type, enabled, state);
if (state)
g_variant_unref (state);
}
g_free (fullname);
}
static void
gtk_action_muxer_action_removed (GtkActionMuxer *muxer,
const char *action_name)
{
Action *action;
GSList *node;
action = find_observers (muxer, action_name);
for (node = action ? action->watchers : NULL; node; node = node->next)
gtk_action_observer_action_removed (node->data, GTK_ACTION_OBSERVABLE (muxer), action_name);
}
static void
gtk_action_muxer_action_removed_from_group (GActionGroup *action_group,
const char *action_name,
gpointer user_data)
{
Group *group = user_data;
GtkActionMuxer *muxer = group->muxer;
char *fullname;
Action *action;
fullname = g_strconcat (group->prefix, ".", action_name, NULL);
gtk_action_muxer_action_removed (muxer, fullname);
g_free (fullname);
action = find_observers (muxer, action_name);
if (action && action->watchers &&
!action_muxer_query_action (muxer, action_name,
NULL, NULL, NULL, NULL, NULL, FALSE))
{
if (muxer->parent)
gtk_action_observable_register_observer (GTK_ACTION_OBSERVABLE (muxer->parent),
action_name,
GTK_ACTION_OBSERVER (muxer));
}
}
static void
gtk_action_muxer_primary_accel_changed (GtkActionMuxer *muxer,
const char *action_name,
const char *action_and_target)
{
Action *action;
GSList *node;
if (!action_name)
action_name = strrchr (action_and_target, '|') + 1;
action = find_observers (muxer, 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);
}
static GVariant *
prop_action_get_state (GtkWidget *widget,
GtkWidgetAction *action)
{
GValue value = G_VALUE_INIT;
GVariant *result;
g_value_init (&value, action->pspec->value_type);
g_object_get_property (G_OBJECT (widget), action->pspec->name, &value);
result = g_settings_set_mapping (&value, action->state_type, NULL);
g_value_unset (&value);
return g_variant_ref_sink (result);
}
static GVariant *
prop_action_get_state_hint (GtkWidget *widget,
GtkWidgetAction *action)
{
if (action->pspec->value_type == G_TYPE_INT)
{
GParamSpecInt *pspec = (GParamSpecInt *)action->pspec;
return g_variant_new ("(ii)", pspec->minimum, pspec->maximum);
}
else if (action->pspec->value_type == G_TYPE_UINT)
{
GParamSpecUInt *pspec = (GParamSpecUInt *)action->pspec;
return g_variant_new ("(uu)", pspec->minimum, pspec->maximum);
}
else if (action->pspec->value_type == G_TYPE_FLOAT)
{
GParamSpecFloat *pspec = (GParamSpecFloat *)action->pspec;
return g_variant_new ("(dd)", (double)pspec->minimum, (double)pspec->maximum);
}
else if (action->pspec->value_type == G_TYPE_DOUBLE)
{
GParamSpecDouble *pspec = (GParamSpecDouble *)action->pspec;
return g_variant_new ("(dd)", pspec->minimum, pspec->maximum);
}
return NULL;
}
static void
prop_action_set_state (GtkWidget *widget,
GtkWidgetAction *action,
GVariant *state)
{
GValue value = G_VALUE_INIT;
g_value_init (&value, action->pspec->value_type);
g_settings_get_mapping (&value, state, NULL);
g_object_set_property (G_OBJECT (widget), action->pspec->name, &value);
g_value_unset (&value);
}
static void
prop_action_activate (GtkWidget *widget,
GtkWidgetAction *action,
GVariant *parameter)
{
if (action->pspec->value_type == G_TYPE_BOOLEAN)
{
gboolean value;
g_return_if_fail (parameter == NULL);
g_object_get (G_OBJECT (widget), action->pspec->name, &value, NULL);
value = !value;
g_object_set (G_OBJECT (widget), action->pspec->name, value, NULL);
}
else
{
g_return_if_fail (parameter != NULL && g_variant_is_of_type (parameter, action->state_type));
prop_action_set_state (widget, action, parameter);
}
}
static void
prop_action_notify (GObject *object,
GParamSpec *pspec,
gpointer user_data)
{
GtkWidget *widget = GTK_WIDGET (object);
GtkWidgetAction *action = user_data;
GtkActionMuxer *muxer = _gtk_widget_get_action_muxer (widget, TRUE);
GVariant *state;
g_assert (muxer->widget == widget);
g_assert (action->pspec == pspec);
state = prop_action_get_state (widget, action);
gtk_action_muxer_action_state_changed (muxer, action->name, state);
g_variant_unref (state);
}
static void
prop_actions_connect (GtkActionMuxer *muxer)
{
GtkWidgetClassPrivate *priv;
GtkWidgetAction *action;
GtkWidgetClass *klass;
guint signal_id;
if (!muxer->widget)
return;
klass = GTK_WIDGET_GET_CLASS (muxer->widget);
priv = klass->priv;
if (!priv->actions)
return;
signal_id = g_signal_lookup ("notify", G_TYPE_OBJECT);
for (action = priv->actions; action; action = action->next)
{
if (!action->pspec)
continue;
g_signal_connect_closure_by_id (muxer->widget,
signal_id,
g_param_spec_get_name_quark (action->pspec),
g_cclosure_new (G_CALLBACK (prop_action_notify),
action,
NULL),
FALSE);
}
}
static gboolean
action_muxer_query_action (GtkActionMuxer *muxer,
const char *action_name,
gboolean *enabled,
const GVariantType **parameter_type,
const GVariantType **state_type,
GVariant **state_hint,
GVariant **state,
gboolean recurse)
{
GtkWidgetAction *action;
Group *group;
const char *unprefixed_name;
if (muxer->widget)
{
GtkWidgetClass *klass = GTK_WIDGET_GET_CLASS (muxer->widget);
GtkWidgetClassPrivate *priv = klass->priv;
for (action = priv->actions; action; action = action->next)
{
guint position;
if (strcmp (action->name, action_name) != 0)
continue;
position = get_action_position (action);
if (enabled)
*enabled = !_gtk_bitmask_get (muxer->widget_actions_disabled, position);
if (parameter_type)
*parameter_type = action->parameter_type;
if (state_type)
*state_type = action->state_type;
if (state_hint)
*state_hint = NULL;
if (state)
*state = NULL;
if (action->pspec)
{
if (state)
*state = prop_action_get_state (muxer->widget, action);
if (state_hint)
*state_hint = prop_action_get_state_hint (muxer->widget, action);
}
return TRUE;
}
}
group = gtk_action_muxer_find_group (muxer, action_name, &unprefixed_name);
if (group)
return g_action_group_query_action (group->group, unprefixed_name, enabled,
parameter_type, state_type, state_hint, state);
if (muxer->parent && recurse)
return gtk_action_muxer_query_action (muxer->parent, action_name,
enabled, parameter_type,
state_type, state_hint, state);
return FALSE;
}
gboolean
gtk_action_muxer_query_action (GtkActionMuxer *muxer,
const char *action_name,
gboolean *enabled,
const GVariantType **parameter_type,
const GVariantType **state_type,
GVariant **state_hint,
GVariant **state)
{
return action_muxer_query_action (muxer, action_name,
enabled, parameter_type,
state_type, state_hint, state,
TRUE);
}
gboolean
gtk_action_muxer_has_action (GtkActionMuxer *muxer,
const char *action_name)
{
return action_muxer_query_action (muxer, action_name,
NULL, NULL, NULL, NULL, NULL,
TRUE);
}
void
gtk_action_muxer_activate_action (GtkActionMuxer *muxer,
const char *action_name,
GVariant *parameter)
{
const char *unprefixed_name;
Group *group;
if (muxer->widget)
{
GtkWidgetClass *klass = GTK_WIDGET_GET_CLASS (muxer->widget);
GtkWidgetClassPrivate *priv = klass->priv;
GtkWidgetAction *action;
for (action = priv->actions; action; action = action->next)
{
if (strcmp (action->name, action_name) == 0)
{
guint position = get_action_position (action);
if (!_gtk_bitmask_get (muxer->widget_actions_disabled, position))
{
if (action->activate)
{
GTK_DEBUG (ACTIONS, "%s: activate action", action->name);
action->activate (muxer->widget, action->name, parameter);
}
else if (action->pspec)
{
GTK_DEBUG (ACTIONS, "%s: activate prop action", action->pspec->name);
prop_action_activate (muxer->widget, action, parameter);
}
}
return;
}
}
}
group = gtk_action_muxer_find_group (muxer, action_name, &unprefixed_name);
if (group)
g_action_group_activate_action (group->group, unprefixed_name, parameter);
else if (muxer->parent)
gtk_action_muxer_activate_action (muxer->parent, action_name, parameter);
}
void
gtk_action_muxer_change_action_state (GtkActionMuxer *muxer,
const char *action_name,
GVariant *state)
{
GtkWidgetAction *action;
const char *unprefixed_name;
Group *group;
if (muxer->widget)
{
GtkWidgetClass *klass = GTK_WIDGET_GET_CLASS (muxer->widget);
GtkWidgetClassPrivate *priv = klass->priv;
for (action = priv->actions; action; action = action->next)
{
if (strcmp (action->name, action_name) == 0)
{
if (action->pspec)
prop_action_set_state (muxer->widget, action, state);
return;
}
}
}
group = gtk_action_muxer_find_group (muxer, action_name, &unprefixed_name);
if (group)
g_action_group_change_action_state (group->group, unprefixed_name, state);
else if (muxer->parent)
gtk_action_muxer_change_action_state (muxer->parent, action_name, state);
}
static void
gtk_action_muxer_unregister_internal (Action *action,
gpointer observer)
{
GtkActionMuxer *muxer = action->muxer;
GSList **ptr;
for (ptr = &action->watchers; *ptr; ptr = &(*ptr)->next)
if ((*ptr)->data == observer)
{
*ptr = g_slist_remove (*ptr, observer);
if (action->watchers == NULL)
{
if (muxer->parent)
gtk_action_observable_unregister_observer (GTK_ACTION_OBSERVABLE (muxer->parent),
action->fullname,
GTK_ACTION_OBSERVER (muxer));
g_hash_table_remove (muxer->observed_actions, action->fullname);
}
break;
}
}
static void
gtk_action_muxer_weak_notify (gpointer data,
GObject *where_the_object_was)
{
Action *action = data;
gtk_action_muxer_unregister_internal (action, where_the_object_was);
}
static void gtk_action_muxer_free_action (gpointer data);
static void
gtk_action_muxer_register_observer (GtkActionObservable *observable,
const char *name,
GtkActionObserver *observer)
{
GtkActionMuxer *muxer = GTK_ACTION_MUXER (observable);
Action *action;
gboolean enabled;
const GVariantType *parameter_type;
GVariant *state;
gboolean is_duplicate;
if (!muxer->observed_actions)
muxer->observed_actions = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, gtk_action_muxer_free_action);
action = g_hash_table_lookup (muxer->observed_actions, name);
if (action == NULL)
{
action = g_new (Action, 1);
action->muxer = muxer;
action->fullname = g_strdup (name);
action->watchers = NULL;
g_hash_table_insert (muxer->observed_actions, action->fullname, action);
}
is_duplicate = g_slist_find (action->watchers, observer) != NULL;
action->watchers = g_slist_prepend (action->watchers, observer);
g_object_weak_ref (G_OBJECT (observer), gtk_action_muxer_weak_notify, action);
if (!is_duplicate)
{
if (action_muxer_query_action (muxer, name,
&enabled, &parameter_type,
NULL, NULL, &state, TRUE))
{
gtk_action_muxer_action_added (muxer, name, parameter_type, enabled, state);
g_clear_pointer (&state, g_variant_unref);
}
if (muxer->parent)
{
gtk_action_observable_register_observer (GTK_ACTION_OBSERVABLE (muxer->parent),
name,
GTK_ACTION_OBSERVER (muxer));
}
}
}
static void
gtk_action_muxer_unregister_observer (GtkActionObservable *observable,
const char *name,
GtkActionObserver *observer)
{
GtkActionMuxer *muxer = GTK_ACTION_MUXER (observable);
Action *action = find_observers (muxer, name);
if (action)
{
if (g_slist_find (action->watchers, observer) != NULL)
{
g_object_weak_unref (G_OBJECT (observer), gtk_action_muxer_weak_notify, action);
gtk_action_muxer_unregister_internal (action, observer);
}
}
}
static void
gtk_action_muxer_free_group (gpointer data)
{
Group *group = data;
int i;
/* 'for loop' or 'four loop'? */
for (i = 0; i < 4; i++)
g_signal_handler_disconnect (group->group, group->handler_ids[i]);
g_object_unref (group->group);
g_free (group->prefix);
g_free (group);
}
static void
gtk_action_muxer_free_action (gpointer data)
{
Action *action = data;
GSList *it;
for (it = action->watchers; it; it = it->next)
g_object_weak_unref (G_OBJECT (it->data), gtk_action_muxer_weak_notify, action);
g_slist_free (action->watchers);
g_free (action->fullname);
g_free (action);
}
static void
gtk_action_muxer_finalize (GObject *object)
{
GtkActionMuxer *muxer = GTK_ACTION_MUXER (object);
if (muxer->observed_actions)
{
g_assert_cmpint (g_hash_table_size (muxer->observed_actions), ==, 0);
g_hash_table_unref (muxer->observed_actions);
}
if (muxer->groups)
g_hash_table_unref (muxer->groups);
gtk_accels_clear (&muxer->primary_accels);
_gtk_bitmask_free (muxer->widget_actions_disabled);
G_OBJECT_CLASS (gtk_action_muxer_parent_class)->finalize (object);
}
static void
gtk_action_muxer_dispose (GObject *object)
{
GtkActionMuxer *muxer = GTK_ACTION_MUXER (object);
g_clear_object (&muxer->parent);
if (muxer->observed_actions)
g_hash_table_remove_all (muxer->observed_actions);
muxer->widget = NULL;
G_OBJECT_CLASS (gtk_action_muxer_parent_class)->dispose (object);
}
void
gtk_action_muxer_connect_class_actions (GtkActionMuxer *muxer)
{
prop_actions_connect (muxer);
}
static void
gtk_action_muxer_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GtkActionMuxer *muxer = GTK_ACTION_MUXER (object);
switch (property_id)
{
case PROP_PARENT:
g_value_set_object (value, gtk_action_muxer_get_parent (muxer));
break;
case PROP_WIDGET:
g_value_set_object (value, muxer->widget);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
static void
gtk_action_muxer_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GtkActionMuxer *muxer = GTK_ACTION_MUXER (object);
switch (property_id)
{
case PROP_PARENT:
gtk_action_muxer_set_parent (muxer, g_value_get_object (value));
break;
case PROP_WIDGET:
muxer->widget = g_value_get_object (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
static void
gtk_action_muxer_init (GtkActionMuxer *muxer)
{
muxer->widget_actions_disabled = _gtk_bitmask_new ();
}
static void
gtk_action_muxer_observable_iface_init (GtkActionObservableInterface *iface)
{
iface->register_observer = gtk_action_muxer_register_observer;
iface->unregister_observer = gtk_action_muxer_unregister_observer;
}
static void
gtk_action_muxer_observer_action_added (GtkActionObserver *observer,
GtkActionObservable *observable,
const char *action_name,
const GVariantType *parameter_type,
gboolean enabled,
GVariant *state)
{
if (action_muxer_query_action (GTK_ACTION_MUXER (observer), action_name,
NULL, NULL, NULL, NULL, NULL, FALSE))
return;
gtk_action_muxer_action_added (GTK_ACTION_MUXER (observer),
action_name,
parameter_type,
enabled,
state);
}
static void
gtk_action_muxer_observer_action_removed (GtkActionObserver *observer,
GtkActionObservable *observable,
const char *action_name)
{
if (action_muxer_query_action (GTK_ACTION_MUXER (observer), action_name,
NULL, NULL, NULL, NULL, NULL, FALSE))
return;
gtk_action_muxer_action_removed (GTK_ACTION_MUXER (observer), action_name);
}
static void
gtk_action_muxer_observer_action_enabled_changed (GtkActionObserver *observer,
GtkActionObservable *observable,
const char *action_name,
gboolean enabled)
{
if (action_muxer_query_action (GTK_ACTION_MUXER (observer), action_name,
NULL, NULL, NULL, NULL, NULL, FALSE))
return;
gtk_action_muxer_action_enabled_changed (GTK_ACTION_MUXER (observer), action_name, enabled);
}
static void
gtk_action_muxer_observer_action_state_changed (GtkActionObserver *observer,
GtkActionObservable *observable,
const char *action_name,
GVariant *state)
{
if (action_muxer_query_action (GTK_ACTION_MUXER (observer), action_name,
NULL, NULL, NULL, NULL, NULL, FALSE))
return;
gtk_action_muxer_action_state_changed (GTK_ACTION_MUXER (observer), action_name, state);
}
static void
gtk_action_muxer_observer_primary_accel_changed (GtkActionObserver *observer,
GtkActionObservable *observable,
const char *action_name,
const char *action_and_target)
{
gtk_action_muxer_primary_accel_changed (GTK_ACTION_MUXER (observer),
action_name,
action_and_target);
}
static void
gtk_action_muxer_observer_iface_init (GtkActionObserverInterface *iface)
{
iface->action_added = gtk_action_muxer_observer_action_added;
iface->action_removed = gtk_action_muxer_observer_action_removed;
iface->action_enabled_changed = gtk_action_muxer_observer_action_enabled_changed;
iface->action_state_changed = gtk_action_muxer_observer_action_state_changed;
iface->primary_accel_changed = gtk_action_muxer_observer_primary_accel_changed;
}
static void
gtk_action_muxer_class_init (GObjectClass *class)
{
class->get_property = gtk_action_muxer_get_property;
class->set_property = gtk_action_muxer_set_property;
class->finalize = gtk_action_muxer_finalize;
class->dispose = gtk_action_muxer_dispose;
properties[PROP_PARENT] = g_param_spec_object ("parent", NULL, NULL,
GTK_TYPE_ACTION_MUXER,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
properties[PROP_WIDGET] = g_param_spec_object ("widget", NULL, NULL,
GTK_TYPE_WIDGET,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
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
* @action_group: a `GActionGroup`
*
* 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.
*
* 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 `GtkActionObserver`s are registered for actions in the group,
* “action_added” notifications will be emitted, as appropriate.
*
* @prefix must not contain a dot ('.').
*/
void
gtk_action_muxer_insert (GtkActionMuxer *muxer,
const char *prefix,
GActionGroup *action_group)
{
char **actions;
Group *group;
int i;
/* TODO: diff instead of ripout and replace */
gtk_action_muxer_remove (muxer, prefix);
if (!muxer->groups)
muxer->groups = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, gtk_action_muxer_free_group);
group = g_new0 (Group, 1);
group->muxer = muxer;
group->group = g_object_ref (action_group);
group->prefix = g_strdup (prefix);
g_hash_table_insert (muxer->groups, group->prefix, group);
actions = g_action_group_list_actions (group->group);
for (i = 0; actions[i]; i++)
gtk_action_muxer_action_added_to_group (group->group, actions[i], group);
g_strfreev (actions);
group->handler_ids[0] = g_signal_connect (group->group, "action-added",
G_CALLBACK (gtk_action_muxer_action_added_to_group), group);
group->handler_ids[1] = g_signal_connect (group->group, "action-removed",
G_CALLBACK (gtk_action_muxer_action_removed_from_group), group);
group->handler_ids[2] = g_signal_connect (group->group, "action-enabled-changed",
G_CALLBACK (gtk_action_muxer_group_action_enabled_changed), group);
group->handler_ids[3] = g_signal_connect (group->group, "action-state-changed",
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
*
* Removes a `GActionGroup` from the `GtkActionMuxer`.
*
* If any `GtkActionObserver`s are registered for actions in the group,
* “action_removed” notifications will be emitted, as appropriate.
*/
void
gtk_action_muxer_remove (GtkActionMuxer *muxer,
const char *prefix)
{
Group *group;
if (!muxer->groups)
return;
group = g_hash_table_lookup (muxer->groups, prefix);
if (group != NULL)
{
char **actions;
int i;
g_hash_table_steal (muxer->groups, prefix);
actions = g_action_group_list_actions (group->group);
for (i = 0; actions[i]; i++)
gtk_action_muxer_action_removed_from_group (group->group, actions[i], group);
g_strfreev (actions);
gtk_action_muxer_free_group (group);
}
}
/*< private >
* gtk_action_muxer_new:
* @widget: the widget to which the muxer belongs
*
* Creates a new `GtkActionMuxer`.
*/
GtkActionMuxer *
gtk_action_muxer_new (GtkWidget *widget)
{
return g_object_new (GTK_TYPE_ACTION_MUXER,
"widget", widget,
NULL);
}
/*< private >
* gtk_action_muxer_get_parent:
* @muxer: a `GtkActionMuxer`
*
* Returns: (transfer none): the parent of @muxer, or NULL.
*/
GtkActionMuxer *
gtk_action_muxer_get_parent (GtkActionMuxer *muxer)
{
g_return_val_if_fail (GTK_IS_ACTION_MUXER (muxer), NULL);
return muxer->parent;
}
/*< private >
* gtk_action_muxer_set_parent:
* @muxer: a `GtkActionMuxer`
* @parent: (nullable): the new parent `GtkActionMuxer`
*
* Sets the parent of @muxer to @parent.
*/
void
gtk_action_muxer_set_parent (GtkActionMuxer *muxer,
GtkActionMuxer *parent)
{
g_return_if_fail (GTK_IS_ACTION_MUXER (muxer));
g_return_if_fail (parent == NULL || GTK_IS_ACTION_MUXER (parent));
if (muxer->parent == parent)
return;
if (muxer->parent != NULL)
{
notify_observers_removed (muxer, muxer->parent);
g_object_unref (muxer->parent);
}
muxer->parent = parent;
if (muxer->parent != NULL)
{
g_object_ref (muxer->parent);
notify_observers_added (muxer, muxer->parent);
}
g_object_notify_by_pspec (G_OBJECT (muxer), properties[PROP_PARENT]);
}
void
gtk_action_muxer_set_primary_accel (GtkActionMuxer *muxer,
const char *action_and_target,
const char *primary_accel)
{
if (primary_accel)
gtk_accels_replace (&muxer->primary_accels, action_and_target, primary_accel);
else
gtk_accels_remove (&muxer->primary_accels, action_and_target);
gtk_action_muxer_primary_accel_changed (muxer, NULL, action_and_target);
}
const char *
gtk_action_muxer_get_primary_accel (GtkActionMuxer *muxer,
const char *action_and_target)
{
guint position;
position = gtk_accels_find (&muxer->primary_accels, action_and_target);
if (position < G_MAXUINT)
return gtk_accels_index (&muxer->primary_accels, position)->accel;
if (!muxer->parent)
return NULL;
return gtk_action_muxer_get_primary_accel (muxer->parent, action_and_target);
}
char *
gtk_print_action_and_target (const char *action_namespace,
const char *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);
}
char *
gtk_normalise_detailed_action_name (const char *detailed_action_name)
{
GError *error = NULL;
char *action_and_target;
char *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;
}