Adding upstream version 2.10.22.upstream/2.10.22upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1068 insertions, 0 deletions

diff --git a/app/widgets/gimpactiongroup.c b/app/widgets/gimpactiongroup.c
new file mode 100644
index 0000000..04bd1b6
--- /dev/null
+++ b/app/widgets/gimpactiongroup.c
@@ -0,0 +1,1068 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * gimpactiongroup.c
+ * Copyright (C) 2004 Michael Natterer <mitch@gimp.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+
+#include "libgimpbase/gimpbase.h"
+#include "libgimpwidgets/gimpwidgets.h"
+
+#include "widgets-types.h"
+
+#include "core/gimp.h"
+#include "core/gimpcontext.h"
+#include "core/gimpmarshal.h"
+#include "core/gimpviewable.h"
+
+#include "gimpaction.h"
+#include "gimpactiongroup.h"
+#include "gimpactionimpl.h"
+#include "gimpenumaction.h"
+#include "gimpprocedureaction.h"
+#include "gimpradioaction.h"
+#include "gimpstringaction.h"
+#include "gimptoggleaction.h"
+
+#include "gimp-intl.h"
+
+enum
+{
+  ACTION_ADDED,
+  LAST_SIGNAL
+};
+
+enum
+{
+  PROP_0,
+  PROP_GIMP,
+  PROP_LABEL,
+  PROP_ICON_NAME
+};
+
+
+static void   gimp_action_group_constructed   (GObject      *object);
+static void   gimp_action_group_dispose       (GObject      *object);
+static void   gimp_action_group_finalize      (GObject      *object);
+static void   gimp_action_group_set_property  (GObject      *object,
+                                               guint         prop_id,
+                                               const GValue *value,
+                                               GParamSpec   *pspec);
+static void   gimp_action_group_get_property  (GObject      *object,
+                                               guint         prop_id,
+                                               GValue       *value,
+                                               GParamSpec   *pspec);
+
+
+G_DEFINE_TYPE (GimpActionGroup, gimp_action_group, GTK_TYPE_ACTION_GROUP)
+
+static guint signals[LAST_SIGNAL] = { 0, };
+
+#define parent_class gimp_action_group_parent_class
+
+
+static void
+gimp_action_group_class_init (GimpActionGroupClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->constructed  = gimp_action_group_constructed;
+  object_class->dispose      = gimp_action_group_dispose;
+  object_class->finalize     = gimp_action_group_finalize;
+  object_class->set_property = gimp_action_group_set_property;
+  object_class->get_property = gimp_action_group_get_property;
+
+  g_object_class_install_property (object_class, PROP_GIMP,
+                                   g_param_spec_object ("gimp",
+                                                        NULL, NULL,
+                                                        GIMP_TYPE_GIMP,
+                                                        GIMP_PARAM_READWRITE |
+                                                        G_PARAM_CONSTRUCT_ONLY));
+
+  g_object_class_install_property (object_class, PROP_LABEL,
+                                   g_param_spec_string ("label",
+                                                        NULL, NULL,
+                                                        NULL,
+                                                        GIMP_PARAM_READWRITE |
+                                                        G_PARAM_CONSTRUCT_ONLY));
+
+  g_object_class_install_property (object_class, PROP_ICON_NAME,
+                                   g_param_spec_string ("icon-name",
+                                                        NULL, NULL,
+                                                        NULL,
+                                                        GIMP_PARAM_READWRITE |
+                                                        G_PARAM_CONSTRUCT_ONLY));
+
+  klass->groups = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
+
+  signals[ACTION_ADDED] =
+    g_signal_new ("action-added",
+                  G_OBJECT_CLASS_TYPE (klass),
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (GimpActionGroupClass, action_added),
+                  NULL, NULL,
+                  gimp_marshal_VOID__OBJECT,
+                  G_TYPE_NONE, 1,
+                  GIMP_TYPE_ACTION);
+}
+
+static void
+gimp_action_group_init (GimpActionGroup *group)
+{
+}
+
+static void
+gimp_action_group_constructed (GObject *object)
+{
+  GimpActionGroup *group = GIMP_ACTION_GROUP (object);
+  const gchar     *name;
+
+  G_OBJECT_CLASS (parent_class)->constructed (object);
+
+  gimp_assert (GIMP_IS_GIMP (group->gimp));
+
+  name = gimp_action_group_get_name (group);
+
+  if (name)
+    {
+      GimpActionGroupClass *group_class;
+      GList                *list;
+
+      group_class = GIMP_ACTION_GROUP_GET_CLASS (object);
+
+      list = g_hash_table_lookup (group_class->groups, name);
+
+      list = g_list_append (list, object);
+
+      g_hash_table_replace (group_class->groups,
+                            g_strdup (name), list);
+    }
+}
+
+static void
+gimp_action_group_dispose (GObject *object)
+{
+  const gchar *name = gimp_action_group_get_name (GIMP_ACTION_GROUP (object));
+
+  if (name)
+    {
+      GimpActionGroupClass *group_class;
+      GList                *list;
+
+      group_class = GIMP_ACTION_GROUP_GET_CLASS (object);
+
+      list = g_hash_table_lookup (group_class->groups, name);
+
+      if (list)
+        {
+          list = g_list_remove (list, object);
+
+          if (list)
+            g_hash_table_replace (group_class->groups,
+                                  g_strdup (name), list);
+          else
+            g_hash_table_remove (group_class->groups, name);
+        }
+    }
+
+  G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+gimp_action_group_finalize (GObject *object)
+{
+  GimpActionGroup *group = GIMP_ACTION_GROUP (object);
+
+  g_clear_pointer (&group->label,     g_free);
+  g_clear_pointer (&group->icon_name, g_free);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gimp_action_group_set_property (GObject      *object,
+                                guint         prop_id,
+                                const GValue *value,
+                                GParamSpec   *pspec)
+{
+  GimpActionGroup *group = GIMP_ACTION_GROUP (object);
+
+  switch (prop_id)
+    {
+    case PROP_GIMP:
+      group->gimp = g_value_get_object (value);
+      break;
+    case PROP_LABEL:
+      group->label = g_value_dup_string (value);
+      break;
+    case PROP_ICON_NAME:
+      group->icon_name = g_value_dup_string (value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gimp_action_group_get_property (GObject    *object,
+                                guint       prop_id,
+                                GValue     *value,
+                                GParamSpec *pspec)
+{
+  GimpActionGroup *group = GIMP_ACTION_GROUP (object);
+
+  switch (prop_id)
+    {
+    case PROP_GIMP:
+      g_value_set_object (value, group->gimp);
+      break;
+    case PROP_LABEL:
+      g_value_set_string (value, group->label);
+      break;
+    case PROP_ICON_NAME:
+      g_value_set_string (value, group->icon_name);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static gboolean
+gimp_action_group_check_unique_action (GimpActionGroup *group,
+                                       const gchar     *action_name)
+{
+  if (G_UNLIKELY (gimp_action_group_get_action (group, action_name)))
+    {
+      g_warning ("Refusing to add non-unique action '%s' to action group '%s'",
+                 action_name,
+                 gimp_action_group_get_name (group));
+      return FALSE;
+    }
+
+  return TRUE;
+
+}
+
+/**
+ * gimp_action_group_new:
+ * @gimp:        the @Gimp instance this action group belongs to
+ * @name:        the name of the action group.
+ * @label:       the user visible label of the action group.
+ * @icon_name:   the icon of the action group.
+ * @user_data:   the user_data for #GtkAction callbacks.
+ * @update_func: the function that will be called on
+ *               gimp_action_group_update().
+ *
+ * Creates a new #GimpActionGroup object. The name of the action group
+ * is used when associating <link linkend="Action-Accel">keybindings</link>
+ * with the actions.
+ *
+ * Returns: the new #GimpActionGroup
+ */
+GimpActionGroup *
+gimp_action_group_new (Gimp                      *gimp,
+                       const gchar               *name,
+                       const gchar               *label,
+                       const gchar               *icon_name,
+                       gpointer                   user_data,
+                       GimpActionGroupUpdateFunc  update_func)
+{
+  GimpActionGroup *group;
+
+  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
+  g_return_val_if_fail (name != NULL, NULL);
+
+  group = g_object_new (GIMP_TYPE_ACTION_GROUP,
+                        "gimp",      gimp,
+                        "name",      name,
+                        "label",     label,
+                        "icon-name", icon_name,
+                        NULL);
+
+  group->user_data   = user_data;
+  group->update_func = update_func;
+
+  return group;
+}
+
+const gchar *
+gimp_action_group_get_name (GimpActionGroup *group)
+{
+  return gtk_action_group_get_name ((GtkActionGroup *) group);
+}
+
+void
+gimp_action_group_add_action (GimpActionGroup *action_group,
+                              GimpAction      *action)
+{
+  gtk_action_group_add_action ((GtkActionGroup *) action_group,
+                               (GtkAction *) action);
+}
+
+void
+gimp_action_group_add_action_with_accel (GimpActionGroup *action_group,
+                                         GimpAction      *action,
+                                         const gchar     *accelerator)
+{
+  gtk_action_group_add_action_with_accel ((GtkActionGroup *) action_group,
+                                          (GtkAction *) action,
+                                          accelerator);
+}
+
+void
+gimp_action_group_remove_action (GimpActionGroup *action_group,
+                                 GimpAction      *action)
+{
+  gtk_action_group_remove_action ((GtkActionGroup *) action_group,
+                                  (GtkAction *) action);
+}
+
+GimpAction *
+gimp_action_group_get_action (GimpActionGroup *group,
+                              const gchar     *action_name)
+{
+  return (GimpAction *) gtk_action_group_get_action ((GtkActionGroup *) group,
+                                                     action_name);
+}
+
+GList *
+gimp_action_group_list_actions (GimpActionGroup *group)
+{
+  return gtk_action_group_list_actions ((GtkActionGroup *) group);
+}
+
+GList *
+gimp_action_groups_from_name (const gchar *name)
+{
+  GimpActionGroupClass *group_class;
+  GList                *list;
+
+  g_return_val_if_fail (name != NULL, NULL);
+
+  group_class = g_type_class_ref (GIMP_TYPE_ACTION_GROUP);
+
+  list = g_hash_table_lookup (group_class->groups, name);
+
+  g_type_class_unref (group_class);
+
+  return list;
+}
+
+void
+gimp_action_group_update (GimpActionGroup *group,
+                          gpointer         update_data)
+{
+  g_return_if_fail (GIMP_IS_ACTION_GROUP (group));
+
+  if (group->update_func)
+    group->update_func (group, update_data);
+}
+
+void
+gimp_action_group_add_actions (GimpActionGroup       *group,
+                               const gchar           *msg_context,
+                               const GimpActionEntry *entries,
+                               guint                  n_entries)
+{
+  gint i;
+
+  g_return_if_fail (GIMP_IS_ACTION_GROUP (group));
+
+  for (i = 0; i < n_entries; i++)
+    {
+      GimpAction  *action;
+      const gchar *label;
+      const gchar *tooltip = NULL;
+
+      if (! gimp_action_group_check_unique_action (group, entries[i].name))
+        continue;
+
+      if (msg_context)
+        {
+          label = g_dpgettext2 (NULL, msg_context, entries[i].label);
+
+          if (entries[i].tooltip)
+            tooltip = g_dpgettext2 (NULL, msg_context, entries[i].tooltip);
+        }
+      else
+        {
+          label   = gettext (entries[i].label);
+          tooltip = gettext (entries[i].tooltip);
+        }
+
+      action = gimp_action_impl_new (entries[i].name, label, tooltip,
+                                     entries[i].icon_name,
+                                     entries[i].help_id);
+
+      if (entries[i].callback)
+        g_signal_connect (action, "gimp-activate",
+                          G_CALLBACK (entries[i].callback),
+                          group->user_data);
+
+      gimp_action_group_add_action_with_accel (group, GIMP_ACTION (action),
+                                               entries[i].accelerator);
+      g_signal_emit (group, signals[ACTION_ADDED], 0, action);
+
+      g_object_unref (action);
+    }
+}
+
+void
+gimp_action_group_add_toggle_actions (GimpActionGroup             *group,
+                                      const gchar                 *msg_context,
+                                      const GimpToggleActionEntry *entries,
+                                      guint                        n_entries)
+{
+  gint i;
+
+  g_return_if_fail (GIMP_IS_ACTION_GROUP (group));
+
+  for (i = 0; i < n_entries; i++)
+    {
+      GtkToggleAction *action;
+      const gchar     *label;
+      const gchar     *tooltip = NULL;
+
+      if (! gimp_action_group_check_unique_action (group, entries[i].name))
+        continue;
+
+      if (msg_context)
+        {
+          label = g_dpgettext2 (NULL, msg_context, entries[i].label);
+
+          if (entries[i].tooltip)
+            tooltip = g_dpgettext2 (NULL, msg_context, entries[i].tooltip);
+        }
+      else
+        {
+          label   = gettext (entries[i].label);
+          tooltip = gettext (entries[i].tooltip);
+        }
+
+      action = gimp_toggle_action_new (entries[i].name, label, tooltip,
+                                       entries[i].icon_name,
+                                       entries[i].help_id);
+
+      gimp_toggle_action_set_active (GIMP_TOGGLE_ACTION (action),
+                                     entries[i].is_active);
+
+      if (entries[i].callback)
+        g_signal_connect (action, "gimp-change-state",
+                          G_CALLBACK (entries[i].callback),
+                          group->user_data);
+
+      gimp_action_group_add_action_with_accel (group, GIMP_ACTION (action),
+                                               entries[i].accelerator);
+      g_signal_emit (group, signals[ACTION_ADDED], 0, action);
+
+      g_object_unref (action);
+    }
+}
+
+GSList *
+gimp_action_group_add_radio_actions (GimpActionGroup            *group,
+                                     const gchar                *msg_context,
+                                     const GimpRadioActionEntry *entries,
+                                     guint                       n_entries,
+                                     GSList                     *radio_group,
+                                     gint                        value,
+                                     GimpActionCallback          callback)
+{
+  GtkRadioAction *first_action = NULL;
+  gint            i;
+
+  g_return_val_if_fail (GIMP_IS_ACTION_GROUP (group), NULL);
+
+  for (i = 0; i < n_entries; i++)
+    {
+      GtkRadioAction *action;
+      const gchar    *label;
+      const gchar    *tooltip = NULL;
+
+      if (! gimp_action_group_check_unique_action (group, entries[i].name))
+        continue;
+
+      if (msg_context)
+        {
+          label = g_dpgettext2 (NULL, msg_context, entries[i].label);
+
+          if (entries[i].tooltip)
+            tooltip = g_dpgettext2 (NULL, msg_context, entries[i].tooltip);
+        }
+      else
+        {
+          label   = gettext (entries[i].label);
+          tooltip = gettext (entries[i].tooltip);
+        }
+
+      action = gimp_radio_action_new (entries[i].name, label, tooltip,
+                                      entries[i].icon_name,
+                                      entries[i].help_id,
+                                      entries[i].value);
+
+      if (i == 0)
+        first_action = action;
+
+      gtk_radio_action_set_group (action, radio_group);
+      radio_group = gtk_radio_action_get_group (action);
+
+      if (value == entries[i].value)
+        gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), TRUE);
+
+      gimp_action_group_add_action_with_accel (group, GIMP_ACTION (action),
+                                               entries[i].accelerator);
+      g_signal_emit (group, signals[ACTION_ADDED], 0, action);
+
+      g_object_unref (action);
+    }
+
+  if (callback && first_action)
+    g_signal_connect (first_action, "gimp-change-state",
+                      G_CALLBACK (callback),
+                      group->user_data);
+
+  return radio_group;
+}
+
+void
+gimp_action_group_add_enum_actions (GimpActionGroup           *group,
+                                    const gchar               *msg_context,
+                                    const GimpEnumActionEntry *entries,
+                                    guint                      n_entries,
+                                    GimpActionCallback         callback)
+{
+  gint i;
+
+  g_return_if_fail (GIMP_IS_ACTION_GROUP (group));
+
+  for (i = 0; i < n_entries; i++)
+    {
+      GimpEnumAction *action;
+      const gchar    *label;
+      const gchar    *tooltip = NULL;
+
+      if (! gimp_action_group_check_unique_action (group, entries[i].name))
+        continue;
+
+      if (msg_context)
+        {
+          label = g_dpgettext2 (NULL, msg_context, entries[i].label);
+
+          if (entries[i].tooltip)
+            tooltip = g_dpgettext2 (NULL, msg_context, entries[i].tooltip);
+        }
+      else
+        {
+          label   = gettext (entries[i].label);
+          tooltip = gettext (entries[i].tooltip);
+        }
+
+      action = gimp_enum_action_new (entries[i].name, label, tooltip,
+                                     entries[i].icon_name,
+                                     entries[i].help_id,
+                                     entries[i].value,
+                                     entries[i].value_variable);
+
+      if (callback)
+        g_signal_connect (action, "gimp-activate",
+                          G_CALLBACK (callback),
+                          group->user_data);
+
+      gimp_action_group_add_action_with_accel (group, GIMP_ACTION (action),
+                                               entries[i].accelerator);
+      g_signal_emit (group, signals[ACTION_ADDED], 0, action);
+
+      g_object_unref (action);
+    }
+}
+
+void
+gimp_action_group_add_string_actions (GimpActionGroup             *group,
+                                      const gchar                 *msg_context,
+                                      const GimpStringActionEntry *entries,
+                                      guint                        n_entries,
+                                      GimpActionCallback           callback)
+{
+  gint i;
+
+  g_return_if_fail (GIMP_IS_ACTION_GROUP (group));
+
+  for (i = 0; i < n_entries; i++)
+    {
+      GimpStringAction *action;
+      const gchar      *label;
+      const gchar      *tooltip = NULL;
+
+      if (! gimp_action_group_check_unique_action (group, entries[i].name))
+        continue;
+
+      if (msg_context)
+        {
+          label = g_dpgettext2 (NULL, msg_context, entries[i].label);
+
+          if (entries[i].tooltip)
+            tooltip = g_dpgettext2 (NULL, msg_context, entries[i].tooltip);
+        }
+      else
+        {
+          label   = gettext (entries[i].label);
+          tooltip = gettext (entries[i].tooltip);
+        }
+
+      action = gimp_string_action_new (entries[i].name, label, tooltip,
+                                       entries[i].icon_name,
+                                       entries[i].help_id,
+                                       entries[i].value);
+
+      if (callback)
+        g_signal_connect (action, "gimp-activate",
+                          G_CALLBACK (callback),
+                          group->user_data);
+
+      gimp_action_group_add_action_with_accel (group, GIMP_ACTION (action),
+                                               entries[i].accelerator);
+      g_signal_emit (group, signals[ACTION_ADDED], 0, action);
+
+      g_object_unref (action);
+    }
+}
+
+void
+gimp_action_group_add_procedure_actions (GimpActionGroup                *group,
+                                         const GimpProcedureActionEntry *entries,
+                                         guint                           n_entries,
+                                         GimpActionCallback              callback)
+{
+  gint i;
+
+  g_return_if_fail (GIMP_IS_ACTION_GROUP (group));
+
+  for (i = 0; i < n_entries; i++)
+    {
+      GimpProcedureAction *action;
+
+      if (! gimp_action_group_check_unique_action (group, entries[i].name))
+        continue;
+
+      action = gimp_procedure_action_new (entries[i].name,
+                                          entries[i].label,
+                                          entries[i].tooltip,
+                                          entries[i].icon_name,
+                                          entries[i].help_id,
+                                          entries[i].procedure);
+
+      if (callback)
+        g_signal_connect (action, "gimp-activate",
+                          G_CALLBACK (callback),
+                          group->user_data);
+
+      gimp_action_group_add_action_with_accel (group, GIMP_ACTION (action),
+                                               entries[i].accelerator);
+      g_signal_emit (group, signals[ACTION_ADDED], 0, action);
+
+      g_object_unref (action);
+    }
+}
+
+/**
+ * gimp_action_group_remove_action_and_accel:
+ * @group:  the #GimpActionGroup to which @action belongs.
+ * @action: the #GimpAction.
+ *
+ * This function removes @action from @group and clean any
+ * accelerator this action may have set.
+ * If you wish to only remove the action from the group, use
+ * gimp_action_group_remove_action() instead.
+ */
+void
+gimp_action_group_remove_action_and_accel (GimpActionGroup *group,
+                                           GimpAction      *action)
+{
+  const gchar *action_name;
+  const gchar *group_name;
+  gchar       *accel_path;
+
+  action_name = gimp_action_get_name (action);
+  group_name  = gimp_action_group_get_name (group);
+  accel_path = g_strconcat ("<Actions>/", group_name, "/",
+                            action_name, NULL);
+
+  gtk_accel_map_change_entry (accel_path, 0, 0, FALSE);
+
+  gimp_action_group_remove_action (group, action);
+  g_free (accel_path);
+}
+
+void
+gimp_action_group_activate_action (GimpActionGroup *group,
+                                   const gchar     *action_name)
+{
+  GimpAction *action;
+
+  g_return_if_fail (GIMP_IS_ACTION_GROUP (group));
+  g_return_if_fail (action_name != NULL);
+
+  action = gimp_action_group_get_action (group, action_name);
+
+  if (! action)
+    {
+      g_warning ("%s: Unable to activate action which doesn't exist: %s",
+                 G_STRFUNC, action_name);
+      return;
+    }
+
+  gimp_action_activate (action);
+}
+
+void
+gimp_action_group_set_action_visible (GimpActionGroup *group,
+                                      const gchar     *action_name,
+                                      gboolean         visible)
+{
+  GimpAction *action;
+
+  g_return_if_fail (GIMP_IS_ACTION_GROUP (group));
+  g_return_if_fail (action_name != NULL);
+
+  action = gimp_action_group_get_action (group, action_name);
+
+  if (! action)
+    {
+      g_warning ("%s: Unable to set visibility of action "
+                 "which doesn't exist: %s",
+                 G_STRFUNC, action_name);
+      return;
+    }
+
+  gimp_action_set_visible (action, visible);
+}
+
+void
+gimp_action_group_set_action_sensitive (GimpActionGroup *group,
+                                        const gchar     *action_name,
+                                        gboolean         sensitive)
+{
+  GimpAction *action;
+
+  g_return_if_fail (GIMP_IS_ACTION_GROUP (group));
+  g_return_if_fail (action_name != NULL);
+
+  action = gimp_action_group_get_action (group, action_name);
+
+  if (! action)
+    {
+      g_warning ("%s: Unable to set sensitivity of action "
+                 "which doesn't exist: %s",
+                 G_STRFUNC, action_name);
+      return;
+    }
+
+  gimp_action_set_sensitive (action, sensitive);
+}
+
+void
+gimp_action_group_set_action_active (GimpActionGroup *group,
+                                     const gchar     *action_name,
+                                     gboolean         active)
+{
+  GimpAction *action;
+
+  g_return_if_fail (GIMP_IS_ACTION_GROUP (group));
+  g_return_if_fail (action_name != NULL);
+
+  action = gimp_action_group_get_action (group, action_name);
+
+  if (! action)
+    {
+      g_warning ("%s: Unable to set \"active\" of action "
+                 "which doesn't exist: %s",
+                 G_STRFUNC, action_name);
+      return;
+    }
+
+  if (! GTK_IS_TOGGLE_ACTION (action))
+    {
+      g_warning ("%s: Unable to set \"active\" of action "
+                 "which is not a GtkToggleAction: %s",
+                 G_STRFUNC, action_name);
+      return;
+    }
+
+  gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
+                                active ? TRUE : FALSE);
+}
+
+void
+gimp_action_group_set_action_label (GimpActionGroup *group,
+                                    const gchar     *action_name,
+                                    const gchar     *label)
+{
+  GimpAction *action;
+
+  g_return_if_fail (GIMP_IS_ACTION_GROUP (group));
+  g_return_if_fail (action_name != NULL);
+
+  action = gimp_action_group_get_action (group, action_name);
+
+  if (! action)
+    {
+      g_warning ("%s: Unable to set label of action "
+                 "which doesn't exist: %s",
+                 G_STRFUNC, action_name);
+      return;
+    }
+
+  gimp_action_set_label (action, label);
+}
+
+void
+gimp_action_group_set_action_pixbuf (GimpActionGroup *group,
+                                     const gchar     *action_name,
+                                     GdkPixbuf       *pixbuf)
+{
+  GimpAction *action;
+
+  g_return_if_fail (GIMP_IS_ACTION_GROUP (group));
+  g_return_if_fail (action_name != NULL);
+
+  action = gimp_action_group_get_action (group, action_name);
+
+  if (! action)
+    {
+      g_warning ("%s: Unable to set pixbuf of action "
+                 "which doesn't exist: %s",
+                 G_STRFUNC, action_name);
+      return;
+    }
+
+  gimp_action_set_gicon (action, G_ICON (pixbuf));
+}
+
+
+void
+gimp_action_group_set_action_tooltip (GimpActionGroup     *group,
+                                      const gchar         *action_name,
+                                      const gchar         *tooltip)
+{
+  GimpAction *action;
+
+  g_return_if_fail (GIMP_IS_ACTION_GROUP (group));
+  g_return_if_fail (action_name != NULL);
+
+  action = gimp_action_group_get_action (group, action_name);
+
+  if (! action)
+    {
+      g_warning ("%s: Unable to set tooltip of action "
+                 "which doesn't exist: %s",
+                 G_STRFUNC, action_name);
+      return;
+    }
+
+  gimp_action_set_tooltip (action, tooltip);
+}
+
+const gchar *
+gimp_action_group_get_action_tooltip (GimpActionGroup     *group,
+                                      const gchar         *action_name)
+{
+  GimpAction *action;
+
+  g_return_val_if_fail (GIMP_IS_ACTION_GROUP (group), NULL);
+  g_return_val_if_fail (action_name != NULL, NULL);
+
+  action = gimp_action_group_get_action (group, action_name);
+
+  if (! action)
+    {
+      g_warning ("%s: Unable to get tooltip of action "
+                 "which doesn't exist: %s",
+                 G_STRFUNC, action_name);
+      return NULL;
+    }
+
+  return gimp_action_get_tooltip (action);
+}
+
+void
+gimp_action_group_set_action_context (GimpActionGroup *group,
+                                      const gchar     *action_name,
+                                      GimpContext     *context)
+{
+  GimpAction *action;
+
+  g_return_if_fail (GIMP_IS_ACTION_GROUP (group));
+  g_return_if_fail (action_name != NULL);
+  g_return_if_fail (context == NULL || GIMP_IS_CONTEXT (context));
+
+  action = gimp_action_group_get_action (group, action_name);
+
+  if (! action)
+    {
+      g_warning ("%s: Unable to set context of action "
+                 "which doesn't exist: %s",
+                 G_STRFUNC, action_name);
+      return;
+    }
+
+  if (! GIMP_IS_ACTION (action))
+    {
+      g_warning ("%s: Unable to set \"context\" of action "
+                 "which is not a GimpAction: %s",
+                 G_STRFUNC, action_name);
+      return;
+    }
+
+  g_object_set (action, "context", context, NULL);
+}
+
+void
+gimp_action_group_set_action_color (GimpActionGroup *group,
+                                    const gchar     *action_name,
+                                    const GimpRGB   *color,
+                                    gboolean         set_label)
+{
+  GimpAction *action;
+
+  g_return_if_fail (GIMP_IS_ACTION_GROUP (group));
+  g_return_if_fail (action_name != NULL);
+
+  action = gimp_action_group_get_action (group, action_name);
+
+  if (! action)
+    {
+      g_warning ("%s: Unable to set color of action "
+                 "which doesn't exist: %s",
+                 G_STRFUNC, action_name);
+      return;
+    }
+
+  if (! GIMP_IS_ACTION (action))
+    {
+      g_warning ("%s: Unable to set \"color\" of action "
+                 "which is not a GimpAction: %s",
+                 G_STRFUNC, action_name);
+      return;
+    }
+
+  if (set_label)
+    {
+      gchar *label;
+
+      if (color)
+        label = g_strdup_printf (_("RGBA (%0.3f, %0.3f, %0.3f, %0.3f)"),
+                                 color->r, color->g, color->b, color->a);
+      else
+        label = g_strdup (_("(none)"));
+
+      g_object_set (action,
+                    "color", color,
+                    "label", label,
+                    NULL);
+      g_free (label);
+    }
+  else
+    {
+      g_object_set (action, "color", color, NULL);
+    }
+}
+
+void
+gimp_action_group_set_action_viewable (GimpActionGroup *group,
+                                       const gchar     *action_name,
+                                       GimpViewable    *viewable)
+{
+  GimpAction *action;
+
+  g_return_if_fail (GIMP_IS_ACTION_GROUP (group));
+  g_return_if_fail (action_name != NULL);
+  g_return_if_fail (viewable == NULL || GIMP_IS_VIEWABLE (viewable));
+
+  action = gimp_action_group_get_action (group, action_name);
+
+  if (! action)
+    {
+      g_warning ("%s: Unable to set viewable of action "
+                 "which doesn't exist: %s",
+                 G_STRFUNC, action_name);
+      return;
+    }
+
+  if (! GIMP_IS_ACTION (action))
+    {
+      g_warning ("%s: Unable to set \"viewable\" of action "
+                 "which is not a GimpAction: %s",
+                 G_STRFUNC, action_name);
+      return;
+    }
+
+  g_object_set (action, "viewable", viewable, NULL);
+}
+
+void
+gimp_action_group_set_action_hide_empty (GimpActionGroup *group,
+                                         const gchar     *action_name,
+                                         gboolean         hide_empty)
+{
+  GimpAction *action;
+
+  g_return_if_fail (GIMP_IS_ACTION_GROUP (group));
+  g_return_if_fail (action_name != NULL);
+
+  action = gimp_action_group_get_action (group, action_name);
+
+  if (! action)
+    {
+      g_warning ("%s: Unable to set \"hide-if-empty\" of action "
+                 "which doesn't exist: %s",
+                 G_STRFUNC, action_name);
+      return;
+    }
+
+  g_object_set (action, "hide-if-empty", hide_empty ? TRUE : FALSE, NULL);
+}
+
+void
+gimp_action_group_set_action_always_show_image (GimpActionGroup *group,
+                                                const gchar     *action_name,
+                                                gboolean         always_show_image)
+{
+  GimpAction *action;
+
+  g_return_if_fail (GIMP_IS_ACTION_GROUP (group));
+  g_return_if_fail (action_name != NULL);
+
+  action = gimp_action_group_get_action (group, action_name);
+
+  if (! action)
+    {
+      g_warning ("%s: Unable to set \"always-show-image\" of action "
+                 "which doesn't exist: %s",
+                 G_STRFUNC, action_name);
+      return;
+    }
+
+  gtk_action_set_always_show_image ((GtkAction *) action, always_show_image);
+}