Pileus Git - ~andy/gtk/blob - gtk/gtkcolorchooserwidget.c

   1 /* GTK - The GIMP Toolkit
   2  *
   3  * Copyright (C) 2012 Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "config.h"
  20
  21 #include "gtkcolorchooserprivate.h"
  22 #include "gtkcolorchooserwidget.h"
  23 #include "gtkcoloreditorprivate.h"
  24 #include "gtkcolorswatchprivate.h"
  25 #include "gtkbox.h"
  26 #include "gtkgrid.h"
  27 #include "gtklabel.h"
  28 #include "gtkorientable.h"
  29 #include "gtkprivate.h"
  30 #include "gtkintl.h"
  31 #include "gtksizegroup.h"
  32
  33 #include <math.h>
  34
  35 /**
  36  * SECTION:gtkcolorchooserwidget
  37  * @Short_description: A widget for choosing colors
  38  * @Title: GtkColorChooserWidget
  39  * @See_also: #GtkColorChooserDialog
  40  *
  41  * The #GtkColorChooserWidget widget lets the user select a
  42  * color. By default, the chooser presents a prefined palette
  43  * of colors, plus a small number of settable custom colors.
  44  * It is also possible to select a different color with the
  45  * single-color editor. To enter the single-color editing mode,
  46  * use the context menu of any color of the palette, or use the
  47  * '+' button to add a new custom color.
  48  *
  49  * The chooser automatically remembers the last selection, as well
  50  * as custom colors.
  51  *
  52  * To change the initially selected color, use gtk_color_chooser_set_rgba().
  53  * To get the selected font use gtk_color_chooser_get_rgba().
  54  *
  55  * The #GtkColorChooserWidget is used in the #GtkColorChooserDialog
  56  * to provide a dialog for selecting colors.
  57  *
  58  * Since: 3.4
  59  */
  60
  61 struct _GtkColorChooserWidgetPrivate
  62 {
  63   GtkWidget *palette;
  64   GtkWidget *editor;
  65   GtkSizeGroup *size_group;
  66
  67   GtkWidget *custom_label;
  68   GtkWidget *custom;
  69
  70   GtkWidget *button;
  71   GtkColorSwatch *current;
  72
  73   gboolean use_alpha;
  74   gboolean has_default_palette;
  75
  76   GSettings *settings;
  77 };
  78
  79 enum
  80 {
  81   PROP_ZERO,
  82   PROP_RGBA,
  83   PROP_USE_ALPHA,
  84   PROP_SHOW_EDITOR
  85 };
  86
  87 static void gtk_color_chooser_widget_iface_init (GtkColorChooserInterface *iface);
  88
  89 G_DEFINE_TYPE_WITH_CODE (GtkColorChooserWidget, gtk_color_chooser_widget, GTK_TYPE_BOX,
  90                          G_IMPLEMENT_INTERFACE (GTK_TYPE_COLOR_CHOOSER,
  91                                                 gtk_color_chooser_widget_iface_init))
  92
  93 static void
  94 select_swatch (GtkColorChooserWidget *cc,
  95                GtkColorSwatch        *swatch)
  96 {
  97   GdkRGBA color;
  98
  99   if (cc->priv->current == swatch)
 100     return;
 101
 102   if (cc->priv->current != NULL)
 103     gtk_widget_unset_state_flags (GTK_WIDGET (cc->priv->current), GTK_STATE_FLAG_SELECTED);
 104   gtk_widget_set_state_flags (GTK_WIDGET (swatch), GTK_STATE_FLAG_SELECTED, FALSE);
 105   cc->priv->current = swatch;
 106
 107   gtk_color_swatch_get_rgba (swatch, &color);
 108   g_settings_set (cc->priv->settings, "selected-color", "(bdddd)",
 109                   TRUE, color.red, color.green, color.blue, color.alpha);
 110
 111   g_object_notify (G_OBJECT (cc), "rgba");
 112 }
 113
 114 static void
 115 swatch_activate (GtkColorSwatch        *swatch,
 116                  GtkColorChooserWidget *cc)
 117 {
 118   GdkRGBA color;
 119
 120   gtk_color_swatch_get_rgba (swatch, &color);
 121   _gtk_color_chooser_color_activated (GTK_COLOR_CHOOSER (cc), &color);
 122 }
 123
 124 static void
 125 swatch_customize (GtkColorSwatch        *swatch,
 126                   GtkColorChooserWidget *cc)
 127 {
 128   GdkRGBA color;
 129
 130   gtk_color_swatch_get_rgba (swatch, &color);
 131   gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (cc->priv->editor), &color);
 132
 133   gtk_widget_hide (cc->priv->palette);
 134   gtk_widget_show (cc->priv->editor);
 135   g_object_notify (G_OBJECT (cc), "show-editor");
 136 }
 137
 138 static void
 139 swatch_selected (GtkColorSwatch        *swatch,
 140                  GtkStateFlags          previous,
 141                  GtkColorChooserWidget *cc)
 142 {
 143   GtkStateFlags flags;
 144
 145   flags = gtk_widget_get_state_flags (GTK_WIDGET (swatch));
 146   if ((flags & GTK_STATE_FLAG_SELECTED) != (previous & GTK_STATE_FLAG_SELECTED) &&
 147       (flags & GTK_STATE_FLAG_SELECTED) != 0)
 148     select_swatch (cc, swatch);
 149 }
 150
 151 static void
 152 connect_swatch_signals (GtkWidget *p,
 153                         gpointer   data)
 154 {
 155   g_signal_connect (p, "activate", G_CALLBACK (swatch_activate), data);
 156   g_signal_connect (p, "customize", G_CALLBACK (swatch_customize), data);
 157   g_signal_connect (p, "state-flags-changed", G_CALLBACK (swatch_selected), data);
 158 }
 159
 160 static void
 161 button_activate (GtkColorSwatch        *swatch,
 162                  GtkColorChooserWidget *cc)
 163 {
 164   /* somewhat random, makes the hairline nicely visible */
 165   GdkRGBA color = { 0.75, 0.25, 0.25, 1.0 };
 166
 167   gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (cc->priv->editor), &color);
 168
 169   gtk_widget_hide (cc->priv->palette);
 170   gtk_widget_show (cc->priv->editor);
 171   g_object_notify (G_OBJECT (cc), "show-editor");
 172 }
 173
 174 static void
 175 connect_button_signals (GtkWidget *p,
 176                         gpointer   data)
 177 {
 178   g_signal_connect (p, "activate", G_CALLBACK (button_activate), data);
 179 }
 180
 181 static void
 182 save_custom_colors (GtkColorChooserWidget *cc)
 183 {
 184   GVariantBuilder builder;
 185   GVariant *variant;
 186   GdkRGBA color;
 187   GList *children, *l;
 188   GtkWidget *child;
 189
 190   g_variant_builder_init (&builder, G_VARIANT_TYPE ("a(dddd)"));
 191
 192   children = gtk_container_get_children (GTK_CONTAINER (cc->priv->custom));
 193   for (l = g_list_nth (children, 1); l != NULL; l = l->next)
 194     {
 195       child = l->data;
 196       if (gtk_color_swatch_get_rgba (GTK_COLOR_SWATCH (child), &color))
 197         g_variant_builder_add (&builder, "(dddd)",
 198                                color.red, color.green, color.blue, color.alpha);
 199     }
 200
 201   variant = g_variant_builder_end (&builder);
 202   g_settings_set_value (cc->priv->settings, "custom-colors", variant);
 203
 204   g_list_free (children);
 205 }
 206
 207 static void
 208 connect_custom_signals (GtkWidget *p,
 209                         gpointer   data)
 210 {
 211   connect_swatch_signals (p, data);
 212   g_signal_connect_swapped (p, "notify::rgba",
 213                             G_CALLBACK (save_custom_colors), data);
 214 }
 215
 216 static void
 217 gtk_color_chooser_widget_set_use_alpha (GtkColorChooserWidget *cc,
 218                                         gboolean               use_alpha)
 219 {
 220   GList *children, *l;
 221   GList *palettes, *p;
 222   GtkWidget *swatch;
 223   GtkWidget *grid;
 224
 225   cc->priv->use_alpha = use_alpha;
 226   gtk_color_chooser_set_use_alpha (GTK_COLOR_CHOOSER (cc->priv->editor), use_alpha);
 227
 228   palettes = gtk_container_get_children (GTK_CONTAINER (cc->priv->palette));
 229   for (p = palettes; p; p = p->next)
 230     {
 231       grid = p->data;
 232
 233       if (!GTK_IS_CONTAINER (grid))
 234         continue;
 235
 236       children = gtk_container_get_children (GTK_CONTAINER (grid));
 237       for (l = children; l; l = l->next)
 238         {
 239           swatch = l->data;
 240           gtk_color_swatch_set_use_alpha (GTK_COLOR_SWATCH (swatch), use_alpha);
 241         }
 242       g_list_free (children);
 243     }
 244   g_list_free (palettes);
 245
 246   gtk_widget_queue_draw (GTK_WIDGET (cc));
 247 }
 248
 249 static void
 250 gtk_color_chooser_widget_set_show_editor (GtkColorChooserWidget *cc,
 251                                           gboolean               show_editor)
 252 {
 253   if (show_editor)
 254     {
 255       GdkRGBA color = { 0.75, 0.25, 0.25, 1.0 };
 256
 257       if (cc->priv->current)
 258         gtk_color_swatch_get_rgba (cc->priv->current, &color);
 259       gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (cc->priv->editor), &color);
 260     }
 261
 262   gtk_widget_set_visible (cc->priv->editor, show_editor);
 263   gtk_widget_set_visible (cc->priv->palette, !show_editor);
 264 }
 265
 266 /* UI construction {{{1 */
 267
 268 static guint
 269 scale_round (gdouble value, gdouble scale)
 270 {
 271   value = floor (value * scale + 0.5);
 272   value = MAX (value, 0);
 273   value = MIN (value, scale);
 274   return (guint)value;
 275 }
 276
 277 static gchar *
 278 accessible_color_name (GdkRGBA *color)
 279 {
 280   if (color->alpha < 1.0)
 281     return g_strdup_printf (_("Red %d%%, Green %d%%, Blue %d%%, Alpha %d%%"),
 282                             scale_round (color->red, 100),
 283                             scale_round (color->green, 100),
 284                             scale_round (color->blue, 100),
 285                             scale_round (color->alpha, 100));
 286   else
 287     return g_strdup_printf (_("Red %d%%, Green %d%%, Blue %d%%"),
 288                             scale_round (color->red, 100),
 289                             scale_round (color->green, 100),
 290                             scale_round (color->blue, 100));
 291 }
 292
 293 static void
 294 remove_palette (GtkColorChooserWidget *cc)
 295 {
 296   GList *children, *l;
 297   GtkWidget *widget;
 298
 299   if (cc->priv->current != NULL &&
 300       gtk_widget_get_parent (GTK_WIDGET (cc->priv->current)) != cc->priv->custom)
 301     cc->priv->current = NULL;
 302
 303   children = gtk_container_get_children (GTK_CONTAINER (cc->priv->palette));
 304   for (l = children; l; l = l->next)
 305     {
 306       widget = l->data;
 307       if (widget == cc->priv->custom_label || widget == cc->priv->custom)
 308         continue;
 309       gtk_container_remove (GTK_CONTAINER (cc->priv->palette), widget);
 310     }
 311   g_list_free (children);
 312 }
 313
 314 static void
 315 add_palette (GtkColorChooserWidget  *cc,
 316              GtkOrientation          orientation,
 317              gint                    colors_per_line,
 318              gint                    n_colors,
 319              GdkRGBA                *colors,
 320              const gchar           **names)
 321 {
 322   GtkWidget *grid;
 323   GtkWidget *p;
 324   AtkObject *atk_obj;
 325   gint line, pos;
 326   gint i;
 327   gint left, right;
 328
 329   if (colors == NULL)
 330     {
 331       remove_palette (cc);
 332       return;
 333     }
 334
 335   grid = gtk_grid_new ();
 336   gtk_widget_set_margin_bottom (grid, 12);
 337   gtk_grid_set_row_spacing (GTK_GRID (grid), 2);
 338   gtk_grid_set_column_spacing (GTK_GRID (grid), 4);
 339   gtk_container_add (GTK_CONTAINER (cc->priv->palette), grid);
 340
 341   left = 0;
 342   right = colors_per_line - 1;
 343   if (gtk_widget_get_direction (GTK_WIDGET (cc)) == GTK_TEXT_DIR_RTL)
 344     {
 345       i = left;
 346       left = right;
 347       right = i;
 348     }
 349
 350   for (i = 0; i < n_colors; i++)
 351     {
 352       p = gtk_color_swatch_new ();
 353       atk_obj = gtk_widget_get_accessible (p);
 354       if (names)
 355         {
 356           atk_object_set_description (atk_obj,
 357                                       g_dpgettext2 (GETTEXT_PACKAGE, "Color name", names[i]));
 358         }
 359       else
 360         {
 361           gchar *text, *name;
 362
 363           name = accessible_color_name (&colors[i]);
 364           text = g_strdup_printf (_("Color: %s"), name);
 365           atk_object_set_description (atk_obj, text);
 366           g_free (text);
 367           g_free (name);
 368         }
 369       gtk_color_swatch_set_rgba (GTK_COLOR_SWATCH (p), &colors[i]);
 370       connect_swatch_signals (p, cc);
 371
 372       line = i / colors_per_line;
 373       pos = i % colors_per_line;
 374
 375       if (orientation == GTK_ORIENTATION_HORIZONTAL)
 376         {
 377             if (pos == left)
 378               gtk_style_context_add_class (gtk_widget_get_style_context (p), GTK_STYLE_CLASS_LEFT);
 379             else if (pos == right)
 380               gtk_style_context_add_class (gtk_widget_get_style_context (p), GTK_STYLE_CLASS_RIGHT);
 381
 382             gtk_grid_attach (GTK_GRID (grid), p, pos, line, 1, 1);
 383         }
 384       else
 385         {
 386           if (pos == 0)
 387             gtk_style_context_add_class (gtk_widget_get_style_context (p), GTK_STYLE_CLASS_TOP);
 388           else if (pos == colors_per_line - 1)
 389             gtk_style_context_add_class (gtk_widget_get_style_context (p), GTK_STYLE_CLASS_BOTTOM);
 390
 391           gtk_grid_attach (GTK_GRID (grid), p, line, pos, 1, 1);
 392        }
 393     }
 394
 395   gtk_widget_show_all (grid);
 396 }
 397
 398 static void
 399 remove_default_palette (GtkColorChooserWidget *cc)
 400 {
 401   if (!cc->priv->has_default_palette)
 402     return;
 403
 404   remove_palette (cc);
 405   cc->priv->has_default_palette = FALSE;
 406 }
 407
 408 static void
 409 add_default_palette (GtkColorChooserWidget *cc)
 410 {
 411   const gchar *default_colors[9][3] = {
 412     { "#ef2929", "#cc0000", "#a40000" }, /* Scarlet Red */
 413     { "#fcaf3e", "#f57900", "#ce5c00" }, /* Orange */
 414     { "#fce94f", "#edd400", "#c4a000" }, /* Butter */
 415     { "#8ae234", "#73d216", "#4e9a06" }, /* Chameleon */
 416     { "#729fcf", "#3465a4", "#204a87" }, /* Sky Blue */
 417     { "#ad7fa8", "#75507b", "#5c3566" }, /* Plum */
 418     { "#e9b96e", "#c17d11", "#8f5902" }, /* Chocolate */
 419     { "#888a85", "#555753", "#2e3436" }, /* Aluminum 1 */
 420     { "#eeeeec", "#d3d7cf", "#babdb6" }  /* Aluminum 2 */
 421   };
 422   const gchar *color_names[] = {
 423     NC_("Color name", "Light Scarlet Red"),
 424     NC_("Color name", "Scarlet Red"),
 425     NC_("Color name", "Dark Scarlet Red"),
 426     NC_("Color name", "Light Orange"),
 427     NC_("Color name", "Orange"),
 428     NC_("Color name", "Dark Orange"),
 429     NC_("Color name", "Light Butter"),
 430     NC_("Color name", "Butter"),
 431     NC_("Color name", "Dark Butter"),
 432     NC_("Color name", "Light Chameleon"),
 433     NC_("Color name", "Chameleon"),
 434     NC_("Color name", "Dark Chameleon"),
 435     NC_("Color name", "Light Sky Blue"),
 436     NC_("Color name", "Sky Blue"),
 437     NC_("Color name", "Dark Sky Blue"),
 438     NC_("Color name", "Light Plum"),
 439     NC_("Color name", "Plum"),
 440     NC_("Color name", "Dark Plum"),
 441     NC_("Color name", "Light Chocolate"),
 442     NC_("Color name", "Chocolate"),
 443     NC_("Color name", "Dark Chocolate"),
 444     NC_("Color name", "Light Aluminum 1"),
 445     NC_("Color name", "Aluminum 1"),
 446     NC_("Color name", "Dark Aluminum 1"),
 447     NC_("Color name", "Light Aluminum 2"),
 448     NC_("Color name", "Aluminum 2"),
 449     NC_("Color name", "Dark Aluminum 2")
 450   };
 451   const gchar *default_grays[9] = {
 452     "#000000", /* black */
 453     "#2e3436", /* very dark gray */
 454     "#555753", /* darker gray */
 455     "#888a85", /* dark gray */
 456     "#babdb6", /* medium gray */
 457     "#d3d7cf", /* light gray */
 458     "#eeeeec", /* lighter gray */
 459     "#f3f3f3", /* very light gray */
 460     "#ffffff"  /* white */
 461   };
 462   const gchar *gray_names[] = {
 463     NC_("Color name", "Black"),
 464     NC_("Color name", "Very Dark Gray"),
 465     NC_("Color name", "Darker Gray"),
 466     NC_("Color name", "Dark Gray"),
 467     NC_("Color name", "Medium Gray"),
 468     NC_("Color name", "Light Gray"),
 469     NC_("Color name", "Lighter Gray"),
 470     NC_("Color name", "Very Light Gray"),
 471     NC_("Color name", "White")
 472   };
 473   GdkRGBA colors[9*3];
 474   gint i, j;
 475
 476   for (i = 0; i < 9; i++)
 477     for (j = 0; j < 3; j++)
 478       gdk_rgba_parse (&colors[i*3 + j], default_colors[i][j]);
 479
 480   add_palette (cc, GTK_ORIENTATION_VERTICAL, 3, 9*3, colors, color_names);
 481
 482   for (i = 0; i < 9; i++)
 483     gdk_rgba_parse (&colors[i], default_grays[i]);
 484
 485   add_palette (cc, GTK_ORIENTATION_HORIZONTAL, 9, 9, colors, gray_names);
 486
 487   cc->priv->has_default_palette = TRUE;
 488 }
 489
 490 static void
 491 gtk_color_chooser_widget_init (GtkColorChooserWidget *cc)
 492 {
 493   GtkWidget *box;
 494   GtkWidget *p;
 495   GtkWidget *button;
 496   GtkWidget *label;
 497   gint i;
 498   GdkRGBA color;
 499   GVariant *variant;
 500   GVariantIter iter;
 501   gboolean selected;
 502   AtkObject *atk_obj;
 503   gchar *text, *name;
 504
 505   cc->priv = G_TYPE_INSTANCE_GET_PRIVATE (cc, GTK_TYPE_COLOR_CHOOSER_WIDGET, GtkColorChooserWidgetPrivate);
 506
 507   cc->priv->use_alpha = TRUE;
 508
 509   gtk_orientable_set_orientation (GTK_ORIENTABLE (cc), GTK_ORIENTATION_VERTICAL);
 510   cc->priv->palette = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
 511   gtk_container_add (GTK_CONTAINER (cc), cc->priv->palette);
 512
 513   add_default_palette (cc);
 514
 515   cc->priv->custom = box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
 516   g_object_set (box, "margin-top", 12, NULL);
 517   gtk_box_pack_end (GTK_BOX (cc->priv->palette), box, FALSE, TRUE, 0);
 518
 519   /* translators: label for the custom section in the color chooser */
 520   cc->priv->custom_label = label = gtk_label_new (_("Custom"));
 521   gtk_widget_set_halign (label, GTK_ALIGN_START);
 522   gtk_box_pack_end (GTK_BOX (cc->priv->palette), label, FALSE, TRUE, 0);
 523
 524   cc->priv->button = button = gtk_color_swatch_new ();
 525   gtk_widget_set_name (button, "add-color-button");
 526   atk_obj = gtk_widget_get_accessible (button);
 527   atk_object_set_role (atk_obj, ATK_ROLE_PUSH_BUTTON);
 528   atk_object_set_description (atk_obj, _("Create custom color"));
 529   connect_button_signals (button, cc);
 530   gtk_color_swatch_set_icon (GTK_COLOR_SWATCH (button), "list-add-symbolic");
 531   gtk_container_add (GTK_CONTAINER (box), button);
 532
 533   cc->priv->settings = g_settings_new ("org.gtk.Settings.ColorChooser");
 534   variant = g_settings_get_value (cc->priv->settings, "custom-colors");
 535   g_variant_iter_init (&iter, variant);
 536   i = 0;
 537   p = NULL;
 538   while (g_variant_iter_loop (&iter, "(dddd)", &color.red, &color.green, &color.blue, &color.alpha))
 539     {
 540       i++;
 541       p = gtk_color_swatch_new ();
 542       gtk_color_swatch_set_rgba (GTK_COLOR_SWATCH (p), &color);
 543       gtk_color_swatch_set_can_drop (GTK_COLOR_SWATCH (p), TRUE);
 544       atk_obj = gtk_widget_get_accessible (p);
 545       name = accessible_color_name (&color);
 546       text = g_strdup_printf (_("Custom color %d: %s"), i, name);
 547       atk_object_set_description (atk_obj, text);
 548       g_free (text);
 549       g_free (name);
 550       connect_custom_signals (p, cc);
 551       gtk_container_add (GTK_CONTAINER (box), p);
 552
 553       if (i == 8)
 554         break;
 555     }
 556   g_variant_unref (variant);
 557
 558   cc->priv->editor = gtk_color_editor_new ();
 559   gtk_widget_set_halign (cc->priv->editor, GTK_ALIGN_CENTER);
 560   gtk_widget_set_hexpand (cc->priv->editor, TRUE);
 561
 562   box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
 563   gtk_container_add (GTK_CONTAINER (cc), box);
 564   gtk_container_add (GTK_CONTAINER (box), cc->priv->editor);
 565
 566   g_settings_get (cc->priv->settings, "selected-color", "(bdddd)",
 567                   &selected,
 568                   &color.red, &color.green, &color.blue, &color.alpha);
 569   if (selected)
 570     gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (cc), &color);
 571
 572   gtk_widget_show_all (GTK_WIDGET (cc));
 573   gtk_widget_hide (GTK_WIDGET (cc->priv->editor));
 574   gtk_widget_hide (GTK_WIDGET (cc));
 575
 576   gtk_widget_set_no_show_all (cc->priv->palette, TRUE);
 577   gtk_widget_set_no_show_all (cc->priv->editor, TRUE);
 578
 579   cc->priv->size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
 580   gtk_size_group_add_widget (cc->priv->size_group, cc->priv->palette);
 581   gtk_size_group_add_widget (cc->priv->size_group, box);
 582 }
 583
 584 /* GObject implementation {{{1 */
 585
 586 static void
 587 gtk_color_chooser_widget_get_property (GObject    *object,
 588                                        guint       prop_id,
 589                                        GValue     *value,
 590                                        GParamSpec *pspec)
 591 {
 592   GtkColorChooserWidget *cw = GTK_COLOR_CHOOSER_WIDGET (object);
 593   GtkColorChooser *cc = GTK_COLOR_CHOOSER (object);
 594
 595   switch (prop_id)
 596     {
 597     case PROP_RGBA:
 598       {
 599         GdkRGBA color;
 600
 601         gtk_color_chooser_get_rgba (cc, &color);
 602         g_value_set_boxed (value, &color);
 603       }
 604       break;
 605     case PROP_USE_ALPHA:
 606       g_value_set_boolean (value, cw->priv->use_alpha);
 607       break;
 608     case PROP_SHOW_EDITOR:
 609       g_value_set_boolean (value, gtk_widget_get_visible (cw->priv->editor));
 610       break;
 611     default:
 612       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 613       break;
 614     }
 615 }
 616
 617 static void
 618 gtk_color_chooser_widget_set_property (GObject      *object,
 619                                        guint         prop_id,
 620                                        const GValue *value,
 621                                        GParamSpec   *pspec)
 622 {
 623   GtkColorChooserWidget *cc = GTK_COLOR_CHOOSER_WIDGET (object);
 624
 625   switch (prop_id)
 626     {
 627     case PROP_RGBA:
 628       gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (cc),
 629                                   g_value_get_boxed (value));
 630       break;
 631     case PROP_USE_ALPHA:
 632       gtk_color_chooser_widget_set_use_alpha (cc,
 633                                               g_value_get_boolean (value));
 634       break;
 635     case PROP_SHOW_EDITOR:
 636       gtk_color_chooser_widget_set_show_editor (cc,
 637                                                 g_value_get_boolean (value));
 638       break;
 639     default:
 640       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 641       break;
 642     }
 643 }
 644
 645 static void
 646 gtk_color_chooser_widget_finalize (GObject *object)
 647 {
 648   GtkColorChooserWidget *cc = GTK_COLOR_CHOOSER_WIDGET (object);
 649
 650   g_object_unref (cc->priv->size_group);
 651   g_object_unref (cc->priv->settings);
 652
 653   G_OBJECT_CLASS (gtk_color_chooser_widget_parent_class)->finalize (object);
 654 }
 655
 656 static void
 657 gtk_color_chooser_widget_class_init (GtkColorChooserWidgetClass *class)
 658 {
 659   GObjectClass *object_class = G_OBJECT_CLASS (class);
 660
 661   object_class->get_property = gtk_color_chooser_widget_get_property;
 662   object_class->set_property = gtk_color_chooser_widget_set_property;
 663   object_class->finalize = gtk_color_chooser_widget_finalize;
 664
 665   g_object_class_override_property (object_class, PROP_RGBA, "rgba");
 666   g_object_class_override_property (object_class, PROP_USE_ALPHA, "use-alpha");
 667
 668   /**
 669    * GtkColorChooserWidget:show-editor:
 670    *
 671    * The ::show-editor property is %TRUE when the color chooser
 672    * is showing the single-color editor. It can be set to switch
 673    * the color chooser into single-color editing mode.
 674    *
 675    * Since: 3.4
 676    */
 677   g_object_class_install_property (object_class, PROP_SHOW_EDITOR,
 678       g_param_spec_boolean ("show-editor", P_("Show editor"), P_("Show editor"),
 679                             FALSE, GTK_PARAM_READWRITE));
 680
 681   g_type_class_add_private (object_class, sizeof (GtkColorChooserWidgetPrivate));
 682 }
 683
 684 /* GtkColorChooser implementation {{{1 */
 685
 686 static void
 687 gtk_color_chooser_widget_get_rgba (GtkColorChooser *chooser,
 688                                    GdkRGBA         *color)
 689 {
 690   GtkColorChooserWidget *cc = GTK_COLOR_CHOOSER_WIDGET (chooser);
 691
 692   if (gtk_widget_get_visible (cc->priv->editor))
 693     gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (cc->priv->editor), color);
 694   else if (cc->priv->current)
 695     gtk_color_swatch_get_rgba (cc->priv->current, color);
 696   else
 697     {
 698       color->red = 1.0;
 699       color->green = 1.0;
 700       color->blue = 1.0;
 701       color->alpha = 1.0;
 702     }
 703
 704   if (!cc->priv->use_alpha)
 705     color->alpha = 1.0;
 706 }
 707
 708 static void
 709 add_custom_color (GtkColorChooserWidget *cc,
 710                   const GdkRGBA         *color)
 711 {
 712   GtkWidget *last;
 713   GtkWidget *p;
 714   GList *children;
 715
 716   children = gtk_container_get_children (GTK_CONTAINER (cc->priv->custom));
 717   if (g_list_length (children) >= 8)
 718     {
 719       last = g_list_last (children)->data;
 720       gtk_widget_destroy (last);
 721     }
 722
 723   g_list_free (children);
 724
 725   p = gtk_color_swatch_new ();
 726   gtk_color_swatch_set_rgba (GTK_COLOR_SWATCH (p), color);
 727   gtk_color_swatch_set_can_drop (GTK_COLOR_SWATCH (p), TRUE);
 728   connect_custom_signals (p, cc);
 729
 730   gtk_container_add (GTK_CONTAINER (cc->priv->custom), p);
 731   gtk_box_reorder_child (GTK_BOX (cc->priv->custom), p, 1);
 732   gtk_widget_show (p);
 733
 734   select_swatch (cc, GTK_COLOR_SWATCH (p));
 735   save_custom_colors (cc);
 736 }
 737
 738 static void
 739 gtk_color_chooser_widget_set_rgba (GtkColorChooser *chooser,
 740                                    const GdkRGBA   *color)
 741 {
 742   GtkColorChooserWidget *cc = GTK_COLOR_CHOOSER_WIDGET (chooser);
 743   GList *children, *l;
 744   GList *palettes, *p;
 745   GtkColorSwatch *swatch;
 746   GtkWidget *w;
 747   GdkRGBA c;
 748
 749   palettes = gtk_container_get_children (GTK_CONTAINER (cc->priv->palette));
 750   for (p = palettes; p; p = p->next)
 751     {
 752       w = p->data;
 753       if (!GTK_IS_GRID (w) && !GTK_IS_BOX (w))
 754         continue;
 755
 756       children = gtk_container_get_children (GTK_CONTAINER (w));
 757       for (l = children; l; l = l->next)
 758         {
 759           swatch = l->data;
 760           gtk_color_swatch_get_rgba (swatch, &c);
 761           if (!cc->priv->use_alpha)
 762             c.alpha = color->alpha;
 763           if (gdk_rgba_equal (color, &c))
 764             {
 765               select_swatch (cc, swatch);
 766               g_list_free (children);
 767               g_list_free (palettes);
 768               return;
 769             }
 770         }
 771       g_list_free (children);
 772     }
 773   g_list_free (palettes);
 774
 775   add_custom_color (cc, color);
 776 }
 777
 778 static void
 779 gtk_color_chooser_widget_add_palette (GtkColorChooser *chooser,
 780                                       GtkOrientation   orientation,
 781                                       gint             colors_per_line,
 782                                       gint             n_colors,
 783                                       GdkRGBA         *colors)
 784 {
 785   GtkColorChooserWidget *cc = GTK_COLOR_CHOOSER_WIDGET (chooser);
 786
 787   remove_default_palette (cc);
 788   add_palette (cc, orientation, colors_per_line, n_colors, colors, NULL);
 789 }
 790
 791 static void
 792 gtk_color_chooser_widget_iface_init (GtkColorChooserInterface *iface)
 793 {
 794   iface->get_rgba = gtk_color_chooser_widget_get_rgba;
 795   iface->set_rgba = gtk_color_chooser_widget_set_rgba;
 796   iface->add_palette = gtk_color_chooser_widget_add_palette;
 797 }
 798
 799 /* Public API {{{1 */
 800
 801 /**
 802  * gtk_color_chooser_widget_new:
 803  *
 804  * Creates a new #GtkColorChooserWidget.
 805  *
 806  * Returns: a new #GtkColorChooserWidget
 807  *
 808  * Since: 3.4
 809  */
 810 GtkWidget *
 811 gtk_color_chooser_widget_new (void)
 812 {
 813   return g_object_new (GTK_TYPE_COLOR_CHOOSER_WIDGET, NULL);
 814 }
 815
 816 /* vim:set foldmethod=marker: */