* 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 Library General Public
+ * 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
- * Library General Public License for more details.
+ * Lesser General Public License for more details.
*
- * You should have received a copy of the GNU Library General Public
+ * 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-1999. See the AUTHORS
+ * 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 "x11/gdkx.h"
+#include <config.h>
+#include "gdkconfig.h"
+#include <math.h>
+
#include "gdk/gdkkeysyms.h"
#include "gtkcolorsel.h"
#include "gtkhsv.h"
#include "gtkselection.h"
#include "gtkdnd.h"
#include "gtkdrawingarea.h"
-#include "gtksignal.h"
#include "gtkhbox.h"
#include "gtkhbbox.h"
#include "gtkrc.h"
#include "gtkframe.h"
#include "gtktable.h"
#include "gtklabel.h"
-#include "gtkpixmap.h"
+#include "gtkmarshalers.h"
+#include "gtkimage.h"
#include "gtkspinbutton.h"
#include "gtkrange.h"
#include "gtkhscale.h"
#include "gtkentry.h"
#include "gtkbutton.h"
#include "gtkhseparator.h"
+#include "gtktooltips.h"
+#include "gtkinvisible.h"
+#include "gtkmenuitem.h"
+#include "gtkmain.h"
+#include "gtksettings.h"
+#include "gtkimage.h"
+#include "gtkstock.h"
+#include "gtkaccessible.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
+#include "gtkalias.h"
+
+#include <string.h>
+
+/* Number of elements in the custom palatte */
+#define GTK_CUSTOM_PALETTE_WIDTH 10
+#define GTK_CUSTOM_PALETTE_HEIGHT 2
+
+/* 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))
+
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,
struct _ColorSelectionPrivate
{
- guint use_opacity : 1;
- guint use_palette : 1;
+ guint has_opacity : 1;
+ guint has_palette : 1;
guint changing : 1;
guint default_set : 1;
-
- /* The color dropper */
- guint moving_dropper : 1;
+ guint default_alpha_set : 1;
gdouble color[COLORSEL_NUM_CHANNELS];
gdouble old_color[COLORSEL_NUM_CHANNELS];
/* The Palette code */
GtkWidget *custom_palette [GTK_CUSTOM_PALETTE_WIDTH][GTK_CUSTOM_PALETTE_HEIGHT];
- GtkWidget *last_palette;
/* The color_sample stuff */
GtkWidget *sample_area;
GtkWidget *old_sample;
GtkWidget *cur_sample;
GtkWidget *colorsel;
+
+ /* Tooltips group */
+ GtkTooltips *tooltips;
+
+ /* Window for grabbing on */
+ GtkWidget *dropper_grab_widget;
+
+ /* Connection to settings */
+ gulong settings_connection;
};
static void gtk_color_selection_init (GtkColorSelection *colorsel);
static void gtk_color_selection_class_init (GtkColorSelectionClass *klass);
static void gtk_color_selection_destroy (GtkObject *object);
+static void gtk_color_selection_finalize (GObject *object);
static void update_color (GtkColorSelection *colorsel);
+static void gtk_color_selection_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void gtk_color_selection_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
+
+static void gtk_color_selection_realize (GtkWidget *widget);
+static void gtk_color_selection_unrealize (GtkWidget *widget);
+static void gtk_color_selection_show_all (GtkWidget *widget);
+
+static void gtk_color_selection_set_palette_color (GtkColorSelection *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 gpointer parent_class = NULL;
static guint color_selection_signals[LAST_SIGNAL] = { 0 };
+static const gchar default_colors[] = "black:white:gray50:red:purple:blue:light blue:green:yellow:orange:lavender:brown:goldenrod4:dodger blue:pink:light green:gray10:gray30:gray75:gray90";
+
+static GtkColorSelectionChangePaletteFunc noscreen_change_palette_hook = default_noscreen_change_palette_func;
+static GtkColorSelectionChangePaletteWithScreenFunc change_palette_hook = default_change_palette_func;
/* The cursor for the dropper */
#define DROPPER_WIDTH 17
#define DROPPER_Y_HOT 16
-static char dropper_bits[] = {
+static const guchar dropper_bits[] = {
0xff, 0x8f, 0x01, 0xff, 0x77, 0x01, 0xff, 0xfb, 0x00, 0xff, 0xf8, 0x00,
0x7f, 0xff, 0x00, 0xff, 0x7e, 0x01, 0xff, 0x9d, 0x01, 0xff, 0xd8, 0x01,
0x7f, 0xd4, 0x01, 0x3f, 0xee, 0x01, 0x1f, 0xff, 0x01, 0x8f, 0xff, 0x01,
0xc7, 0xff, 0x01, 0xe3, 0xff, 0x01, 0xf3, 0xff, 0x01, 0xfd, 0xff, 0x01,
0xff, 0xff, 0x01, };
-static char dropper_mask[] = {
+static const guchar dropper_mask[] = {
0x00, 0x70, 0x00, 0x00, 0xf8, 0x00, 0x00, 0xfc, 0x01, 0x00, 0xff, 0x01,
0x80, 0xff, 0x01, 0x00, 0xff, 0x00, 0x00, 0x7f, 0x00, 0x80, 0x3f, 0x00,
0xc0, 0x3f, 0x00, 0xe0, 0x13, 0x00, 0xf0, 0x01, 0x00, 0xf8, 0x00, 0x00,
0x7c, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x0d, 0x00, 0x00,
0x02, 0x00, 0x00, };
-static GdkCursor *picker_cursor = NULL;
-
-
-/* XPM */
-static char *picker[] = {
- /* columns rows colors chars-per-pixel */
- "25 25 8 1",
- " c Gray0",
- ". c #020202",
- "X c Gray12",
- "o c Gray13",
- "O c Gray52",
- "+ c #929292",
- "@ c Gray100",
- "# c None",
- /* pixels */
- "#########################",
- "#########################",
- "#########################",
- "#########################",
- "#########################",
- "################# #####",
- "################ ####",
- "################ +###",
- "############# +###",
- "############## ++###",
- "#############+@ +++####",
- "############+@@@ +######",
- "###########+@@@ + +######",
- "##########+@@@ ++#+######",
- "#########+@@@ ++#########",
- "########+@@@ ++##########",
- "#######+@@@ ++###########",
- "######+@@@ ++############",
- "######+@@ ++#############",
- "#####+@ ++##############",
- "###### +++###############",
- "#########################",
- "#########################",
- "#########################",
- "#########################"
-};
-
/*
*
#define SAMPLE_HEIGHT 28
static void color_sample_draw_sample (GtkColorSelection *colorsel, int which);
-static void color_sample_draw_samples (GtkColorSelection *colorsel);
+static void color_sample_update_samples (GtkColorSelection *colorsel);
+
+static void
+set_color_internal (GtkColorSelection *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,
{
GtkColorSelection *colorsel = data;
ColorSelectionPrivate *priv;
- GtkWidget *window;
- gdouble colors[4];
gdouble *colsrc;
- GdkColor bg;
- gint n, i;
-
- priv = colorsel->private;
- window = gtk_window_new (GTK_WINDOW_POPUP);
- gtk_widget_set_app_paintable (GTK_WIDGET (window), TRUE);
- gtk_widget_set_usize (window, 48, 32);
- gtk_widget_realize (window);
- gtk_object_set_data_full (GTK_OBJECT (widget),
- "gtk-color-selection-drag-window",
- window,
- (GtkDestroyNotify) gtk_widget_destroy);
+
+ priv = colorsel->private_data;
if (widget == priv->old_sample)
colsrc = priv->old_color;
else
colsrc = priv->color;
-
- for (i=0, n = COLORSEL_RED; n <= COLORSEL_BLUE; n++)
- {
- colors[i++] = colsrc[n];
- }
-
- if (priv->use_opacity)
- {
- colors[i] = colsrc[COLORSEL_OPACITY];
- }
-
- bg.red = 0xffff * colors[0];
- bg.green = 0xffff * colors[1];
- bg.blue = 0xffff * colors[2];
-
- gdk_color_alloc (gtk_widget_get_colormap (window), &bg);
- gdk_window_set_background (window->window, &bg);
-
- gtk_drag_set_icon_widget (context, window, -2, -2);
+
+ set_color_icon (context, colsrc);
}
static void
GdkDragContext *context,
gpointer data)
{
- gtk_object_set_data (GTK_OBJECT (widget), "gtk-color-selection-drag-window", NULL);
+ g_object_set_data (G_OBJECT (widget), "gtk-color-selection-drag-window", NULL);
}
static void
ColorSelectionPrivate *priv;
guint16 *vals;
gdouble color[4];
- priv = colorsel->private;
+ priv = colorsel->private_data;
/* This is currently a guint16 array of the format:
* R
if (selection_data->length < 0)
return;
- if ((selection_data->format != 16) ||
- (selection_data->length != 8))
+ /* 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;
color[2] = (gdouble)vals[2] / 0xffff;
color[3] = (gdouble)vals[3] / 0xffff;
- gtk_color_selection_set_color (colorsel, color);
+ set_color_internal (colorsel, color);
}
}
guint16 vals[4];
gdouble *colsrc;
- priv = colorsel->private;
+ priv = colorsel->private_data;
if (widget == priv->old_sample)
colsrc = priv->old_color;
vals[0] = colsrc[COLORSEL_RED] * 0xffff;
vals[1] = colsrc[COLORSEL_GREEN] * 0xffff;
vals[2] = colsrc[COLORSEL_BLUE] * 0xffff;
- vals[3] = priv->use_opacity ? colsrc[COLORSEL_OPACITY] * 0xffff : 0xffff;
+ vals[3] = priv->has_opacity ? colsrc[COLORSEL_OPACITY] * 0xffff : 0xffff;
gtk_selection_data_set (selection_data,
gdk_atom_intern ("application/x-color", FALSE),
color_sample_draw_sample (GtkColorSelection *colorsel, int which)
{
GtkWidget *da;
- gint x, y, i, wid, heig, f, n, goff;
- guchar c[3 * 2], cc[3 * 4], *cp = c;
- gdouble o;
- guchar *buf;
+ gint x, y, wid, heig, goff;
ColorSelectionPrivate *priv;
+ cairo_t *cr;
g_return_if_fail (colorsel != NULL);
- priv = colorsel->private;
+ priv = colorsel->private_data;
g_return_if_fail (priv->sample_area != NULL);
if (!GTK_WIDGET_DRAWABLE (priv->sample_area))
return;
-
+
if (which == 0)
{
da = priv->old_sample;
- for (n = 0, i = COLORSEL_RED; n < 3; n++, i++)
- c[n] = (guchar) (255.0 * priv->old_color[i]);
goff = 0;
}
else
{
da = priv->cur_sample;
- for (n = 0, i = COLORSEL_RED; n < 3; n++, i++)
- c[n] = (guchar) (255.0 * priv->color[i]);
goff = priv->old_sample->allocation.width % 32;
}
+
+ cr = gdk_drawable_create_cairo_context (da->window);
wid = da->allocation.width;
heig = da->allocation.height;
+
+ /* Below needs tweaking for non-power-of-two */
+#define CHECK_SIZE 16
- buf = g_new(guchar, 3 * wid * heig);
-
-#if 0
- i = COLORSEL_RED;
- for (n = 0; n < 3; n++)
+ if (priv->has_opacity)
{
- c[n] = (guchar) (255.0 * priv->old_color[i]);
- c[n + 3] = (guchar) (255.0 * priv->color[i++]);
+ /* 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);
}
-#endif
-
- if (priv->use_opacity)
+
+ if (which == 0)
{
- o = (which) ? priv->color[COLORSEL_OPACITY] : priv->old_color[COLORSEL_OPACITY];
-
- for (n = 0; n < 3; n++)
- {
- cc[n] = (guchar) ((1.0 - o) * 192 + (o * (gdouble) c[n]));
- cc[n + 3] = (guchar) ((1.0 - o) * 128 + (o * (gdouble) c[n]));
- }
- cp = cc;
+ if (priv->has_opacity)
+ 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);
}
-
- i = 0;
- for (y = 0; y < heig; y++)
+ else
{
- for (x = 0; x < wid; x++)
- {
- if (priv->use_opacity)
- f = 3 * ((((goff + x) % 32) < 16) ^ ((y % 32) < 16));
- else
- f = 0;
-
- for (n = 0; n < 3; n++)
- buf[i++] = cp[n + f];
- }
+ if (priv->has_opacity)
+ 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);
}
-
- gdk_draw_rgb_image(da->window,
- da->style->black_gc,
- 0, 0,
- wid, heig,
- GDK_RGB_DITHER_NORMAL,
- buf,
- 3*wid);
-
-
- g_free (buf);
+
+ cairo_rectangle (cr, 0, 0, wid, heig);
+ cairo_fill (cr);
+
+ cairo_destroy (cr);
}
static void
-color_sample_draw_samples (GtkColorSelection *colorsel)
+color_sample_update_samples (GtkColorSelection *colorsel)
{
- color_sample_draw_sample (colorsel, 0);
- color_sample_draw_sample (colorsel, 1);
+ ColorSelectionPrivate *priv = colorsel->private_data;
+ gtk_widget_queue_draw (priv->old_sample);
+ gtk_widget_queue_draw (priv->cur_sample);
}
-static void
-color_old_sample_expose(GtkWidget* da, GdkEventExpose* event, GtkColorSelection *colorsel)
+static gboolean
+color_old_sample_expose (GtkWidget *da,
+ GdkEventExpose *event,
+ GtkColorSelection *colorsel)
{
color_sample_draw_sample (colorsel, 0);
+ return FALSE;
}
-static void
-color_cur_sample_expose(GtkWidget* da, GdkEventExpose* event, GtkColorSelection *colorsel)
+static gboolean
+color_cur_sample_expose (GtkWidget *da,
+ GdkEventExpose *event,
+ GtkColorSelection *colorsel)
{
color_sample_draw_sample (colorsel, 1);
+ return FALSE;
}
static void
{ "application/x-color", 0 }
};
ColorSelectionPrivate *priv;
- priv = colorsel->private;
+ priv = colorsel->private_data;
gtk_drag_source_set (sample,
GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
targets, 1,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
- gtk_signal_connect (GTK_OBJECT (sample),
- "drag_begin",
- GTK_SIGNAL_FUNC (color_sample_drag_begin),
- colorsel);
+ g_signal_connect (sample,
+ "drag_begin",
+ G_CALLBACK (color_sample_drag_begin),
+ colorsel);
if (sample == priv->cur_sample)
{
targets, 1,
GDK_ACTION_COPY);
- gtk_signal_connect (GTK_OBJECT (sample),
- "drag_end",
- GTK_SIGNAL_FUNC (color_sample_drag_end),
- colorsel);
+ g_signal_connect (sample,
+ "drag_end",
+ G_CALLBACK (color_sample_drag_end),
+ colorsel);
}
- gtk_signal_connect (GTK_OBJECT (sample),
- "drag_data_get",
- GTK_SIGNAL_FUNC (color_sample_drag_handle),
- colorsel);
- gtk_signal_connect (GTK_OBJECT (sample),
- "drag_data_received",
- GTK_SIGNAL_FUNC (color_sample_drop_handle),
- 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);
}
{
ColorSelectionPrivate *priv;
- priv = colorsel->private;
-
- gtk_widget_push_visual(gdk_rgb_get_visual());
- gtk_widget_push_colormap(gdk_rgb_get_cmap());
+ 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 ();
+
+ /* We need enter/leave to do tooltips */
+ gtk_widget_add_events (priv->old_sample,
+ GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
+ gtk_widget_add_events (priv->cur_sample,
+ GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
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);
- gtk_widget_pop_visual();
- gtk_widget_pop_colormap();
- gtk_signal_connect(GTK_OBJECT (priv->old_sample), "expose_event",
- GTK_SIGNAL_FUNC (color_old_sample_expose),
- colorsel);
- gtk_signal_connect(GTK_OBJECT (priv->cur_sample), "expose_event",
- GTK_SIGNAL_FUNC (color_cur_sample_expose),
- colorsel);
+ 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);
+
+ gtk_tooltips_set_tip (priv->tooltips,
+ 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."), NULL);
+
+
+ gtk_tooltips_set_tip (priv->tooltips,
+ 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."), NULL);
gtk_widget_show_all (priv->sample_area);
}
* The palette area code
*
*/
-#define CUSTOM_PALETTE_ENTRY_WIDTH 18
-#define CUSTOM_PALETTE_ENTRY_HEIGHT 18
+#define CUSTOM_PALETTE_ENTRY_WIDTH 20
+#define CUSTOM_PALETTE_ENTRY_HEIGHT 20
static void
palette_get_color (GtkWidget *drawing_area, gdouble *color)
g_return_if_fail (color != NULL);
- color_val = gtk_object_get_data (GTK_OBJECT (drawing_area), "color_val");
+ color_val = g_object_get_data (G_OBJECT (drawing_area), "color_val");
if (color_val == NULL)
{
/* Default to white for no good reason */
GdkRectangle *area,
gpointer data)
{
+ cairo_t *cr;
+ gint focus_width;
+
if (drawing_area->window == NULL)
return;
-
- gdk_window_clear_area (drawing_area->window,
- area->x,
- area->y,
- area->width,
- area->height);
+
+ cr = gdk_drawable_create_cairo_context (drawing_area->window);
+
+ gdk_cairo_set_source_color (cr, &drawing_area->style->bg[GTK_STATE_NORMAL]);
+ cairo_rectangle (cr,
+ area->x, area->y, area->width, area->height);
+ cairo_fill (cr);
if (GTK_WIDGET_HAS_FOCUS (drawing_area))
{
- GdkGC *gc;
- gdouble color[4];
-
- palette_get_color (drawing_area, color);
-
- if (INTENSITY (color[0], color[1], color[2]) > 0.5)
- gc = drawing_area->style->black_gc;
- else
- gc = drawing_area->style->white_gc;
-
- gdk_draw_rectangle (drawing_area->window,
- gc, FALSE, 0, 0,
- drawing_area->allocation.width - 1,
- drawing_area->allocation.height - 1);
+ set_focus_line_attributes (drawing_area, cr, &focus_width);
+ g_print ("%g %g %g %g\n",
+ focus_width / 2., focus_width / 2.,
+ (double)drawing_area->allocation.width - focus_width,
+ (double)drawing_area->allocation.height - 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);
}
-}
-static void
-palette_expose (GtkWidget *drawing_area,
- GdkEventExpose *event,
- gpointer data)
-{
- if (drawing_area->window == NULL)
- return;
-
- palette_paint (drawing_area, &(event->area), data);
+ cairo_destroy (cr);
}
static void
-palette_focus_in (GtkWidget *drawing_area,
- GdkEventFocus *event,
- gpointer data)
+set_focus_line_attributes (GtkWidget *drawing_area,
+ cairo_t *cr,
+ gint *focus_width)
{
- ColorSelectionPrivate *priv;
-
- if (drawing_area->window == NULL)
- return;
-
- priv = GTK_COLOR_SELECTION (data)->private;
- priv->last_palette = drawing_area;
- GTK_WIDGET_SET_FLAGS (drawing_area, GTK_HAS_FOCUS);
+ gdouble color[4];
+ gint8 *dash_list;
- gtk_widget_queue_clear_area (drawing_area, 0, 0, drawing_area->allocation.x, drawing_area->allocation.y);
-}
+ gtk_widget_style_get (drawing_area,
+ "focus-line-width", focus_width,
+ "focus-line-pattern", (gchar *)&dash_list,
+ NULL);
+
+ palette_get_color (drawing_area, color);
-static void
-palette_focus_out (GtkWidget *drawing_area,
- GdkEventFocus *event,
- gpointer data)
-{
- GTK_WIDGET_UNSET_FLAGS (drawing_area, GTK_HAS_FOCUS);
- gtk_widget_queue_clear_area (drawing_area, 0, 0, drawing_area->allocation.x, drawing_area->allocation.y);
-}
+ 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.);
-static void
-palette_press (GtkWidget *drawing_area,
- GdkEventButton *event,
- gpointer data)
-{
- gtk_widget_grab_focus (drawing_area);
- if (GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (drawing_area), "color_set")) != 0)
+ cairo_set_line_width (cr, *focus_width);
+
+ if (dash_list[0])
{
- gdouble color[4];
- palette_get_color (drawing_area, color);
- gtk_color_selection_set_color (GTK_COLOR_SELECTION (data), color);
- }
-}
+ gint n_dashes = strlen (dash_list);
+ gdouble *dashes = g_new (gdouble, n_dashes);
+ gdouble total_length = 0;
+ gdouble dash_offset;
+ gint i;
-static void
-palette_draw (GtkWidget *drawing_area,
- GdkRectangle *area,
- gpointer data)
-{
- palette_paint (drawing_area, area, data);
-}
+ for (i = 0; i < n_dashes; i++)
+ {
+ dashes[i] = dash_list[i];
+ total_length += dash_list[i];
+ }
-static void
-palette_unset_color (GtkWidget *drawing_area)
-{
- if (GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (drawing_area), "color_set")) == 0)
- return;
-
- gtk_widget_reset_rc_styles (drawing_area);
- gtk_object_set_data (GTK_OBJECT (drawing_area), "color_set", GINT_TO_POINTER (0));
+ /* 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
GdkDragContext *context,
gpointer data)
{
- GtkColorSelection *colorsel = data;
- ColorSelectionPrivate *priv;
- GtkWidget *window;
gdouble colors[4];
- GdkColor bg;
-
- priv = colorsel->private;
- window = gtk_window_new (GTK_WINDOW_POPUP);
- gtk_widget_set_app_paintable (GTK_WIDGET (window), TRUE);
- gtk_widget_set_usize (window, 48, 32);
- gtk_widget_realize (window);
- gtk_object_set_data_full (GTK_OBJECT (widget),
- "gtk-color-selection-drag-window",
- window,
- (GtkDestroyNotify) gtk_widget_destroy);
palette_get_color (widget, colors);
- bg.red = 0xffff * colors[0];
- bg.green = 0xffff * colors[1];
- bg.blue = 0xffff * colors[2];
-
- gdk_color_alloc (gtk_widget_get_colormap (window), &bg);
- gdk_window_set_background (window->window, &bg);
-
- gtk_drag_set_icon_widget (context, window, -2, -2);
+ set_color_icon (context, colors);
}
static void
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 (GtkColorSelection *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 (!gtk_color_selection_palette_from_string (palette, &colors, &n_colors))
+ {
+ gtk_color_selection_palette_from_string (default_colors, &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;
+
+ gtk_color_selection_palette_from_string (default_colors, &colors, &n_colors);
+ memcpy (colors, tmp_colors, sizeof (GdkColor) * tmp_n_colors);
+
+ g_free (tmp_colors);
+ }
+ }
+
+ 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,
+ GtkColorSelection *colorsel,
+ gdouble *color)
+{
+ gint x, y;
+ ColorSelectionPrivate *priv;
+ GdkColor gdk_color;
+ GdkColor *current_colors;
+ GdkScreen *screen;
+
+ g_return_if_fail (GTK_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]);
+
+ 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 ("gtk_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,
GtkColorSelection *colorsel,
gdouble *color)
{
- GtkRcStyle *rc_style;
gdouble *new_color = g_new (double, 4);
- gdouble *old_color;
+ GdkColor gdk_color;
- rc_style = gtk_rc_style_new ();
- rc_style->bg[GTK_STATE_NORMAL].red = color[0]*65535;
- rc_style->bg[GTK_STATE_NORMAL].green = color[1]*65535;
- rc_style->bg[GTK_STATE_NORMAL].blue = color[2]*65535;
- rc_style->color_flags[GTK_STATE_NORMAL] = GTK_RC_BG;
- gtk_rc_style_ref (rc_style);
- gtk_widget_modify_style (drawing_area, rc_style);
+ 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 (gtk_object_get_data (GTK_OBJECT (drawing_area), "color_set")) == 0)
+ if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (drawing_area), "color_set")) == 0)
{
static const GtkTargetEntry targets[] = {
{ "application/x-color", 0 }
targets, 1,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
- gtk_signal_connect (GTK_OBJECT (drawing_area),
- "drag_begin",
- GTK_SIGNAL_FUNC (palette_drag_begin),
- colorsel);
- gtk_signal_connect (GTK_OBJECT (drawing_area),
- "drag_data_get",
- GTK_SIGNAL_FUNC (palette_drag_handle),
- colorsel);
+ 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);
- gtk_object_set_data (GTK_OBJECT (drawing_area), "color_set", GINT_TO_POINTER (1));
- }
- else
- {
- old_color = (gdouble *) gtk_object_get_data (GTK_OBJECT (drawing_area), "color_val");
- if (old_color)
- {
- g_free (old_color);
- }
+ 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;
- gtk_object_set_data (GTK_OBJECT (drawing_area), "color_val", new_color);
+ g_object_set_data_full (G_OBJECT (drawing_area), "color_val", new_color, (GDestroyNotify)g_free);
}
-static void
-palette_drag_end (GtkWidget *widget,
- GdkDragContext *context,
- gpointer data)
+static gboolean
+palette_expose (GtkWidget *drawing_area,
+ GdkEventExpose *event,
+ gpointer data)
{
- gtk_object_set_data (GTK_OBJECT (widget), "gtk-color-selection-drag-window", NULL);
+ if (drawing_area->window == NULL)
+ return FALSE;
+
+ palette_paint (drawing_area, &(event->area), data);
+
+ return FALSE;
}
static void
-palette_drop_handle (GtkWidget *widget,
- GdkDragContext *context,
- gint x,
- gint y,
- GtkSelectionData *selection_data,
- guint info,
- guint time,
- gpointer data)
+popup_position_func (GtkMenu *menu,
+ gint *x,
+ gint *y,
+ gboolean *push_in,
+ gpointer user_data)
{
- guint16 *vals;
- gdouble color[4];
-
- if (selection_data->length < 0)
- return;
+ GtkWidget *widget;
+ GtkRequisition req;
+ gint root_x, root_y;
+ GdkScreen *screen;
- if ((selection_data->format != 16) ||
- (selection_data->length != 8))
- {
- g_warning ("Received invalid color data\n");
- return;
- }
+ widget = GTK_WIDGET (user_data);
- vals = (guint16 *)selection_data->data;
+ g_return_if_fail (GTK_WIDGET_REALIZED (widget));
+
+ gdk_window_get_origin (widget->window, &root_x, &root_y);
- 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_set_color (widget, GTK_COLOR_SELECTION (data), color);
- gtk_color_selection_set_color (GTK_COLOR_SELECTION (data), color);
+ 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 gint
-palette_activate (GtkWidget *widget,
- GdkEventKey *event,
- gpointer data)
+static void
+save_color_selected (GtkWidget *menuitem,
+ gpointer data)
{
- GtkColorSelection *colorsel = data;
+ GtkColorSelection *colorsel;
+ GtkWidget *drawing_area;
ColorSelectionPrivate *priv;
+
+ drawing_area = GTK_WIDGET (data);
- if ((event->keyval == ' ') || (event->keyval == GDK_Return))
- {
- priv = colorsel->private;
- palette_set_color (widget, GTK_COLOR_SELECTION (data), priv->color);
- }
+ colorsel = GTK_COLOR_SELECTION (g_object_get_data (G_OBJECT (drawing_area),
+ "gtk-color-sel"));
+
+ priv = colorsel->private_data;
- return TRUE;
+ palette_change_color (drawing_area, colorsel, priv->color);
}
-static GtkWidget*
-palette_new (GtkColorSelection *colorsel)
+static void
+do_popup (GtkColorSelection *colorsel,
+ GtkWidget *drawing_area,
+ guint32 timestamp)
{
- GtkWidget *retval;
+ GtkWidget *menu;
+ GtkWidget *mi;
- static const GtkTargetEntry targets[] = {
- { "application/x-color", 0 }
- };
+ g_object_set_data (G_OBJECT (drawing_area),
+ "gtk-color-sel",
+ colorsel);
- retval = gtk_drawing_area_new ();
- gtk_object_set_data (GTK_OBJECT (retval), "color_set", GINT_TO_POINTER (0));
- gtk_widget_set_events (retval, GDK_BUTTON_PRESS_MASK | GDK_EXPOSURE_MASK);
+ 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;
+}
+
+static gboolean
+palette_press (GtkWidget *drawing_area,
+ GdkEventButton *event,
+ gpointer data)
+{
+ GtkColorSelection *colorsel = GTK_COLOR_SELECTION (data);
+
+ gtk_widget_grab_focus (drawing_area);
+
+ if (event->button == 3 &&
+ event->type == GDK_BUTTON_PRESS)
+ {
+ do_popup (colorsel, drawing_area, event->time);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static gboolean
+palette_release (GtkWidget *drawing_area,
+ GdkEventButton *event,
+ gpointer data)
+{
+ GtkColorSelection *colorsel = GTK_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)
+{
+ GtkColorSelection *colorsel = GTK_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_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 (GTK_COLOR_SELECTION (data), color);
+ }
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static gboolean
+palette_popup (GtkWidget *widget,
+ gpointer data)
+{
+ GtkColorSelection *colorsel = GTK_COLOR_SELECTION (data);
+
+ do_popup (colorsel, widget, GDK_CURRENT_TIME);
+ return TRUE;
+}
+
+
+static GtkWidget*
+palette_new (GtkColorSelection *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_FLAGS (retval, GTK_CAN_FOCUS);
- gtk_signal_connect (GTK_OBJECT (retval), "focus_in_event", palette_focus_in, colorsel);
- gtk_signal_connect (GTK_OBJECT (retval), "focus_out_event", palette_focus_out, colorsel);
- gtk_signal_connect (GTK_OBJECT (retval), "draw", palette_draw, colorsel);
- gtk_signal_connect (GTK_OBJECT (retval), "expose_event", palette_expose, colorsel);
- gtk_signal_connect (GTK_OBJECT (retval), "button_press_event", palette_press, colorsel);
+
+ 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 |
targets, 1,
GDK_ACTION_COPY);
- gtk_signal_connect (GTK_OBJECT (retval), "drag_end", palette_drag_end, NULL);
- gtk_signal_connect (GTK_OBJECT (retval), "drag_data_received", palette_drop_handle, colorsel);
- gtk_signal_connect (GTK_OBJECT (retval), "key_press_event", GTK_SIGNAL_FUNC (palette_activate), colorsel);
-
+ 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_tooltips_set_tip (priv->tooltips,
+ 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.\""),
+ NULL);
return retval;
}
*
*/
-static void
-initialize_cursor (void)
+static GdkCursor *
+make_picker_cursor (GdkScreen *screen)
{
- GdkColor fg, bg;
+ GdkCursor *cursor;
+ GdkColor bg = { 0, 0xffff, 0xffff, 0xffff };
+ GdkColor fg = { 0, 0x0000, 0x0000, 0x0000 };
+ GdkWindow *window = gdk_screen_get_root_window (screen);
GdkPixmap *pixmap =
- gdk_bitmap_create_from_data (NULL,
- dropper_bits,
+ gdk_bitmap_create_from_data (window, (gchar *) dropper_bits,
DROPPER_WIDTH, DROPPER_HEIGHT);
+
GdkPixmap *mask =
- gdk_bitmap_create_from_data (NULL,
- dropper_mask,
+ gdk_bitmap_create_from_data (window, (gchar *) dropper_mask,
DROPPER_WIDTH, DROPPER_HEIGHT);
+
+ cursor = gdk_cursor_new_from_pixmap (pixmap, mask, &fg, &bg,
+ DROPPER_X_HOT, DROPPER_Y_HOT);
- gdk_color_white (gdk_colormap_get_system (), &bg);
- gdk_color_black (gdk_colormap_get_system (), &fg);
-
- picker_cursor = gdk_cursor_new_from_pixmap (pixmap, mask, &fg, &bg, DROPPER_X_HOT ,DROPPER_Y_HOT);
-
- gdk_pixmap_unref (pixmap);
- gdk_pixmap_unref (mask);
-
+ g_object_unref (pixmap);
+ g_object_unref (mask);
+
+ return cursor;
}
static void
-grab_color_at_mouse (GtkWidget *button,
+grab_color_at_mouse (GdkScreen *screen,
gint x_root,
gint y_root,
gpointer data)
{
GdkImage *image;
guint32 pixel;
- GdkVisual *visual;
GtkColorSelection *colorsel = data;
ColorSelectionPrivate *priv;
- GdkColormap *colormap = gdk_colormap_get_system ();
- XColor xcolor;
+ GdkColor color;
+ GdkColormap *colormap = gdk_screen_get_system_colormap (screen);
+ GdkWindow *root_window = gdk_screen_get_root_window (screen);
- priv = colorsel->private;
+ priv = colorsel->private_data;
- image = gdk_image_get (GDK_ROOT_PARENT (), x_root, y_root, 1, 1);
+ image = gdk_drawable_get_image (root_window, x_root, y_root, 1, 1);
pixel = gdk_image_get_pixel (image, 0, 0);
- visual = gdk_colormap_get_visual (colormap);
-
- switch (visual->type) {
- case GDK_VISUAL_DIRECT_COLOR:
- case GDK_VISUAL_TRUE_COLOR:
- priv->color[COLORSEL_RED] = (double)((pixel & visual->red_mask)>>visual->red_shift)/((1<<visual->red_prec) - 1);
- priv->color[COLORSEL_GREEN] = (double)((pixel & visual->green_mask)>>visual->green_shift)/((1<<visual->green_prec) - 1);
- priv->color[COLORSEL_BLUE] = (double)((pixel & visual->blue_mask)>>visual->blue_shift)/((1<<visual->blue_prec) - 1);
- break;
- case GDK_VISUAL_STATIC_GRAY:
- case GDK_VISUAL_GRAYSCALE:
- priv->color[COLORSEL_RED] = (double)pixel/((1<<visual->depth) - 1);
- priv->color[COLORSEL_GREEN] = (double)pixel/((1<<visual->depth) - 1);
- priv->color[COLORSEL_BLUE] = (double)pixel/((1<<visual->depth) - 1);
- break;
- case GDK_VISUAL_STATIC_COLOR:
- xcolor.pixel = pixel;
- XQueryColor (GDK_DISPLAY (), GDK_COLORMAP_XCOLORMAP (colormap), &xcolor);
- priv->color[COLORSEL_RED] = xcolor.red/65535.0;
- priv->color[COLORSEL_GREEN] = xcolor.green/65535.0;
- priv->color[COLORSEL_BLUE] = xcolor.blue/65535.0;
- break;
- case GDK_VISUAL_PSEUDO_COLOR:
- priv->color[COLORSEL_RED] = colormap->colors[pixel].red/(double)0xffffff;
- priv->color[COLORSEL_GREEN] = colormap->colors[pixel].green/(double)0xffffff;
- priv->color[COLORSEL_BLUE] = colormap->colors[pixel].blue/(double)0xffffff;
- break;
- default:
- g_assert_not_reached ();
- break;
- }
+ g_object_unref (image);
+
+ gdk_colormap_query_color (colormap, pixel, &color);
+
+ 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_HUE],
&priv->color[COLORSEL_SATURATION],
&priv->color[COLORSEL_VALUE]);
+
update_color (colorsel);
}
static void
-mouse_motion (GtkWidget *button,
+shutdown_eyedropper (GtkWidget *widget)
+{
+ GtkColorSelection *colorsel;
+ ColorSelectionPrivate *priv;
+ GdkDisplay *display = gtk_widget_get_display (widget);
+ guint32 time = gtk_get_current_event_time ();
+
+ colorsel = GTK_COLOR_SELECTION (widget);
+ priv = colorsel->private_data;
+
+ gdk_display_keyboard_ungrab (display, time);
+ gdk_display_pointer_ungrab (display, time);
+ gtk_grab_remove (priv->dropper_grab_widget);
+}
+
+static void
+mouse_motion (GtkWidget *invisible,
GdkEventMotion *event,
gpointer data)
{
- grab_color_at_mouse (button, event->x_root, event->y_root, data);
+ grab_color_at_mouse (gdk_event_get_screen ((GdkEvent *)event),
+ event->x_root, event->y_root, data);
}
-static void
-mouse_release (GtkWidget *button,
+static gboolean
+mouse_release (GtkWidget *invisible,
GdkEventButton *event,
gpointer data)
{
GtkColorSelection *colorsel = data;
ColorSelectionPrivate *priv;
- priv = colorsel->private;
-
- gtk_signal_disconnect_by_func (GTK_OBJECT (button), mouse_motion, data);
- gtk_signal_disconnect_by_func (GTK_OBJECT (button), mouse_release, data);
+ priv = colorsel->private_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));
- grab_color_at_mouse (button, event->x_root, event->y_root, data);
- gdk_pointer_ungrab (0);
+ 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 void
-mouse_press (GtkWidget *button,
+
+static gboolean mouse_press (GtkWidget *invisible,
+ GdkEventButton *event,
+ gpointer data);
+
+#define BIG_STEP 20
+
+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_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)
{
GtkColorSelection *colorsel = data;
ColorSelectionPrivate *priv;
- priv = colorsel->private;
+ priv = colorsel->private_data;
- gtk_signal_connect (GTK_OBJECT (button), "motion_notify_event", mouse_motion, data);
- gtk_signal_connect (GTK_OBJECT (button), "button_release_event", mouse_release, data);
- gtk_signal_disconnect_by_func (GTK_OBJECT (button), mouse_press, 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)
{
- GtkColorSelection *colorsel = gtk_object_get_data (GTK_OBJECT (button), "COLORSEL");
- ColorSelectionPrivate *priv = colorsel->private;
-
- if (picker_cursor == NULL)
- {
- initialize_cursor ();
- }
+ GtkColorSelection *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;
- /* Why do we do this? Because the "clicked" signal will be emitted after the "button_released"
- signal. We don't want to do this stuff again, though, or else it will get trapped here. So,
- priv->moving_dropper is initialized to FALSE at the initialization of the colorselector,
- it is initialized to true when we start waiting for the user to click the the dropper on a
- color, and whenver it is true when this function starts to execute, we set it to false. */
- if (priv->moving_dropper == FALSE)
+ if (priv->dropper_grab_widget == NULL)
{
- priv->moving_dropper = TRUE;
- gtk_signal_connect (GTK_OBJECT (button), "button_press_event", mouse_press, colorsel);
+ priv->dropper_grab_widget = gtk_invisible_new_for_screen (screen);
+
+ gtk_widget_add_events (priv->dropper_grab_widget,
+ GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK);
- gdk_pointer_grab (button->window,
- FALSE,
- GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK,
- NULL,
- picker_cursor,
- 0);
+ gtk_widget_show (priv->dropper_grab_widget);
}
- else
+
+ if (gdk_keyboard_grab (priv->dropper_grab_widget->window,
+ FALSE,
+ gtk_get_current_event_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,
+ gtk_get_current_event_time ());
+ gdk_cursor_unref (picker_cursor);
+
+ if (grab_status != GDK_GRAB_SUCCESS)
{
- priv->moving_dropper = FALSE;
+ gdk_display_keyboard_ungrab (gtk_widget_get_display (button), GDK_CURRENT_TIME);
+ return;
}
+
+ gtk_grab_add (priv->dropper_grab_widget);
+
+ 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);
}
-void
+static void
hex_changed (GtkWidget *hex_entry,
gpointer data)
{
gchar *text;
colorsel = GTK_COLOR_SELECTION (data);
- priv = colorsel->private;
+ 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/65280.0, 0.0, 1.0);
- priv->color[COLORSEL_GREEN] = CLAMP (color.green/65280.0, 0.0, 1.0);
- priv->color[COLORSEL_BLUE] = CLAMP (color.blue/65280.0, 0.0, 1.0);
+ 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],
g_free (text);
}
-void
+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)
{
ColorSelectionPrivate *priv;
colorsel = GTK_COLOR_SELECTION (data);
- priv = colorsel->private;
+ priv = colorsel->private_data;
if (priv->changing)
return;
update_color (colorsel);
}
-void
+static void
adjustment_changed (GtkAdjustment *adjustment,
gpointer data)
{
GtkColorSelection *colorsel;
ColorSelectionPrivate *priv;
- colorsel = GTK_COLOR_SELECTION (gtk_object_get_data (GTK_OBJECT (adjustment), "COLORSEL"));
- priv = colorsel->private;
+ colorsel = GTK_COLOR_SELECTION (g_object_get_data (G_OBJECT (adjustment), "COLORSEL"));
+ priv = colorsel->private_data;
if (priv->changing)
return;
{
case COLORSEL_SATURATION:
case COLORSEL_VALUE:
- priv->color[GPOINTER_TO_INT (data)] = adjustment->value / 255;
+ 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],
update_color (colorsel);
}
-void
+static void
opacity_entry_changed (GtkWidget *opacity_entry,
gpointer data)
{
gchar *text;
colorsel = GTK_COLOR_SELECTION (data);
- priv = colorsel->private;
+ priv = colorsel->private_data;
if (priv->changing)
return;
g_free (text);
}
-static void
-widget_focus_in (GtkWidget *drawing_area,
- GdkEventFocus *event,
- gpointer data)
-{
- GtkColorSelection *colorsel = GTK_COLOR_SELECTION (data);
- ColorSelectionPrivate *priv = colorsel->private;
-
- /* This signal is connected to by all of the widgets except the "Set Color" button
- * This will let you add a color to the currently selected palette
- */
-
- priv->last_palette = NULL;
-}
-
-
static void
make_label_spinbutton (GtkColorSelection *colorsel,
GtkWidget **spinbutton,
GtkWidget *table,
gint i,
gint j,
- gint channel_type)
+ gint channel_type,
+ const gchar *tooltip)
{
GtkWidget *label;
GtkAdjustment *adjust;
+ ColorSelectionPrivate *priv = colorsel->private_data;
if (channel_type == COLORSEL_HUE)
{
adjust = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 360.0, 1.0, 1.0, 1.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, 1.0));
+ }
else
{
adjust = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 255.0, 1.0, 1.0, 1.0));
}
- gtk_object_set_data (GTK_OBJECT (adjust), "COLORSEL", colorsel);
+ g_object_set_data (G_OBJECT (adjust), "COLORSEL", colorsel);
*spinbutton = gtk_spin_button_new (adjust, 10.0, 0);
- gtk_signal_connect (GTK_OBJECT (*spinbutton), "focus_in_event", widget_focus_in, colorsel);
- gtk_signal_connect (GTK_OBJECT (adjust), "value_changed", adjustment_changed, GINT_TO_POINTER (channel_type));
- label = gtk_label_new (text);
+
+ gtk_tooltips_set_tip (priv->tooltips, *spinbutton, tooltip, NULL);
+
+ 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), 1.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
GtkWidget *frame;
ColorSelectionPrivate *priv;
- priv = colorsel->private;
+ 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_usize (priv->custom_palette[i][j], CUSTOM_PALETTE_ENTRY_WIDTH, CUSTOM_PALETTE_ENTRY_HEIGHT);
+ 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 (GtkColorSelection *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 (GtkColorSelection *colorsel)
{
- ColorSelectionPrivate *priv = colorsel->private;
+ ColorSelectionPrivate *priv = colorsel->private_data;
gchar entryval[12];
gchar opacity_text[32];
gchar *ptr;
priv->changing = TRUE;
- color_sample_draw_samples (colorsel);
+ color_sample_update_samples (colorsel);
gtk_hsv_set_color (GTK_HSV (priv->triangle_colorsel),
priv->color[COLORSEL_HUE],
priv->color[COLORSEL_VALUE]);
gtk_adjustment_set_value (gtk_spin_button_get_adjustment
(GTK_SPIN_BUTTON (priv->hue_spinbutton)),
- priv->color[COLORSEL_HUE] * 360);
+ scale_round (priv->color[COLORSEL_HUE], 360));
gtk_adjustment_set_value (gtk_spin_button_get_adjustment
(GTK_SPIN_BUTTON (priv->sat_spinbutton)),
- priv->color[COLORSEL_SATURATION] * 255);
+ scale_round (priv->color[COLORSEL_SATURATION], 100));
gtk_adjustment_set_value (gtk_spin_button_get_adjustment
(GTK_SPIN_BUTTON (priv->val_spinbutton)),
- priv->color[COLORSEL_VALUE] * 255);
+ scale_round (priv->color[COLORSEL_VALUE], 100));
gtk_adjustment_set_value (gtk_spin_button_get_adjustment
(GTK_SPIN_BUTTON (priv->red_spinbutton)),
- priv->color[COLORSEL_RED] * 255);
+ scale_round (priv->color[COLORSEL_RED], 255));
gtk_adjustment_set_value (gtk_spin_button_get_adjustment
(GTK_SPIN_BUTTON (priv->green_spinbutton)),
- priv->color[COLORSEL_GREEN] * 255);
+ scale_round (priv->color[COLORSEL_GREEN], 255));
gtk_adjustment_set_value (gtk_spin_button_get_adjustment
(GTK_SPIN_BUTTON (priv->blue_spinbutton)),
- priv->color[COLORSEL_BLUE] * 255);
+ scale_round (priv->color[COLORSEL_BLUE], 255));
gtk_adjustment_set_value (gtk_range_get_adjustment
(GTK_RANGE (priv->opacity_slider)),
- priv->color[COLORSEL_OPACITY] * 255);
+ scale_round (priv->color[COLORSEL_OPACITY], 255));
- g_snprintf (opacity_text, 32, "%.0f", 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) (255 * priv->color[COLORSEL_RED]),
- (guint) (255 * priv->color[COLORSEL_GREEN]),
- (guint) (255 * priv->color[COLORSEL_BLUE]));
+ (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
-add_button_pressed (GtkWidget *button,
- GtkColorSelection *colorsel)
+update_palette (GtkColorSelection *colorsel)
{
- ColorSelectionPrivate *priv;
+ GdkColor *current_colors;
gint i, j;
+
+ current_colors = get_current_colors (colorsel);
- priv = colorsel->private;
-
- for (j = 0; j < GTK_CUSTOM_PALETTE_HEIGHT; j++)
+ for (i = 0; i < GTK_CUSTOM_PALETTE_HEIGHT; i++)
{
- for (i = 0; i < GTK_CUSTOM_PALETTE_WIDTH; i++)
+ for (j = 0; j < GTK_CUSTOM_PALETTE_WIDTH; j++)
{
- /* Either last_palette is set and we're on it, or it's an empty palette */
- if ((priv->last_palette && priv->last_palette == priv->custom_palette[i][j]) ||
- ((priv->last_palette == NULL) &&
- (GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (priv->custom_palette[i][j]),
- "color_set")) == 0)))
- {
- palette_set_color (priv->custom_palette[i][j], colorsel, priv->color);
-
- /* forward the selection */
- if ((i == GTK_CUSTOM_PALETTE_WIDTH - 1) && (j == GTK_CUSTOM_PALETTE_HEIGHT - 1))
- gtk_widget_grab_focus (priv->custom_palette[0][0]);
- else if (i == GTK_CUSTOM_PALETTE_WIDTH - 1)
- gtk_widget_grab_focus (priv->custom_palette[0][j + 1]);
- else
- gtk_widget_grab_focus (priv->custom_palette[i + 1][j]);
-
- return;
- }
+ gint index;
+
+ index = i * GTK_CUSTOM_PALETTE_WIDTH + j;
+
+ gtk_color_selection_set_palette_color (colorsel,
+ index,
+ ¤t_colors[index]);
}
}
- /* the palette is totally full. Add to the first one totally arbitrarily */
- palette_set_color (priv->custom_palette[0][0], colorsel, priv->color);
+ g_free (current_colors);
+}
- /* forward the selection */
- gtk_widget_grab_focus (priv->custom_palette[1][0]);
+static void
+palette_change_notify_instance (GObject *object,
+ GParamSpec *pspec,
+ gpointer data)
+{
+ update_palette (GTK_COLOR_SELECTION (data));
}
-GtkType
+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 = gtk_color_selection_palette_to_string (colors, n_colors);
+
+ gtk_settings_set_string_property (gtk_settings_get_for_screen (screen),
+ "gtk-color-palette",
+ str,
+ "gtk_color_selection_palette_to_string");
+
+ g_free (str);
+}
+
+GType
gtk_color_selection_get_type (void)
{
- static GtkType color_selection_type = 0;
+ static GType color_selection_type = 0;
if (!color_selection_type)
{
- static const GtkTypeInfo color_selection_info =
+ static const GTypeInfo color_selection_info =
{
- "GtkColorSelection",
- sizeof (GtkColorSelection),
sizeof (GtkColorSelectionClass),
- (GtkClassInitFunc) gtk_color_selection_class_init,
- (GtkObjectInitFunc) gtk_color_selection_init,
- /* reserved_1 */ NULL,
- /* reserved_2 */ NULL,
- (GtkClassInitFunc) NULL,
+ NULL, /* base_init */
+ NULL, /* base_finalize */
+ (GClassInitFunc) gtk_color_selection_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GtkColorSelection),
+ 0, /* n_preallocs */
+ (GInstanceInitFunc) gtk_color_selection_init,
};
- color_selection_type = gtk_type_unique (GTK_TYPE_VBOX, &color_selection_info);
+ color_selection_type =
+ g_type_register_static (GTK_TYPE_VBOX, "GtkColorSelection",
+ &color_selection_info, 0);
}
return color_selection_type;
static void
gtk_color_selection_class_init (GtkColorSelectionClass *klass)
{
+ GObjectClass *gobject_class;
GtkObjectClass *object_class;
+ GtkWidgetClass *widget_class;
- object_class = (GtkObjectClass*) klass;
-
- parent_class = gtk_type_class (GTK_TYPE_VBOX);
-
- color_selection_signals[COLOR_CHANGED] =
- gtk_signal_new ("color_changed",
- GTK_RUN_FIRST,
- GTK_CLASS_TYPE (object_class),
- GTK_SIGNAL_OFFSET (GtkColorSelectionClass, color_changed),
- gtk_marshal_NONE__NONE,
- GTK_TYPE_NONE, 0);
-
+ gobject_class = G_OBJECT_CLASS (klass);
+ object_class = GTK_OBJECT_CLASS (klass);
+ widget_class = GTK_WIDGET_CLASS (klass);
- gtk_object_class_add_signals (object_class, color_selection_signals, LAST_SIGNAL);
+ parent_class = g_type_class_peek_parent (klass);
object_class->destroy = gtk_color_selection_destroy;
+ gobject_class->finalize = gtk_color_selection_finalize;
+
+ gobject_class->set_property = gtk_color_selection_set_property;
+ gobject_class->get_property = gtk_color_selection_get_property;
+
+ widget_class->realize = gtk_color_selection_realize;
+ widget_class->unrealize = gtk_color_selection_unrealize;
+ widget_class->show_all = gtk_color_selection_show_all;
+
+ g_object_class_install_property (gobject_class,
+ PROP_HAS_OPACITY_CONTROL,
+ g_param_spec_boolean ("has-opacity-control",
+ P_("Has Opacity Control"),
+ P_("Whether the color selector should allow setting opacity"),
+ FALSE,
+ GTK_PARAM_READWRITE));
+ g_object_class_install_property (gobject_class,
+ PROP_HAS_PALETTE,
+ g_param_spec_boolean ("has-palette",
+ P_("Has palette"),
+ P_("Whether a palette should be used"),
+ FALSE,
+ GTK_PARAM_READWRITE));
+ g_object_class_install_property (gobject_class,
+ PROP_CURRENT_COLOR,
+ g_param_spec_boxed ("current-color",
+ P_("Current Color"),
+ P_("The current color"),
+ GDK_TYPE_COLOR,
+ GTK_PARAM_READWRITE));
+ g_object_class_install_property (gobject_class,
+ PROP_CURRENT_ALPHA,
+ g_param_spec_uint ("current-alpha",
+ P_("Current Alpha"),
+ P_("The current opacity value (0 fully transparent, 65535 fully opaque)"),
+ 0, 65535, 65535,
+ GTK_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 (GtkColorSelectionClass, color_changed),
+ NULL, NULL,
+ _gtk_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+
+ gtk_settings_install_property (g_param_spec_string ("gtk-color-palette",
+ P_("Custom palette"),
+ P_("Palette to use in the color selector"),
+ default_colors,
+ GTK_PARAM_READWRITE));
}
/* widget functions */
+
static void
gtk_color_selection_init (GtkColorSelection *colorsel)
{
GtkWidget *top_hbox;
GtkWidget *top_right_vbox;
- GtkWidget *table, *label, *hbox, *frame, *vbox;
+ GtkWidget *table, *label, *hbox, *frame, *vbox, *button;
GtkAdjustment *adjust;
- GdkPixmap *dropper_pixmap;
- GtkWidget *dropper_image;
- GtkWidget *button;
- GdkBitmap *mask = NULL;
+ GtkWidget *picker_image;
gint i, j;
ColorSelectionPrivate *priv;
+ AtkObject *atk_obj;
- priv = colorsel->private = g_new0 (ColorSelectionPrivate, 1);
+ gtk_widget_push_composite_child ();
+
+ priv = colorsel->private_data = g_new0 (ColorSelectionPrivate, 1);
priv->changing = FALSE;
priv->default_set = FALSE;
- priv->last_palette = NULL;
- priv->moving_dropper = FALSE;
+ priv->default_alpha_set = FALSE;
+
+ priv->tooltips = gtk_tooltips_new ();
+ g_object_ref (priv->tooltips);
+ gtk_object_sink (GTK_OBJECT (priv->tooltips));
gtk_box_set_spacing (GTK_BOX (colorsel), 4);
top_hbox = gtk_hbox_new (FALSE, 8);
vbox = gtk_vbox_new (FALSE, 4);
priv->triangle_colorsel = gtk_hsv_new ();
- gtk_signal_connect (GTK_OBJECT (priv->triangle_colorsel), "changed", hsv_changed, colorsel);
+ 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_tooltips_set_tip (priv->tooltips, priv->triangle_colorsel,
+ _("Select the color you want from the outer ring. Select the darkness or lightness of that color using the inner triangle."), NULL);
hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
frame = gtk_frame_new (NULL);
- gtk_widget_set_usize (frame, -1, 30);
+ 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_signal_connect (GTK_OBJECT (button), "focus_in_event", widget_focus_in, colorsel);
+
gtk_widget_set_events (button, GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
- gtk_object_set_data (GTK_OBJECT (button), "COLORSEL", colorsel);
- gtk_signal_connect (GTK_OBJECT (button), "clicked", get_screen_color, NULL);
- dropper_pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL, gtk_widget_get_colormap (button), &mask, NULL, picker);
- dropper_image = gtk_pixmap_new (dropper_pixmap, mask);
- gtk_container_add (GTK_CONTAINER (button), dropper_image);
+ 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_tooltips_set_tip (priv->tooltips,
+ button,
+ _("Click the eyedropper, then click a color anywhere on your screen to select that color."), NULL);
top_right_vbox = gtk_vbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (top_hbox), top_right_vbox, FALSE, FALSE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
- make_label_spinbutton (colorsel, &priv->hue_spinbutton, _("Hue:"), table, 0, 0, COLORSEL_HUE);
- make_label_spinbutton (colorsel, &priv->sat_spinbutton, _("Saturation:"), table, 0, 1, COLORSEL_SATURATION);
- make_label_spinbutton (colorsel, &priv->val_spinbutton, _("Value:"), table, 0, 2, COLORSEL_VALUE);
- make_label_spinbutton (colorsel, &priv->red_spinbutton, _("Red:"), table, 6, 0, COLORSEL_RED);
- make_label_spinbutton (colorsel, &priv->green_spinbutton, _("Green:"), table, 6, 1, COLORSEL_GREEN);
- make_label_spinbutton (colorsel, &priv->blue_spinbutton, _("Blue:"), table, 6, 2, COLORSEL_BLUE);
+ 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 (_("Opacity:"));
+ priv->opacity_label = gtk_label_new_with_mnemonic (_("_Opacity:"));
gtk_misc_set_alignment (GTK_MISC (priv->opacity_label), 1.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));
- gtk_object_set_data (GTK_OBJECT (adjust), "COLORSEL", colorsel);
- priv->opacity_slider = gtk_hscale_new (adjust);
+ g_object_set_data (G_OBJECT (adjust), "COLORSEL", colorsel);
+ priv->opacity_slider = gtk_hscale_new (adjust);
+ gtk_tooltips_set_tip (priv->tooltips,
+ priv->opacity_slider,
+ _("Transparency of the color."), NULL);
+ gtk_label_set_mnemonic_widget (GTK_LABEL (priv->opacity_label),
+ priv->opacity_slider);
gtk_scale_set_draw_value (GTK_SCALE (priv->opacity_slider), FALSE);
- gtk_signal_connect (GTK_OBJECT(adjust), "value_changed", adjustment_changed, GINT_TO_POINTER (COLORSEL_OPACITY));
+ 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_usize (priv->opacity_entry, 40, 0);
- gtk_signal_connect (GTK_OBJECT (priv->opacity_entry), "focus_in_event", widget_focus_in, colorsel);
- gtk_signal_connect (GTK_OBJECT (priv->opacity_entry), "activate", opacity_entry_changed, colorsel);
+ gtk_tooltips_set_tip (priv->tooltips,
+ priv->opacity_entry,
+ _("Transparency of the color."), NULL);
+ 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 (_("Hex Value:"));
+ 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), 1.0, 0.5);
priv->hex_entry = gtk_entry_new ();
- gtk_signal_connect (GTK_OBJECT (priv->hex_entry), "activate", hex_changed, colorsel);
- gtk_widget_set_usize (priv->hex_entry, 75, -1);
- gtk_table_set_col_spacing (GTK_TABLE (table), 3, 25);
+
+ 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_tooltips_set_tip (priv->tooltips,
+ priv->hex_entry,
+ _("You can enter an HTML-style hexadecimal color value, or simply a color name such as 'orange' in this entry."), NULL);
+
+ gtk_entry_set_width_chars (GTK_ENTRY (priv->hex_entry), 7);
+ gtk_table_set_col_spacing (GTK_TABLE (table), 3, 15);
gtk_table_attach_defaults (GTK_TABLE (table), priv->hex_entry, 1, 5, 5, 6);
/* Set up the palette */
make_palette_frame (colorsel, table, i, j);
}
}
- priv->palette_frame = gtk_frame_new (_("Custom Palette"));
+ set_selected_palette (colorsel, 0, 0);
+ priv->palette_frame = gtk_frame_new (NULL);
+ label = gtk_label_new_with_mnemonic (_("_Palette"));
+ gtk_frame_set_label_widget (GTK_FRAME (priv->palette_frame), label);
+
+ 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);
vbox = gtk_vbox_new (FALSE, 4);
gtk_container_add (GTK_CONTAINER (priv->palette_frame), vbox);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
- button = gtk_button_new_with_label (_("Set Color"));
- gtk_signal_connect (GTK_OBJECT (button), "clicked", add_button_pressed, colorsel);
- gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_widget_show_all (top_hbox);
+
+ /* hide unused stuff */
- if (priv->use_opacity == FALSE)
+ 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->use_palette == FALSE)
+ 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 ();
}
static void
gtk_color_selection_destroy (GtkObject *object)
{
GtkColorSelection *cselection = GTK_COLOR_SELECTION (object);
-
- if (cselection->private)
+ ColorSelectionPrivate *priv = cselection->private_data;
+
+ if (priv->dropper_grab_widget)
+ {
+ gtk_widget_destroy (priv->dropper_grab_widget);
+ priv->dropper_grab_widget = NULL;
+ }
+
+ if (priv->tooltips)
{
- g_free (cselection->private);
- cselection->private = NULL;
+ g_object_unref (priv->tooltips);
+ priv->tooltips = NULL;
}
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
+static void
+gtk_color_selection_finalize (GObject *object)
+{
+ GtkColorSelection *cselection = GTK_COLOR_SELECTION (object);
+
+ if (cselection->private_data)
+ {
+ g_free (cselection->private_data);
+ cselection->private_data = NULL;
+ }
+
+ G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gtk_color_selection_realize (GtkWidget *widget)
+{
+ GtkColorSelection *colorsel = GTK_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 (parent_class)->realize (widget);
+}
+
+static void
+gtk_color_selection_unrealize (GtkWidget *widget)
+{
+ GtkColorSelection *colorsel = GTK_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 (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
+gtk_color_selection_show_all (GtkWidget *widget)
+{
+ gtk_widget_show (widget);
+}
/**
* gtk_color_selection_new:
- * @void:
*
* Creates a new GtkColorSelection.
*
- * Return value: The new GtkColorSelection.
+ * Return value: a new #GtkColorSelection
**/
GtkWidget *
gtk_color_selection_new (void)
color[2] = 1.0;
color[3] = 1.0;
- colorsel = gtk_type_new (GTK_TYPE_COLOR_SELECTION);
- priv = colorsel->private;
- gtk_color_selection_set_color (colorsel, color);
- gtk_color_selection_set_use_opacity (colorsel, FALSE);
+ colorsel = g_object_new (GTK_TYPE_COLOR_SELECTION, NULL);
+ priv = colorsel->private_data;
+ set_color_internal (colorsel, color);
+ gtk_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);
}
gtk_color_selection_set_update_policy (GtkColorSelection *colorsel,
GtkUpdateType policy)
{
- g_return_if_fail (colorsel != NULL);
g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
- /* */
- g_warning (G_STRLOC ": This function is deprecated.");
}
/**
- * gtk_color_selection_get_use_opacity:
- * @colorsel: A GtkColorSelection.
+ * gtk_color_selection_get_has_opacity_control:
+ * @colorsel: a #GtkColorSelection.
*
- * Determines whether the colorsel can use opacity.
+ * Determines whether the colorsel has an opacity control.
*
- * Return value: TRUE if the @colorsel uses opacity. FALSE if it does't.
+ * Return value: %TRUE if the @colorsel has an opacity control. %FALSE if it does't.
**/
gboolean
-gtk_color_selection_get_use_opacity (GtkColorSelection *colorsel)
+gtk_color_selection_get_has_opacity_control (GtkColorSelection *colorsel)
{
ColorSelectionPrivate *priv;
- g_return_val_if_fail (colorsel != NULL, FALSE);
g_return_val_if_fail (GTK_IS_COLOR_SELECTION (colorsel), FALSE);
- priv = colorsel->private;
+ priv = colorsel->private_data;
- return priv->use_opacity;
+ return priv->has_opacity;
}
/**
- * gtk_color_selection_set_use_opacity:
- * @colorsel: A GtkColorSelection.
- * @use_opacity: TRUE if @colorsel can set the opacity, FALSE otherwise.
+ * gtk_color_selection_set_has_opacity_control:
+ * @colorsel: a #GtkColorSelection.
+ * @has_opacity: %TRUE if @colorsel can set the opacity, %FALSE otherwise.
*
* Sets the @colorsel to use or not use opacity.
*
**/
void
-gtk_color_selection_set_use_opacity (GtkColorSelection *colorsel,
- gboolean use_opacity)
+gtk_color_selection_set_has_opacity_control (GtkColorSelection *colorsel,
+ gboolean has_opacity)
{
ColorSelectionPrivate *priv;
- g_return_if_fail (colorsel != NULL);
g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
- priv = colorsel->private;
- use_opacity = use_opacity != FALSE;
+ priv = colorsel->private_data;
+ has_opacity = has_opacity != FALSE;
- if (priv->use_opacity != use_opacity)
+ if (priv->has_opacity != has_opacity)
{
- priv->use_opacity = use_opacity;
- if (use_opacity)
+ priv->has_opacity = has_opacity;
+ if (has_opacity)
{
gtk_widget_show (priv->opacity_slider);
gtk_widget_show (priv->opacity_label);
gtk_widget_hide (priv->opacity_label);
gtk_widget_hide (priv->opacity_entry);
}
- color_sample_draw_samples (colorsel);
+ color_sample_update_samples (colorsel);
+
+ g_object_notify (G_OBJECT (colorsel), "has-opacity-control");
}
}
/**
- * gtk_color_selection_get_use_palette:
- * @colorsel: A GtkColorSelection.
+ * gtk_color_selection_get_has_palette:
+ * @colorsel: a #GtkColorSelection.
*
- * Determines whether the palette is used.
+ * Determines whether the color selector has a color palette.
*
- * Return value: TRUE if the palette is used. FALSE if it isn't.
+ * Return value: %TRUE if the selector has a palette. %FALSE if it hasn't.
**/
gboolean
-gtk_color_selection_get_use_palette (GtkColorSelection *colorsel)
+gtk_color_selection_get_has_palette (GtkColorSelection *colorsel)
{
ColorSelectionPrivate *priv;
g_return_val_if_fail (GTK_IS_COLOR_SELECTION (colorsel), FALSE);
- priv = colorsel->private;
+ priv = colorsel->private_data;
- return priv->use_palette;
+ return priv->has_palette;
}
/**
- * gtk_color_selection_set_use_palette:
- * @colorsel: A GtkColorSelection.
- * @use_palette: TRUE if palette is to be visible, FALSE otherwise.
+ * gtk_color_selection_set_has_palette:
+ * @colorsel: a #GtkColorSelection.
+ * @has_palette: %TRUE if palette is to be visible, %FALSE otherwise.
*
- * Shows and hides the palette based upon the value of @use_palette.
+ * Shows and hides the palette based upon the value of @has_palette.
*
**/
void
-gtk_color_selection_set_use_palette (GtkColorSelection *colorsel,
- gboolean use_palette)
+gtk_color_selection_set_has_palette (GtkColorSelection *colorsel,
+ gboolean has_palette)
{
ColorSelectionPrivate *priv;
- g_return_if_fail (colorsel != NULL);
g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
- priv = colorsel->private;
- use_palette = use_palette != FALSE;
+ priv = colorsel->private_data;
+ has_palette = has_palette != FALSE;
- if (priv->use_palette != use_palette)
+ if (priv->has_palette != has_palette)
{
- priv->use_palette = use_palette;
- if (use_palette)
+ priv->has_palette = has_palette;
+ if (has_palette)
gtk_widget_show (priv->palette_frame);
else
gtk_widget_hide (priv->palette_frame);
+
+ g_object_notify (G_OBJECT (colorsel), "has-palette");
}
}
/**
- * gtk_color_selection_set_color:
- * @colorsel: A GtkColorSelection.
- * @color: A color to set the current color with.
+ * gtk_color_selection_set_current_color:
+ * @colorsel: a #GtkColorSelection.
+ * @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
-gtk_color_selection_set_color (GtkColorSelection *colorsel,
- gdouble *color)
+gtk_color_selection_set_current_color (GtkColorSelection *colorsel,
+ const GdkColor *color)
{
ColorSelectionPrivate *priv;
gint i;
+ gboolean previous_changed;
- g_return_if_fail (colorsel != NULL);
g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
-
- priv = colorsel->private;
+ g_return_if_fail (color != NULL);
+
+ 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];
+ 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_VALUE]);
if (priv->default_set == FALSE)
{
+ previous_changed = TRUE;
for (i = 0; i < COLORSEL_NUM_CHANNELS; i++)
priv->old_color[i] = priv->color[i];
}
- update_color (colorsel);
priv->default_set = TRUE;
+ update_color (colorsel);
+}
+
+/**
+ * gtk_color_selection_set_current_alpha:
+ * @colorsel: a #GtkColorSelection.
+ * @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
+gtk_color_selection_set_current_alpha (GtkColorSelection *colorsel,
+ guint16 alpha)
+{
+ ColorSelectionPrivate *priv;
+ gint i;
+
+ g_return_if_fail (GTK_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);
+}
+
+/**
+ * gtk_color_selection_set_color:
+ * @colorsel: a #GtkColorSelection.
+ * @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: Use gtk_color_selection_set_current_color() instead.
+ **/
+void
+gtk_color_selection_set_color (GtkColorSelection *colorsel,
+ gdouble *color)
+{
+ g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
+
+ set_color_internal (colorsel, color);
+}
+
+/**
+ * gtk_color_selection_get_current_color:
+ * @colorsel: a #GtkColorSelection.
+ * @color: a #GdkColor to fill in with the current color.
+ *
+ * Sets @color to be the current color in the GtkColorSelection widget.
+ **/
+void
+gtk_color_selection_get_current_color (GtkColorSelection *colorsel,
+ GdkColor *color)
+{
+ ColorSelectionPrivate *priv;
+
+ g_return_if_fail (GTK_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]);
+}
+
+/**
+ * gtk_color_selection_get_current_alpha:
+ * @colorsel: a #GtkColorSelection.
+ *
+ * Returns the current alpha value.
+ *
+ * Return value: an integer between 0 and 65535.
+ **/
+guint16
+gtk_color_selection_get_current_alpha (GtkColorSelection *colorsel)
+{
+ ColorSelectionPrivate *priv;
+
+ g_return_val_if_fail (GTK_IS_COLOR_SELECTION (colorsel), 0);
+
+ priv = colorsel->private_data;
+ return priv->has_opacity ? UNSCALE (priv->color[COLORSEL_OPACITY]) : 65535;
}
/**
* gtk_color_selection_get_color:
- * @colorsel: A GtkColorSelection.
- * @color: A color to fill in with the current color.
+ * @colorsel: a #GtkColorSelection.
+ * @color: an array of 4 #gdouble to fill in with the current color.
*
* Sets @color to be the current color in the GtkColorSelection widget.
*
+ * This function is deprecated, use gtk_color_selection_get_current_color() instead.
**/
void
gtk_color_selection_get_color (GtkColorSelection *colorsel,
{
ColorSelectionPrivate *priv;
- g_return_if_fail (colorsel != NULL);
g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
- priv = colorsel->private;
+ 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->use_opacity ? priv->color[COLORSEL_OPACITY] : 1.0;
+ color[3] = priv->has_opacity ? priv->color[COLORSEL_OPACITY] : 65535;
}
/**
- * gtk_color_selection_get_old_color:
- * @colorsel: A GtkColorSelection.
- * @color: A color to set the original color with.
+ * gtk_color_selection_set_previous_color:
+ * @colorsel: a #GtkColorSelection.
+ * @color: a #GdkColor to set the previous color with.
*
- * Sets the 'original' color to be @color. This function should be called 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 gtk_color_selection_set_color will also set this color the first
+ * Calling gtk_color_selection_set_current_color() will also set this color the first
* time it is called.
- *
**/
void
-gtk_color_selection_set_old_color (GtkColorSelection *colorsel,
- gdouble *color)
+gtk_color_selection_set_previous_color (GtkColorSelection *colorsel,
+ const GdkColor *color)
{
ColorSelectionPrivate *priv;
- g_return_if_fail (colorsel != NULL);
g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
+ g_return_if_fail (color != NULL);
- priv = colorsel->private;
+ priv = colorsel->private_data;
priv->changing = TRUE;
- priv->old_color[COLORSEL_RED] = color[0];
- priv->old_color[COLORSEL_GREEN] = color[1];
- priv->old_color[COLORSEL_BLUE] = color[2];
- priv->old_color[COLORSEL_OPACITY] = color[3];
+ 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_draw_samples (colorsel);
+ color_sample_update_samples (colorsel);
priv->default_set = TRUE;
+ priv->changing = FALSE;
}
/**
- * gtk_color_selection_get_old_color:
- * @colorsel: A GtkColorSelection.
- * @color: A color to fill in with the original color value.
+ * gtk_color_selection_set_previous_alpha:
+ * @colorsel: a #GtkColorSelection.
+ * @alpha: an integer between 0 and 65535.
*
- * Fills @color in with the original color value.
- *
+ * 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
-gtk_color_selection_get_old_color (GtkColorSelection *colorsel,
- gdouble *color)
+gtk_color_selection_set_previous_alpha (GtkColorSelection *colorsel,
+ guint16 alpha)
{
ColorSelectionPrivate *priv;
- g_return_if_fail (colorsel != NULL);
g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
- priv = colorsel->private;
- color[0] = priv->old_color[COLORSEL_RED];
- color[1] = priv->old_color[COLORSEL_GREEN];
- color[2] = priv->old_color[COLORSEL_BLUE];
- color[3] = priv->use_opacity ? priv->old_color[COLORSEL_OPACITY] : 1.0;
+ 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;
}
+
/**
- * gtk_color_selection_set_palette_color:
- * @colorsel: A GtkColorSelection.
- * @x: The x coordinate of the palette.
- * @y: The y coordinate of the palette.
- * @color: A color to set the palette with.
+ * gtk_color_selection_get_previous_color:
+ * @colorsel: a #GtkColorSelection.
+ * @color: a #GdkColor to fill in with the original color value.
*
- * Set the palette located at (@x, @y) to have @color set as its color.
- *
+ * Fills @color in with the original color value.
**/
void
-gtk_color_selection_set_palette_color (GtkColorSelection *colorsel,
- gint x,
- gint y,
- gdouble *color)
+gtk_color_selection_get_previous_color (GtkColorSelection *colorsel,
+ GdkColor *color)
{
ColorSelectionPrivate *priv;
- g_return_if_fail (colorsel != NULL);
g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
- g_return_if_fail (x >= 0 && y >= 0 && x < GTK_CUSTOM_PALETTE_WIDTH && y < GTK_CUSTOM_PALETTE_HEIGHT);
+ g_return_if_fail (color != NULL);
- priv = colorsel->private;
- palette_set_color (priv->custom_palette[x][y], colorsel, color);
+ 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]);
}
/**
- * gtk_color_selection_get_palette_color:
- * @colorsel: A GtkColorSelection.
- * @x: The x coordinate of the palette.
- * @y: The y coordinate of the palette.
- * @color: A color to fill in with the color value.
- *
- * Set @color to have the color found in the palette located at (@x, @y). If
- * the palette is unset, it will leave the color unset.
- *
- * Return value: TRUE if the palette located at (@x, @y) has a color set. FALSE
- * if it doesn't.
+ * gtk_color_selection_get_previous_alpha:
+ * @colorsel: a #GtkColorSelection.
+ *
+ * Returns the previous alpha value.
+ *
+ * Return value: an integer between 0 and 65535.
**/
-gboolean
-gtk_color_selection_get_palette_color (GtkColorSelection *colorsel,
- gint x,
- gint y,
- gdouble *color)
+guint16
+gtk_color_selection_get_previous_alpha (GtkColorSelection *colorsel)
{
ColorSelectionPrivate *priv;
- g_return_val_if_fail (colorsel != NULL, FALSE);
- g_return_val_if_fail (GTK_IS_COLOR_SELECTION (colorsel), FALSE);
- g_return_val_if_fail (x >= 0 && y >= 0 && x < GTK_CUSTOM_PALETTE_WIDTH && y < GTK_CUSTOM_PALETTE_HEIGHT, FALSE);
-
- priv = colorsel->private;
-
- if (GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (priv->custom_palette[x][y]), "color_set")) == 0)
- return FALSE;
+ g_return_val_if_fail (GTK_IS_COLOR_SELECTION (colorsel), 0);
- palette_get_color (priv->custom_palette[x][y], color);
- return TRUE;
+ priv = colorsel->private_data;
+ return priv->has_opacity ? UNSCALE (priv->old_color[COLORSEL_OPACITY]) : 65535;
}
/**
- * gtk_color_selection_unset_palette_color:
- * @colorsel: A GtkColorSelection.
- * @x: The x coordinate of the palette.
- * @y: The y coordinate of the palette.
+ * gtk_color_selection_set_palette_color:
+ * @colorsel: a #GtkColorSelection.
+ * @index: the color index of the palette.
+ * @color: A #GdkColor to set the palette with.
*
- * Change the palette located at (@x, @y) to have no color set.
+ * Sets the palette located at @index to have @color as its color.
*
**/
-void
-gtk_color_selection_unset_palette_color (GtkColorSelection *colorsel,
- gint x,
- gint y)
+static void
+gtk_color_selection_set_palette_color (GtkColorSelection *colorsel,
+ gint index,
+ GdkColor *color)
{
ColorSelectionPrivate *priv;
+ gint x, y;
+ gdouble col[3];
- g_return_if_fail (colorsel != NULL);
g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
- g_return_if_fail (x >= 0 && y >= 0 && x < GTK_CUSTOM_PALETTE_WIDTH && y < GTK_CUSTOM_PALETTE_HEIGHT);
+ 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;
- palette_unset_color (priv->custom_palette[x][y]);
+ 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);
}
/**
* gtk_color_selection_is_adjusting:
- * @colorsel: A GtkColorSelection.
+ * @colorsel: a #GtkColorSelection.
*
* Gets the current state of the @colorsel.
*
- * Return value: TRUE if the user is currently dragging a color around, and FALSE
+ * Return value: %TRUE if the user is currently dragging a color around, and %FALSE
* if the selection has stopped.
**/
gboolean
{
ColorSelectionPrivate *priv;
- g_return_val_if_fail (colorsel != NULL, FALSE);
g_return_val_if_fail (GTK_IS_COLOR_SELECTION (colorsel), FALSE);
- priv = colorsel->private;
+ priv = colorsel->private_data;
return (gtk_hsv_is_adjusting (GTK_HSV (priv->triangle_colorsel)));
}
+
+static void
+gtk_color_selection_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GtkColorSelection *colorsel = GTK_COLOR_SELECTION (object);
+
+ switch (prop_id)
+ {
+ case PROP_HAS_OPACITY_CONTROL:
+ gtk_color_selection_set_has_opacity_control (colorsel,
+ g_value_get_boolean (value));
+ break;
+ case PROP_HAS_PALETTE:
+ gtk_color_selection_set_has_palette (colorsel,
+ g_value_get_boolean (value));
+ break;
+ case PROP_CURRENT_COLOR:
+ gtk_color_selection_set_current_color (colorsel, g_value_get_boxed (value));
+ break;
+ case PROP_CURRENT_ALPHA:
+ gtk_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
+gtk_color_selection_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GtkColorSelection *colorsel = GTK_COLOR_SELECTION (object);
+ GdkColor color;
+
+ switch (prop_id)
+ {
+ case PROP_HAS_OPACITY_CONTROL:
+ g_value_set_boolean (value, gtk_color_selection_get_has_opacity_control (colorsel));
+ break;
+ case PROP_HAS_PALETTE:
+ g_value_set_boolean (value, gtk_color_selection_get_has_palette (colorsel));
+ break;
+ case PROP_CURRENT_COLOR:
+ gtk_color_selection_get_current_color (colorsel, &color);
+ g_value_set_boxed (value, &color);
+ break;
+ case PROP_CURRENT_ALPHA:
+ g_value_set_uint (value, gtk_color_selection_get_current_alpha (colorsel));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+
+/**
+ * gtk_color_selection_palette_from_string:
+ * @str: a string encoding a color palette.
+ * @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
+gtk_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;
+}
+
+/**
+ * gtk_color_selection_palette_to_string:
+ * @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*
+gtk_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;
+}
+
+/**
+ * gtk_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 GtkColorSelection widgets will be modified.
+ *
+ * Return value: the previous change palette hook (that was replaced).
+ *
+ * Deprecated: This function is deprecated in favor of
+ * gtk_color_selection_set_change_palette_with_screen_hook(), and does
+ * not work in multihead environments.
+ *
+ **/
+GtkColorSelectionChangePaletteFunc
+gtk_color_selection_set_change_palette_hook (GtkColorSelectionChangePaletteFunc func)
+{
+ GtkColorSelectionChangePaletteFunc old;
+
+ old = noscreen_change_palette_hook;
+
+ noscreen_change_palette_hook = func;
+
+ return old;
+}
+
+/**
+ * gtk_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 GtkColorSelection widgets will be modified.
+ *
+ * Return value: the previous change palette hook (that was replaced).
+ *
+ * Since: 2.2
+ **/
+GtkColorSelectionChangePaletteWithScreenFunc
+gtk_color_selection_set_change_palette_with_screen_hook (GtkColorSelectionChangePaletteWithScreenFunc func)
+{
+ GtkColorSelectionChangePaletteWithScreenFunc 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);
+}
+
+#define __GTK_COLOR_SELECTION_C__
+#include "gtkaliasdef.c"
+
projects / ~andy / gtk / blobdiff