libmate-desktop: Add MateColorButton dialog

Code taken from GTK 2.24 source and renamed for MATE
This will allow to use traditional color selection with GTK2 and GTK3

7 files changed, 4347 insertions, 1 deletions

diff --git a/libmate-desktop/Makefile.am b/libmate-desktop/Makefile.am
index b36047c..3e35321 100644
--- a/libmate-desktop/Makefile.am
+++ b/libmate-desktop/Makefile.am
@@ -11,7 +11,10 @@ libmate_desktop_HEADERS = \
 	mate-desktop-thumbnail.h	\
 	mate-rr.h			\
 	mate-rr-config.h		\
-	mate-rr-labeler.h
+	mate-rr-labeler.h \
+	mate-colorbutton.h \
+	mate-colorsel.h \
+	mate-colorseldialog.h
 
 lib_LTLIBRARIES = libmate-desktop-2.la
 
@@ -43,6 +46,9 @@ libmate_desktop_2_la_SOURCES = \
 	mate-rr-config.c	\
 	mate-rr-labeler.c	\
 	mate-rr-private.h	\
+	mate-colorbutton.c \
+	mate-colorsel.c \
+	mate-colorseldialog.c \
 	edid-parse.c		\
 	edid.h			\
 	private.h
diff --git a/libmate-desktop/mate-colorbutton.c b/libmate-desktop/mate-colorbutton.c
new file mode 100644
index 0000000..e329d3a
--- /dev/null
+++ b/libmate-desktop/mate-colorbutton.c
@@ -0,0 +1,865 @@
+/*
+ * GTK - The GIMP Toolkit
+ * Copyright (C) 1998, 1999 Red Hat, Inc.
+ * All rights reserved.
+ *
+ * This Library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 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 Library General Public
+ * License along with the Gnome Library; see the file COPYING.LIB.  If not,
+ * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+/* Color picker button for GNOME
+ *
+ * Author: Federico Mena <[email protected]>
+ *
+ * Modified by the GTK+ Team and others 2003.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+#include "config.h"
+#include "private.h"
+
+#include "mate-colorbutton.h"
+#include "mate-colorsel.h"
+#include "mate-colorseldialog.h"
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <glib/gi18n-lib.h>
+
+/* Size of checks and gray levels for alpha compositing checkerboard */
+#define CHECK_SIZE  4
+#define CHECK_DARK  (1.0 / 3.0)
+#define CHECK_LIGHT (2.0 / 3.0)
+
+#define MATE_COLOR_BUTTON_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), MATE_TYPE_COLOR_BUTTON, MateColorButtonPrivate))
+
+struct _MateColorButtonPrivate 
+{
+  GtkWidget *draw_area; /* Widget where we draw the color sample */
+  GtkWidget *cs_dialog; /* Color selection dialog */
+  
+  gchar *title;         /* Title for the color selection window */
+  
+  GdkColor color;
+  guint16 alpha;
+  
+  guint use_alpha : 1;  /* Use alpha or not */
+};
+
+/* Properties */
+enum 
+{
+  PROP_0,
+  PROP_USE_ALPHA,
+  PROP_TITLE,
+  PROP_COLOR,
+  PROP_ALPHA
+};
+
+/* Signals */
+enum 
+{
+  COLOR_SET,
+  LAST_SIGNAL
+};
+
+/* gobject signals */
+static void mate_color_button_finalize      (GObject             *object);
+static void mate_color_button_set_property  (GObject        *object,
+					    guint           param_id,
+					    const GValue   *value,
+					    GParamSpec     *pspec);
+static void mate_color_button_get_property  (GObject        *object,
+					    guint           param_id,
+					    GValue         *value,
+					    GParamSpec     *pspec);
+
+/* gtkwidget signals */
+static void mate_color_button_state_changed (GtkWidget           *widget, 
+					    GtkStateType         previous_state);
+
+/* gtkbutton signals */
+static void mate_color_button_clicked       (GtkButton           *button);
+
+/* source side drag signals */
+static void mate_color_button_drag_begin (GtkWidget        *widget,
+					 GdkDragContext   *context,
+					 gpointer          data);
+static void mate_color_button_drag_data_get (GtkWidget        *widget,
+                                            GdkDragContext   *context,
+                                            GtkSelectionData *selection_data,
+                                            guint             info,
+                                            guint             time,
+                                            MateColorButton   *color_button);
+
+/* target side drag signals */
+static void mate_color_button_drag_data_received (GtkWidget        *widget,
+						 GdkDragContext   *context,
+						 gint              x,
+						 gint              y,
+						 GtkSelectionData *selection_data,
+						 guint             info,
+						 guint32           time,
+						 MateColorButton   *color_button);
+
+
+static guint color_button_signals[LAST_SIGNAL] = { 0 };
+
+static const GtkTargetEntry drop_types[] = { { "application/x-color", 0, 0 } };
+
+G_DEFINE_TYPE (MateColorButton, mate_color_button, GTK_TYPE_BUTTON)
+
+static void
+mate_color_button_class_init (MateColorButtonClass *klass)
+{
+  GObjectClass *gobject_class;
+  GtkWidgetClass *widget_class;
+  GtkButtonClass *button_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  widget_class = GTK_WIDGET_CLASS (klass);
+  button_class = GTK_BUTTON_CLASS (klass);
+
+  gobject_class->get_property = mate_color_button_get_property;
+  gobject_class->set_property = mate_color_button_set_property;
+  gobject_class->finalize = mate_color_button_finalize;
+  widget_class->state_changed = mate_color_button_state_changed;
+  button_class->clicked = mate_color_button_clicked;
+  klass->color_set = NULL;
+
+  /**
+   * MateColorButton:use-alpha:
+   *
+   * If this property is set to %TRUE, the color swatch on the button is rendered against a 
+   * checkerboard background to show its opacity and the opacity slider is displayed in the 
+   * color selection dialog. 
+   *
+   * Since: 2.4
+   */
+  g_object_class_install_property (gobject_class,
+                                   PROP_USE_ALPHA,
+                                   g_param_spec_boolean ("use-alpha", _("Use alpha"), 
+                                                         _("Whether or not to give the color an alpha value"),
+                                                         FALSE,
+                                                         G_PARAM_READWRITE));
+
+  /**
+   * MateColorButton:title:
+   *
+   * The title of the color selection dialog
+   *
+   * Since: 2.4
+   */
+  g_object_class_install_property (gobject_class,
+                                   PROP_TITLE,
+                                   g_param_spec_string ("title", 
+							_("Title"), 
+                                                        _("The title of the color selection dialog"),
+                                                        _("Pick a Color"),
+                                                        G_PARAM_READWRITE));
+
+  /**
+   * MateColorButton:color:
+   *
+   * The selected color.
+   *
+   * Since: 2.4
+   */
+  g_object_class_install_property (gobject_class,
+                                   PROP_COLOR,
+                                   g_param_spec_boxed ("color",
+                                                       _("Current Color"),
+                                                       _("The selected color"),
+                                                       GDK_TYPE_COLOR,
+                                                       G_PARAM_READWRITE));
+
+  /**
+   * MateColorButton:alpha:
+   *
+   * The selected opacity value (0 fully transparent, 65535 fully opaque). 
+   *
+   * Since: 2.4
+   */
+  g_object_class_install_property (gobject_class,
+                                   PROP_ALPHA,
+                                   g_param_spec_uint ("alpha",
+                                                      _("Current Alpha"),
+                                                      _("The selected opacity value (0 fully transparent, 65535 fully opaque)"),
+                                                      0, 65535, 65535,
+                                                      G_PARAM_READWRITE));
+        
+  /**
+   * MateColorButton::color-set:
+   * @widget: the object which received the signal.
+   * 
+   * The ::color-set signal is emitted when the user selects a color. 
+   * When handling this signal, use mate_color_button_get_color() and 
+   * mate_color_button_get_alpha() to find out which color was just selected.
+   *
+   * Note that this signal is only emitted when the <emphasis>user</emphasis>
+   * changes the color. If you need to react to programmatic color changes
+   * as well, use the notify::color signal.
+   *
+   * Since: 2.4
+   */
+  color_button_signals[COLOR_SET] = g_signal_new ("color-set",
+						  G_TYPE_FROM_CLASS (gobject_class),
+						  G_SIGNAL_RUN_FIRST,
+						  G_STRUCT_OFFSET (MateColorButtonClass, color_set),
+						  NULL, NULL,
+						  g_cclosure_marshal_VOID__VOID,
+						  G_TYPE_NONE, 0);
+
+  g_type_class_add_private (gobject_class, sizeof (MateColorButtonPrivate));
+}
+
+static gboolean
+mate_color_button_has_alpha (MateColorButton *color_button)
+{
+  return color_button->priv->use_alpha &&
+      color_button->priv->alpha < 65535;
+}
+
+static cairo_pattern_t *
+mate_color_button_get_checkered (void)
+{
+  /* need to respect pixman's stride being a multiple of 4 */
+  static unsigned char data[8] = { 0xFF, 0x00, 0x00, 0x00,
+                                   0x00, 0xFF, 0x00, 0x00 };
+  static cairo_surface_t *checkered = NULL;
+  cairo_pattern_t *pattern;
+
+  if (checkered == NULL)
+    {
+      checkered = cairo_image_surface_create_for_data (data,
+                                                       CAIRO_FORMAT_A8,
+                                                       2, 2, 4);
+    }
+
+  pattern = cairo_pattern_create_for_surface (checkered);
+  cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
+  cairo_pattern_set_filter (pattern, CAIRO_FILTER_NEAREST);
+
+  return pattern;
+}
+
+/* Handle exposure events for the color picker's drawing area */
+static gint
+expose_event (GtkWidget      *widget, 
+              GdkEventExpose *event, 
+              gpointer        data)
+{
+  MateColorButton *color_button = MATE_COLOR_BUTTON (data);
+  GtkAllocation allocation;
+  cairo_pattern_t *checkered;
+  cairo_t *cr;
+
+  cr = gdk_cairo_create (event->window);
+
+  gtk_widget_get_allocation (widget, &allocation);
+  gdk_cairo_rectangle (cr, &allocation);
+  cairo_clip (cr);
+
+  if (mate_color_button_has_alpha (color_button))
+    {
+      cairo_save (cr);
+
+      cairo_set_source_rgb (cr, CHECK_DARK, CHECK_DARK, CHECK_DARK);
+      cairo_paint (cr);
+
+      cairo_set_source_rgb (cr, CHECK_LIGHT, CHECK_LIGHT, CHECK_LIGHT);
+      cairo_scale (cr, CHECK_SIZE, CHECK_SIZE);
+
+      checkered = mate_color_button_get_checkered ();
+      cairo_mask (cr, checkered);
+      cairo_pattern_destroy (checkered);
+
+      cairo_restore (cr);
+
+      cairo_set_source_rgba (cr,
+                             color_button->priv->color.red / 65535.,
+                             color_button->priv->color.green / 65535.,
+                             color_button->priv->color.blue / 65535.,
+                             color_button->priv->alpha / 65535.);
+    }
+  else
+    {
+      gdk_cairo_set_source_color (cr, &color_button->priv->color);
+    }
+
+  cairo_paint (cr);
+
+  if (!gtk_widget_is_sensitive (GTK_WIDGET (color_button)))
+    {
+      gdk_cairo_set_source_color (cr, &GTK_WIDGET(color_button)->style->bg[GTK_STATE_INSENSITIVE]);
+      checkered = mate_color_button_get_checkered ();
+      cairo_mask (cr, checkered);
+      cairo_pattern_destroy (checkered);
+    }
+
+  cairo_destroy (cr);
+
+  return FALSE;
+}
+
+static void
+mate_color_button_state_changed (GtkWidget   *widget, 
+                                GtkStateType previous_state)
+{
+  gtk_widget_queue_draw (widget);
+}
+
+static void
+mate_color_button_drag_data_received (GtkWidget        *widget,
+				     GdkDragContext   *context,
+				     gint              x,
+				     gint              y,
+				     GtkSelectionData *selection_data,
+				     guint             info,
+				     guint32           time,
+				     MateColorButton   *color_button)
+{
+  guint16 *dropped;
+
+  if (selection_data->length < 0)
+    return;
+
+  /* We accept drops with the wrong format, since the KDE color
+   * chooser incorrectly drops application/x-color with format 8.
+   */
+  if (selection_data->length != 8) 
+    {
+      g_warning (_("Received invalid color data\n"));
+      return;
+    }
+
+
+  dropped = (guint16 *)selection_data->data;
+
+  color_button->priv->color.red = dropped[0];
+  color_button->priv->color.green = dropped[1];
+  color_button->priv->color.blue = dropped[2];
+  color_button->priv->alpha = dropped[3];
+
+  gtk_widget_queue_draw (color_button->priv->draw_area);
+
+  g_signal_emit (color_button, color_button_signals[COLOR_SET], 0);
+
+  g_object_freeze_notify (G_OBJECT (color_button));
+  g_object_notify (G_OBJECT (color_button), "color");
+  g_object_notify (G_OBJECT (color_button), "alpha");
+  g_object_thaw_notify (G_OBJECT (color_button));
+}
+
+static void
+set_color_icon (GdkDragContext *context,
+		GdkColor       *color)
+{
+  GdkPixbuf *pixbuf;
+  guint32 pixel;
+
+  pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE,
+			   8, 48, 32);
+
+  pixel = ((color->red & 0xff00) << 16) | 
+          ((color->green & 0xff00) << 8) | 
+           (color->blue & 0xff00);
+
+  gdk_pixbuf_fill (pixbuf, pixel);
+  
+  gtk_drag_set_icon_pixbuf (context, pixbuf, -2, -2);
+  g_object_unref (pixbuf);
+}
+
+static void
+mate_color_button_drag_begin (GtkWidget      *widget,
+			     GdkDragContext *context,
+			     gpointer        data)
+{
+  MateColorButton *color_button = data;
+  
+  set_color_icon (context, &color_button->priv->color);
+}
+
+static void
+mate_color_button_drag_data_get (GtkWidget        *widget,
+				GdkDragContext   *context,
+				GtkSelectionData *selection_data,
+				guint             info,
+				guint             time,
+				MateColorButton   *color_button)
+{
+  guint16 dropped[4];
+
+  dropped[0] = color_button->priv->color.red;
+  dropped[1] = color_button->priv->color.green;
+  dropped[2] = color_button->priv->color.blue;
+  dropped[3] = color_button->priv->alpha;
+
+  gtk_selection_data_set (selection_data, selection_data->target,
+			  16, (guchar *)dropped, 8);
+}
+
+static void
+mate_color_button_init (MateColorButton *color_button)
+{
+  GtkWidget *alignment;
+  GtkWidget *frame;
+  PangoLayout *layout;
+  PangoRectangle rect;
+
+  _mate_desktop_init_i18n ();
+
+  /* Create the widgets */
+  color_button->priv = MATE_COLOR_BUTTON_GET_PRIVATE (color_button);
+
+  gtk_widget_push_composite_child ();
+
+  alignment = gtk_alignment_new (0.5, 0.5, 0.5, 1.0);
+  gtk_container_set_border_width (GTK_CONTAINER (alignment), 1);
+  gtk_container_add (GTK_CONTAINER (color_button), alignment);
+  gtk_widget_show (alignment);
+
+  frame = gtk_frame_new (NULL);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_OUT);
+  gtk_container_add (GTK_CONTAINER (alignment), frame);
+  gtk_widget_show (frame);
+
+  /* Just some widget we can hook to expose-event on */
+  color_button->priv->draw_area = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
+
+  layout = gtk_widget_create_pango_layout (GTK_WIDGET (color_button), "Black");
+  pango_layout_get_pixel_extents (layout, NULL, &rect);
+  g_object_unref (layout);
+
+  gtk_widget_set_size_request (color_button->priv->draw_area, rect.width - 2, rect.height - 2);
+  g_signal_connect (color_button->priv->draw_area, "expose-event",
+                    G_CALLBACK (expose_event), color_button);
+  gtk_container_add (GTK_CONTAINER (frame), color_button->priv->draw_area);
+  gtk_widget_show (color_button->priv->draw_area);
+
+  color_button->priv->title = g_strdup (_("Pick a Color")); /* default title */
+
+  /* Start with opaque black, alpha disabled */
+
+  color_button->priv->color.red = 0;
+  color_button->priv->color.green = 0;
+  color_button->priv->color.blue = 0;
+  color_button->priv->alpha = 65535;
+  color_button->priv->use_alpha = FALSE;
+
+  gtk_drag_dest_set (GTK_WIDGET (color_button),
+                     GTK_DEST_DEFAULT_MOTION |
+                     GTK_DEST_DEFAULT_HIGHLIGHT |
+                     GTK_DEST_DEFAULT_DROP,
+                     drop_types, 1, GDK_ACTION_COPY);
+  gtk_drag_source_set (GTK_WIDGET(color_button),
+                       GDK_BUTTON1_MASK|GDK_BUTTON3_MASK,
+                       drop_types, 1,
+                       GDK_ACTION_COPY);
+  g_signal_connect (color_button, "drag-begin",
+		    G_CALLBACK (mate_color_button_drag_begin), color_button);
+  g_signal_connect (color_button, "drag-data-received",
+                    G_CALLBACK (mate_color_button_drag_data_received), color_button);
+  g_signal_connect (color_button, "drag-data-get",
+                    G_CALLBACK (mate_color_button_drag_data_get), color_button);
+
+  gtk_widget_pop_composite_child ();
+}
+
+static void
+mate_color_button_finalize (GObject *object)
+{
+  MateColorButton *color_button = MATE_COLOR_BUTTON (object);
+
+  if (color_button->priv->cs_dialog != NULL)
+    gtk_widget_destroy (color_button->priv->cs_dialog);
+  color_button->priv->cs_dialog = NULL;
+
+  g_free (color_button->priv->title);
+  color_button->priv->title = NULL;
+
+  G_OBJECT_CLASS (mate_color_button_parent_class)->finalize (object);
+}
+
+
+/**
+ * mate_color_button_new:
+ *
+ * Creates a new color button. This returns a widget in the form of
+ * a small button containing a swatch representing the current selected 
+ * color. When the button is clicked, a color-selection dialog will open, 
+ * allowing the user to select a color. The swatch will be updated to reflect 
+ * the new color when the user finishes.
+ *
+ * Returns: a new color button.
+ *
+ * Since: 2.4
+ */
+GtkWidget *
+mate_color_button_new (void)
+{
+  return g_object_new (MATE_TYPE_COLOR_BUTTON, NULL);
+}
+
+/**
+ * mate_color_button_new_with_color:
+ * @color: A #GdkColor to set the current color with.
+ *
+ * Creates a new color button. 
+ *
+ * Returns: a new color button.
+ *
+ * Since: 2.4
+ */
+GtkWidget *
+mate_color_button_new_with_color (const GdkColor *color)
+{
+  return g_object_new (MATE_TYPE_COLOR_BUTTON, "color", color, NULL);
+}
+
+static void
+dialog_ok_clicked (GtkWidget *widget, 
+		   gpointer   data)
+{
+  MateColorButton *color_button = MATE_COLOR_BUTTON (data);
+  MateColorSelection *color_selection;
+
+  color_selection = MATE_COLOR_SELECTION (MATE_COLOR_SELECTION_DIALOG (color_button->priv->cs_dialog)->colorsel);
+
+  mate_color_selection_get_current_color (color_selection, &color_button->priv->color);
+  color_button->priv->alpha = mate_color_selection_get_current_alpha (color_selection);
+
+  gtk_widget_hide (color_button->priv->cs_dialog);
+
+  gtk_widget_queue_draw (color_button->priv->draw_area);
+
+  g_signal_emit (color_button, color_button_signals[COLOR_SET], 0);
+
+  g_object_freeze_notify (G_OBJECT (color_button));
+  g_object_notify (G_OBJECT (color_button), "color");
+  g_object_notify (G_OBJECT (color_button), "alpha");
+  g_object_thaw_notify (G_OBJECT (color_button));
+}
+
+static gboolean
+dialog_destroy (GtkWidget *widget, 
+		gpointer   data)
+{
+  MateColorButton *color_button = MATE_COLOR_BUTTON (data);
+  
+  color_button->priv->cs_dialog = NULL;
+
+  return FALSE;
+}
+
+static void
+dialog_cancel_clicked (GtkWidget *widget,
+		       gpointer   data)
+{
+  MateColorButton *color_button = MATE_COLOR_BUTTON (data);
+  
+  gtk_widget_hide (color_button->priv->cs_dialog);  
+}
+
+static void
+mate_color_button_clicked (GtkButton *button)
+{
+  MateColorButton *color_button = MATE_COLOR_BUTTON (button);
+  MateColorSelectionDialog *color_dialog;
+
+  /* if dialog already exists, make sure it's shown and raised */
+  if (!color_button->priv->cs_dialog) 
+    {
+      /* Create the dialog and connects its buttons */
+      GtkWidget *parent;
+      
+      parent = gtk_widget_get_toplevel (GTK_WIDGET (color_button));
+      
+      color_button->priv->cs_dialog = mate_color_selection_dialog_new (color_button->priv->title);
+      
+      color_dialog = MATE_COLOR_SELECTION_DIALOG (color_button->priv->cs_dialog);
+
+      if (gtk_widget_is_toplevel (parent) && GTK_IS_WINDOW (parent))
+        {
+          if (GTK_WINDOW (parent) != gtk_window_get_transient_for (GTK_WINDOW (color_dialog)))
+ 	    gtk_window_set_transient_for (GTK_WINDOW (color_dialog), GTK_WINDOW (parent));
+	       
+	  gtk_window_set_modal (GTK_WINDOW (color_dialog),
+				gtk_window_get_modal (GTK_WINDOW (parent)));
+	}
+      
+      g_signal_connect (color_dialog->ok_button, "clicked",
+                        G_CALLBACK (dialog_ok_clicked), color_button);
+      g_signal_connect (color_dialog->cancel_button, "clicked",
+			G_CALLBACK (dialog_cancel_clicked), color_button);
+      g_signal_connect (color_dialog, "destroy",
+                        G_CALLBACK (dialog_destroy), color_button);
+    }
+
+  color_dialog = MATE_COLOR_SELECTION_DIALOG (color_button->priv->cs_dialog);
+
+  mate_color_selection_set_has_opacity_control (MATE_COLOR_SELECTION (color_dialog->colorsel),
+                                               color_button->priv->use_alpha);
+  
+  mate_color_selection_set_previous_color (MATE_COLOR_SELECTION (color_dialog->colorsel), 
+					  &color_button->priv->color);
+  mate_color_selection_set_previous_alpha (MATE_COLOR_SELECTION (color_dialog->colorsel), 
+					  color_button->priv->alpha);
+
+  mate_color_selection_set_current_color (MATE_COLOR_SELECTION (color_dialog->colorsel), 
+					 &color_button->priv->color);
+  mate_color_selection_set_current_alpha (MATE_COLOR_SELECTION (color_dialog->colorsel), 
+					 color_button->priv->alpha);
+
+  gtk_window_present (GTK_WINDOW (color_button->priv->cs_dialog));
+}
+
+/**
+ * mate_color_button_set_color:
+ * @color_button: a #MateColorButton.
+ * @color: A #GdkColor to set the current color with.
+ *
+ * Sets the current color to be @color.
+ *
+ * Since: 2.4
+ **/
+void
+mate_color_button_set_color (MateColorButton *color_button,
+			    const GdkColor *color)
+{
+  g_return_if_fail (MATE_IS_COLOR_BUTTON (color_button));
+  g_return_if_fail (color != NULL);
+
+  color_button->priv->color.red = color->red;
+  color_button->priv->color.green = color->green;
+  color_button->priv->color.blue = color->blue;
+
+  gtk_widget_queue_draw (color_button->priv->draw_area);
+  
+  g_object_notify (G_OBJECT (color_button), "color");
+}
+
+
+/**
+ * mate_color_button_set_alpha:
+ * @color_button: a #MateColorButton.
+ * @alpha: an integer between 0 and 65535.
+ *
+ * Sets the current opacity to be @alpha. 
+ *
+ * Since: 2.4
+ **/
+void
+mate_color_button_set_alpha (MateColorButton *color_button,
+			    guint16         alpha)
+{
+  g_return_if_fail (MATE_IS_COLOR_BUTTON (color_button));
+
+  color_button->priv->alpha = alpha;
+
+  gtk_widget_queue_draw (color_button->priv->draw_area);
+
+  g_object_notify (G_OBJECT (color_button), "alpha");
+}
+
+/**
+ * mate_color_button_get_color:
+ * @color_button: a #MateColorButton.
+ * @color: a #GdkColor to fill in with the current color.
+ *
+ * Sets @color to be the current color in the #MateColorButton widget.
+ *
+ * Since: 2.4
+ **/
+void
+mate_color_button_get_color (MateColorButton *color_button,
+			    GdkColor       *color)
+{
+  g_return_if_fail (MATE_IS_COLOR_BUTTON (color_button));
+  
+  color->red = color_button->priv->color.red;
+  color->green = color_button->priv->color.green;
+  color->blue = color_button->priv->color.blue;
+}
+
+/**
+ * mate_color_button_get_alpha:
+ * @color_button: a #MateColorButton.
+ *
+ * Returns the current alpha value. 
+ *
+ * Return value: an integer between 0 and 65535.
+ *
+ * Since: 2.4
+ **/
+guint16
+mate_color_button_get_alpha (MateColorButton *color_button)
+{
+  g_return_val_if_fail (MATE_IS_COLOR_BUTTON (color_button), 0);
+  
+  return color_button->priv->alpha;
+}
+
+/**
+ * mate_color_button_set_use_alpha:
+ * @color_button: a #MateColorButton.
+ * @use_alpha: %TRUE if color button should use alpha channel, %FALSE if not.
+ *
+ * Sets whether or not the color button should use the alpha channel.
+ *
+ * Since: 2.4
+ */
+void
+mate_color_button_set_use_alpha (MateColorButton *color_button, 
+				gboolean        use_alpha)
+{
+  g_return_if_fail (MATE_IS_COLOR_BUTTON (color_button));
+
+  use_alpha = (use_alpha != FALSE);
+
+  if (color_button->priv->use_alpha != use_alpha) 
+    {
+      color_button->priv->use_alpha = use_alpha;
+
+      gtk_widget_queue_draw (color_button->priv->draw_area);
+
+      g_object_notify (G_OBJECT (color_button), "use-alpha");
+    }
+}
+
+/**
+ * mate_color_button_get_use_alpha:
+ * @color_button: a #MateColorButton.
+ *
+ * Does the color selection dialog use the alpha channel?
+ *
+ * Returns: %TRUE if the color sample uses alpha channel, %FALSE if not.
+ *
+ * Since: 2.4
+ */
+gboolean
+mate_color_button_get_use_alpha (MateColorButton *color_button)
+{
+  g_return_val_if_fail (MATE_IS_COLOR_BUTTON (color_button), FALSE);
+
+  return color_button->priv->use_alpha;
+}
+
+
+/**
+ * mate_color_button_set_title:
+ * @color_button: a #MateColorButton
+ * @title: String containing new window title.
+ *
+ * Sets the title for the color selection dialog.
+ *
+ * Since: 2.4
+ */
+void
+mate_color_button_set_title (MateColorButton *color_button, 
+			    const gchar    *title)
+{
+  gchar *old_title;
+
+  g_return_if_fail (MATE_IS_COLOR_BUTTON (color_button));
+
+  old_title = color_button->priv->title;
+  color_button->priv->title = g_strdup (title);
+  g_free (old_title);
+
+  if (color_button->priv->cs_dialog)
+    gtk_window_set_title (GTK_WINDOW (color_button->priv->cs_dialog), 
+			  color_button->priv->title);
+  
+  g_object_notify (G_OBJECT (color_button), "title");
+}
+
+/**
+ * mate_color_button_get_title:
+ * @color_button: a #MateColorButton
+ *
+ * Gets the title of the color selection dialog.
+ *
+ * Returns: An internal string, do not free the return value
+ *
+ * Since: 2.4
+ */
+const gchar *
+mate_color_button_get_title (MateColorButton *color_button)
+{
+  g_return_val_if_fail (MATE_IS_COLOR_BUTTON (color_button), NULL);
+
+  return color_button->priv->title;
+}
+
+static void
+mate_color_button_set_property (GObject      *object,
+			       guint         param_id,
+			       const GValue *value,
+			       GParamSpec   *pspec)
+{
+  MateColorButton *color_button = MATE_COLOR_BUTTON (object);
+
+  switch (param_id) 
+    {
+    case PROP_USE_ALPHA:
+      mate_color_button_set_use_alpha (color_button, g_value_get_boolean (value));
+      break;
+    case PROP_TITLE:
+      mate_color_button_set_title (color_button, g_value_get_string (value));
+      break;
+    case PROP_COLOR:
+      mate_color_button_set_color (color_button, g_value_get_boxed (value));
+      break;
+    case PROP_ALPHA:
+      mate_color_button_set_alpha (color_button, g_value_get_uint (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+      break;
+    }
+}
+
+static void
+mate_color_button_get_property (GObject    *object,
+			       guint       param_id,
+			       GValue     *value,
+			       GParamSpec *pspec)
+{
+  MateColorButton *color_button = MATE_COLOR_BUTTON (object);
+  GdkColor color;
+
+  switch (param_id) 
+    {
+    case PROP_USE_ALPHA:
+      g_value_set_boolean (value, mate_color_button_get_use_alpha (color_button));
+      break;
+    case PROP_TITLE:
+      g_value_set_string (value, mate_color_button_get_title (color_button));
+      break;
+    case PROP_COLOR:
+      mate_color_button_get_color (color_button, &color);
+      g_value_set_boxed (value, &color);
+      break;
+    case PROP_ALPHA:
+      g_value_set_uint (value, mate_color_button_get_alpha (color_button));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+      break;
+    }
+}
diff --git a/libmate-desktop/mate-colorbutton.h b/libmate-desktop/mate-colorbutton.h
new file mode 100644
index 0000000..04809bd
--- /dev/null
+++ b/libmate-desktop/mate-colorbutton.h
@@ -0,0 +1,98 @@
+/*
+ * GTK - The GIMP Toolkit
+ * Copyright (C) 1998, 1999 Red Hat, Inc.
+ * All rights reserved.
+ *
+ * This Library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 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 Library General Public
+ * License along with the Gnome Library; see the file COPYING.LIB.  If not,
+ * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/* Color picker button for GNOME
+ *
+ * Author: Federico Mena <[email protected]>
+ *
+ * Modified by the GTK+ Team and others 2003.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+#ifndef __MATE_COLOR_BUTTON_H__
+#define __MATE_COLOR_BUTTON_H__
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+
+/* The MateColorButton widget is a simple color picker in a button.
+ * The button displays a sample of the currently selected color.  When
+ * the user clicks on the button, a color selection dialog pops up.
+ * The color picker emits the "color_set" signal when the color is set.
+ */
+
+#define MATE_TYPE_COLOR_BUTTON             (mate_color_button_get_type ())
+#define MATE_COLOR_BUTTON(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), MATE_TYPE_COLOR_BUTTON, MateColorButton))
+#define MATE_COLOR_BUTTON_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), MATE_TYPE_COLOR_BUTTON, MateColorButtonClass))
+#define MATE_IS_COLOR_BUTTON(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MATE_TYPE_COLOR_BUTTON))
+#define MATE_IS_COLOR_BUTTON_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), MATE_TYPE_COLOR_BUTTON))
+#define MATE_COLOR_BUTTON_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), MATE_TYPE_COLOR_BUTTON, MateColorButtonClass))
+
+typedef struct _MateColorButton          MateColorButton;
+typedef struct _MateColorButtonClass     MateColorButtonClass;
+typedef struct _MateColorButtonPrivate   MateColorButtonPrivate;
+
+struct _MateColorButton {
+  GtkButton button;
+
+  /*< private >*/
+
+  MateColorButtonPrivate *GSEAL (priv);
+};
+
+struct _MateColorButtonClass {
+  GtkButtonClass parent_class;
+
+  void (* color_set) (MateColorButton *cp);
+
+  /* Padding for future expansion */
+  void (*_gtk_reserved1) (void);
+  void (*_gtk_reserved2) (void);
+  void (*_gtk_reserved3) (void);
+  void (*_gtk_reserved4) (void);
+};
+
+
+GType      mate_color_button_get_type       (void) G_GNUC_CONST;
+GtkWidget *mate_color_button_new            (void);
+GtkWidget *mate_color_button_new_with_color (const GdkColor *color);
+void       mate_color_button_set_color      (MateColorButton *color_button,
+					    const GdkColor *color);
+void       mate_color_button_set_alpha      (MateColorButton *color_button,
+					    guint16         alpha);
+void       mate_color_button_get_color      (MateColorButton *color_button,
+					    GdkColor       *color);
+guint16    mate_color_button_get_alpha      (MateColorButton *color_button);
+void       mate_color_button_set_use_alpha  (MateColorButton *color_button,
+					    gboolean        use_alpha);
+gboolean   mate_color_button_get_use_alpha  (MateColorButton *color_button);
+void       mate_color_button_set_title      (MateColorButton *color_button,
+					    const gchar    *title);
+const gchar *mate_color_button_get_title (MateColorButton *color_button);
+
+
+G_END_DECLS
+
+#endif  /* __MATE_COLOR_BUTTON_H__ */
diff --git a/libmate-desktop/mate-colorsel.c b/libmate-desktop/mate-colorsel.c
new file mode 100644
index 0000000..40f9856
--- /dev/null
+++ b/libmate-desktop/mate-colorsel.c
@@ -0,0 +1,2943 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2000 Red Hat, Inc.
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * 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 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-2001.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+#include "config.h"
+#include "private.h"
+#include <math.h>
+#include <string.h>
+
+#include <gdkconfig.h>
+#include <gdk/gdkkeysyms.h>
+#include <gtk/gtk.h>
+#include <glib/gi18n-lib.h>
+#include "mate-colorsel.h"
+
+/* Keep it in sync with gtksettings.c:default_color_palette */
+#define DEFAULT_COLOR_PALETTE   "black:white:gray50:red:purple:blue:light blue:green:yellow:orange:lavender:brown:goldenrod4:dodger blue:pink:light green:gray10:gray30:gray75:gray90"
+
+/* Number of elements in the custom palatte */
+#define GTK_CUSTOM_PALETTE_WIDTH 10
+#define GTK_CUSTOM_PALETTE_HEIGHT 2
+
+#define CUSTOM_PALETTE_ENTRY_WIDTH   20
+#define CUSTOM_PALETTE_ENTRY_HEIGHT  20
+
+/* The cursor for the dropper */
+#define DROPPER_WIDTH 17
+#define DROPPER_HEIGHT 17
+#define DROPPER_STRIDE 4
+#define DROPPER_X_HOT 2
+#define DROPPER_Y_HOT 16
+
+#define SAMPLE_WIDTH  64
+#define SAMPLE_HEIGHT 28
+#define CHECK_SIZE 16  
+#define BIG_STEP 20
+
+/* Conversion between 0->1 double and and guint16. See
+ * scale_round() below for more general conversions
+ */
+#define SCALE(i) (i / 65535.)
+#define UNSCALE(d) ((guint16)(d * 65535 + 0.5))
+#define INTENSITY(r, g, b) ((r) * 0.30 + (g) * 0.59 + (b) * 0.11)
+
+enum {
+  COLOR_CHANGED,
+  LAST_SIGNAL
+};
+
+enum {
+  PROP_0,
+  PROP_HAS_PALETTE,
+  PROP_HAS_OPACITY_CONTROL,
+  PROP_CURRENT_COLOR,
+  PROP_CURRENT_ALPHA
+};
+
+enum {
+  COLORSEL_RED = 0,
+  COLORSEL_GREEN = 1,
+  COLORSEL_BLUE = 2,
+  COLORSEL_OPACITY = 3,
+  COLORSEL_HUE,
+  COLORSEL_SATURATION,
+  COLORSEL_VALUE,
+  COLORSEL_NUM_CHANNELS
+};
+
+typedef struct _ColorSelectionPrivate ColorSelectionPrivate;
+
+struct _ColorSelectionPrivate
+{
+  guint has_opacity : 1;
+  guint has_palette : 1;
+  guint changing : 1;
+  guint default_set : 1;
+  guint default_alpha_set : 1;
+  guint has_grab : 1;
+  
+  gdouble color[COLORSEL_NUM_CHANNELS];
+  gdouble old_color[COLORSEL_NUM_CHANNELS];
+  
+  GtkWidget *triangle_colorsel;
+  GtkWidget *hue_spinbutton;
+  GtkWidget *sat_spinbutton;
+  GtkWidget *val_spinbutton;
+  GtkWidget *red_spinbutton;
+  GtkWidget *green_spinbutton;
+  GtkWidget *blue_spinbutton;
+  GtkWidget *opacity_slider;
+  GtkWidget *opacity_label;
+  GtkWidget *opacity_entry;
+  GtkWidget *palette_frame;
+  GtkWidget *hex_entry;
+  
+  /* The Palette code */
+  GtkWidget *custom_palette [GTK_CUSTOM_PALETTE_WIDTH][GTK_CUSTOM_PALETTE_HEIGHT];
+  
+  /* The color_sample stuff */
+  GtkWidget *sample_area;
+  GtkWidget *old_sample;
+  GtkWidget *cur_sample;
+  GtkWidget *colorsel;
+
+  /* Window for grabbing on */
+  GtkWidget *dropper_grab_widget;
+  guint32    grab_time;
+
+  /* Connection to settings */
+  gulong settings_connection;
+};
+
+
+static void mate_color_selection_destroy		(GtkObject		 *object);
+static void mate_color_selection_finalize        (GObject		 *object);
+static void update_color			(MateColorSelection	 *colorsel);
+static void mate_color_selection_set_property    (GObject                 *object,
+					         guint                    prop_id,
+					         const GValue            *value,
+					         GParamSpec              *pspec);
+static void mate_color_selection_get_property    (GObject                 *object,
+					         guint                    prop_id,
+					         GValue                  *value,
+					         GParamSpec              *pspec);
+
+static void mate_color_selection_realize         (GtkWidget               *widget);
+static void mate_color_selection_unrealize       (GtkWidget               *widget);
+static void mate_color_selection_show_all        (GtkWidget               *widget);
+static gboolean mate_color_selection_grab_broken (GtkWidget               *widget,
+						 GdkEventGrabBroken      *event);
+
+static void     mate_color_selection_set_palette_color   (MateColorSelection *colorsel,
+                                                         gint               index,
+                                                         GdkColor          *color);
+static void     set_focus_line_attributes               (GtkWidget         *drawing_area,
+							 cairo_t           *cr,
+							 gint              *focus_width);
+static void     default_noscreen_change_palette_func    (const GdkColor    *colors,
+							 gint               n_colors);
+static void     default_change_palette_func             (GdkScreen	   *screen,
+							 const GdkColor    *colors,
+							 gint               n_colors);
+static void     make_control_relations                  (AtkObject         *atk_obj,
+                                                         GtkWidget         *widget);
+static void     make_all_relations                      (AtkObject         *atk_obj,
+                                                         ColorSelectionPrivate *priv);
+
+static void 	hsv_changed                             (GtkWidget         *hsv,
+							 gpointer           data);
+static void 	get_screen_color                        (GtkWidget         *button);
+static void 	adjustment_changed                      (GtkAdjustment     *adjustment,
+							 gpointer           data);
+static void 	opacity_entry_changed                   (GtkWidget 	   *opacity_entry,
+							 gpointer  	    data);
+static void 	hex_changed                             (GtkWidget 	   *hex_entry,
+							 gpointer  	    data);
+static gboolean hex_focus_out                           (GtkWidget     	   *hex_entry, 
+							 GdkEventFocus 	   *event,
+							 gpointer      	    data);
+static void 	color_sample_new                        (MateColorSelection *colorsel);
+static void 	make_label_spinbutton     		(MateColorSelection *colorsel,
+	    				  		 GtkWidget        **spinbutton,
+	    				  		 gchar             *text,
+	    				  		 GtkWidget         *table,
+	    				  		 gint               i,
+	    				  		 gint               j,
+	    				  		 gint               channel_type,
+	    				  		 const gchar       *tooltip);
+static void 	make_palette_frame                      (MateColorSelection *colorsel,
+							 GtkWidget         *table,
+							 gint               i,
+							 gint               j);
+static void 	set_selected_palette                    (MateColorSelection *colorsel,
+							 int                x,
+							 int                y);
+static void 	set_focus_line_attributes               (GtkWidget 	   *drawing_area,
+							 cairo_t   	   *cr,
+							 gint      	   *focus_width);
+static gboolean mouse_press 		     	       	(GtkWidget         *invisible,
+                            		     	       	 GdkEventButton    *event,
+                            		     	       	 gpointer           data);
+static void  palette_change_notify_instance (GObject    *object,
+					     GParamSpec *pspec,
+					     gpointer    data);
+static void update_palette (MateColorSelection *colorsel);
+static void shutdown_eyedropper (GtkWidget *widget);
+
+static guint color_selection_signals[LAST_SIGNAL] = { 0 };
+
+static MateColorSelectionChangePaletteFunc noscreen_change_palette_hook = default_noscreen_change_palette_func;
+static MateColorSelectionChangePaletteWithScreenFunc change_palette_hook = default_change_palette_func;
+
+static const guchar dropper_bits[] = {
+  0xff, 0x8f, 0x01, 0x00,  0xff, 0x77, 0x01, 0x00,
+  0xff, 0xfb, 0x00, 0x00,  0xff, 0xf8, 0x00, 0x00,
+  0x7f, 0xff, 0x00, 0x00,  0xff, 0x7e, 0x01, 0x00,
+  0xff, 0x9d, 0x01, 0x00,  0xff, 0xd8, 0x01, 0x00,
+  0x7f, 0xd4, 0x01, 0x00,  0x3f, 0xee, 0x01, 0x00,
+  0x1f, 0xff, 0x01, 0x00,  0x8f, 0xff, 0x01, 0x00,
+  0xc7, 0xff, 0x01, 0x00,  0xe3, 0xff, 0x01, 0x00,
+  0xf3, 0xff, 0x01, 0x00,  0xfd, 0xff, 0x01, 0x00,
+  0xff, 0xff, 0x01, 0x00 };
+
+static const guchar dropper_mask[] = {
+  0x00, 0x70, 0x00, 0x00,  0x00, 0xf8, 0x00, 0x00,
+  0x00, 0xfc, 0x01, 0x00,  0x00, 0xff, 0x01, 0x00,
+  0x80, 0xff, 0x01, 0x00,  0x00, 0xff, 0x00, 0x00,
+  0x00, 0x7f, 0x00, 0x00,  0x80, 0x3f, 0x00, 0x00,
+  0xc0, 0x3f, 0x00, 0x00,  0xe0, 0x13, 0x00, 0x00,
+  0xf0, 0x01, 0x00, 0x00,  0xf8, 0x00, 0x00, 0x00,
+  0x7c, 0x00, 0x00, 0x00,  0x3e, 0x00, 0x00, 0x00,
+  0x1e, 0x00, 0x00, 0x00,  0x0d, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00 };
+
+G_DEFINE_TYPE (MateColorSelection, mate_color_selection, GTK_TYPE_VBOX)
+
+static void
+mate_color_selection_class_init (MateColorSelectionClass *klass)
+{
+  GObjectClass *gobject_class;
+  GtkObjectClass *object_class;
+  GtkWidgetClass *widget_class;
+  
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize = mate_color_selection_finalize;
+  gobject_class->set_property = mate_color_selection_set_property;
+  gobject_class->get_property = mate_color_selection_get_property;
+
+  object_class = GTK_OBJECT_CLASS (klass);
+  object_class->destroy = mate_color_selection_destroy;
+  
+  widget_class = GTK_WIDGET_CLASS (klass);
+  widget_class->realize = mate_color_selection_realize;
+  widget_class->unrealize = mate_color_selection_unrealize;
+  widget_class->show_all = mate_color_selection_show_all;
+  widget_class->grab_broken_event = mate_color_selection_grab_broken;
+  
+  g_object_class_install_property (gobject_class,
+                                   PROP_HAS_OPACITY_CONTROL,
+                                   g_param_spec_boolean ("has-opacity-control",
+							 _("Has Opacity Control"),
+							 _("Whether the color selector should allow setting opacity"),
+							 FALSE,
+							 G_PARAM_READWRITE));
+  g_object_class_install_property (gobject_class,
+                                   PROP_HAS_PALETTE,
+                                   g_param_spec_boolean ("has-palette",
+							 _("Has palette"),
+							 _("Whether a palette should be used"),
+							 FALSE,
+							 G_PARAM_READWRITE));
+  g_object_class_install_property (gobject_class,
+                                   PROP_CURRENT_COLOR,
+                                   g_param_spec_boxed ("current-color",
+                                                       _("Current Color"),
+                                                       _("The current color"),
+                                                       GDK_TYPE_COLOR,
+                                                       G_PARAM_READWRITE));
+  g_object_class_install_property (gobject_class,
+                                   PROP_CURRENT_ALPHA,
+                                   g_param_spec_uint ("current-alpha",
+						      _("Current Alpha"),
+						      _("The current opacity value (0 fully transparent, 65535 fully opaque)"),
+						      0, 65535, 65535,
+						      G_PARAM_READWRITE));
+  
+  color_selection_signals[COLOR_CHANGED] =
+    g_signal_new ("color-changed",
+		  G_OBJECT_CLASS_TYPE (object_class),
+		  G_SIGNAL_RUN_FIRST,
+		  G_STRUCT_OFFSET (MateColorSelectionClass, color_changed),
+		  NULL, NULL,
+		  g_cclosure_marshal_VOID__VOID,
+		  G_TYPE_NONE, 0);
+
+  g_type_class_add_private (gobject_class, sizeof (ColorSelectionPrivate));
+}
+
+static void
+mate_color_selection_init (MateColorSelection *colorsel)
+{
+  GtkWidget *top_hbox;
+  GtkWidget *top_right_vbox;
+  GtkWidget *table, *label, *hbox, *frame, *vbox, *button;
+  GtkAdjustment *adjust;
+  GtkWidget *picker_image;
+  gint i, j;
+  ColorSelectionPrivate *priv;
+  AtkObject *atk_obj;
+  GList *focus_chain = NULL;
+  
+  _mate_desktop_init_i18n ();
+  
+  gtk_widget_push_composite_child ();
+
+  priv = colorsel->private_data = G_TYPE_INSTANCE_GET_PRIVATE (colorsel, MATE_TYPE_COLOR_SELECTION, ColorSelectionPrivate);
+  priv->changing = FALSE;
+  priv->default_set = FALSE;
+  priv->default_alpha_set = FALSE;
+  
+  top_hbox = gtk_hbox_new (FALSE, 12);
+  gtk_box_pack_start (GTK_BOX (colorsel), top_hbox, FALSE, FALSE, 0);
+  
+  vbox = gtk_vbox_new (FALSE, 6);
+  priv->triangle_colorsel = gtk_hsv_new ();
+  g_signal_connect (priv->triangle_colorsel, "changed",
+                    G_CALLBACK (hsv_changed), colorsel);
+  gtk_hsv_set_metrics (GTK_HSV (priv->triangle_colorsel), 174, 15);
+  gtk_box_pack_start (GTK_BOX (top_hbox), vbox, FALSE, FALSE, 0);
+  gtk_box_pack_start (GTK_BOX (vbox), priv->triangle_colorsel, FALSE, FALSE, 0);
+  gtk_widget_set_tooltip_text (priv->triangle_colorsel,
+                        _("Select the color you want from the outer ring. Select the darkness or lightness of that color using the inner triangle."));
+  
+  hbox = gtk_hbox_new (FALSE, 6);
+  gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+  
+  frame = gtk_frame_new (NULL);
+  gtk_widget_set_size_request (frame, -1, 30);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
+  color_sample_new (colorsel);
+  gtk_container_add (GTK_CONTAINER (frame), priv->sample_area);
+  gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
+  
+  button = gtk_button_new ();
+
+  gtk_widget_set_events (button, GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
+  g_object_set_data (G_OBJECT (button), "COLORSEL", colorsel); 
+  g_signal_connect (button, "clicked",
+                    G_CALLBACK (get_screen_color), NULL);
+  picker_image = gtk_image_new_from_stock (GTK_STOCK_COLOR_PICKER, GTK_ICON_SIZE_BUTTON);
+  gtk_container_add (GTK_CONTAINER (button), picker_image);
+  gtk_widget_show (GTK_WIDGET (picker_image));
+  gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+
+  gtk_widget_set_tooltip_text (button,
+                        _("Click the eyedropper, then click a color anywhere on your screen to select that color."));
+  
+  top_right_vbox = gtk_vbox_new (FALSE, 6);
+  gtk_box_pack_start (GTK_BOX (top_hbox), top_right_vbox, FALSE, FALSE, 0);
+  table = gtk_table_new (8, 6, FALSE);
+  gtk_box_pack_start (GTK_BOX (top_right_vbox), table, FALSE, FALSE, 0);
+  gtk_table_set_row_spacings (GTK_TABLE (table), 6);
+  gtk_table_set_col_spacings (GTK_TABLE (table), 12);
+  
+  make_label_spinbutton (colorsel, &priv->hue_spinbutton, _("_Hue:"), table, 0, 0, COLORSEL_HUE,
+                         _("Position on the color wheel."));
+  gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (priv->hue_spinbutton), TRUE);
+  make_label_spinbutton (colorsel, &priv->sat_spinbutton, _("_Saturation:"), table, 0, 1, COLORSEL_SATURATION,
+                         _("\"Deepness\" of the color."));
+  make_label_spinbutton (colorsel, &priv->val_spinbutton, _("_Value:"), table, 0, 2, COLORSEL_VALUE,
+                         _("Brightness of the color."));
+  make_label_spinbutton (colorsel, &priv->red_spinbutton, _("_Red:"), table, 6, 0, COLORSEL_RED,
+                         _("Amount of red light in the color."));
+  make_label_spinbutton (colorsel, &priv->green_spinbutton, _("_Green:"), table, 6, 1, COLORSEL_GREEN,
+                         _("Amount of green light in the color."));
+  make_label_spinbutton (colorsel, &priv->blue_spinbutton, _("_Blue:"), table, 6, 2, COLORSEL_BLUE,
+                         _("Amount of blue light in the color."));
+  gtk_table_attach_defaults (GTK_TABLE (table), gtk_hseparator_new (), 0, 8, 3, 4); 
+
+  priv->opacity_label = gtk_label_new_with_mnemonic (_("Op_acity:")); 
+  gtk_misc_set_alignment (GTK_MISC (priv->opacity_label), 0.0, 0.5); 
+  gtk_table_attach_defaults (GTK_TABLE (table), priv->opacity_label, 0, 1, 4, 5); 
+  adjust = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 255.0, 1.0, 1.0, 0.0)); 
+  g_object_set_data (G_OBJECT (adjust), "COLORSEL", colorsel); 
+  priv->opacity_slider = gtk_hscale_new (adjust);
+  gtk_widget_set_tooltip_text (priv->opacity_slider,
+                        _("Transparency of the color."));
+  gtk_label_set_mnemonic_widget (GTK_LABEL (priv->opacity_label),
+                                 priv->opacity_slider);
+  gtk_scale_set_draw_value (GTK_SCALE (priv->opacity_slider), FALSE);
+  g_signal_connect (adjust, "value-changed",
+                    G_CALLBACK (adjustment_changed),
+                    GINT_TO_POINTER (COLORSEL_OPACITY));
+  gtk_table_attach_defaults (GTK_TABLE (table), priv->opacity_slider, 1, 7, 4, 5); 
+  priv->opacity_entry = gtk_entry_new (); 
+  gtk_widget_set_tooltip_text (priv->opacity_entry,
+                        _("Transparency of the color."));
+  gtk_widget_set_size_request (priv->opacity_entry, 40, -1); 
+
+  g_signal_connect (priv->opacity_entry, "activate",
+                    G_CALLBACK (opacity_entry_changed), colorsel);
+  gtk_table_attach_defaults (GTK_TABLE (table), priv->opacity_entry, 7, 8, 4, 5);
+  
+  label = gtk_label_new_with_mnemonic (_("Color _name:"));
+  gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 5, 6);
+  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+  priv->hex_entry = gtk_entry_new ();
+
+  gtk_label_set_mnemonic_widget (GTK_LABEL (label), priv->hex_entry);
+
+  g_signal_connect (priv->hex_entry, "activate",
+                    G_CALLBACK (hex_changed), colorsel);
+
+  g_signal_connect (priv->hex_entry, "focus-out-event",
+                    G_CALLBACK (hex_focus_out), colorsel);
+
+  gtk_widget_set_tooltip_text (priv->hex_entry,
+                        _("You can enter an HTML-style hexadecimal color value, or simply a color name such as 'orange' in this entry."));
+  
+  gtk_entry_set_width_chars (GTK_ENTRY (priv->hex_entry), 7);
+  gtk_table_attach_defaults (GTK_TABLE (table), priv->hex_entry, 1, 5, 5, 6);
+
+  focus_chain = g_list_append (focus_chain, priv->hue_spinbutton);
+  focus_chain = g_list_append (focus_chain, priv->sat_spinbutton);
+  focus_chain = g_list_append (focus_chain, priv->val_spinbutton);
+  focus_chain = g_list_append (focus_chain, priv->red_spinbutton);
+  focus_chain = g_list_append (focus_chain, priv->green_spinbutton);
+  focus_chain = g_list_append (focus_chain, priv->blue_spinbutton);
+  focus_chain = g_list_append (focus_chain, priv->opacity_slider);
+  focus_chain = g_list_append (focus_chain, priv->opacity_entry);
+  focus_chain = g_list_append (focus_chain, priv->hex_entry);
+  gtk_container_set_focus_chain (GTK_CONTAINER (table), focus_chain);
+  g_list_free (focus_chain);
+
+  /* Set up the palette */
+  table = gtk_table_new (GTK_CUSTOM_PALETTE_HEIGHT, GTK_CUSTOM_PALETTE_WIDTH, TRUE);
+  gtk_table_set_row_spacings (GTK_TABLE (table), 1);
+  gtk_table_set_col_spacings (GTK_TABLE (table), 1);
+  for (i = 0; i < GTK_CUSTOM_PALETTE_WIDTH; i++)
+    {
+      for (j = 0; j < GTK_CUSTOM_PALETTE_HEIGHT; j++)
+	{
+	  make_palette_frame (colorsel, table, i, j);
+	}
+    }
+  set_selected_palette (colorsel, 0, 0);
+  priv->palette_frame = gtk_vbox_new (FALSE, 6);
+  label = gtk_label_new_with_mnemonic (_("_Palette:"));
+  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+  gtk_box_pack_start (GTK_BOX (priv->palette_frame), label, FALSE, FALSE, 0);
+
+  gtk_label_set_mnemonic_widget (GTK_LABEL (label),
+                                 priv->custom_palette[0][0]);
+  
+  gtk_box_pack_end (GTK_BOX (top_right_vbox), priv->palette_frame, FALSE, FALSE, 0);
+  gtk_box_pack_start (GTK_BOX (priv->palette_frame), table, FALSE, FALSE, 0);
+  
+  gtk_widget_show_all (top_hbox);
+
+  /* hide unused stuff */
+  
+  if (priv->has_opacity == FALSE)
+    {
+      gtk_widget_hide (priv->opacity_label);
+      gtk_widget_hide (priv->opacity_slider);
+      gtk_widget_hide (priv->opacity_entry);
+    }
+  
+  if (priv->has_palette == FALSE)
+    {
+      gtk_widget_hide (priv->palette_frame);
+    }
+
+  atk_obj = gtk_widget_get_accessible (priv->triangle_colorsel);
+  if (GTK_IS_ACCESSIBLE (atk_obj))
+    {
+      atk_object_set_name (atk_obj, _("Color Wheel"));
+      atk_object_set_role (gtk_widget_get_accessible (GTK_WIDGET (colorsel)), ATK_ROLE_COLOR_CHOOSER);
+      make_all_relations (atk_obj, priv);
+    } 
+
+  gtk_widget_pop_composite_child ();
+}
+
+/* GObject methods */
+static void
+mate_color_selection_finalize (GObject *object)
+{
+  G_OBJECT_CLASS (mate_color_selection_parent_class)->finalize (object);
+}
+
+static void
+mate_color_selection_set_property (GObject         *object,
+				  guint            prop_id,
+				  const GValue    *value,
+				  GParamSpec      *pspec)
+{
+  MateColorSelection *colorsel = MATE_COLOR_SELECTION (object);
+  
+  switch (prop_id)
+    {
+    case PROP_HAS_OPACITY_CONTROL:
+      mate_color_selection_set_has_opacity_control (colorsel, 
+						   g_value_get_boolean (value));
+      break;
+    case PROP_HAS_PALETTE:
+      mate_color_selection_set_has_palette (colorsel, 
+					   g_value_get_boolean (value));
+      break;
+    case PROP_CURRENT_COLOR:
+      mate_color_selection_set_current_color (colorsel, g_value_get_boxed (value));
+      break;
+    case PROP_CURRENT_ALPHA:
+      mate_color_selection_set_current_alpha (colorsel, g_value_get_uint (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+  
+}
+
+static void
+mate_color_selection_get_property (GObject     *object,
+				  guint        prop_id,
+				  GValue      *value,
+				  GParamSpec  *pspec)
+{
+  MateColorSelection *colorsel = MATE_COLOR_SELECTION (object);
+  GdkColor color;
+  
+  switch (prop_id)
+    {
+    case PROP_HAS_OPACITY_CONTROL:
+      g_value_set_boolean (value, mate_color_selection_get_has_opacity_control (colorsel));
+      break;
+    case PROP_HAS_PALETTE:
+      g_value_set_boolean (value, mate_color_selection_get_has_palette (colorsel));
+      break;
+    case PROP_CURRENT_COLOR:
+      mate_color_selection_get_current_color (colorsel, &color);
+      g_value_set_boxed (value, &color);
+      break;
+    case PROP_CURRENT_ALPHA:
+      g_value_set_uint (value, mate_color_selection_get_current_alpha (colorsel));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+/* GtkObject methods */
+
+static void
+mate_color_selection_destroy (GtkObject *object)
+{
+  MateColorSelection *cselection = MATE_COLOR_SELECTION (object);
+  ColorSelectionPrivate *priv = cselection->private_data;
+
+  if (priv->dropper_grab_widget)
+    {
+      gtk_widget_destroy (priv->dropper_grab_widget);
+      priv->dropper_grab_widget = NULL;
+    }
+
+  GTK_OBJECT_CLASS (mate_color_selection_parent_class)->destroy (object);
+}
+
+/* GtkWidget methods */
+
+static void
+mate_color_selection_realize (GtkWidget *widget)
+{
+  MateColorSelection *colorsel = MATE_COLOR_SELECTION (widget);
+  ColorSelectionPrivate *priv = colorsel->private_data;
+  GtkSettings *settings = gtk_widget_get_settings (widget);
+
+  priv->settings_connection =  g_signal_connect (settings,
+						 "notify::gtk-color-palette",
+						 G_CALLBACK (palette_change_notify_instance),
+						 widget);
+  update_palette (colorsel);
+
+  GTK_WIDGET_CLASS (mate_color_selection_parent_class)->realize (widget);
+}
+
+static void
+mate_color_selection_unrealize (GtkWidget *widget)
+{
+  MateColorSelection *colorsel = MATE_COLOR_SELECTION (widget);
+  ColorSelectionPrivate *priv = colorsel->private_data;
+  GtkSettings *settings = gtk_widget_get_settings (widget);
+
+  g_signal_handler_disconnect (settings, priv->settings_connection);
+
+  GTK_WIDGET_CLASS (mate_color_selection_parent_class)->unrealize (widget);
+}
+
+/* We override show-all since we have internal widgets that
+ * shouldn't be shown when you call show_all(), like the
+ * palette and opacity sliders.
+ */
+static void
+mate_color_selection_show_all (GtkWidget *widget)
+{
+  gtk_widget_show (widget);
+}
+
+static gboolean 
+mate_color_selection_grab_broken (GtkWidget          *widget,
+				 GdkEventGrabBroken *event)
+{
+  shutdown_eyedropper (widget);
+
+  return TRUE;
+}
+
+/*
+ *
+ * The Sample Color
+ *
+ */
+
+static void color_sample_draw_sample (MateColorSelection *colorsel, int which);
+static void color_sample_update_samples (MateColorSelection *colorsel);
+
+static void
+set_color_internal (MateColorSelection *colorsel,
+		    gdouble           *color)
+{
+  ColorSelectionPrivate *priv;
+  gint i;
+  
+  priv = colorsel->private_data;
+  priv->changing = TRUE;
+  priv->color[COLORSEL_RED] = color[0];
+  priv->color[COLORSEL_GREEN] = color[1];
+  priv->color[COLORSEL_BLUE] = color[2];
+  priv->color[COLORSEL_OPACITY] = color[3];
+  gtk_rgb_to_hsv (priv->color[COLORSEL_RED],
+		  priv->color[COLORSEL_GREEN],
+		  priv->color[COLORSEL_BLUE],
+		  &priv->color[COLORSEL_HUE],
+		  &priv->color[COLORSEL_SATURATION],
+		  &priv->color[COLORSEL_VALUE]);
+  if (priv->default_set == FALSE)
+    {
+      for (i = 0; i < COLORSEL_NUM_CHANNELS; i++)
+	priv->old_color[i] = priv->color[i];
+    }
+  priv->default_set = TRUE;
+  priv->default_alpha_set = TRUE;
+  update_color (colorsel);
+}
+
+static void
+set_color_icon (GdkDragContext *context,
+		gdouble        *colors)
+{
+  GdkPixbuf *pixbuf;
+  guint32 pixel;
+
+  pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE,
+			   8, 48, 32);
+
+  pixel = (((UNSCALE (colors[COLORSEL_RED])   & 0xff00) << 16) |
+	   ((UNSCALE (colors[COLORSEL_GREEN]) & 0xff00) << 8) |
+	   ((UNSCALE (colors[COLORSEL_BLUE])  & 0xff00)));
+
+  gdk_pixbuf_fill (pixbuf, pixel);
+  
+  gtk_drag_set_icon_pixbuf (context, pixbuf, -2, -2);
+  g_object_unref (pixbuf);
+}
+
+static void
+color_sample_drag_begin (GtkWidget      *widget,
+			 GdkDragContext *context,
+			 gpointer        data)
+{
+  MateColorSelection *colorsel = data;
+  ColorSelectionPrivate *priv;
+  gdouble *colsrc;
+  
+  priv = colorsel->private_data;
+  
+  if (widget == priv->old_sample)
+    colsrc = priv->old_color;
+  else
+    colsrc = priv->color;
+
+  set_color_icon (context, colsrc);
+}
+
+static void
+color_sample_drag_end (GtkWidget      *widget,
+		       GdkDragContext *context,
+		       gpointer        data)
+{
+  g_object_set_data (G_OBJECT (widget), "gtk-color-selection-drag-window", NULL);
+}
+
+static void
+color_sample_drop_handle (GtkWidget        *widget,
+			  GdkDragContext   *context,
+			  gint              x,
+			  gint              y,
+			  GtkSelectionData *selection_data,
+			  guint             info,
+			  guint             time,
+			  gpointer          data)
+{
+  MateColorSelection *colorsel = data;
+  ColorSelectionPrivate *priv;
+  guint16 *vals;
+  gdouble color[4];
+  priv = colorsel->private_data;
+  
+  /* This is currently a guint16 array of the format:
+   * R
+   * G
+   * B
+   * opacity
+   */
+  
+  if (selection_data->length < 0)
+    return;
+  
+  /* We accept drops with the wrong format, since the KDE color
+   * chooser incorrectly drops application/x-color with format 8.
+   */
+  if (selection_data->length != 8)
+    {
+      g_warning ("Received invalid color data\n");
+      return;
+    }
+  
+  vals = (guint16 *)selection_data->data;
+  
+  if (widget == priv->cur_sample)
+    {
+      color[0] = (gdouble)vals[0] / 0xffff;
+      color[1] = (gdouble)vals[1] / 0xffff;
+      color[2] = (gdouble)vals[2] / 0xffff;
+      color[3] = (gdouble)vals[3] / 0xffff;
+      
+      set_color_internal (colorsel, color);
+    }
+}
+
+static void
+color_sample_drag_handle (GtkWidget        *widget,
+			  GdkDragContext   *context,
+			  GtkSelectionData *selection_data,
+			  guint             info,
+			  guint             time,
+			  gpointer          data)
+{
+  MateColorSelection *colorsel = data;
+  ColorSelectionPrivate *priv;
+  guint16 vals[4];
+  gdouble *colsrc;
+  
+  priv = colorsel->private_data;
+  
+  if (widget == priv->old_sample)
+    colsrc = priv->old_color;
+  else
+    colsrc = priv->color;
+  
+  vals[0] = colsrc[COLORSEL_RED] * 0xffff;
+  vals[1] = colsrc[COLORSEL_GREEN] * 0xffff;
+  vals[2] = colsrc[COLORSEL_BLUE] * 0xffff;
+  vals[3] = priv->has_opacity ? colsrc[COLORSEL_OPACITY] * 0xffff : 0xffff;
+  
+  gtk_selection_data_set (selection_data,
+			  gdk_atom_intern_static_string ("application/x-color"),
+			  16, (guchar *)vals, 8);
+}
+
+/* which = 0 means draw old sample, which = 1 means draw new */
+static void
+color_sample_draw_sample (MateColorSelection *colorsel, int which)
+{
+  GtkWidget *da;
+  gint x, y, wid, heig, goff;
+  ColorSelectionPrivate *priv;
+  cairo_t *cr;
+  
+  g_return_if_fail (colorsel != NULL);
+  priv = colorsel->private_data;
+  
+  g_return_if_fail (priv->sample_area != NULL);
+  if (!gtk_widget_is_drawable (priv->sample_area))
+    return;
+
+  if (which == 0)
+    {
+      da = priv->old_sample;
+      goff = 0;
+    }
+  else
+    {
+      da = priv->cur_sample;
+      goff =  priv->old_sample->allocation.width % 32;
+    }
+
+  cr = gdk_cairo_create (da->window);
+  
+  wid = da->allocation.width;
+  heig = da->allocation.height;
+
+  /* Below needs tweaking for non-power-of-two */  
+  
+  if (priv->has_opacity)
+    {
+      /* Draw checks in background */
+
+      cairo_set_source_rgb (cr, 0.5, 0.5, 0.5);
+      cairo_rectangle (cr, 0, 0, wid, heig);
+      cairo_fill (cr);
+
+      cairo_set_source_rgb (cr, 0.75, 0.75, 0.75);
+      for (x = goff & -CHECK_SIZE; x < goff + wid; x += CHECK_SIZE)
+	for (y = 0; y < heig; y += CHECK_SIZE)
+	  if ((x / CHECK_SIZE + y / CHECK_SIZE) % 2 == 0)
+	    cairo_rectangle (cr, x - goff, y, CHECK_SIZE, CHECK_SIZE);
+      cairo_fill (cr);
+    }
+
+  if (which == 0)
+    {
+      cairo_set_source_rgba (cr,
+			     priv->old_color[COLORSEL_RED], 
+			     priv->old_color[COLORSEL_GREEN], 
+			     priv->old_color[COLORSEL_BLUE],
+			     priv->has_opacity ?
+			        priv->old_color[COLORSEL_OPACITY] : 1.0);
+    }
+  else
+    {
+      cairo_set_source_rgba (cr,
+			     priv->color[COLORSEL_RED], 
+			     priv->color[COLORSEL_GREEN], 
+			     priv->color[COLORSEL_BLUE],
+			     priv->has_opacity ?
+			       priv->color[COLORSEL_OPACITY] : 1.0);
+    }
+
+  cairo_rectangle (cr, 0, 0, wid, heig);
+  cairo_fill (cr);
+
+  cairo_destroy (cr);
+}
+
+
+static void
+color_sample_update_samples (MateColorSelection *colorsel)
+{
+  ColorSelectionPrivate *priv = colorsel->private_data;
+  gtk_widget_queue_draw (priv->old_sample);
+  gtk_widget_queue_draw (priv->cur_sample);
+}
+
+static gboolean
+color_old_sample_expose (GtkWidget         *da,
+			 GdkEventExpose    *event,
+			 MateColorSelection *colorsel)
+{
+  color_sample_draw_sample (colorsel, 0);
+  return FALSE;
+}
+
+
+static gboolean
+color_cur_sample_expose (GtkWidget         *da,
+			 GdkEventExpose    *event,
+			 MateColorSelection *colorsel)
+{
+  color_sample_draw_sample (colorsel, 1);
+  return FALSE;
+}
+
+static void
+color_sample_setup_dnd (MateColorSelection *colorsel, GtkWidget *sample)
+{
+  static const GtkTargetEntry targets[] = {
+    { "application/x-color", 0 }
+  };
+  ColorSelectionPrivate *priv;
+  priv = colorsel->private_data;
+  
+  gtk_drag_source_set (sample,
+		       GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
+		       targets, 1,
+		       GDK_ACTION_COPY | GDK_ACTION_MOVE);
+  
+  g_signal_connect (sample, "drag-begin",
+		    G_CALLBACK (color_sample_drag_begin),
+		    colorsel);
+  if (sample == priv->cur_sample)
+    {
+      
+      gtk_drag_dest_set (sample,
+			 GTK_DEST_DEFAULT_HIGHLIGHT |
+			 GTK_DEST_DEFAULT_MOTION |
+			 GTK_DEST_DEFAULT_DROP,
+			 targets, 1,
+			 GDK_ACTION_COPY);
+      
+      g_signal_connect (sample, "drag-end",
+			G_CALLBACK (color_sample_drag_end),
+			colorsel);
+    }
+  
+  g_signal_connect (sample, "drag-data-get",
+		    G_CALLBACK (color_sample_drag_handle),
+		    colorsel);
+  g_signal_connect (sample, "drag-data-received",
+		    G_CALLBACK (color_sample_drop_handle),
+		    colorsel);
+  
+}
+
+static void
+update_tooltips (MateColorSelection *colorsel)
+{
+  ColorSelectionPrivate *priv;
+
+  priv = colorsel->private_data;
+
+  if (priv->has_palette == TRUE)
+    {
+      gtk_widget_set_tooltip_text (priv->old_sample,
+                            _("The previously-selected color, for comparison to the color you're selecting now. You can drag this color to a palette entry, or select this color as current by dragging it to the other color swatch alongside."));
+
+      gtk_widget_set_tooltip_text (priv->cur_sample,
+                            _("The color you've chosen. You can drag this color to a palette entry to save it for use in the future."));
+    }
+  else
+    {
+      gtk_widget_set_tooltip_text (priv->old_sample,
+                            _("The previously-selected color, for comparison to the color you're selecting now."));
+
+      gtk_widget_set_tooltip_text (priv->cur_sample,
+                            _("The color you've chosen."));
+    }
+}
+
+static void
+color_sample_new (MateColorSelection *colorsel)
+{
+  ColorSelectionPrivate *priv;
+  
+  priv = colorsel->private_data;
+  
+  priv->sample_area = gtk_hbox_new (FALSE, 0);
+  priv->old_sample = gtk_drawing_area_new ();
+  priv->cur_sample = gtk_drawing_area_new ();
+
+  gtk_box_pack_start (GTK_BOX (priv->sample_area), priv->old_sample,
+		      TRUE, TRUE, 0);
+  gtk_box_pack_start (GTK_BOX (priv->sample_area), priv->cur_sample,
+		      TRUE, TRUE, 0);
+  
+  g_signal_connect (priv->old_sample, "expose-event",
+		    G_CALLBACK (color_old_sample_expose),
+		    colorsel);
+  g_signal_connect (priv->cur_sample, "expose-event",
+		    G_CALLBACK (color_cur_sample_expose),
+		    colorsel);
+  
+  color_sample_setup_dnd (colorsel, priv->old_sample);
+  color_sample_setup_dnd (colorsel, priv->cur_sample);
+
+  update_tooltips (colorsel);
+
+  gtk_widget_show_all (priv->sample_area);
+}
+
+
+/*
+ *
+ * The palette area code
+ *
+ */
+
+static void
+palette_get_color (GtkWidget *drawing_area, gdouble *color)
+{
+  gdouble *color_val;
+  
+  g_return_if_fail (color != NULL);
+  
+  color_val = g_object_get_data (G_OBJECT (drawing_area), "color_val");
+  if (color_val == NULL)
+    {
+      /* Default to white for no good reason */
+      color[0] = 1.0;
+      color[1] = 1.0;
+      color[2] = 1.0;
+      color[3] = 1.0;
+      return;
+    }
+  
+  color[0] = color_val[0];
+  color[1] = color_val[1];
+  color[2] = color_val[2];
+  color[3] = 1.0;
+}
+
+static void
+palette_paint (GtkWidget    *drawing_area,
+	       GdkRectangle *area,
+	       gpointer      data)
+{
+  cairo_t *cr;
+  gint focus_width;
+    
+  if (drawing_area->window == NULL)
+    return;
+
+  cr = gdk_cairo_create (drawing_area->window);
+
+  gdk_cairo_set_source_color (cr, &drawing_area->style->bg[GTK_STATE_NORMAL]);
+  gdk_cairo_rectangle (cr, area);
+  cairo_fill (cr);
+  
+  if (gtk_widget_has_focus (drawing_area))
+    {
+      set_focus_line_attributes (drawing_area, cr, &focus_width);
+
+      cairo_rectangle (cr,
+		       focus_width / 2., focus_width / 2.,
+		       drawing_area->allocation.width - focus_width,
+		       drawing_area->allocation.height - focus_width);
+      cairo_stroke (cr);
+    }
+
+  cairo_destroy (cr);
+}
+
+static void
+set_focus_line_attributes (GtkWidget *drawing_area,
+			   cairo_t   *cr,
+			   gint      *focus_width)
+{
+  gdouble color[4];
+  gint8 *dash_list;
+  
+  gtk_widget_style_get (drawing_area,
+			"focus-line-width", focus_width,
+			"focus-line-pattern", (gchar *)&dash_list,
+			NULL);
+      
+  palette_get_color (drawing_area, color);
+
+  if (INTENSITY (color[0], color[1], color[2]) > 0.5)
+    cairo_set_source_rgb (cr, 0., 0., 0.);
+  else
+    cairo_set_source_rgb (cr, 1., 1., 1.);
+
+  cairo_set_line_width (cr, *focus_width);
+
+  if (dash_list[0])
+    {
+      gint n_dashes = strlen ((gchar *)dash_list);
+      gdouble *dashes = g_new (gdouble, n_dashes);
+      gdouble total_length = 0;
+      gdouble dash_offset;
+      gint i;
+
+      for (i = 0; i < n_dashes; i++)
+	{
+	  dashes[i] = dash_list[i];
+	  total_length += dash_list[i];
+	}
+
+      /* The dash offset here aligns the pattern to integer pixels
+       * by starting the dash at the right side of the left border
+       * Negative dash offsets in cairo don't work
+       * (https://bugs.freedesktop.org/show_bug.cgi?id=2729)
+       */
+      dash_offset = - *focus_width / 2.;
+      while (dash_offset < 0)
+	dash_offset += total_length;
+      
+      cairo_set_dash (cr, dashes, n_dashes, dash_offset);
+      g_free (dashes);
+    }
+
+  g_free (dash_list);
+}
+
+static void
+palette_drag_begin (GtkWidget      *widget,
+		    GdkDragContext *context,
+		    gpointer        data)
+{
+  gdouble colors[4];
+  
+  palette_get_color (widget, colors);
+  set_color_icon (context, colors);
+}
+
+static void
+palette_drag_handle (GtkWidget        *widget,
+		     GdkDragContext   *context,
+		     GtkSelectionData *selection_data,
+		     guint             info,
+		     guint             time,
+		     gpointer          data)
+{
+  guint16 vals[4];
+  gdouble colsrc[4];
+  
+  palette_get_color (widget, colsrc);
+  
+  vals[0] = colsrc[COLORSEL_RED] * 0xffff;
+  vals[1] = colsrc[COLORSEL_GREEN] * 0xffff;
+  vals[2] = colsrc[COLORSEL_BLUE] * 0xffff;
+  vals[3] = 0xffff;
+  
+  gtk_selection_data_set (selection_data,
+			  gdk_atom_intern_static_string ("application/x-color"),
+			  16, (guchar *)vals, 8);
+}
+
+static void
+palette_drag_end (GtkWidget      *widget,
+		  GdkDragContext *context,
+		  gpointer        data)
+{
+  g_object_set_data (G_OBJECT (widget), "gtk-color-selection-drag-window", NULL);
+}
+
+static GdkColor *
+get_current_colors (MateColorSelection *colorsel)
+{
+  GtkSettings *settings;
+  GdkColor *colors = NULL;
+  gint n_colors = 0;
+  gchar *palette;
+
+  settings = gtk_widget_get_settings (GTK_WIDGET (colorsel));
+  g_object_get (settings, "gtk-color-palette", &palette, NULL);
+  
+  if (!mate_color_selection_palette_from_string (palette, &colors, &n_colors))
+    {
+      mate_color_selection_palette_from_string (DEFAULT_COLOR_PALETTE,
+                                               &colors,
+                                               &n_colors);
+    }
+  else
+    {
+      /* If there are less colors provided than the number of slots in the
+       * color selection, we fill in the rest from the defaults.
+       */
+      if (n_colors < (GTK_CUSTOM_PALETTE_WIDTH * GTK_CUSTOM_PALETTE_HEIGHT))
+	{
+	  GdkColor *tmp_colors = colors;
+	  gint tmp_n_colors = n_colors;
+	  
+	  mate_color_selection_palette_from_string (DEFAULT_COLOR_PALETTE,
+                                                   &colors,
+                                                   &n_colors);
+	  memcpy (colors, tmp_colors, sizeof (GdkColor) * tmp_n_colors);
+
+	  g_free (tmp_colors);
+	}
+    }
+
+  /* make sure that we fill every slot */
+  g_assert (n_colors == GTK_CUSTOM_PALETTE_WIDTH * GTK_CUSTOM_PALETTE_HEIGHT);
+  g_free (palette);
+  
+  return colors;
+}
+
+/* Changes the model color */
+static void
+palette_change_color (GtkWidget         *drawing_area,
+                      MateColorSelection *colorsel,
+                      gdouble           *color)
+{
+  gint x, y;
+  ColorSelectionPrivate *priv;
+  GdkColor gdk_color;
+  GdkColor *current_colors;
+  GdkScreen *screen;
+
+  g_return_if_fail (MATE_IS_COLOR_SELECTION (colorsel));
+  g_return_if_fail (GTK_IS_DRAWING_AREA (drawing_area));
+  
+  priv = colorsel->private_data;
+  
+  gdk_color.red = UNSCALE (color[0]);
+  gdk_color.green = UNSCALE (color[1]);
+  gdk_color.blue = UNSCALE (color[2]);
+  gdk_color.pixel = 0;
+
+  x = 0;
+  y = 0;			/* Quiet GCC */
+  while (x < GTK_CUSTOM_PALETTE_WIDTH)
+    {
+      y = 0;
+      while (y < GTK_CUSTOM_PALETTE_HEIGHT)
+        {
+          if (priv->custom_palette[x][y] == drawing_area)
+            goto out;
+          
+          ++y;
+        }
+
+      ++x;
+    }
+
+ out:
+  
+  g_assert (x < GTK_CUSTOM_PALETTE_WIDTH || y < GTK_CUSTOM_PALETTE_HEIGHT);
+
+  current_colors = get_current_colors (colorsel);
+  current_colors[y * GTK_CUSTOM_PALETTE_WIDTH + x] = gdk_color;
+
+  screen = gtk_widget_get_screen (GTK_WIDGET (colorsel));
+  if (change_palette_hook != default_change_palette_func)
+    (* change_palette_hook) (screen, current_colors, 
+			     GTK_CUSTOM_PALETTE_WIDTH * GTK_CUSTOM_PALETTE_HEIGHT);
+  else if (noscreen_change_palette_hook != default_noscreen_change_palette_func)
+    {
+      if (screen != gdk_screen_get_default ())
+	g_warning ("mate_color_selection_set_change_palette_hook used by widget is not on the default screen.");
+      (* noscreen_change_palette_hook) (current_colors, 
+					GTK_CUSTOM_PALETTE_WIDTH * GTK_CUSTOM_PALETTE_HEIGHT);
+    }
+  else
+    (* change_palette_hook) (screen, current_colors, 
+			     GTK_CUSTOM_PALETTE_WIDTH * GTK_CUSTOM_PALETTE_HEIGHT);
+
+  g_free (current_colors);
+}
+
+/* Changes the view color */
+static void
+palette_set_color (GtkWidget         *drawing_area,
+		   MateColorSelection *colorsel,
+		   gdouble           *color)
+{
+  gdouble *new_color = g_new (double, 4);
+  GdkColor gdk_color;
+  
+  gdk_color.red = UNSCALE (color[0]);
+  gdk_color.green = UNSCALE (color[1]);
+  gdk_color.blue = UNSCALE (color[2]);
+
+  gtk_widget_modify_bg (drawing_area, GTK_STATE_NORMAL, &gdk_color);
+  
+  if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (drawing_area), "color_set")) == 0)
+    {
+      static const GtkTargetEntry targets[] = {
+	{ "application/x-color", 0 }
+      };
+      gtk_drag_source_set (drawing_area,
+			   GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
+			   targets, 1,
+			   GDK_ACTION_COPY | GDK_ACTION_MOVE);
+      
+      g_signal_connect (drawing_area, "drag-begin",
+			G_CALLBACK (palette_drag_begin),
+			colorsel);
+      g_signal_connect (drawing_area, "drag-data-get",
+			G_CALLBACK (palette_drag_handle),
+			colorsel);
+      
+      g_object_set_data (G_OBJECT (drawing_area), "color_set",
+			 GINT_TO_POINTER (1));
+    }
+
+  new_color[0] = color[0];
+  new_color[1] = color[1];
+  new_color[2] = color[2];
+  new_color[3] = 1.0;
+  
+  g_object_set_data_full (G_OBJECT (drawing_area), "color_val", new_color, (GDestroyNotify)g_free);
+}
+
+static gboolean
+palette_expose (GtkWidget      *drawing_area,
+		GdkEventExpose *event,
+		gpointer        data)
+{
+  if (drawing_area->window == NULL)
+    return FALSE;
+  
+  palette_paint (drawing_area, &(event->area), data);
+  
+  return FALSE;
+}
+
+static void
+popup_position_func (GtkMenu   *menu,
+                     gint      *x,
+                     gint      *y,
+                     gboolean  *push_in,
+                     gpointer	user_data)
+{
+  GtkWidget *widget;
+  GtkRequisition req;      
+  gint root_x, root_y;
+  GdkScreen *screen;
+  
+  widget = GTK_WIDGET (user_data);
+  
+  g_return_if_fail (gtk_widget_get_realized (widget));
+
+  gdk_window_get_origin (widget->window, &root_x, &root_y);
+  
+  gtk_widget_size_request (GTK_WIDGET (menu), &req);
+
+  /* Put corner of menu centered on color cell */
+  *x = root_x + widget->allocation.width / 2;
+  *y = root_y + widget->allocation.height / 2;
+
+  /* Ensure sanity */
+  screen = gtk_widget_get_screen (widget);
+  *x = CLAMP (*x, 0, MAX (0, gdk_screen_get_width (screen) - req.width));
+  *y = CLAMP (*y, 0, MAX (0, gdk_screen_get_height (screen) - req.height));
+}
+
+static void
+save_color_selected (GtkWidget *menuitem,
+                     gpointer   data)
+{
+  MateColorSelection *colorsel;
+  GtkWidget *drawing_area;
+  ColorSelectionPrivate *priv;
+
+  drawing_area = GTK_WIDGET (data);
+  
+  colorsel = MATE_COLOR_SELECTION (g_object_get_data (G_OBJECT (drawing_area),
+                                                     "gtk-color-sel"));
+
+  priv = colorsel->private_data;
+  
+  palette_change_color (drawing_area, colorsel, priv->color);  
+}
+
+static void
+do_popup (MateColorSelection *colorsel,
+          GtkWidget         *drawing_area,
+          guint32            timestamp)
+{
+  GtkWidget *menu;
+  GtkWidget *mi;
+  
+  g_object_set_data (G_OBJECT (drawing_area),
+                     _("gtk-color-sel"),
+                     colorsel);
+  
+  menu = gtk_menu_new ();
+
+  mi = gtk_menu_item_new_with_mnemonic (_("_Save color here"));
+
+  g_signal_connect (mi, "activate",
+                    G_CALLBACK (save_color_selected),
+                    drawing_area);
+  
+  gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
+
+  gtk_widget_show_all (mi);
+
+  gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
+                  popup_position_func, drawing_area,
+                  3, timestamp);
+}
+
+
+static gboolean
+palette_enter (GtkWidget        *drawing_area,
+	       GdkEventCrossing *event,
+	       gpointer        data)
+{
+  g_object_set_data (G_OBJECT (drawing_area),
+		     "gtk-colorsel-have-pointer",
+		     GUINT_TO_POINTER (TRUE));
+
+  return FALSE;
+}
+
+static gboolean
+palette_leave (GtkWidget        *drawing_area,
+	       GdkEventCrossing *event,
+	       gpointer        data)
+{
+  g_object_set_data (G_OBJECT (drawing_area),
+		     "gtk-colorsel-have-pointer",
+		     NULL);
+
+  return FALSE;
+}
+
+/* private function copied from gtk2/gtkmain.c */
+static gboolean
+_gtk_button_event_triggers_context_menu (GdkEventButton *event)
+{
+  if (event->type == GDK_BUTTON_PRESS)
+    {
+      if (event->button == 3 &&
+          ! (event->state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK)))
+        return TRUE;
+
+#ifdef GDK_WINDOWING_QUARTZ
+      if (event->button == 1 &&
+          ! (event->state & (GDK_BUTTON2_MASK | GDK_BUTTON3_MASK)) &&
+          (event->state & GDK_CONTROL_MASK))
+        return TRUE;
+#endif
+    }
+
+  return FALSE;
+}
+
+static gboolean
+palette_press (GtkWidget      *drawing_area,
+	       GdkEventButton *event,
+	       gpointer        data)
+{
+  MateColorSelection *colorsel = MATE_COLOR_SELECTION (data);
+
+  gtk_widget_grab_focus (drawing_area);
+
+  if (_gtk_button_event_triggers_context_menu (event))
+    {
+      do_popup (colorsel, drawing_area, event->time);
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gboolean
+palette_release (GtkWidget      *drawing_area,
+		 GdkEventButton *event,
+		 gpointer        data)
+{
+  MateColorSelection *colorsel = MATE_COLOR_SELECTION (data);
+
+  gtk_widget_grab_focus (drawing_area);
+
+  if (event->button == 1 &&
+      g_object_get_data (G_OBJECT (drawing_area),
+			 "gtk-colorsel-have-pointer") != NULL)
+    {
+      if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (drawing_area), "color_set")) != 0)
+        {
+          gdouble color[4];
+          palette_get_color (drawing_area, color);
+          set_color_internal (colorsel, color);
+        }
+    }
+
+  return FALSE;
+}
+
+static void
+palette_drop_handle (GtkWidget        *widget,
+		     GdkDragContext   *context,
+		     gint              x,
+		     gint              y,
+		     GtkSelectionData *selection_data,
+		     guint             info,
+		     guint             time,
+		     gpointer          data)
+{
+  MateColorSelection *colorsel = MATE_COLOR_SELECTION (data);
+  guint16 *vals;
+  gdouble color[4];
+  
+  if (selection_data->length < 0)
+    return;
+  
+  /* We accept drops with the wrong format, since the KDE color
+   * chooser incorrectly drops application/x-color with format 8.
+   */
+  if (selection_data->length != 8)
+    {
+      g_warning ("Received invalid color data\n");
+      return;
+    }
+  
+  vals = (guint16 *)selection_data->data;
+  
+  color[0] = (gdouble)vals[0] / 0xffff;
+  color[1] = (gdouble)vals[1] / 0xffff;
+  color[2] = (gdouble)vals[2] / 0xffff;
+  color[3] = (gdouble)vals[3] / 0xffff;
+  palette_change_color (widget, colorsel, color);
+  set_color_internal (colorsel, color);
+}
+
+static gint
+palette_activate (GtkWidget   *widget,
+		  GdkEventKey *event,
+		  gpointer     data)
+{
+  /* should have a drawing area subclass with an activate signal */
+  if ((event->keyval == GDK_space) ||
+      (event->keyval == GDK_Return) ||
+      (event->keyval == GDK_ISO_Enter) ||
+      (event->keyval == GDK_KP_Enter) ||
+      (event->keyval == GDK_KP_Space))
+    {
+      if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), "color_set")) != 0)
+        {
+          gdouble color[4];
+          palette_get_color (widget, color);
+          set_color_internal (MATE_COLOR_SELECTION (data), color);
+        }
+      return TRUE;
+    }
+  
+  return FALSE;
+}
+
+static gboolean
+palette_popup (GtkWidget *widget,
+               gpointer   data)
+{
+  MateColorSelection *colorsel = MATE_COLOR_SELECTION (data);
+
+  do_popup (colorsel, widget, GDK_CURRENT_TIME);
+  return TRUE;
+}
+               
+
+static GtkWidget*
+palette_new (MateColorSelection *colorsel)
+{
+  GtkWidget *retval;
+  ColorSelectionPrivate *priv;
+  
+  static const GtkTargetEntry targets[] = {
+    { "application/x-color", 0 }
+  };
+
+  priv = colorsel->private_data;
+  
+  retval = gtk_drawing_area_new ();
+
+  gtk_widget_set_can_focus (retval, TRUE);
+  
+  g_object_set_data (G_OBJECT (retval), "color_set", GINT_TO_POINTER (0)); 
+  gtk_widget_set_events (retval, GDK_BUTTON_PRESS_MASK
+                         | GDK_BUTTON_RELEASE_MASK
+                         | GDK_EXPOSURE_MASK
+                         | GDK_ENTER_NOTIFY_MASK
+                         | GDK_LEAVE_NOTIFY_MASK);
+  
+  g_signal_connect (retval, "expose-event",
+		    G_CALLBACK (palette_expose), colorsel);
+  g_signal_connect (retval, "button-press-event",
+		    G_CALLBACK (palette_press), colorsel);
+  g_signal_connect (retval, "button-release-event",
+		    G_CALLBACK (palette_release), colorsel);
+  g_signal_connect (retval, "enter-notify-event",
+		    G_CALLBACK (palette_enter), colorsel);
+  g_signal_connect (retval, "leave-notify-event",
+		    G_CALLBACK (palette_leave), colorsel);
+  g_signal_connect (retval, "key-press-event",
+		    G_CALLBACK (palette_activate), colorsel);
+  g_signal_connect (retval, "popup-menu",
+		    G_CALLBACK (palette_popup), colorsel);
+  
+  gtk_drag_dest_set (retval,
+		     GTK_DEST_DEFAULT_HIGHLIGHT |
+		     GTK_DEST_DEFAULT_MOTION |
+		     GTK_DEST_DEFAULT_DROP,
+		     targets, 1,
+		     GDK_ACTION_COPY);
+  
+  g_signal_connect (retval, "drag-end",
+                    G_CALLBACK (palette_drag_end), NULL);
+  g_signal_connect (retval, "drag-data-received",
+                    G_CALLBACK (palette_drop_handle), colorsel);
+
+  gtk_widget_set_tooltip_text (retval,
+                        _("Click this palette entry to make it the current color. To change this entry, drag a color swatch here or right-click it and select \"Save color here.\""));
+  return retval;
+}
+
+
+/*
+ *
+ * The actual MateColorSelection widget
+ *
+ */
+
+static GdkCursor *
+make_picker_cursor (GdkScreen *screen)
+{
+  GdkCursor *cursor;
+
+  cursor = gdk_cursor_new_from_name (gdk_screen_get_display (screen),
+				     "color-picker");
+
+  if (!cursor)
+    {
+      GdkColor bg = { 0, 0xffff, 0xffff, 0xffff };
+      GdkColor fg = { 0, 0x0000, 0x0000, 0x0000 };
+      GdkWindow *window;
+      GdkPixmap *pixmap, *mask;
+      cairo_surface_t *image;
+      cairo_t *cr;
+
+      window = gdk_screen_get_root_window (screen);
+      
+
+      pixmap = gdk_pixmap_new (window, DROPPER_WIDTH, DROPPER_HEIGHT, 1);
+
+      cr = gdk_cairo_create (pixmap);
+      cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+      image = cairo_image_surface_create_for_data ((guchar *) dropper_bits,
+                                                   CAIRO_FORMAT_A1,
+                                                   DROPPER_WIDTH,
+                                                   DROPPER_HEIGHT,
+                                                   DROPPER_STRIDE);
+      cairo_set_source_surface (cr, image, 0, 0);
+      cairo_surface_destroy (image);
+      cairo_paint (cr);
+      cairo_destroy (cr);
+      
+
+      mask = gdk_pixmap_new (window, DROPPER_WIDTH, DROPPER_HEIGHT, 1);
+
+      cr = gdk_cairo_create (mask);
+      cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+      image = cairo_image_surface_create_for_data ((guchar *) dropper_mask,
+                                                   CAIRO_FORMAT_A1,
+                                                   DROPPER_WIDTH,
+                                                   DROPPER_HEIGHT,
+                                                   DROPPER_STRIDE);
+      cairo_set_source_surface (cr, image, 0, 0);
+      cairo_surface_destroy (image);
+      cairo_paint (cr);
+      cairo_destroy (cr);
+      
+      cursor = gdk_cursor_new_from_pixmap (pixmap, mask, &fg, &bg,
+					   DROPPER_X_HOT, DROPPER_Y_HOT);
+      
+      g_object_unref (pixmap);
+      g_object_unref (mask);
+    }
+      
+  return cursor;
+}
+
+static void
+grab_color_at_mouse (GdkScreen *screen,
+		     gint       x_root,
+		     gint       y_root,
+		     gpointer   data)
+{
+  GdkPixbuf *pixbuf;
+  guchar *pixels;
+  MateColorSelection *colorsel = data;
+  ColorSelectionPrivate *priv;
+  GdkColor color;
+  GdkWindow *root_window = gdk_screen_get_root_window (screen);
+  
+  priv = colorsel->private_data;
+  
+  pixbuf = gdk_pixbuf_get_from_drawable (NULL, root_window, NULL,
+                                         x_root, y_root,
+                                         0, 0,
+                                         1, 1);
+  if (!pixbuf)
+    {
+      gint x, y;
+      GdkDisplay *display = gdk_screen_get_display (screen);
+      GdkWindow *window = gdk_display_get_window_at_pointer (display, &x, &y);
+      if (!window)
+	return;
+      pixbuf = gdk_pixbuf_get_from_drawable (NULL, window, NULL,
+                                             x, y,
+                                             0, 0,
+                                             1, 1);
+      if (!pixbuf)
+	return;
+    }
+  pixels = gdk_pixbuf_get_pixels (pixbuf);
+  color.red = pixels[0] * 0x101;
+  color.green = pixels[1] * 0x101;
+  color.blue = pixels[2] * 0x101;
+  g_object_unref (pixbuf);
+
+  priv->color[COLORSEL_RED] = SCALE (color.red);
+  priv->color[COLORSEL_GREEN] = SCALE (color.green);
+  priv->color[COLORSEL_BLUE] = SCALE (color.blue);
+  
+  gtk_rgb_to_hsv (priv->color[COLORSEL_RED],
+		  priv->color[COLORSEL_GREEN],
+		  priv->color[COLORSEL_BLUE],
+		  &priv->color[COLORSEL_HUE],
+		  &priv->color[COLORSEL_SATURATION],
+		  &priv->color[COLORSEL_VALUE]);
+
+  update_color (colorsel);
+}
+
+static void
+shutdown_eyedropper (GtkWidget *widget)
+{
+  MateColorSelection *colorsel;
+  ColorSelectionPrivate *priv;
+  GdkDisplay *display = gtk_widget_get_display (widget);
+
+  colorsel = MATE_COLOR_SELECTION (widget);
+  priv = colorsel->private_data;    
+
+  if (priv->has_grab)
+    {
+      gdk_display_keyboard_ungrab (display, priv->grab_time);
+      gdk_display_pointer_ungrab (display, priv->grab_time);
+      gtk_grab_remove (priv->dropper_grab_widget);
+
+      priv->has_grab = FALSE;
+    }
+}
+
+static void
+mouse_motion (GtkWidget      *invisible,
+	      GdkEventMotion *event,
+	      gpointer        data)
+{
+  grab_color_at_mouse (gdk_event_get_screen ((GdkEvent *)event),
+		       event->x_root, event->y_root, data); 
+}
+
+static gboolean
+mouse_release (GtkWidget      *invisible,
+	       GdkEventButton *event,
+	       gpointer        data)
+{
+  /* MateColorSelection *colorsel = data; */
+
+  if (event->button != 1)
+    return FALSE;
+
+  grab_color_at_mouse (gdk_event_get_screen ((GdkEvent *)event),
+		       event->x_root, event->y_root, data);
+
+  shutdown_eyedropper (GTK_WIDGET (data));
+  
+  g_signal_handlers_disconnect_by_func (invisible,
+					mouse_motion,
+					data);
+  g_signal_handlers_disconnect_by_func (invisible,
+					mouse_release,
+					data);
+
+  return TRUE;
+}
+
+/* Helper Functions */
+
+static gboolean
+key_press (GtkWidget   *invisible,
+           GdkEventKey *event,
+           gpointer     data)
+{  
+  GdkDisplay *display = gtk_widget_get_display (invisible);
+  GdkScreen *screen = gdk_event_get_screen ((GdkEvent *)event);
+  guint state = event->state & gtk_accelerator_get_default_mod_mask ();
+  gint x, y;
+  gint dx, dy;
+
+  gdk_display_get_pointer (display, NULL, &x, &y, NULL);
+
+  dx = 0;
+  dy = 0;
+
+  switch (event->keyval) 
+    {
+    case GDK_space:
+    case GDK_Return:
+    case GDK_ISO_Enter:
+    case GDK_KP_Enter:
+    case GDK_KP_Space:
+      grab_color_at_mouse (screen, x, y, data);
+      /* fall through */
+
+    case GDK_Escape:
+      shutdown_eyedropper (data);
+      
+      g_signal_handlers_disconnect_by_func (invisible,
+					    mouse_press,
+					    data);
+      g_signal_handlers_disconnect_by_func (invisible,
+					    key_press,
+					    data);
+      
+      return TRUE;
+
+#if defined GDK_WINDOWING_X11 || defined GDK_WINDOWING_WIN32
+    case GDK_Up:
+    case GDK_KP_Up:
+      dy = state == GDK_MOD1_MASK ? -BIG_STEP : -1;
+      break;
+
+    case GDK_Down:
+    case GDK_KP_Down:
+      dy = state == GDK_MOD1_MASK ? BIG_STEP : 1;
+      break;
+
+    case GDK_Left:
+    case GDK_KP_Left:
+      dx = state == GDK_MOD1_MASK ? -BIG_STEP : -1;
+      break;
+
+    case GDK_Right:
+    case GDK_KP_Right:
+      dx = state == GDK_MOD1_MASK ? BIG_STEP : 1;
+      break;
+#endif
+
+    default:
+      return FALSE;
+    }
+
+  gdk_display_warp_pointer (display, screen, x + dx, y + dy);
+  
+  return TRUE;
+
+}
+
+static gboolean
+mouse_press (GtkWidget      *invisible,
+	     GdkEventButton *event,
+	     gpointer        data)
+{
+  /* MateColorSelection *colorsel = data; */
+  
+  if (event->type == GDK_BUTTON_PRESS &&
+      event->button == 1)
+    {
+      g_signal_connect (invisible, "motion-notify-event",
+                        G_CALLBACK (mouse_motion),
+                        data);
+      g_signal_connect (invisible, "button-release-event",
+                        G_CALLBACK (mouse_release),
+                        data);
+      g_signal_handlers_disconnect_by_func (invisible,
+					    mouse_press,
+					    data);
+      g_signal_handlers_disconnect_by_func (invisible,
+					    key_press,
+					    data);
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+/* when the button is clicked */
+static void
+get_screen_color (GtkWidget *button)
+{
+  MateColorSelection *colorsel = g_object_get_data (G_OBJECT (button), "COLORSEL");
+  ColorSelectionPrivate *priv = colorsel->private_data;
+  GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (button));
+  GdkCursor *picker_cursor;
+  GdkGrabStatus grab_status;
+  GtkWidget *grab_widget, *toplevel;
+
+  guint32 time = gtk_get_current_event_time ();
+  
+  if (priv->dropper_grab_widget == NULL)
+    {
+      grab_widget = gtk_window_new (GTK_WINDOW_POPUP);
+      gtk_window_set_screen (GTK_WINDOW (grab_widget), screen);
+      gtk_window_resize (GTK_WINDOW (grab_widget), 1, 1);
+      gtk_window_move (GTK_WINDOW (grab_widget), -100, -100);
+      gtk_widget_show (grab_widget);
+
+      gtk_widget_add_events (grab_widget,
+                             GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK);
+      
+      toplevel = gtk_widget_get_toplevel (GTK_WIDGET (colorsel));
+  
+      if (GTK_IS_WINDOW (toplevel))
+	{
+	  if (GTK_WINDOW (toplevel)->group)
+	    gtk_window_group_add_window (GTK_WINDOW (toplevel)->group, 
+					 GTK_WINDOW (grab_widget));
+	}
+
+      priv->dropper_grab_widget = grab_widget;
+    }
+
+  if (gdk_keyboard_grab (priv->dropper_grab_widget->window,
+                         FALSE, time) != GDK_GRAB_SUCCESS)
+    return;
+  
+  picker_cursor = make_picker_cursor (screen);
+  grab_status = gdk_pointer_grab (priv->dropper_grab_widget->window,
+				  FALSE,
+				  GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK,
+				  NULL,
+				  picker_cursor,
+				  time);
+  gdk_cursor_unref (picker_cursor);
+  
+  if (grab_status != GDK_GRAB_SUCCESS)
+    {
+      gdk_display_keyboard_ungrab (gtk_widget_get_display (button), time);
+      return;
+    }
+
+  gtk_grab_add (priv->dropper_grab_widget);
+  priv->grab_time = time;
+  priv->has_grab = TRUE;
+  
+  g_signal_connect (priv->dropper_grab_widget, "button-press-event",
+                    G_CALLBACK (mouse_press), colorsel);
+  g_signal_connect (priv->dropper_grab_widget, "key-press-event",
+                    G_CALLBACK (key_press), colorsel);
+}
+
+static void
+hex_changed (GtkWidget *hex_entry,
+	     gpointer   data)
+{
+  MateColorSelection *colorsel;
+  ColorSelectionPrivate *priv;
+  GdkColor color;
+  gchar *text;
+  
+  colorsel = MATE_COLOR_SELECTION (data);
+  priv = colorsel->private_data;
+  
+  if (priv->changing)
+    return;
+  
+  text = gtk_editable_get_chars (GTK_EDITABLE (priv->hex_entry), 0, -1);
+  if (gdk_color_parse (text, &color))
+    {
+      priv->color[COLORSEL_RED] = CLAMP (color.red/65535.0, 0.0, 1.0);
+      priv->color[COLORSEL_GREEN] = CLAMP (color.green/65535.0, 0.0, 1.0);
+      priv->color[COLORSEL_BLUE] = CLAMP (color.blue/65535.0, 0.0, 1.0);
+      gtk_rgb_to_hsv (priv->color[COLORSEL_RED],
+		      priv->color[COLORSEL_GREEN],
+		      priv->color[COLORSEL_BLUE],
+		      &priv->color[COLORSEL_HUE],
+		      &priv->color[COLORSEL_SATURATION],
+		      &priv->color[COLORSEL_VALUE]);
+      update_color (colorsel);
+    }
+  g_free (text);
+}
+
+static gboolean
+hex_focus_out (GtkWidget     *hex_entry, 
+	       GdkEventFocus *event,
+	       gpointer       data)
+{
+  hex_changed (hex_entry, data);
+  
+  return FALSE;
+}
+
+static void
+hsv_changed (GtkWidget *hsv,
+	     gpointer   data)
+{
+  MateColorSelection *colorsel;
+  ColorSelectionPrivate *priv;
+  
+  colorsel = MATE_COLOR_SELECTION (data);
+  priv = colorsel->private_data;
+  
+  if (priv->changing)
+    return;
+  
+  gtk_hsv_get_color (GTK_HSV (hsv),
+		     &priv->color[COLORSEL_HUE],
+		     &priv->color[COLORSEL_SATURATION],
+		     &priv->color[COLORSEL_VALUE]);
+  gtk_hsv_to_rgb (priv->color[COLORSEL_HUE],
+		  priv->color[COLORSEL_SATURATION],
+		  priv->color[COLORSEL_VALUE],
+		  &priv->color[COLORSEL_RED],
+		  &priv->color[COLORSEL_GREEN],
+		  &priv->color[COLORSEL_BLUE]);
+  update_color (colorsel);
+}
+
+static void
+adjustment_changed (GtkAdjustment *adjustment,
+		    gpointer       data)
+{
+  MateColorSelection *colorsel;
+  ColorSelectionPrivate *priv;
+  
+  colorsel = MATE_COLOR_SELECTION (g_object_get_data (G_OBJECT (adjustment), "COLORSEL"));
+  priv = colorsel->private_data;
+  
+  if (priv->changing)
+    return;
+  
+  switch (GPOINTER_TO_INT (data))
+    {
+    case COLORSEL_SATURATION:
+    case COLORSEL_VALUE:
+      priv->color[GPOINTER_TO_INT (data)] = adjustment->value / 100;
+      gtk_hsv_to_rgb (priv->color[COLORSEL_HUE],
+		      priv->color[COLORSEL_SATURATION],
+		      priv->color[COLORSEL_VALUE],
+		      &priv->color[COLORSEL_RED],
+		      &priv->color[COLORSEL_GREEN],
+		      &priv->color[COLORSEL_BLUE]);
+      break;
+    case COLORSEL_HUE:
+      priv->color[GPOINTER_TO_INT (data)] = adjustment->value / 360;
+      gtk_hsv_to_rgb (priv->color[COLORSEL_HUE],
+		      priv->color[COLORSEL_SATURATION],
+		      priv->color[COLORSEL_VALUE],
+		      &priv->color[COLORSEL_RED],
+		      &priv->color[COLORSEL_GREEN],
+		      &priv->color[COLORSEL_BLUE]);
+      break;
+    case COLORSEL_RED:
+    case COLORSEL_GREEN:
+    case COLORSEL_BLUE:
+      priv->color[GPOINTER_TO_INT (data)] = adjustment->value / 255;
+      
+      gtk_rgb_to_hsv (priv->color[COLORSEL_RED],
+		      priv->color[COLORSEL_GREEN],
+		      priv->color[COLORSEL_BLUE],
+		      &priv->color[COLORSEL_HUE],
+		      &priv->color[COLORSEL_SATURATION],
+		      &priv->color[COLORSEL_VALUE]);
+      break;
+    default:
+      priv->color[GPOINTER_TO_INT (data)] = adjustment->value / 255;
+      break;
+    }
+  update_color (colorsel);
+}
+
+static void 
+opacity_entry_changed (GtkWidget *opacity_entry,
+		       gpointer   data)
+{
+  MateColorSelection *colorsel;
+  ColorSelectionPrivate *priv;
+  GtkAdjustment *adj;
+  gchar *text;
+  
+  colorsel = MATE_COLOR_SELECTION (data);
+  priv = colorsel->private_data;
+  
+  if (priv->changing)
+    return;
+  
+  text = gtk_editable_get_chars (GTK_EDITABLE (priv->opacity_entry), 0, -1);
+  adj = gtk_range_get_adjustment (GTK_RANGE (priv->opacity_slider));
+  gtk_adjustment_set_value (adj, g_strtod (text, NULL)); 
+  
+  update_color (colorsel);
+  
+  g_free (text);
+}
+
+static void
+make_label_spinbutton (MateColorSelection *colorsel,
+		       GtkWidget        **spinbutton,
+		       gchar             *text,
+		       GtkWidget         *table,
+		       gint               i,
+		       gint               j,
+		       gint               channel_type,
+                       const gchar       *tooltip)
+{
+  GtkWidget *label;
+  GtkAdjustment *adjust;
+
+  if (channel_type == COLORSEL_HUE)
+    {
+      adjust = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 360.0, 1.0, 1.0, 0.0));
+    }
+  else if (channel_type == COLORSEL_SATURATION ||
+	   channel_type == COLORSEL_VALUE)
+    {
+      adjust = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 100.0, 1.0, 1.0, 0.0));
+    }
+  else
+    {
+      adjust = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 255.0, 1.0, 1.0, 0.0));
+    }
+  g_object_set_data (G_OBJECT (adjust), "COLORSEL", colorsel);
+  *spinbutton = gtk_spin_button_new (adjust, 10.0, 0);
+
+  gtk_widget_set_tooltip_text (*spinbutton, tooltip);  
+
+  g_signal_connect (adjust, "value-changed",
+                    G_CALLBACK (adjustment_changed),
+                    GINT_TO_POINTER (channel_type));
+  label = gtk_label_new_with_mnemonic (text);
+  gtk_label_set_mnemonic_widget (GTK_LABEL (label), *spinbutton);
+
+  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+  gtk_table_attach_defaults (GTK_TABLE (table), label, i, i+1, j, j+1);
+  gtk_table_attach_defaults (GTK_TABLE (table), *spinbutton, i+1, i+2, j, j+1);
+}
+
+static void
+make_palette_frame (MateColorSelection *colorsel,
+		    GtkWidget         *table,
+		    gint               i,
+		    gint               j)
+{
+  GtkWidget *frame;
+  ColorSelectionPrivate *priv;
+  
+  priv = colorsel->private_data;
+  frame = gtk_frame_new (NULL);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
+  priv->custom_palette[i][j] = palette_new (colorsel);
+  gtk_widget_set_size_request (priv->custom_palette[i][j], CUSTOM_PALETTE_ENTRY_WIDTH, CUSTOM_PALETTE_ENTRY_HEIGHT);
+  gtk_container_add (GTK_CONTAINER (frame), priv->custom_palette[i][j]);
+  gtk_table_attach_defaults (GTK_TABLE (table), frame, i, i+1, j, j+1);
+}
+
+/* Set the palette entry [x][y] to be the currently selected one. */
+static void 
+set_selected_palette (MateColorSelection *colorsel, int x, int y)
+{
+  ColorSelectionPrivate *priv = colorsel->private_data; 
+
+  gtk_widget_grab_focus (priv->custom_palette[x][y]);
+}
+
+static double
+scale_round (double val, double factor)
+{
+  val = floor (val * factor + 0.5);
+  val = MAX (val, 0);
+  val = MIN (val, factor);
+  return val;
+}
+
+static void
+update_color (MateColorSelection *colorsel)
+{
+  ColorSelectionPrivate *priv = colorsel->private_data;
+  gchar entryval[12];
+  gchar opacity_text[32];
+  gchar *ptr;
+  
+  priv->changing = TRUE;
+  color_sample_update_samples (colorsel);
+  
+  gtk_hsv_set_color (GTK_HSV (priv->triangle_colorsel),
+		     priv->color[COLORSEL_HUE],
+		     priv->color[COLORSEL_SATURATION],
+		     priv->color[COLORSEL_VALUE]);
+  gtk_adjustment_set_value (gtk_spin_button_get_adjustment
+			    (GTK_SPIN_BUTTON (priv->hue_spinbutton)),
+			    scale_round (priv->color[COLORSEL_HUE], 360));
+  gtk_adjustment_set_value (gtk_spin_button_get_adjustment
+			    (GTK_SPIN_BUTTON (priv->sat_spinbutton)),
+			    scale_round (priv->color[COLORSEL_SATURATION], 100));
+  gtk_adjustment_set_value (gtk_spin_button_get_adjustment
+			    (GTK_SPIN_BUTTON (priv->val_spinbutton)),
+			    scale_round (priv->color[COLORSEL_VALUE], 100));
+  gtk_adjustment_set_value (gtk_spin_button_get_adjustment
+			    (GTK_SPIN_BUTTON (priv->red_spinbutton)),
+			    scale_round (priv->color[COLORSEL_RED], 255));
+  gtk_adjustment_set_value (gtk_spin_button_get_adjustment
+			    (GTK_SPIN_BUTTON (priv->green_spinbutton)),
+			    scale_round (priv->color[COLORSEL_GREEN], 255));
+  gtk_adjustment_set_value (gtk_spin_button_get_adjustment
+			    (GTK_SPIN_BUTTON (priv->blue_spinbutton)),
+			    scale_round (priv->color[COLORSEL_BLUE], 255));
+  gtk_adjustment_set_value (gtk_range_get_adjustment
+			    (GTK_RANGE (priv->opacity_slider)),
+			    scale_round (priv->color[COLORSEL_OPACITY], 255));
+  
+  g_snprintf (opacity_text, 32, "%.0f", scale_round (priv->color[COLORSEL_OPACITY], 255));
+  gtk_entry_set_text (GTK_ENTRY (priv->opacity_entry), opacity_text);
+  
+  g_snprintf (entryval, 11, "#%2X%2X%2X",
+	      (guint) (scale_round (priv->color[COLORSEL_RED], 255)),
+	      (guint) (scale_round (priv->color[COLORSEL_GREEN], 255)),
+	      (guint) (scale_round (priv->color[COLORSEL_BLUE], 255)));
+  
+  for (ptr = entryval; *ptr; ptr++)
+    if (*ptr == ' ')
+      *ptr = '0';
+  gtk_entry_set_text (GTK_ENTRY (priv->hex_entry), entryval);
+  priv->changing = FALSE;
+
+  g_object_ref (colorsel);
+  
+  g_signal_emit (colorsel, color_selection_signals[COLOR_CHANGED], 0);
+  
+  g_object_freeze_notify (G_OBJECT (colorsel));
+  g_object_notify (G_OBJECT (colorsel), "current-color");
+  g_object_notify (G_OBJECT (colorsel), "current-alpha");
+  g_object_thaw_notify (G_OBJECT (colorsel));
+  
+  g_object_unref (colorsel);
+}
+
+static void
+update_palette (MateColorSelection *colorsel)
+{
+  GdkColor *current_colors;
+  gint i, j;
+
+  current_colors = get_current_colors (colorsel);
+  
+  for (i = 0; i < GTK_CUSTOM_PALETTE_HEIGHT; i++)
+    {
+      for (j = 0; j < GTK_CUSTOM_PALETTE_WIDTH; j++)
+	{
+          gint index;
+
+          index = i * GTK_CUSTOM_PALETTE_WIDTH + j;
+          
+          mate_color_selection_set_palette_color (colorsel,
+                                                 index,
+                                                 &current_colors[index]);
+	}
+    }
+
+  g_free (current_colors);
+}
+
+static void
+palette_change_notify_instance (GObject    *object,
+                                GParamSpec *pspec,
+                                gpointer    data)
+{
+  update_palette (MATE_COLOR_SELECTION (data));
+}
+
+static void
+default_noscreen_change_palette_func (const GdkColor *colors,
+				      gint            n_colors)
+{
+  default_change_palette_func (gdk_screen_get_default (), colors, n_colors);
+}
+
+static void
+default_change_palette_func (GdkScreen	    *screen,
+			     const GdkColor *colors,
+                             gint            n_colors)
+{
+  gchar *str;
+  
+  str = mate_color_selection_palette_to_string (colors, n_colors);
+
+  gtk_settings_set_string_property (gtk_settings_get_for_screen (screen),
+                                    "gtk-color-palette",
+                                    str,
+                                    "mate_color_selection_palette_to_string");
+
+  g_free (str);
+}
+
+/**
+ * mate_color_selection_new:
+ * 
+ * Creates a new MateColorSelection.
+ * 
+ * Return value: a new #MateColorSelection
+ **/
+GtkWidget *
+mate_color_selection_new (void)
+{
+  MateColorSelection *colorsel;
+  ColorSelectionPrivate *priv;
+  gdouble color[4];
+  color[0] = 1.0;
+  color[1] = 1.0;
+  color[2] = 1.0;
+  color[3] = 1.0;
+  
+  colorsel = g_object_new (MATE_TYPE_COLOR_SELECTION, NULL);
+  priv = colorsel->private_data;
+  set_color_internal (colorsel, color);
+  mate_color_selection_set_has_opacity_control (colorsel, TRUE);
+  
+  /* We want to make sure that default_set is FALSE */
+  /* This way the user can still set it */
+  priv->default_set = FALSE;
+  priv->default_alpha_set = FALSE;
+  
+  return GTK_WIDGET (colorsel);
+}
+
+
+void
+mate_color_selection_set_update_policy (MateColorSelection *colorsel,
+				       GtkUpdateType      policy)
+{
+  g_return_if_fail (MATE_IS_COLOR_SELECTION (colorsel));
+}
+
+/**
+ * mate_color_selection_get_has_opacity_control:
+ * @colorsel: a #MateColorSelection.
+ * 
+ * Determines whether the colorsel has an opacity control.
+ * 
+ * Return value: %TRUE if the @colorsel has an opacity control.  %FALSE if it does't.
+ **/
+gboolean
+mate_color_selection_get_has_opacity_control (MateColorSelection *colorsel)
+{
+  ColorSelectionPrivate *priv;
+  
+  g_return_val_if_fail (MATE_IS_COLOR_SELECTION (colorsel), FALSE);
+  
+  priv = colorsel->private_data;
+  
+  return priv->has_opacity;
+}
+
+/**
+ * mate_color_selection_set_has_opacity_control:
+ * @colorsel: a #MateColorSelection.
+ * @has_opacity: %TRUE if @colorsel can set the opacity, %FALSE otherwise.
+ *
+ * Sets the @colorsel to use or not use opacity.
+ * 
+ **/
+void
+mate_color_selection_set_has_opacity_control (MateColorSelection *colorsel,
+					     gboolean           has_opacity)
+{
+  ColorSelectionPrivate *priv;
+  
+  g_return_if_fail (MATE_IS_COLOR_SELECTION (colorsel));
+  
+  priv = colorsel->private_data;
+  has_opacity = has_opacity != FALSE;
+  
+  if (priv->has_opacity != has_opacity)
+    {
+      priv->has_opacity = has_opacity;
+      if (has_opacity)
+	{
+	  gtk_widget_show (priv->opacity_slider);
+	  gtk_widget_show (priv->opacity_label);
+	  gtk_widget_show (priv->opacity_entry);
+	}
+      else
+	{
+	  gtk_widget_hide (priv->opacity_slider);
+	  gtk_widget_hide (priv->opacity_label);
+	  gtk_widget_hide (priv->opacity_entry);
+	}
+      color_sample_update_samples (colorsel);
+      
+      g_object_notify (G_OBJECT (colorsel), "has-opacity-control");
+    }
+}
+
+/**
+ * mate_color_selection_get_has_palette:
+ * @colorsel: a #MateColorSelection.
+ * 
+ * Determines whether the color selector has a color palette.
+ * 
+ * Return value: %TRUE if the selector has a palette.  %FALSE if it hasn't.
+ **/
+gboolean
+mate_color_selection_get_has_palette (MateColorSelection *colorsel)
+{
+  ColorSelectionPrivate *priv;
+  
+  g_return_val_if_fail (MATE_IS_COLOR_SELECTION (colorsel), FALSE);
+  
+  priv = colorsel->private_data;
+  
+  return priv->has_palette;
+}
+
+/**
+ * mate_color_selection_set_has_palette:
+ * @colorsel: a #MateColorSelection.
+ * @has_palette: %TRUE if palette is to be visible, %FALSE otherwise.
+ *
+ * Shows and hides the palette based upon the value of @has_palette.
+ * 
+ **/
+void
+mate_color_selection_set_has_palette (MateColorSelection *colorsel,
+				     gboolean           has_palette)
+{
+  ColorSelectionPrivate *priv;
+  g_return_if_fail (MATE_IS_COLOR_SELECTION (colorsel));
+  
+  priv = colorsel->private_data;
+  has_palette = has_palette != FALSE;
+  
+  if (priv->has_palette != has_palette)
+    {
+      priv->has_palette = has_palette;
+      if (has_palette)
+	gtk_widget_show (priv->palette_frame);
+      else
+	gtk_widget_hide (priv->palette_frame);
+
+      update_tooltips (colorsel);
+
+      g_object_notify (G_OBJECT (colorsel), "has-palette");
+    }
+}
+
+/**
+ * mate_color_selection_set_current_color:
+ * @colorsel: a #MateColorSelection.
+ * @color: A #GdkColor to set the current color with.
+ *
+ * Sets the current color to be @color.  The first time this is called, it will
+ * also set the original color to be @color too.
+ **/
+void
+mate_color_selection_set_current_color (MateColorSelection *colorsel,
+				       const GdkColor    *color)
+{
+  ColorSelectionPrivate *priv;
+  gint i;
+  
+  g_return_if_fail (MATE_IS_COLOR_SELECTION (colorsel));
+  g_return_if_fail (color != NULL);
+
+  priv = colorsel->private_data;
+  priv->changing = TRUE;
+  priv->color[COLORSEL_RED] = SCALE (color->red);
+  priv->color[COLORSEL_GREEN] = SCALE (color->green);
+  priv->color[COLORSEL_BLUE] = SCALE (color->blue);
+  gtk_rgb_to_hsv (priv->color[COLORSEL_RED],
+		  priv->color[COLORSEL_GREEN],
+		  priv->color[COLORSEL_BLUE],
+		  &priv->color[COLORSEL_HUE],
+		  &priv->color[COLORSEL_SATURATION],
+		  &priv->color[COLORSEL_VALUE]);
+  if (priv->default_set == FALSE)
+    {
+      for (i = 0; i < COLORSEL_NUM_CHANNELS; i++)
+	priv->old_color[i] = priv->color[i];
+    }
+  priv->default_set = TRUE;
+  update_color (colorsel);
+}
+
+/**
+ * mate_color_selection_set_current_alpha:
+ * @colorsel: a #MateColorSelection.
+ * @alpha: an integer between 0 and 65535.
+ *
+ * Sets the current opacity to be @alpha.  The first time this is called, it will
+ * also set the original opacity to be @alpha too.
+ **/
+void
+mate_color_selection_set_current_alpha (MateColorSelection *colorsel,
+				       guint16            alpha)
+{
+  ColorSelectionPrivate *priv;
+  gint i;
+  
+  g_return_if_fail (MATE_IS_COLOR_SELECTION (colorsel));
+  
+  priv = colorsel->private_data;
+  priv->changing = TRUE;
+  priv->color[COLORSEL_OPACITY] = SCALE (alpha);
+  if (priv->default_alpha_set == FALSE)
+    {
+      for (i = 0; i < COLORSEL_NUM_CHANNELS; i++)
+	priv->old_color[i] = priv->color[i];
+    }
+  priv->default_alpha_set = TRUE;
+  update_color (colorsel);
+}
+
+/**
+ * mate_color_selection_set_color:
+ * @colorsel: a #MateColorSelection.
+ * @color: an array of 4 doubles specifying the red, green, blue and opacity 
+ *   to set the current color to.
+ *
+ * Sets the current color to be @color.  The first time this is called, it will
+ * also set the original color to be @color too.
+ *
+ * Deprecated: 2.0: Use mate_color_selection_set_current_color() instead.
+ **/
+void
+mate_color_selection_set_color (MateColorSelection    *colorsel,
+			       gdouble              *color)
+{
+  g_return_if_fail (MATE_IS_COLOR_SELECTION (colorsel));
+
+  set_color_internal (colorsel, color);
+}
+
+/**
+ * mate_color_selection_get_current_color:
+ * @colorsel: a #MateColorSelection.
+ * @color: (out): a #GdkColor to fill in with the current color.
+ *
+ * Sets @color to be the current color in the MateColorSelection widget.
+ **/
+void
+mate_color_selection_get_current_color (MateColorSelection *colorsel,
+				       GdkColor          *color)
+{
+  ColorSelectionPrivate *priv;
+  
+  g_return_if_fail (MATE_IS_COLOR_SELECTION (colorsel));
+  g_return_if_fail (color != NULL);
+  
+  priv = colorsel->private_data;
+  color->red = UNSCALE (priv->color[COLORSEL_RED]);
+  color->green = UNSCALE (priv->color[COLORSEL_GREEN]);
+  color->blue = UNSCALE (priv->color[COLORSEL_BLUE]);
+}
+
+/**
+ * mate_color_selection_get_current_alpha:
+ * @colorsel: a #MateColorSelection.
+ *
+ * Returns the current alpha value.
+ *
+ * Return value: an integer between 0 and 65535.
+ **/
+guint16
+mate_color_selection_get_current_alpha (MateColorSelection *colorsel)
+{
+  ColorSelectionPrivate *priv;
+  
+  g_return_val_if_fail (MATE_IS_COLOR_SELECTION (colorsel), 0);
+  
+  priv = colorsel->private_data;
+  return priv->has_opacity ? UNSCALE (priv->color[COLORSEL_OPACITY]) : 65535;
+}
+
+/**
+ * mate_color_selection_get_color:
+ * @colorsel: a #MateColorSelection.
+ * @color: an array of 4 #gdouble to fill in with the current color.
+ *
+ * Sets @color to be the current color in the MateColorSelection widget.
+ *
+ * Deprecated: 2.0: Use mate_color_selection_get_current_color() instead.
+ **/
+void
+mate_color_selection_get_color (MateColorSelection *colorsel,
+			       gdouble           *color)
+{
+  ColorSelectionPrivate *priv;
+  
+  g_return_if_fail (MATE_IS_COLOR_SELECTION (colorsel));
+  
+  priv = colorsel->private_data;
+  color[0] = priv->color[COLORSEL_RED];
+  color[1] = priv->color[COLORSEL_GREEN];
+  color[2] = priv->color[COLORSEL_BLUE];
+  color[3] = priv->has_opacity ? priv->color[COLORSEL_OPACITY] : 65535;
+}
+
+/**
+ * mate_color_selection_set_previous_color:
+ * @colorsel: a #MateColorSelection.
+ * @color: a #GdkColor to set the previous color with.
+ *
+ * Sets the 'previous' color to be @color.  This function should be called with
+ * some hesitations, as it might seem confusing to have that color change.
+ * Calling mate_color_selection_set_current_color() will also set this color the first
+ * time it is called.
+ **/
+void
+mate_color_selection_set_previous_color (MateColorSelection *colorsel,
+					const GdkColor    *color)
+{
+  ColorSelectionPrivate *priv;
+  
+  g_return_if_fail (MATE_IS_COLOR_SELECTION (colorsel));
+  g_return_if_fail (color != NULL);
+  
+  priv = colorsel->private_data;
+  priv->changing = TRUE;
+  priv->old_color[COLORSEL_RED] = SCALE (color->red);
+  priv->old_color[COLORSEL_GREEN] = SCALE (color->green);
+  priv->old_color[COLORSEL_BLUE] = SCALE (color->blue);
+  gtk_rgb_to_hsv (priv->old_color[COLORSEL_RED],
+		  priv->old_color[COLORSEL_GREEN],
+		  priv->old_color[COLORSEL_BLUE],
+		  &priv->old_color[COLORSEL_HUE],
+		  &priv->old_color[COLORSEL_SATURATION],
+		  &priv->old_color[COLORSEL_VALUE]);
+  color_sample_update_samples (colorsel);
+  priv->default_set = TRUE;
+  priv->changing = FALSE;
+}
+
+/**
+ * mate_color_selection_set_previous_alpha:
+ * @colorsel: a #MateColorSelection.
+ * @alpha: an integer between 0 and 65535.
+ *
+ * Sets the 'previous' alpha to be @alpha.  This function should be called with
+ * some hesitations, as it might seem confusing to have that alpha change.
+ **/
+void
+mate_color_selection_set_previous_alpha (MateColorSelection *colorsel,
+					guint16            alpha)
+{
+  ColorSelectionPrivate *priv;
+  
+  g_return_if_fail (MATE_IS_COLOR_SELECTION (colorsel));
+  
+  priv = colorsel->private_data;
+  priv->changing = TRUE;
+  priv->old_color[COLORSEL_OPACITY] = SCALE (alpha);
+  color_sample_update_samples (colorsel);
+  priv->default_alpha_set = TRUE;
+  priv->changing = FALSE;
+}
+
+
+/**
+ * mate_color_selection_get_previous_color:
+ * @colorsel: a #MateColorSelection.
+ * @color: (out): a #GdkColor to fill in with the original color value.
+ *
+ * Fills @color in with the original color value.
+ **/
+void
+mate_color_selection_get_previous_color (MateColorSelection *colorsel,
+					GdkColor           *color)
+{
+  ColorSelectionPrivate *priv;
+  
+  g_return_if_fail (MATE_IS_COLOR_SELECTION (colorsel));
+  g_return_if_fail (color != NULL);
+  
+  priv = colorsel->private_data;
+  color->red = UNSCALE (priv->old_color[COLORSEL_RED]);
+  color->green = UNSCALE (priv->old_color[COLORSEL_GREEN]);
+  color->blue = UNSCALE (priv->old_color[COLORSEL_BLUE]);
+}
+
+/**
+ * mate_color_selection_get_previous_alpha:
+ * @colorsel: a #MateColorSelection.
+ *
+ * Returns the previous alpha value.
+ *
+ * Return value: an integer between 0 and 65535.
+ **/
+guint16
+mate_color_selection_get_previous_alpha (MateColorSelection *colorsel)
+{
+  ColorSelectionPrivate *priv;
+  
+  g_return_val_if_fail (MATE_IS_COLOR_SELECTION (colorsel), 0);
+  
+  priv = colorsel->private_data;
+  return priv->has_opacity ? UNSCALE (priv->old_color[COLORSEL_OPACITY]) : 65535;
+}
+
+/**
+ * mate_color_selection_set_palette_color:
+ * @colorsel: a #MateColorSelection.
+ * @index: the color index of the palette.
+ * @color: A #GdkColor to set the palette with.
+ *
+ * Sets the palette located at @index to have @color as its color.
+ * 
+ **/
+static void
+mate_color_selection_set_palette_color (MateColorSelection   *colorsel,
+				       gint                 index,
+				       GdkColor            *color)
+{
+  ColorSelectionPrivate *priv;
+  gint x, y;
+  gdouble col[3];
+  
+  g_return_if_fail (MATE_IS_COLOR_SELECTION (colorsel));
+  g_return_if_fail (index >= 0  && index < GTK_CUSTOM_PALETTE_WIDTH*GTK_CUSTOM_PALETTE_HEIGHT);
+
+  x = index % GTK_CUSTOM_PALETTE_WIDTH;
+  y = index / GTK_CUSTOM_PALETTE_WIDTH;
+  
+  priv = colorsel->private_data;
+  col[0] = SCALE (color->red);
+  col[1] = SCALE (color->green);
+  col[2] = SCALE (color->blue);
+  
+  palette_set_color (priv->custom_palette[x][y], colorsel, col);
+}
+
+/**
+ * mate_color_selection_is_adjusting:
+ * @colorsel: a #MateColorSelection.
+ *
+ * Gets the current state of the @colorsel.
+ *
+ * Return value: %TRUE if the user is currently dragging a color around, and %FALSE
+ * if the selection has stopped.
+ **/
+gboolean
+mate_color_selection_is_adjusting (MateColorSelection *colorsel)
+{
+  ColorSelectionPrivate *priv;
+  
+  g_return_val_if_fail (MATE_IS_COLOR_SELECTION (colorsel), FALSE);
+  
+  priv = colorsel->private_data;
+  
+  return (gtk_hsv_is_adjusting (GTK_HSV (priv->triangle_colorsel)));
+}
+
+
+/**
+ * mate_color_selection_palette_from_string:
+ * @str: a string encoding a color palette.
+ * @colors: (out) (array length=n_colors): return location for allocated
+ *          array of #GdkColor.
+ * @n_colors: return location for length of array.
+ * 
+ * Parses a color palette string; the string is a colon-separated
+ * list of color names readable by gdk_color_parse().
+ * 
+ * Return value: %TRUE if a palette was successfully parsed.
+ **/
+gboolean
+mate_color_selection_palette_from_string (const gchar *str,
+                                         GdkColor   **colors,
+                                         gint        *n_colors)
+{
+  GdkColor *retval;
+  gint count;
+  gchar *p;
+  gchar *start;
+  gchar *copy;
+  
+  count = 0;
+  retval = NULL;
+  copy = g_strdup (str);
+
+  start = copy;
+  p = copy;
+  while (TRUE)
+    {
+      if (*p == ':' || *p == '\0')
+        {
+          gboolean done = TRUE;
+
+          if (start == p)
+            {
+              goto failed; /* empty entry */
+            }
+              
+          if (*p)
+            {
+              *p = '\0';
+              done = FALSE;
+            }
+
+          retval = g_renew (GdkColor, retval, count + 1);
+          if (!gdk_color_parse (start, retval + count))
+            {
+              goto failed;
+            }
+
+          ++count;
+
+          if (done)
+            break;
+          else
+            start = p + 1;
+        }
+
+      ++p;
+    }
+
+  g_free (copy);
+  
+  if (colors)
+    *colors = retval;
+  else
+    g_free (retval);
+
+  if (n_colors)
+    *n_colors = count;
+
+  return TRUE;
+  
+ failed:
+  g_free (copy);
+  g_free (retval);
+
+  if (colors)
+    *colors = NULL;
+  if (n_colors)
+    *n_colors = 0;
+
+  return FALSE;
+}
+
+/**
+ * mate_color_selection_palette_to_string:
+ * @colors: (array length=n_colors): an array of colors.
+ * @n_colors: length of the array.
+ * 
+ * Encodes a palette as a string, useful for persistent storage.
+ * 
+ * Return value: allocated string encoding the palette.
+ **/
+gchar*
+mate_color_selection_palette_to_string (const GdkColor *colors,
+                                       gint            n_colors)
+{
+  gint i;
+  gchar **strs = NULL;
+  gchar *retval;
+  
+  if (n_colors == 0)
+    return g_strdup ("");
+
+  strs = g_new0 (gchar*, n_colors + 1);
+
+  i = 0;
+  while (i < n_colors)
+    {
+      gchar *ptr;
+      
+      strs[i] =
+        g_strdup_printf ("#%2X%2X%2X",
+                         colors[i].red / 256,
+                         colors[i].green / 256,
+                         colors[i].blue / 256);
+
+      for (ptr = strs[i]; *ptr; ptr++)
+        if (*ptr == ' ')
+          *ptr = '0';
+      
+      ++i;
+    }
+
+  retval = g_strjoinv (":", strs);
+
+  g_strfreev (strs);
+
+  return retval;
+}
+
+/**
+ * mate_color_selection_set_change_palette_hook:
+ * @func: a function to call when the custom palette needs saving.
+ * 
+ * Installs a global function to be called whenever the user tries to
+ * modify the palette in a color selection. This function should save
+ * the new palette contents, and update the GtkSettings property
+ * "gtk-color-palette" so all MateColorSelection widgets will be modified.
+ *
+ * Return value: the previous change palette hook (that was replaced).
+ *
+ * Deprecated: 2.4: This function does not work in multihead environments.
+ *     Use mate_color_selection_set_change_palette_with_screen_hook() instead. 
+ * 
+ **/
+MateColorSelectionChangePaletteFunc
+mate_color_selection_set_change_palette_hook (MateColorSelectionChangePaletteFunc func)
+{
+  MateColorSelectionChangePaletteFunc old;
+
+  old = noscreen_change_palette_hook;
+
+  noscreen_change_palette_hook = func;
+
+  return old;
+}
+
+/**
+ * mate_color_selection_set_change_palette_with_screen_hook:
+ * @func: a function to call when the custom palette needs saving.
+ * 
+ * Installs a global function to be called whenever the user tries to
+ * modify the palette in a color selection. This function should save
+ * the new palette contents, and update the GtkSettings property
+ * "gtk-color-palette" so all MateColorSelection widgets will be modified.
+ * 
+ * Return value: the previous change palette hook (that was replaced).
+ *
+ * Since: 2.2
+ **/
+MateColorSelectionChangePaletteWithScreenFunc
+mate_color_selection_set_change_palette_with_screen_hook (MateColorSelectionChangePaletteWithScreenFunc func)
+{
+  MateColorSelectionChangePaletteWithScreenFunc old;
+
+  old = change_palette_hook;
+
+  change_palette_hook = func;
+
+  return old;
+}
+
+static void
+make_control_relations (AtkObject *atk_obj,
+                        GtkWidget *widget)
+{
+  AtkObject *obj;
+
+  obj = gtk_widget_get_accessible (widget);
+  atk_object_add_relationship (atk_obj, ATK_RELATION_CONTROLLED_BY, obj);
+  atk_object_add_relationship (obj, ATK_RELATION_CONTROLLER_FOR, atk_obj);
+}
+
+static void
+make_all_relations (AtkObject *atk_obj,
+                    ColorSelectionPrivate *priv)
+{
+  make_control_relations (atk_obj, priv->hue_spinbutton);
+  make_control_relations (atk_obj, priv->sat_spinbutton);
+  make_control_relations (atk_obj, priv->val_spinbutton);
+  make_control_relations (atk_obj, priv->red_spinbutton);
+  make_control_relations (atk_obj, priv->green_spinbutton);
+  make_control_relations (atk_obj, priv->blue_spinbutton);
+}
+
+
diff --git a/libmate-desktop/mate-colorsel.h b/libmate-desktop/mate-colorsel.h
new file mode 100644
index 0000000..d292eb4
--- /dev/null
+++ b/libmate-desktop/mate-colorsel.h
@@ -0,0 +1,130 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2000 Red Hat, Inc.
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * 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 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+#ifndef __MATE_COLOR_SELECTION_H__
+#define __MATE_COLOR_SELECTION_H__
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define MATE_TYPE_COLOR_SELECTION			(mate_color_selection_get_type ())
+#define MATE_COLOR_SELECTION(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), MATE_TYPE_COLOR_SELECTION, MateColorSelection))
+#define MATE_COLOR_SELECTION_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST ((klass), MATE_TYPE_COLOR_SELECTION, MateColorSelectionClass))
+#define MATE_IS_COLOR_SELECTION(obj)			(G_TYPE_CHECK_INSTANCE_TYPE ((obj), MATE_TYPE_COLOR_SELECTION))
+#define MATE_IS_COLOR_SELECTION_CLASS(klass)		(G_TYPE_CHECK_CLASS_TYPE ((klass), MATE_TYPE_COLOR_SELECTION))
+#define MATE_COLOR_SELECTION_GET_CLASS(obj)              (G_TYPE_INSTANCE_GET_CLASS ((obj), MATE_TYPE_COLOR_SELECTION, MateColorSelectionClass))
+
+
+typedef struct _MateColorSelection       MateColorSelection;
+typedef struct _MateColorSelectionClass  MateColorSelectionClass;
+
+
+typedef void (* MateColorSelectionChangePaletteFunc) (const GdkColor    *colors,
+                                                     gint               n_colors);
+typedef void (* MateColorSelectionChangePaletteWithScreenFunc) (GdkScreen         *screen,
+							       const GdkColor    *colors,
+							       gint               n_colors);
+
+struct _MateColorSelection
+{
+  GtkVBox parent_instance;
+
+  /* < private_data > */
+  gpointer GSEAL (private_data);
+};
+
+struct _MateColorSelectionClass
+{
+  GtkVBoxClass parent_class;
+
+  void (*color_changed)	(MateColorSelection *color_selection);
+
+  /* Padding for future expansion */
+  void (*_gtk_reserved1) (void);
+  void (*_gtk_reserved2) (void);
+  void (*_gtk_reserved3) (void);
+  void (*_gtk_reserved4) (void);
+};
+
+
+/* ColorSelection */
+
+GType      mate_color_selection_get_type                (void) G_GNUC_CONST;
+GtkWidget *mate_color_selection_new                     (void);
+gboolean   mate_color_selection_get_has_opacity_control (MateColorSelection *colorsel);
+void       mate_color_selection_set_has_opacity_control (MateColorSelection *colorsel,
+							gboolean           has_opacity);
+gboolean   mate_color_selection_get_has_palette         (MateColorSelection *colorsel);
+void       mate_color_selection_set_has_palette         (MateColorSelection *colorsel,
+							gboolean           has_palette);
+
+
+void     mate_color_selection_set_current_color   (MateColorSelection *colorsel,
+						  const GdkColor    *color);
+void     mate_color_selection_set_current_alpha   (MateColorSelection *colorsel,
+						  guint16            alpha);
+void     mate_color_selection_get_current_color   (MateColorSelection *colorsel,
+						  GdkColor          *color);
+guint16  mate_color_selection_get_current_alpha   (MateColorSelection *colorsel);
+void     mate_color_selection_set_previous_color  (MateColorSelection *colorsel,
+						  const GdkColor    *color);
+void     mate_color_selection_set_previous_alpha  (MateColorSelection *colorsel,
+						  guint16            alpha);
+void     mate_color_selection_get_previous_color  (MateColorSelection *colorsel,
+						  GdkColor          *color);
+guint16  mate_color_selection_get_previous_alpha  (MateColorSelection *colorsel);
+
+gboolean mate_color_selection_is_adjusting        (MateColorSelection *colorsel);
+
+gboolean mate_color_selection_palette_from_string (const gchar       *str,
+                                                  GdkColor         **colors,
+                                                  gint              *n_colors);
+gchar*   mate_color_selection_palette_to_string   (const GdkColor    *colors,
+                                                  gint               n_colors);
+
+#ifndef GTK_DISABLE_DEPRECATED
+#ifndef GDK_MULTIHEAD_SAFE
+MateColorSelectionChangePaletteFunc           mate_color_selection_set_change_palette_hook             (MateColorSelectionChangePaletteFunc           func);
+#endif
+#endif
+
+MateColorSelectionChangePaletteWithScreenFunc mate_color_selection_set_change_palette_with_screen_hook (MateColorSelectionChangePaletteWithScreenFunc func);
+
+#ifndef GTK_DISABLE_DEPRECATED
+/* Deprecated calls: */
+void mate_color_selection_set_color         (MateColorSelection *colorsel,
+					    gdouble           *color);
+void mate_color_selection_get_color         (MateColorSelection *colorsel,
+					    gdouble           *color);
+void mate_color_selection_set_update_policy (MateColorSelection *colorsel,
+					    GtkUpdateType      policy);
+#endif /* GTK_DISABLE_DEPRECATED */
+
+G_END_DECLS
+
+#endif /* __MATE_COLOR_SELECTION_H__ */
diff --git a/libmate-desktop/mate-colorseldialog.c b/libmate-desktop/mate-colorseldialog.c
new file mode 100644
index 0000000..6758602
--- /dev/null
+++ b/libmate-desktop/mate-colorseldialog.c
@@ -0,0 +1,228 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * 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 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+#include "config.h"
+#include "private.h"
+#include <string.h>
+#include <glib.h>
+#include <gtk/gtk.h>
+#include <glib/gi18n-lib.h>
+#include "mate-colorsel.h"
+#include "mate-colorseldialog.h"
+
+enum {
+  PROP_0,
+  PROP_COLOR_SELECTION,
+  PROP_OK_BUTTON,
+  PROP_CANCEL_BUTTON,
+  PROP_HELP_BUTTON
+};
+
+
+/***************************/
+/* MateColorSelectionDialog */
+/***************************/
+
+static void mate_color_selection_dialog_buildable_interface_init     (GtkBuildableIface *iface);
+static GObject * mate_color_selection_dialog_buildable_get_internal_child (GtkBuildable *buildable,
+									  GtkBuilder   *builder,
+									  const gchar  *childname);
+
+G_DEFINE_TYPE_WITH_CODE (MateColorSelectionDialog, mate_color_selection_dialog,
+           GTK_TYPE_DIALOG,
+           G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
+                      mate_color_selection_dialog_buildable_interface_init))
+
+static GtkBuildableIface *parent_buildable_iface;
+
+static void
+mate_color_selection_dialog_get_property (GObject         *object,
+					 guint            prop_id,
+					 GValue          *value,
+					 GParamSpec      *pspec)
+{
+  MateColorSelectionDialog *colorsel;
+
+  colorsel = MATE_COLOR_SELECTION_DIALOG (object);
+
+  switch (prop_id)
+    {
+    case PROP_COLOR_SELECTION:
+      g_value_set_object (value, colorsel->colorsel);
+      break;
+    case PROP_OK_BUTTON:
+      g_value_set_object (value, colorsel->ok_button);
+      break;
+    case PROP_CANCEL_BUTTON:
+      g_value_set_object (value, colorsel->cancel_button);
+      break;
+    case PROP_HELP_BUTTON:
+      g_value_set_object (value, colorsel->help_button);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+mate_color_selection_dialog_class_init (MateColorSelectionDialogClass *klass)
+{
+  GObjectClass   *gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->get_property = mate_color_selection_dialog_get_property;
+
+  g_object_class_install_property (gobject_class,
+				   PROP_COLOR_SELECTION,
+				   g_param_spec_object ("color-selection",
+						     _("Color Selection"),
+						     _("The color selection embedded in the dialog."),
+						     GTK_TYPE_WIDGET,
+						     G_PARAM_READABLE));
+  g_object_class_install_property (gobject_class,
+				   PROP_OK_BUTTON,
+				   g_param_spec_object ("ok-button",
+						     _("OK Button"),
+						     _("The OK button of the dialog."),
+						     GTK_TYPE_WIDGET,
+						     G_PARAM_READABLE));
+  g_object_class_install_property (gobject_class,
+				   PROP_CANCEL_BUTTON,
+				   g_param_spec_object ("cancel-button",
+						     _("Cancel Button"),
+						     _("The cancel button of the dialog."),
+						     GTK_TYPE_WIDGET,
+						     G_PARAM_READABLE));
+  g_object_class_install_property (gobject_class,
+				   PROP_HELP_BUTTON,
+				   g_param_spec_object ("help-button",
+						     _("Help Button"),
+						     _("The help button of the dialog."),
+						     GTK_TYPE_WIDGET,
+						     G_PARAM_READABLE));
+}
+
+static void
+mate_color_selection_dialog_init (MateColorSelectionDialog *colorseldiag)
+{
+  GtkDialog *dialog = GTK_DIALOG (colorseldiag);
+
+  _mate_desktop_init_i18n ();
+
+  gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
+  gtk_box_set_spacing (GTK_BOX (dialog->vbox), 2); /* 2 * 5 + 2 = 12 */
+  gtk_container_set_border_width (GTK_CONTAINER (dialog->action_area), 5);
+  gtk_box_set_spacing (GTK_BOX (dialog->action_area), 6);
+
+  colorseldiag->colorsel = mate_color_selection_new ();
+  gtk_container_set_border_width (GTK_CONTAINER (colorseldiag->colorsel), 5);
+  mate_color_selection_set_has_palette (MATE_COLOR_SELECTION(colorseldiag->colorsel), FALSE); 
+  mate_color_selection_set_has_opacity_control (MATE_COLOR_SELECTION(colorseldiag->colorsel), FALSE);
+  gtk_container_add (GTK_CONTAINER (GTK_DIALOG (colorseldiag)->vbox), colorseldiag->colorsel);
+  gtk_widget_show (colorseldiag->colorsel);
+  
+  colorseldiag->cancel_button = gtk_dialog_add_button (GTK_DIALOG (colorseldiag),
+                                                       GTK_STOCK_CANCEL,
+                                                       GTK_RESPONSE_CANCEL);
+
+  colorseldiag->ok_button = gtk_dialog_add_button (GTK_DIALOG (colorseldiag),
+                                                   GTK_STOCK_OK,
+                                                   GTK_RESPONSE_OK);
+                                                   
+  gtk_widget_grab_default (colorseldiag->ok_button);
+  
+  colorseldiag->help_button = gtk_dialog_add_button (GTK_DIALOG (colorseldiag),
+                                                     GTK_STOCK_HELP,
+                                                     GTK_RESPONSE_HELP);
+
+  gtk_widget_hide (colorseldiag->help_button);
+
+  gtk_dialog_set_alternative_button_order (GTK_DIALOG (colorseldiag),
+					   GTK_RESPONSE_OK,
+					   GTK_RESPONSE_CANCEL,
+					   GTK_RESPONSE_HELP,
+					   -1);
+
+  gtk_window_set_title (GTK_WINDOW (colorseldiag),
+                        _("Color Selection"));
+
+  //_gtk_dialog_set_ignore_separator (dialog, TRUE);
+}
+
+GtkWidget*
+mate_color_selection_dialog_new (const gchar *title)
+{
+  MateColorSelectionDialog *colorseldiag;
+  
+  colorseldiag = g_object_new (MATE_TYPE_COLOR_SELECTION_DIALOG, NULL);
+
+  if (title)
+    gtk_window_set_title (GTK_WINDOW (colorseldiag), title);
+
+  gtk_window_set_resizable (GTK_WINDOW (colorseldiag), FALSE);
+  
+  return GTK_WIDGET (colorseldiag);
+}
+
+/**
+ * mate_color_selection_dialog_get_color_selection:
+ * @colorsel: a #MateColorSelectionDialog
+ *
+ * Retrieves the #MateColorSelection widget embedded in the dialog.
+ *
+ * Returns: (transfer none): the embedded #MateColorSelection
+ *
+ * Since: 2.14
+ **/
+GtkWidget*
+mate_color_selection_dialog_get_color_selection (MateColorSelectionDialog *colorsel)
+{
+  g_return_val_if_fail (MATE_IS_COLOR_SELECTION_DIALOG (colorsel), NULL);
+
+  return colorsel->colorsel;
+}
+
+static void
+mate_color_selection_dialog_buildable_interface_init (GtkBuildableIface *iface)
+{
+  parent_buildable_iface = g_type_interface_peek_parent (iface);
+  iface->get_internal_child = mate_color_selection_dialog_buildable_get_internal_child;
+}
+
+static GObject *
+mate_color_selection_dialog_buildable_get_internal_child (GtkBuildable *buildable,
+							 GtkBuilder   *builder,
+							 const gchar  *childname)
+{
+    if (strcmp(childname, "ok_button") == 0)
+	return G_OBJECT (MATE_COLOR_SELECTION_DIALOG (buildable)->ok_button);
+    else if (strcmp(childname, "cancel_button") == 0)
+	return G_OBJECT (MATE_COLOR_SELECTION_DIALOG (buildable)->cancel_button);
+    else if (strcmp(childname, "help_button") == 0)
+	return G_OBJECT (MATE_COLOR_SELECTION_DIALOG(buildable)->help_button);
+    else if (strcmp(childname, "color_selection") == 0)
+	return G_OBJECT (MATE_COLOR_SELECTION_DIALOG(buildable)->colorsel);
+
+    return parent_buildable_iface->get_internal_child (buildable, builder, childname);
+}
diff --git a/libmate-desktop/mate-colorseldialog.h b/libmate-desktop/mate-colorseldialog.h
new file mode 100644
index 0000000..d5fbdee
--- /dev/null
+++ b/libmate-desktop/mate-colorseldialog.h
@@ -0,0 +1,76 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * 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 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+#ifndef __MATE_COLOR_SELECTION_DIALOG_H__
+#define __MATE_COLOR_SELECTION_DIALOG_H__
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define MATE_TYPE_COLOR_SELECTION_DIALOG            (mate_color_selection_dialog_get_type ())
+#define MATE_COLOR_SELECTION_DIALOG(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), MATE_TYPE_COLOR_SELECTION_DIALOG, MateColorSelectionDialog))
+#define MATE_COLOR_SELECTION_DIALOG_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), MATE_TYPE_COLOR_SELECTION_DIALOG, MateColorSelectionDialogClass))
+#define MATE_IS_COLOR_SELECTION_DIALOG(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MATE_TYPE_COLOR_SELECTION_DIALOG))
+#define MATE_IS_COLOR_SELECTION_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MATE_TYPE_COLOR_SELECTION_DIALOG))
+#define MATE_COLOR_SELECTION_DIALOG_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), MATE_TYPE_COLOR_SELECTION_DIALOG, MateColorSelectionDialogClass))
+
+
+typedef struct _MateColorSelectionDialog       MateColorSelectionDialog;
+typedef struct _MateColorSelectionDialogClass  MateColorSelectionDialogClass;
+
+
+struct _MateColorSelectionDialog
+{
+  GtkDialog parent_instance;
+
+  GtkWidget *GSEAL (colorsel);
+  GtkWidget *GSEAL (ok_button);
+  GtkWidget *GSEAL (cancel_button);
+  GtkWidget *GSEAL (help_button);
+};
+
+struct _MateColorSelectionDialogClass
+{
+  GtkDialogClass parent_class;
+
+  /* Padding for future expansion */
+  void (*_gtk_reserved1) (void);
+  void (*_gtk_reserved2) (void);
+  void (*_gtk_reserved3) (void);
+  void (*_gtk_reserved4) (void);
+};
+
+
+/* ColorSelectionDialog */
+GType      mate_color_selection_dialog_get_type            (void) G_GNUC_CONST;
+GtkWidget* mate_color_selection_dialog_new                 (const gchar *title);
+GtkWidget* mate_color_selection_dialog_get_color_selection (MateColorSelectionDialog *colorsel);
+
+
+G_END_DECLS
+
+#endif /* __MATE_COLOR_SELECTION_DIALOG_H__ */