[gtk/widget-class-actions-2: 1/9] Allow registering actions per-class
- From: Matthias Clasen <matthiasc src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gtk/widget-class-actions-2: 1/9] Allow registering actions per-class
- Date: Tue, 18 Jun 2019 18:53:06 +0000 (UTC)
commit ef031e1a9d024d62f5ec24bd70c25f1668ebe943
Author: Matthias Clasen <mclasen redhat com>
Date: Fri Jun 14 12:12:10 2019 +0000
Allow registering actions per-class
Add a facility to register and install actions
at class init time. The intended use for these
actions is for
a) context and other model-based menus
b) key bindings
Most of these actions are going to be stateless,
so add separate apis for the simple and stateful
cases.
We avoid creating an action group for these by
teaching the action muxer about these actions.
The action muxer also maintains the enabled
state for these actions.
docs/reference/gtk/gtk4-sections.txt | 16 +++-
gtk/gtkactionmuxer.c | 153 ++++++++++++++++++++++++++++++++---
gtk/gtkactionmuxerprivate.h | 23 +++++-
gtk/gtkapplication.c | 2 +-
gtk/gtkwidget.c | 137 ++++++++++++++++++++++++++++++-
gtk/gtkwidget.h | 70 ++++++++++++++++
6 files changed, 382 insertions(+), 19 deletions(-)
---
diff --git a/docs/reference/gtk/gtk4-sections.txt b/docs/reference/gtk/gtk4-sections.txt
index 786bcde361..a7d0d15787 100644
--- a/docs/reference/gtk/gtk4-sections.txt
+++ b/docs/reference/gtk/gtk4-sections.txt
@@ -4549,10 +4549,6 @@ gtk_widget_get_opacity
gtk_widget_set_opacity
gtk_widget_get_overflow
gtk_widget_set_overflow
-gtk_widget_insert_action_group
-gtk_widget_list_action_prefixes
-gtk_widget_activate_action
-gtk_widget_activate_default
gtk_widget_measure
gtk_widget_snapshot_child
gtk_widget_get_next_sibling
@@ -4629,6 +4625,18 @@ gtk_widget_class_set_connect_func
gtk_widget_observe_children
gtk_widget_observe_controllers
+<SUBSECTION Actions>
+gtk_widget_insert_action_group
+gtk_widget_activate_action
+gtk_widget_activate_default
+GtkWidgetActionActivateFunc
+GtkWidgetActionSetStateFunc
+GtkWidgetActionGetStateFunc
+gtk_widget_class_install_action
+gtk_widget_class_install_stateful_action
+gtk_widget_action_enabled_changed
+gtk_widget_action_state_changed
+
<SUBSECTION Standard>
GTK_WIDGET
GTK_IS_WIDGET
diff --git a/gtk/gtkactionmuxer.c b/gtk/gtkactionmuxer.c
index f358f8cbbd..33951ce463 100644
--- a/gtk/gtkactionmuxer.c
+++ b/gtk/gtkactionmuxer.c
@@ -72,6 +72,8 @@ struct _GtkActionMuxer
GtkActionMuxer *parent;
GtkWidget *widget;
+ GPtrArray *widget_actions;
+ gboolean *widget_actions_enabled;
};
G_DEFINE_TYPE_WITH_CODE (GtkActionMuxer, gtk_action_muxer, G_TYPE_OBJECT,
@@ -83,6 +85,7 @@ enum
PROP_0,
PROP_PARENT,
PROP_WIDGET,
+ PROP_WIDGET_ACTIONS,
NUM_PROPERTIES
};
@@ -108,7 +111,7 @@ typedef struct
static void
gtk_action_muxer_append_group_actions (const char *prefix,
Group *group,
- GArray *actions)
+ GHashTable *actions)
{
gchar **group_actions;
gchar **action;
@@ -116,10 +119,8 @@ gtk_action_muxer_append_group_actions (const char *prefix,
group_actions = g_action_group_list_actions (group->group);
for (action = group_actions; *action; action++)
{
- gchar *fullname;
-
- fullname = g_strconcat (prefix, ".", *action, NULL);
- g_array_append_val (actions, fullname);
+ char *name = g_strconcat (prefix, ".", *action, NULL);
+ g_hash_table_add (actions, name);
}
g_strfreev (group_actions);
@@ -129,9 +130,11 @@ static gchar **
gtk_action_muxer_list_actions (GActionGroup *action_group)
{
GtkActionMuxer *muxer = GTK_ACTION_MUXER (action_group);
- GArray *actions;
+ GHashTable *actions;
+ char **keys;
- actions = g_array_new (TRUE, FALSE, sizeof (gchar *));
+ actions = g_hash_table_new_full (g_str_hash, g_str_equal,
+ g_free, NULL);
for ( ; muxer != NULL; muxer = muxer->parent)
{
@@ -139,12 +142,28 @@ gtk_action_muxer_list_actions (GActionGroup *action_group)
const char *prefix;
Group *group;
+ if (muxer->widget_actions)
+ {
+ int i;
+
+ for (i = 0; i < muxer->widget_actions->len; i++)
+ {
+ GtkWidgetAction *action = g_ptr_array_index (muxer->widget_actions, i);
+ g_hash_table_add (actions, g_strdup (action->name));
+ }
+ }
+
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);
}
- return (gchar **)(void *) g_array_free (actions, FALSE);
+ 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 *
@@ -183,7 +202,7 @@ gtk_action_muxer_find (GtkActionMuxer *muxer,
return group->group;
}
-static void
+void
gtk_action_muxer_action_enabled_changed (GtkActionMuxer *muxer,
const gchar *action_name,
gboolean enabled)
@@ -191,6 +210,19 @@ gtk_action_muxer_action_enabled_changed (GtkActionMuxer *muxer,
Action *action;
GSList *node;
+ if (muxer->widget_actions)
+ {
+ int i;
+ for (i = 0; i < muxer->widget_actions->len; i++)
+ {
+ GtkWidgetAction *a = g_ptr_array_index (muxer->widget_actions, i);
+ if (strcmp (a->name, action_name) == 0)
+ {
+ muxer->widget_actions_enabled[i] = enabled;
+ break;
+ }
+ }
+ }
action = g_hash_table_lookup (muxer->observed_actions, 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);
@@ -223,7 +255,7 @@ gtk_action_muxer_parent_action_enabled_changed (GActionGroup *action_group,
gtk_action_muxer_action_enabled_changed (muxer, action_name, enabled);
}
-static void
+void
gtk_action_muxer_action_state_changed (GtkActionMuxer *muxer,
const gchar *action_name,
GVariant *state)
@@ -401,6 +433,46 @@ gtk_action_muxer_query_action (GActionGroup *action_group,
Group *group;
const gchar *unprefixed_name;
+ if (muxer->widget_actions)
+ {
+ int i;
+
+ for (i = 0; i < muxer->widget_actions->len; i++)
+ {
+ GtkWidgetAction *action = g_ptr_array_index (muxer->widget_actions, i);
+ if (strcmp (action->name, action_name) == 0)
+ {
+ if (enabled)
+ *enabled = muxer->widget_actions_enabled[i];
+ if (parameter_type)
+ *parameter_type = action->parameter_type;
+
+ if (state_hint)
+ *state_hint = NULL;
+ if (state_type)
+ *state_type = NULL;
+ if (state)
+ *state = NULL;
+
+ if (action->get_state)
+ {
+ GVariant *s;
+
+ s = g_variant_ref_sink (action->get_state (muxer->widget, action->name));
+
+ if (state_type)
+ *state_type = g_variant_get_type (s);
+ if (state)
+ *state = g_variant_ref (s);
+
+ g_variant_unref (s);
+ }
+
+ return TRUE;
+ }
+ }
+ }
+
group = gtk_action_muxer_find_group (muxer, action_name, &unprefixed_name);
if (group)
@@ -424,6 +496,22 @@ gtk_action_muxer_activate_action (GActionGroup *action_group,
Group *group;
const gchar *unprefixed_name;
+ if (muxer->widget_actions)
+ {
+ int i;
+
+ for (i = 0; i < muxer->widget_actions->len; i++)
+ {
+ GtkWidgetAction *action = g_ptr_array_index (muxer->widget_actions, i);
+ if (strcmp (action->name, action_name) == 0)
+ {
+ action->activate (muxer->widget, action->name, parameter);
+
+ return;
+ }
+ }
+ }
+
group = gtk_action_muxer_find_group (muxer, action_name, &unprefixed_name);
if (group)
@@ -441,6 +529,23 @@ gtk_action_muxer_change_action_state (GActionGroup *action_group,
Group *group;
const gchar *unprefixed_name;
+ if (muxer->widget_actions)
+ {
+ int i;
+
+ for (i = 0; i < muxer->widget_actions->len; i++)
+ {
+ GtkWidgetAction *action = g_ptr_array_index (muxer->widget_actions, i);
+ if (strcmp (action->name, action_name) == 0)
+ {
+ if (action->set_state)
+ action->set_state (muxer->widget, action->name, state);
+
+ return;
+ }
+ }
+ }
+
group = gtk_action_muxer_find_group (muxer, action_name, &unprefixed_name);
if (group)
@@ -600,6 +705,10 @@ gtk_action_muxer_get_property (GObject *object,
g_value_set_object (value, muxer->widget);
break;
+ case PROP_WIDGET_ACTIONS:
+ g_value_set_boxed (value, muxer->widget_actions);
+ break;
+
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
@@ -623,6 +732,18 @@ gtk_action_muxer_set_property (GObject *object,
muxer->widget = g_value_get_object (value);
break;
+ case PROP_WIDGET_ACTIONS:
+ muxer->widget_actions = g_value_get_boxed (value);
+ if (muxer->widget_actions)
+ {
+ int i;
+
+ muxer->widget_actions_enabled = g_new (gboolean, muxer->widget_actions->len);
+ for (i = 0; i < muxer->widget_actions->len; i++)
+ muxer->widget_actions_enabled[i] = TRUE;
+ }
+ break;
+
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
@@ -683,6 +804,13 @@ gtk_action_muxer_class_init (GObjectClass *class)
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
+ properties[PROP_WIDGET_ACTIONS] = g_param_spec_boxed ("widget-actions", "Widget actions",
+ "Widget actions",
+ G_TYPE_PTR_ARRAY,
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_STATIC_STRINGS);
+
g_object_class_install_properties (class, NUM_PROPERTIES, properties);
}
@@ -791,14 +919,17 @@ gtk_action_muxer_lookup (GtkActionMuxer *muxer,
/*< private >
* gtk_action_muxer_new:
* @widget: the widget to which the muxer belongs
+ * @actions: widget actions
*
* Creates a new #GtkActionMuxer.
*/
GtkActionMuxer *
-gtk_action_muxer_new (GtkWidget *widget)
+gtk_action_muxer_new (GtkWidget *widget,
+ GPtrArray *actions)
{
return g_object_new (GTK_TYPE_ACTION_MUXER,
"widget", widget,
+ "widget-actions", actions,
NULL);
}
diff --git a/gtk/gtkactionmuxerprivate.h b/gtk/gtkactionmuxerprivate.h
index 190728fafd..325c1f817a 100644
--- a/gtk/gtkactionmuxerprivate.h
+++ b/gtk/gtkactionmuxerprivate.h
@@ -31,10 +31,21 @@ G_BEGIN_DECLS
#define GTK_IS_ACTION_MUXER(inst) (G_TYPE_CHECK_INSTANCE_TYPE ((inst),
\
GTK_TYPE_ACTION_MUXER))
+typedef struct {
+ char *name;
+
+ GVariantType *parameter_type;
+
+ GtkWidgetActionActivateFunc activate;
+ GtkWidgetActionSetStateFunc set_state;
+ GtkWidgetActionGetStateFunc get_state;
+} GtkWidgetAction;
+
typedef struct _GtkActionMuxer GtkActionMuxer;
GType gtk_action_muxer_get_type (void);
-GtkActionMuxer * gtk_action_muxer_new (GtkWidget *widget);
+GtkActionMuxer * gtk_action_muxer_new (GtkWidget *widget,
+ GPtrArray *actions);
void gtk_action_muxer_insert (GtkActionMuxer *muxer,
const gchar *prefix,
@@ -59,6 +70,16 @@ void gtk_action_muxer_set_primary_accel (GtkActi
const gchar * gtk_action_muxer_get_primary_accel (GtkActionMuxer *muxer,
const gchar *action_and_target);
+void
+gtk_action_muxer_action_enabled_changed (GtkActionMuxer *muxer,
+ const char *action_name,
+ gboolean enabled);
+void
+gtk_action_muxer_action_state_changed (GtkActionMuxer *muxer,
+ const gchar *action_name,
+ GVariant *state);
+
+
/* No better place for these... */
gchar * gtk_print_action_and_target (const gchar *action_namespace,
const gchar *action_name,
diff --git a/gtk/gtkapplication.c b/gtk/gtkapplication.c
index f90fd827fc..3b3fe1e5ac 100644
--- a/gtk/gtkapplication.c
+++ b/gtk/gtkapplication.c
@@ -394,7 +394,7 @@ gtk_application_init (GtkApplication *application)
{
GtkApplicationPrivate *priv = gtk_application_get_instance_private (application);
- priv->muxer = gtk_action_muxer_new (NULL);
+ priv->muxer = gtk_action_muxer_new (NULL, NULL);
priv->accels = gtk_application_accels_new ();
}
diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c
index 444ecbe4dd..f2a8c9710c 100644
--- a/gtk/gtkwidget.c
+++ b/gtk/gtkwidget.c
@@ -501,6 +501,7 @@ struct _GtkWidgetClassPrivate
AtkRole accessible_role;
const char *css_name;
GType layout_manager_type;
+ GPtrArray *actions;
};
enum {
@@ -11897,14 +11898,16 @@ _gtk_widget_get_action_muxer (GtkWidget *widget,
gboolean create)
{
GtkActionMuxer *muxer;
+ GtkWidgetClass *widget_class = GTK_WIDGET_GET_CLASS (widget);
+ GtkWidgetClassPrivate *priv = widget_class->priv;
muxer = (GtkActionMuxer*)g_object_get_qdata (G_OBJECT (widget), quark_action_muxer);
if (muxer)
return muxer;
- if (create)
+ if (create || priv->actions)
{
- muxer = gtk_action_muxer_new (widget);
+ muxer = gtk_action_muxer_new (widget, priv->actions);
g_object_set_qdata_full (G_OBJECT (widget),
quark_action_muxer,
muxer,
@@ -13427,3 +13430,133 @@ gtk_widget_should_layout (GtkWidget *widget)
return TRUE;
}
+/*
+ * gtk_widget_class_install_action:
+ * @widget_class: a #GtkWidgetClass
+ * @action_name: a prefixed action name, such as "clipboard.paste"
+ * @activate: callback to use when the action is activated
+ *
+ * This should be called at class initialization time to specify
+ * actions to be added for all instances of this class.
+ *
+ * Actions installed by this function are stateless. The only state
+ * they have is whether they are enabled or not. For more complicated
+ * actions, see gtk_widget_class_install_stateful_action().
+ */
+void
+gtk_widget_class_install_action (GtkWidgetClass *widget_class,
+ const char *action_name,
+ GtkWidgetActionActivateFunc activate)
+{
+ gtk_widget_class_install_stateful_action (widget_class, action_name, activate,
+ NULL, NULL, NULL);
+}
+
+/*
+ * gtk_widget_class_install_stateful_action:
+ * @widget_class: a #GtkWidgetClass
+ * @action_name: a prefixed action name, such as "clipboard.paste"
+ * @activate: callback to use when the action is activated
+ * @parameter_type: (allow-none): the parameter type, or %NULL
+ * @query: (allow-none): callback to use when the action properties
+ are queried, or %NULL for always-enabled stateless actions
+ * @query_state: (allow-none): callback to use when the action state
+ is queried, or %NULL for stateless actions
+ *
+ * This should be called at class initialization time to specify
+ * actions to be added for all instances of this class.
+ *
+ * Actions installed in this way can be simple or stateful.
+ * See the #GAction documentation for more information.
+ */
+void
+gtk_widget_class_install_stateful_action (GtkWidgetClass *widget_class,
+ const char *action_name,
+ GtkWidgetActionActivateFunc activate,
+ const char *parameter_type,
+ GtkWidgetActionSetStateFunc set_state,
+ GtkWidgetActionGetStateFunc get_state)
+{
+ GtkWidgetClassPrivate *priv = widget_class->priv;
+ GtkWidgetAction *action;
+
+ g_return_if_fail (GTK_IS_WIDGET_CLASS (widget_class));
+
+ if (priv->actions == NULL)
+ priv->actions = g_ptr_array_new ();
+ else if (GTK_IS_WIDGET_CLASS (&widget_class->parent_class))
+ {
+ GtkWidgetClass *parent_class = GTK_WIDGET_CLASS (&widget_class->parent_class);
+ GtkWidgetClassPrivate *parent_priv = parent_class->priv;
+ GPtrArray *parent_actions = parent_priv->actions;
+
+ if (priv->actions == parent_actions)
+ {
+ int i;
+
+ priv->actions = g_ptr_array_new ();
+ for (i = 0; i < parent_actions->len; i++)
+ g_ptr_array_add (priv->actions, g_ptr_array_index (parent_actions, i));
+ }
+ }
+
+ action = g_new0 (GtkWidgetAction, 1);
+ action->name = g_strdup (action_name);
+ action->activate = activate;
+ action->parameter_type = parameter_type ? g_variant_type_new (parameter_type) : NULL;
+ action->set_state = set_state;
+ action->get_state = get_state;
+
+ GTK_NOTE(ACTIONS,
+ g_message ("%sClass: Adding %s action\n",
+ g_type_name (G_TYPE_FROM_CLASS (widget_class)),
+ action_name));
+
+ g_ptr_array_add (priv->actions, action);
+}
+
+/**
+ * gtk_widget_action_enabled_changed:
+ * @widget: a #GtkWidget
+ * @action_name: action name, such as "clipboard.paste"
+ * @enabled: whether the action is now enabled
+ *
+ * Notify when an action installed with
+ * gtk_widget_class_install_action() changes its
+ * enabled state.
+ */
+void
+gtk_widget_action_enabled_changed (GtkWidget *widget,
+ const char *action_name,
+ gboolean enabled)
+{
+ GtkActionMuxer *muxer;
+
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ muxer = _gtk_widget_get_action_muxer (widget, TRUE);
+ gtk_action_muxer_action_enabled_changed (muxer, action_name, enabled);
+}
+
+/**
+ * gtk_widget_action_state_changed:
+ * @widget: a #GtkWidget
+ * @action_name: action name, such as "clipboard.paste"
+ * @state: the new state
+ *
+ * Notify when an action installed with
+ * gtk_widget_class_install_stateful_action() changes
+ * its state.
+ */
+void
+gtk_widget_action_state_changed (GtkWidget *widget,
+ const char *action_name,
+ GVariant *state)
+{
+ GtkActionMuxer *muxer;
+
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ muxer = _gtk_widget_get_action_muxer (widget, TRUE);
+ gtk_action_muxer_action_state_changed (muxer, action_name, state);
+}
diff --git a/gtk/gtkwidget.h b/gtk/gtkwidget.h
index ca9d768ea6..73e92ac1cb 100644
--- a/gtk/gtkwidget.h
+++ b/gtk/gtkwidget.h
@@ -1023,6 +1023,76 @@ GDK_AVAILABLE_IN_ALL
gboolean gtk_widget_should_layout (GtkWidget *widget);
+/**
+ * GtkWidgetActionActivateFunc:
+ * @widget: the widget to which the action belongs
+ * @action_name: the action name
+ * @parameter: parameter for activation
+ *
+ * The type of the callback functions used for activating
+ * actions installed with gtk_widget_class_install_action().
+ *
+ * The @parameter must match the @parameter_type of the action.
+ */
+typedef void (* GtkWidgetActionActivateFunc) (GtkWidget *widget,
+ const char *action_name,
+ GVariant *parameter);
+
+/**
+ * GtkWidgetActionGetStateFunc:
+ * @widget: the widget to which the action belongs
+ * @action_name: the action name
+ *
+ * The type of the callback functions used to query the state
+ * of stateful actions installed with gtk_widget_class_install_action().
+ *
+ * See the #GAction documentation for more details about the
+ * meaning of these properties.
+ */
+typedef GVariant * (* GtkWidgetActionGetStateFunc) (GtkWidget *widget,
+ const char *action_name);
+
+/**
+ * GtkWidgetActionSetStateFunc:
+ * @widget: the widget to which the action belongs
+ * @action_name: the action name
+ * @state: the new state
+ *
+ * The type of the callback functions used to change the
+ * state of actions installed with gtk_widget_class_install_action().
+ *
+ * The @state must match the @state_type of the action.
+ *
+ * This callback is used when the action state is
+ * changed via the #GActionGroup API.
+ */
+typedef void (*GtkWidgetActionSetStateFunc) (GtkWidget *widget,
+ const char *action_name,
+ GVariant *state);
+
+GDK_AVAILABLE_IN_ALL
+void gtk_widget_class_install_action (GtkWidgetClass *widget_class,
+ const char *action_name,
+ GtkWidgetActionActivateFunc activate);
+
+GDK_AVAILABLE_IN_ALL
+void gtk_widget_class_install_stateful_action (GtkWidgetClass *widget_class,
+ const char *action_name,
+ GtkWidgetActionActivateFunc activate,
+ const char
*parameter_type,
+ GtkWidgetActionSetStateFunc set_state,
+ GtkWidgetActionGetStateFunc get_state);
+
+GDK_AVAILABLE_IN_ALL
+void gtk_widget_action_enabled_changed (GtkWidget *widget,
+ const char *action_name,
+ gboolean enabled);
+GDK_AVAILABLE_IN_ALL
+void gtk_widget_action_state_changed (GtkWidget *widget,
+ const char *action_name,
+ GVariant *state);
+
+
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkWidget, g_object_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkRequisition, gtk_requisition_free)
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
