Adding upstream version 2.10.36.upstream/2.10.36

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

1 files changed, 1014 insertions, 0 deletions

diff --git a/libgimpwidgets/gimpcolorbutton.c b/libgimpwidgets/gimpcolorbutton.c
new file mode 100644
index 0000000..6ec562e
--- /dev/null
+++ b/libgimpwidgets/gimpcolorbutton.c
@@ -0,0 +1,1014 @@
+/* LIBGIMP - The GIMP Library
+ * Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
+ *
+ * gimpcolorbutton.c
+ * Copyright (C) 1999-2001 Sven Neumann
+ *
+ * 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 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library 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
+ * <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+
+#include "libgimpcolor/gimpcolor.h"
+#include "libgimpconfig/gimpconfig.h"
+
+#include "gimpwidgetstypes.h"
+
+#include "gimpcolorarea.h"
+#include "gimpcolorbutton.h"
+#include "gimpcolornotebook.h"
+#include "gimpcolorselection.h"
+#include "gimpdialog.h"
+#include "gimphelpui.h"
+#include "gimpicons.h"
+#include "gimpwidgets-private.h"
+#include "gimp3migration.h"
+
+#include "libgimp/libgimp-intl.h"
+
+
+/**
+ * SECTION: gimpcolorbutton
+ * @title: GimpColorButton
+ * @short_description: Widget for selecting a color from a simple button.
+ * @see_also: #libgimpcolor-gimpcolorspace
+ *
+ * This widget provides a simple button with a preview showing the
+ * color.
+ *
+ * On click a color selection dialog is opened. Additionally the
+ * button supports Drag and Drop and has a right-click menu that
+ * allows one to choose the color from the current FG or BG color. If
+ * the user changes the color, the "color-changed" signal is emitted.
+ **/
+
+
+#define COLOR_BUTTON_KEY "gimp-color-button"
+#define RESPONSE_RESET   1
+
+#define TODOUBLE(i) (i / 65535.0)
+#define TOUINT16(d) ((guint16) (d * 65535 + 0.5))
+
+
+#define GIMP_COLOR_BUTTON_COLOR_FG    "color-button-use-foreground"
+#define GIMP_COLOR_BUTTON_COLOR_BG    "color-button-use-background"
+#define GIMP_COLOR_BUTTON_COLOR_BLACK "color-button-use-black"
+#define GIMP_COLOR_BUTTON_COLOR_WHITE "color-button-use-white"
+
+
+enum
+{
+  COLOR_CHANGED,
+  LAST_SIGNAL
+};
+
+enum
+{
+  PROP_0,
+  PROP_TITLE,
+  PROP_COLOR,
+  PROP_TYPE,
+  PROP_UPDATE,
+  PROP_AREA_WIDTH,
+  PROP_AREA_HEIGHT,
+  PROP_COLOR_CONFIG
+};
+
+
+typedef struct _GimpColorButtonPrivate GimpColorButtonPrivate;
+
+struct _GimpColorButtonPrivate
+{
+  GtkWidget       *selection;
+
+  GimpColorConfig *config;
+};
+
+#define GET_PRIVATE(obj) (gimp_color_button_get_instance_private (GIMP_COLOR_BUTTON (obj)))
+
+
+static void     gimp_color_button_constructed         (GObject         *object);
+static void     gimp_color_button_finalize            (GObject         *object);
+static void     gimp_color_button_dispose             (GObject         *object);
+static void     gimp_color_button_get_property        (GObject         *object,
+                                                       guint            property_id,
+                                                       GValue          *value,
+                                                       GParamSpec      *pspec);
+static void     gimp_color_button_set_property        (GObject         *object,
+                                                       guint            property_id,
+                                                       const GValue    *value,
+                                                       GParamSpec      *pspec);
+
+static gboolean gimp_color_button_button_press        (GtkWidget       *widget,
+                                                       GdkEventButton  *bevent);
+static void     gimp_color_button_state_changed       (GtkWidget       *widget,
+                                                       GtkStateType     prev_state);
+static void     gimp_color_button_clicked             (GtkButton       *button);
+static GType    gimp_color_button_get_action_type     (GimpColorButton *button);
+
+static void     gimp_color_button_dialog_response     (GtkWidget       *dialog,
+                                                       gint             response_id,
+                                                       GimpColorButton *button);
+static void     gimp_color_button_use_color           (GtkAction       *action,
+                                                       GimpColorButton *button);
+static void     gimp_color_button_area_changed        (GtkWidget       *color_area,
+                                                       GimpColorButton *button);
+static void     gimp_color_button_selection_changed   (GtkWidget       *selection,
+                                                       GimpColorButton *button);
+static void     gimp_color_button_help_func           (const gchar     *help_id,
+                                                       gpointer         help_data);
+
+
+static const GtkActionEntry actions[] =
+{
+  { "color-button-popup", NULL,
+    "Color Button Menu", NULL, NULL,
+    NULL
+  },
+
+  { GIMP_COLOR_BUTTON_COLOR_FG, NULL,
+    N_("_Foreground Color"), NULL, NULL,
+    G_CALLBACK (gimp_color_button_use_color)
+  },
+  { GIMP_COLOR_BUTTON_COLOR_BG, NULL,
+    N_("_Background Color"), NULL, NULL,
+    G_CALLBACK (gimp_color_button_use_color)
+  },
+  { GIMP_COLOR_BUTTON_COLOR_BLACK, NULL,
+    N_("Blac_k"), NULL, NULL,
+    G_CALLBACK (gimp_color_button_use_color)
+  },
+  { GIMP_COLOR_BUTTON_COLOR_WHITE, NULL,
+    N_("_White"), NULL, NULL,
+    G_CALLBACK (gimp_color_button_use_color)
+  }
+};
+
+
+G_DEFINE_TYPE_WITH_CODE (GimpColorButton, gimp_color_button, GIMP_TYPE_BUTTON,
+                         G_ADD_PRIVATE (GimpColorButton))
+
+#define parent_class gimp_color_button_parent_class
+
+static guint gimp_color_button_signals[LAST_SIGNAL] = { 0 };
+
+
+static void
+gimp_color_button_class_init (GimpColorButtonClass *klass)
+{
+  GObjectClass   *object_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+  GtkButtonClass *button_class = GTK_BUTTON_CLASS (klass);
+  GimpRGB         color;
+
+  parent_class = g_type_class_peek_parent (klass);
+
+  gimp_color_button_signals[COLOR_CHANGED] =
+    g_signal_new ("color-changed",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_FIRST,
+                  G_STRUCT_OFFSET (GimpColorButtonClass, color_changed),
+                  NULL, NULL,
+                  g_cclosure_marshal_VOID__VOID,
+                  G_TYPE_NONE, 0);
+
+  object_class->constructed        = gimp_color_button_constructed;
+  object_class->finalize           = gimp_color_button_finalize;
+  object_class->dispose            = gimp_color_button_dispose;
+  object_class->get_property       = gimp_color_button_get_property;
+  object_class->set_property       = gimp_color_button_set_property;
+
+  widget_class->button_press_event = gimp_color_button_button_press;
+  widget_class->state_changed      = gimp_color_button_state_changed;
+
+  button_class->clicked            = gimp_color_button_clicked;
+
+  klass->color_changed             = NULL;
+  klass->get_action_type           = gimp_color_button_get_action_type;
+
+  gimp_rgba_set (&color, 0.0, 0.0, 0.0, 1.0);
+
+  /**
+   * GimpColorButton:title:
+   *
+   * The title to be used for the color selection dialog.
+   *
+   * Since: 2.4
+   */
+  g_object_class_install_property (object_class, PROP_TITLE,
+                                   g_param_spec_string ("title",
+                                                        "Title",
+                                                        "The title to be used for the color selection dialog",
+                                                        NULL,
+                                                        GIMP_PARAM_READWRITE |
+                                                        G_PARAM_CONSTRUCT));
+  /**
+   * GimpColorButton:color:
+   *
+   * The color displayed in the button's color area.
+   *
+   * Since: 2.4
+   */
+  g_object_class_install_property (object_class, PROP_COLOR,
+                                   gimp_param_spec_rgb ("color",
+                                                        "Color",
+                                                        "The color displayed in the button's color area",
+                                                        TRUE, &color,
+                                                        GIMP_PARAM_READWRITE |
+                                                        G_PARAM_CONSTRUCT));
+  /**
+   * GimpColorButton:type:
+   *
+   * The type of the button's color area.
+   *
+   * Since: 2.4
+   */
+  g_object_class_install_property (object_class, PROP_TYPE,
+                                   g_param_spec_enum ("type",
+                                                      "Type",
+                                                      "The type of the button's color area",
+                                                      GIMP_TYPE_COLOR_AREA_TYPE,
+                                                      GIMP_COLOR_AREA_FLAT,
+                                                      GIMP_PARAM_READWRITE |
+                                                      G_PARAM_CONSTRUCT));
+  /**
+   * GimpColorButton:continuous-update:
+   *
+   * The update policy of the color button.
+   *
+   * Since: 2.4
+   */
+  g_object_class_install_property (object_class, PROP_UPDATE,
+                                   g_param_spec_boolean ("continuous-update",
+                                                         "Contiguous Update",
+                                                         "The update policy of the color button",
+                                                         FALSE,
+                                                         G_PARAM_READWRITE |
+                                                         G_PARAM_CONSTRUCT));
+  /**
+   * GimpColorButton:area-width:
+   *
+   * The minimum width of the button's #GimpColorArea.
+   *
+   * Since: 2.8
+   */
+  g_object_class_install_property (object_class, PROP_AREA_WIDTH,
+                                   g_param_spec_int ("area-width",
+                                                     "Area Width",
+                                                     "The minimum width of the button's GimpColorArea",
+                                                     1, G_MAXINT, 16,
+                                                     G_PARAM_WRITABLE |
+                                                     G_PARAM_CONSTRUCT));
+  /**
+   * GimpColorButton:area-height:
+   *
+   * The minimum height of the button's #GimpColorArea.
+   *
+   * Since: 2.8
+   */
+  g_object_class_install_property (object_class, PROP_AREA_HEIGHT,
+                                   g_param_spec_int ("area-height",
+                                                     "Area Height",
+                                                     "The minimum height of the button's GimpColorArea",
+                                                     1, G_MAXINT, 16,
+                                                     G_PARAM_WRITABLE |
+                                                     G_PARAM_CONSTRUCT));
+  /**
+   * GimpColorButton:color-config:
+   *
+   * The #GimpColorConfig object used for the button's #GimpColorArea
+   * and #GimpColorSelection.
+   *
+   * Since: 2.10
+   */
+  g_object_class_install_property (object_class, PROP_COLOR_CONFIG,
+                                   g_param_spec_object ("color-config",
+                                                        "Color Config",
+                                                        "The color config object used",
+                                                        GIMP_TYPE_COLOR_CONFIG,
+                                                        G_PARAM_READWRITE));
+}
+
+static void
+gimp_color_button_init (GimpColorButton *button)
+{
+  button->color_area = g_object_new (GIMP_TYPE_COLOR_AREA,
+                                     "drag-mask", GDK_BUTTON1_MASK,
+                                     NULL);
+
+  g_signal_connect (button->color_area, "color-changed",
+                    G_CALLBACK (gimp_color_button_area_changed),
+                    button);
+
+  gtk_container_add (GTK_CONTAINER (button), button->color_area);
+  gtk_widget_show (button->color_area);
+}
+
+static void
+gimp_color_button_constructed (GObject *object)
+{
+  GimpColorButton      *button = GIMP_COLOR_BUTTON (object);
+  GimpColorButtonClass *klass  = GIMP_COLOR_BUTTON_GET_CLASS (object);
+  GtkUIManager         *ui_manager;
+  GtkActionGroup       *group;
+  gint                  i;
+
+  G_OBJECT_CLASS (parent_class)->constructed (object);
+
+  /* right-click opens a popup */
+  button->popup_menu = ui_manager = gtk_ui_manager_new ();
+
+  group = gtk_action_group_new ("color-button");
+
+  for (i = 0; i < G_N_ELEMENTS (actions); i++)
+    {
+      const gchar *label   = gettext (actions[i].label);
+      const gchar *tooltip = gettext (actions[i].tooltip);
+      GtkAction   *action;
+
+      action = g_object_new (klass->get_action_type (button),
+                             "name",      actions[i].name,
+                             "label",     label,
+                             "tooltip",   tooltip,
+                             "icon-name", actions[i].stock_id,
+                             NULL);
+
+      if (actions[i].callback)
+        g_signal_connect (action, "activate",
+                          actions[i].callback,
+                          button);
+
+      gtk_action_group_add_action_with_accel (group, action,
+                                              actions[i].accelerator);
+
+      g_object_unref (action);
+    }
+
+  gtk_ui_manager_insert_action_group (ui_manager, group, -1);
+  g_object_unref (group);
+
+  gtk_ui_manager_add_ui_from_string
+    (ui_manager,
+     "<ui>\n"
+     "  <popup action=\"color-button-popup\">\n"
+     "    <menuitem action=\"" GIMP_COLOR_BUTTON_COLOR_FG "\" />\n"
+     "    <menuitem action=\"" GIMP_COLOR_BUTTON_COLOR_BG "\" />\n"
+     "    <separator />\n"
+     "    <menuitem action=\"" GIMP_COLOR_BUTTON_COLOR_BLACK "\" />\n"
+     "    <menuitem action=\"" GIMP_COLOR_BUTTON_COLOR_WHITE "\" />\n"
+     "  </popup>\n"
+     "</ui>\n",
+     -1, NULL);
+}
+
+static void
+gimp_color_button_finalize (GObject *object)
+{
+  GimpColorButton *button = GIMP_COLOR_BUTTON (object);
+
+  g_clear_pointer (&button->title, g_free);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gimp_color_button_dispose (GObject *object)
+{
+  GimpColorButton        *button = GIMP_COLOR_BUTTON (object);
+  GimpColorButtonPrivate *priv   = GET_PRIVATE (button);
+
+  g_clear_pointer (&button->dialog, gtk_widget_destroy);
+  priv->selection = NULL;
+
+  g_clear_pointer (&button->color_area, gtk_widget_destroy);
+
+  g_clear_object (&button->popup_menu);
+
+  gimp_color_button_set_color_config (button, NULL);
+
+  G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+gimp_color_button_get_property (GObject    *object,
+                                guint       property_id,
+                                GValue     *value,
+                                GParamSpec *pspec)
+{
+  GimpColorButton        *button = GIMP_COLOR_BUTTON (object);
+  GimpColorButtonPrivate *priv   = GET_PRIVATE (object);
+
+  switch (property_id)
+    {
+    case PROP_TITLE:
+      g_value_set_string (value, button->title);
+      break;
+
+    case PROP_COLOR:
+      g_object_get_property (G_OBJECT (button->color_area), "color", value);
+      break;
+
+    case PROP_TYPE:
+      g_object_get_property (G_OBJECT (button->color_area), "type", value);
+      break;
+
+    case PROP_UPDATE:
+      g_value_set_boolean (value, button->continuous_update);
+      break;
+
+    case PROP_COLOR_CONFIG:
+      g_value_set_object (value, priv->config);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gimp_color_button_set_property (GObject      *object,
+                                guint         property_id,
+                                const GValue *value,
+                                GParamSpec   *pspec)
+{
+  GimpColorButton *button = GIMP_COLOR_BUTTON (object);
+  gint             other;
+
+  switch (property_id)
+    {
+    case PROP_TITLE:
+      gimp_color_button_set_title (button, g_value_get_string (value));
+      break;
+
+    case PROP_COLOR:
+      g_object_set_property (G_OBJECT (button->color_area), "color", value);
+      break;
+
+    case PROP_TYPE:
+      g_object_set_property (G_OBJECT (button->color_area), "type", value);
+      break;
+
+    case PROP_UPDATE:
+      gimp_color_button_set_update (button, g_value_get_boolean (value));
+      break;
+
+    case PROP_AREA_WIDTH:
+      gtk_widget_get_size_request (button->color_area, NULL, &other);
+      gtk_widget_set_size_request (button->color_area,
+                                   g_value_get_int (value), other);
+      break;
+
+    case PROP_AREA_HEIGHT:
+      gtk_widget_get_size_request (button->color_area, &other, NULL);
+      gtk_widget_set_size_request (button->color_area,
+                                   other, g_value_get_int (value));
+      break;
+
+    case PROP_COLOR_CONFIG:
+      gimp_color_button_set_color_config (button, g_value_get_object (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static gboolean
+gimp_color_button_button_press (GtkWidget      *widget,
+                                GdkEventButton *bevent)
+{
+  GimpColorButton *button = GIMP_COLOR_BUTTON (widget);
+
+  if (gdk_event_triggers_context_menu ((GdkEvent *) bevent))
+    {
+      GtkWidget *menu = gtk_ui_manager_get_widget (button->popup_menu,
+                                                   "/color-button-popup");
+
+      gtk_menu_set_screen (GTK_MENU (menu), gtk_widget_get_screen (widget));
+
+      gtk_menu_popup (GTK_MENU (menu),
+                      NULL, NULL, NULL, NULL,
+                      bevent->button, bevent->time);
+    }
+
+  if (GTK_WIDGET_CLASS (parent_class)->button_press_event)
+    return GTK_WIDGET_CLASS (parent_class)->button_press_event (widget, bevent);
+
+  return FALSE;
+}
+
+static void
+gimp_color_button_state_changed (GtkWidget    *widget,
+                                 GtkStateType  prev_state)
+{
+  g_return_if_fail (GIMP_IS_COLOR_BUTTON (widget));
+
+  if (! gtk_widget_is_sensitive (widget) && GIMP_COLOR_BUTTON (widget)->dialog)
+    gtk_widget_hide (GIMP_COLOR_BUTTON (widget)->dialog);
+
+  if (GTK_WIDGET_CLASS (parent_class)->state_changed)
+    GTK_WIDGET_CLASS (parent_class)->state_changed (widget, prev_state);
+}
+
+static void
+gimp_color_button_clicked (GtkButton *button)
+{
+  GimpColorButton        *color_button = GIMP_COLOR_BUTTON (button);
+  GimpColorButtonPrivate *priv         = GET_PRIVATE (button);
+  GimpRGB                 color;
+
+  if (! color_button->dialog)
+    {
+      GtkWidget *dialog;
+
+      dialog = color_button->dialog =
+        gimp_dialog_new (color_button->title, "gimp-color-selection",
+                         gtk_widget_get_toplevel (GTK_WIDGET (button)), 0,
+                         gimp_color_button_help_func, NULL,
+
+                         _("_Reset"),  RESPONSE_RESET,
+                         _("_Cancel"), GTK_RESPONSE_CANCEL,
+                         _("_OK"),     GTK_RESPONSE_OK,
+
+                         NULL);
+
+      g_object_set_data (G_OBJECT (dialog), COLOR_BUTTON_KEY, button);
+
+      gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
+                                               RESPONSE_RESET,
+                                               GTK_RESPONSE_OK,
+                                               GTK_RESPONSE_CANCEL,
+                                               -1);
+
+      g_signal_connect (dialog, "response",
+                        G_CALLBACK (gimp_color_button_dialog_response),
+                        color_button);
+      g_signal_connect (dialog, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed),
+                        &color_button->dialog);
+
+      priv->selection = gimp_color_selection_new ();
+      gtk_container_set_border_width (GTK_CONTAINER (priv->selection), 6);
+      gimp_color_selection_set_show_alpha (GIMP_COLOR_SELECTION (priv->selection),
+                                           gimp_color_button_has_alpha (color_button));
+      gimp_color_selection_set_config (GIMP_COLOR_SELECTION (priv->selection),
+                                       priv->config);
+      gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+                          priv->selection, TRUE, TRUE, 0);
+      gtk_widget_show (priv->selection);
+
+      g_signal_connect (priv->selection, "color-changed",
+                        G_CALLBACK (gimp_color_button_selection_changed),
+                        button);
+    }
+
+  gimp_color_button_get_color (color_button, &color);
+
+  g_signal_handlers_block_by_func (priv->selection,
+                                   gimp_color_button_selection_changed,
+                                   button);
+
+  gimp_color_selection_set_color (GIMP_COLOR_SELECTION (priv->selection), &color);
+  gimp_color_selection_set_old_color (GIMP_COLOR_SELECTION (priv->selection),
+                                      &color);
+
+  g_signal_handlers_unblock_by_func (priv->selection,
+                                     gimp_color_button_selection_changed,
+                                     button);
+
+  gtk_window_present (GTK_WINDOW (color_button->dialog));
+}
+
+static GType
+gimp_color_button_get_action_type (GimpColorButton *button)
+{
+  return GTK_TYPE_ACTION;
+}
+
+
+/*  public functions  */
+
+/**
+ * gimp_color_button_new:
+ * @title:  String that will be used as title for the color_selector.
+ * @width:  Width of the colorpreview in pixels.
+ * @height: Height of the colorpreview in pixels.
+ * @color:  A pointer to a #GimpRGB color.
+ * @type:   The type of transparency to be displayed.
+ *
+ * Creates a new #GimpColorButton widget.
+ *
+ * This returns a button with a preview showing the color.
+ * When the button is clicked a GtkColorSelectionDialog is opened.
+ * If the user changes the color the new color is written into the
+ * array that was used to pass the initial color and the "color-changed"
+ * signal is emitted.
+ *
+ * Returns: Pointer to the new #GimpColorButton widget.
+ **/
+GtkWidget *
+gimp_color_button_new (const gchar       *title,
+                       gint               width,
+                       gint               height,
+                       const GimpRGB     *color,
+                       GimpColorAreaType  type)
+{
+  g_return_val_if_fail (color != NULL, NULL);
+  g_return_val_if_fail (width > 0, NULL);
+  g_return_val_if_fail (height > 0, NULL);
+
+  return g_object_new (GIMP_TYPE_COLOR_BUTTON,
+                       "title",       title,
+                       "type",        type,
+                       "color",       color,
+                       "area-width",  width,
+                       "area-height", height,
+                       NULL);
+}
+
+/**
+ * gimp_color_button_set_title:
+ * @button: a #GimpColorButton.
+ * @title:  the new title.
+ *
+ * Sets the @button dialog's title.
+ *
+ * Since: 2.10
+ **/
+void
+gimp_color_button_set_title (GimpColorButton *button,
+                             const gchar     *title)
+{
+  g_return_if_fail (GIMP_IS_COLOR_BUTTON (button));
+  g_return_if_fail (title != NULL);
+
+  g_free (button->title);
+  button->title = g_strdup (title);
+
+  if (button->dialog)
+    gtk_window_set_title (GTK_WINDOW (button->dialog), title);
+
+  g_object_notify (G_OBJECT (button), "title");
+}
+
+/**
+ * gimp_color_button_get_title:
+ * @button: a #GimpColorButton.
+ *
+ * Returns: The @button dialog's title.
+ *
+ * Since: 2.10
+ **/
+const gchar *
+gimp_color_button_get_title (GimpColorButton *button)
+{
+  g_return_val_if_fail (GIMP_IS_COLOR_BUTTON (button), NULL);
+
+  return button->title;
+}
+
+/**
+ * gimp_color_button_set_color:
+ * @button: Pointer to a #GimpColorButton.
+ * @color:  Pointer to the new #GimpRGB color.
+ *
+ * Sets the @button to the given @color.
+ **/
+void
+gimp_color_button_set_color (GimpColorButton *button,
+                             const GimpRGB   *color)
+{
+  g_return_if_fail (GIMP_IS_COLOR_BUTTON (button));
+  g_return_if_fail (color != NULL);
+
+  gimp_color_area_set_color (GIMP_COLOR_AREA (button->color_area), color);
+
+  g_object_notify (G_OBJECT (button), "color");
+}
+
+/**
+ * gimp_color_button_get_color:
+ * @button: Pointer to a #GimpColorButton.
+ * @color:  Pointer to a #GimpRGB struct used to return the color.
+ *
+ * Retrieves the currently set color from the @button.
+ **/
+void
+gimp_color_button_get_color (GimpColorButton *button,
+                             GimpRGB         *color)
+{
+  g_return_if_fail (GIMP_IS_COLOR_BUTTON (button));
+  g_return_if_fail (color != NULL);
+
+  gimp_color_area_get_color (GIMP_COLOR_AREA (button->color_area), color);
+}
+
+/**
+ * gimp_color_button_has_alpha:
+ * @button: Pointer to a #GimpColorButton.
+ *
+ * Checks whether the @buttons shows transparency information.
+ *
+ * Returns: %TRUE if the @button shows transparency information, %FALSE
+ * otherwise.
+ **/
+gboolean
+gimp_color_button_has_alpha (GimpColorButton *button)
+{
+  g_return_val_if_fail (GIMP_IS_COLOR_BUTTON (button), FALSE);
+
+  return gimp_color_area_has_alpha (GIMP_COLOR_AREA (button->color_area));
+}
+
+/**
+ * gimp_color_button_set_type:
+ * @button: Pointer to a #GimpColorButton.
+ * @type: the new #GimpColorAreaType
+ *
+ * Sets the @button to the given @type. See also gimp_color_area_set_type().
+ **/
+void
+gimp_color_button_set_type (GimpColorButton   *button,
+                            GimpColorAreaType  type)
+{
+  g_return_if_fail (GIMP_IS_COLOR_BUTTON (button));
+
+  gimp_color_area_set_type (GIMP_COLOR_AREA (button->color_area), type);
+
+  g_object_notify (G_OBJECT (button), "type");
+}
+
+/**
+ * gimp_color_button_get_update:
+ * @button: A #GimpColorButton widget.
+ *
+ * Returns the color button's @continuous_update property.
+ *
+ * Return value: the @continuous_update property.
+ **/
+gboolean
+gimp_color_button_get_update (GimpColorButton *button)
+{
+  g_return_val_if_fail (GIMP_IS_COLOR_BUTTON (button), FALSE);
+
+  return button->continuous_update;
+}
+
+/**
+ * gimp_color_button_set_update:
+ * @button:     A #GimpColorButton widget.
+ * @continuous: The new setting of the @continuous_update property.
+ *
+ * When set to #TRUE, the @button will emit the "color-changed"
+ * continuously while the color is changed in the color selection
+ * dialog.
+ **/
+void
+gimp_color_button_set_update (GimpColorButton *button,
+                              gboolean         continuous)
+{
+  GimpColorButtonPrivate *priv;
+
+  g_return_if_fail (GIMP_IS_COLOR_BUTTON (button));
+
+  priv = GET_PRIVATE (button);
+
+  if (continuous != button->continuous_update)
+    {
+      button->continuous_update = continuous ? TRUE : FALSE;
+
+      if (priv->selection)
+        {
+          GimpRGB color;
+
+          if (button->continuous_update)
+            {
+              gimp_color_selection_get_color (GIMP_COLOR_SELECTION (priv->selection),
+                                              &color);
+              gimp_color_button_set_color (button, &color);
+            }
+          else
+            {
+              gimp_color_selection_get_old_color (GIMP_COLOR_SELECTION (priv->selection),
+                                                  &color);
+              gimp_color_button_set_color (button, &color);
+            }
+        }
+
+      g_object_notify (G_OBJECT (button), "continuous-update");
+    }
+}
+
+/**
+ * gimp_color_button_set_color_config:
+ * @button: a #GimpColorButton widget.
+ * @config: a #GimpColorConfig object.
+ *
+ * Sets the color management configuration to use with this color button's
+ * #GimpColorArea.
+ *
+ * Since: 2.10
+ */
+void
+gimp_color_button_set_color_config (GimpColorButton *button,
+                                    GimpColorConfig *config)
+{
+  GimpColorButtonPrivate *priv;
+
+  g_return_if_fail (GIMP_IS_COLOR_BUTTON (button));
+  g_return_if_fail (config == NULL || GIMP_IS_COLOR_CONFIG (config));
+
+  priv = GET_PRIVATE (button);
+
+  if (g_set_object (&priv->config, config))
+    {
+      if (button->color_area)
+        gimp_color_area_set_color_config (GIMP_COLOR_AREA (button->color_area),
+                                          priv->config);
+
+      if (priv->selection)
+        gimp_color_selection_set_config (GIMP_COLOR_SELECTION (priv->selection),
+                                         priv->config);
+    }
+}
+
+/**
+ * gimp_color_button_get_ui_manager:
+ * @button: a #GimpColorButton.
+ *
+ * Returns: The @button's #GtkUIManager.
+ *
+ * Since: 2.10
+ **/
+GtkUIManager *
+gimp_color_button_get_ui_manager (GimpColorButton *button)
+{
+  g_return_val_if_fail (GIMP_IS_COLOR_BUTTON (button), NULL);
+
+  return button->popup_menu;
+}
+
+
+/*  private functions  */
+
+static void
+gimp_color_button_dialog_response (GtkWidget       *dialog,
+                                   gint             response_id,
+                                   GimpColorButton *button)
+{
+  GimpColorButtonPrivate *priv = GET_PRIVATE (button);
+  GimpRGB                 color;
+
+  switch (response_id)
+    {
+    case RESPONSE_RESET:
+      gimp_color_selection_reset (GIMP_COLOR_SELECTION (priv->selection));
+      break;
+
+    case GTK_RESPONSE_OK:
+      if (! button->continuous_update)
+        {
+          gimp_color_selection_get_color (GIMP_COLOR_SELECTION (priv->selection),
+                                          &color);
+          gimp_color_button_set_color (button, &color);
+        }
+
+      gtk_widget_hide (dialog);
+      break;
+
+    default:
+      if (button->continuous_update)
+        {
+          gimp_color_selection_get_old_color (GIMP_COLOR_SELECTION (priv->selection),
+                                              &color);
+          gimp_color_button_set_color (button, &color);
+        }
+
+      gtk_widget_hide (dialog);
+      break;
+    }
+}
+
+static void
+gimp_color_button_use_color (GtkAction       *action,
+                             GimpColorButton *button)
+{
+  const gchar *name;
+  GimpRGB      color;
+
+  name = gtk_action_get_name (action);
+  gimp_color_button_get_color (button, &color);
+
+  if (! strcmp (name, GIMP_COLOR_BUTTON_COLOR_FG))
+    {
+      if (_gimp_get_foreground_func)
+        _gimp_get_foreground_func (&color);
+      else
+        gimp_rgba_set (&color, 0.0, 0.0, 0.0, 1.0);
+    }
+  else if (! strcmp (name, GIMP_COLOR_BUTTON_COLOR_BG))
+    {
+      if (_gimp_get_background_func)
+        _gimp_get_background_func (&color);
+      else
+        gimp_rgba_set (&color, 1.0, 1.0, 1.0, 1.0);
+    }
+  else if (! strcmp (name, GIMP_COLOR_BUTTON_COLOR_BLACK))
+    {
+      gimp_rgba_set (&color, 0.0, 0.0, 0.0, 1.0);
+    }
+  else if (! strcmp (name, GIMP_COLOR_BUTTON_COLOR_WHITE))
+    {
+      gimp_rgba_set (&color, 1.0, 1.0, 1.0, 1.0);
+    }
+
+  gimp_color_button_set_color (button, &color);
+}
+
+static void
+gimp_color_button_area_changed (GtkWidget       *color_area,
+                                GimpColorButton *button)
+{
+  GimpColorButtonPrivate *priv = GET_PRIVATE (button);
+
+  if (priv->selection)
+    {
+      GimpRGB color;
+
+      gimp_color_button_get_color (button, &color);
+
+      g_signal_handlers_block_by_func (priv->selection,
+                                       gimp_color_button_selection_changed,
+                                       button);
+
+      gimp_color_selection_set_color (GIMP_COLOR_SELECTION (priv->selection),
+                                      &color);
+
+      g_signal_handlers_unblock_by_func (priv->selection,
+                                         gimp_color_button_selection_changed,
+                                         button);
+    }
+
+  g_signal_emit (button, gimp_color_button_signals[COLOR_CHANGED], 0);
+}
+
+static void
+gimp_color_button_selection_changed (GtkWidget       *selection,
+                                     GimpColorButton *button)
+{
+  if (button->continuous_update)
+    {
+      GimpRGB color;
+
+      gimp_color_selection_get_color (GIMP_COLOR_SELECTION (selection), &color);
+
+      g_signal_handlers_block_by_func (button->color_area,
+                                       gimp_color_button_area_changed,
+                                       button);
+
+      gimp_color_area_set_color (GIMP_COLOR_AREA (button->color_area), &color);
+
+      g_signal_handlers_unblock_by_func (button->color_area,
+                                         gimp_color_button_area_changed,
+                                         button);
+
+      g_signal_emit (button, gimp_color_button_signals[COLOR_CHANGED], 0);
+    }
+}
+
+static void
+gimp_color_button_help_func (const gchar *help_id,
+                             gpointer     help_data)
+{
+  GimpColorButton        *button;
+  GimpColorButtonPrivate *priv = GET_PRIVATE (help_data);
+  GimpColorNotebook      *notebook;
+
+  button = g_object_get_data (G_OBJECT (help_data), COLOR_BUTTON_KEY);
+  priv   = GET_PRIVATE (button);
+
+  notebook = GIMP_COLOR_NOTEBOOK (GIMP_COLOR_SELECTION (priv->selection)->notebook);
+
+  help_id = GIMP_COLOR_SELECTOR_GET_CLASS (notebook->cur_page)->help_id;
+
+  gimp_standard_help_func (help_id, NULL);
+}