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