src/widgets/paint-selector.cpp

   1 /** \file
   2  * SPPaintSelector: Generic paint selector widget.
   3  */
   4
   5 /*
   6  * Authors:
   7  *   Lauris Kaplinski
   8  *   bulia byak <buliabyak@users.sf.net>
   9  *   John Cliff <simarilius@yahoo.com>
  10  *   Jon A. Cruz <jon@joncruz.org>
  11  *
  12  * Copyright (C) Lauris Kaplinski 2002
  13  * Copyright (C) 2010 Authors
  14 */
  15
  16 #define noSP_PS_VERBOSE
  17
  18 #ifdef HAVE_CONFIG_H
  19 # include "config.h"
  20 #endif
  21
  22 #include <cstring>
  23 #include <string>
  24
  25 #include <gtk/gtkhbox.h>
  26 #include <gtk/gtkradiobutton.h>
  27 #include <gtk/gtkframe.h>
  28 #include <gtk/gtklabel.h>
  29 #include <gtk/gtkoptionmenu.h>
  30 #include <gtk/gtktooltips.h>
  31 #include <gtk/gtkmenuitem.h>
  32 #include <gtk/gtkseparatormenuitem.h>
  33
  34 #include "../sp-pattern.h"
  35 #include <glibmm/i18n.h>
  36 #include "../widgets/icon.h"
  37 #include "widgets/widget-sizes.h"
  38 #include "xml/repr.h"
  39
  40 #include "sp-color-notebook.h"
  41 #include "sp-linear-gradient-fns.h"
  42 #include "sp-radial-gradient-fns.h"
  43 /* fixme: Move it from dialogs to here */
  44 #include "gradient-selector.h"
  45 #include <inkscape.h>
  46 #include <document-private.h>
  47 #include <desktop-style.h>
  48 #include <style.h>
  49 #include "svg/svg-color.h"
  50 #include "svg/css-ostringstream.h"
  51 #include "path-prefix.h"
  52 #include "io/sys.h"
  53 #include "helper/stock-items.h"
  54 #include "ui/icon-names.h"
  55
  56 #include "paint-selector.h"
  57
  58 #ifdef SP_PS_VERBOSE
  59 #include "svg/svg-icc-color.h"
  60 #endif // SP_PS_VERBOSE
  61
  62 enum {
  63     MODE_CHANGED,
  64     GRABBED,
  65     DRAGGED,
  66     RELEASED,
  67     CHANGED,
  68     FILLRULE_CHANGED,
  69     LAST_SIGNAL
  70 };
  71
  72 static void sp_paint_selector_class_init(SPPaintSelectorClass *klass);
  73 static void sp_paint_selector_init(SPPaintSelector *slider);
  74 static void sp_paint_selector_destroy(GtkObject *object);
  75
  76 static GtkWidget *sp_paint_selector_style_button_add(SPPaintSelector *psel, gchar const *px, SPPaintSelectorMode mode, GtkTooltips *tt, gchar const *tip);
  77 static void sp_paint_selector_style_button_toggled(GtkToggleButton *tb, SPPaintSelector *psel);
  78 static void sp_paint_selector_fillrule_toggled(GtkToggleButton *tb, SPPaintSelector *psel);
  79
  80 static void sp_paint_selector_set_mode_empty(SPPaintSelector *psel);
  81 static void sp_paint_selector_set_mode_multiple(SPPaintSelector *psel);
  82 static void sp_paint_selector_set_mode_none(SPPaintSelector *psel);
  83 static void sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelectorMode mode);
  84 static void sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelectorMode mode);
  85 static void sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSelectorMode mode);
  86 static void sp_paint_selector_set_mode_swatch(SPPaintSelector *psel, SPPaintSelectorMode mode);
  87 static void sp_paint_selector_set_mode_unset(SPPaintSelector *psel);
  88
  89
  90 static void sp_paint_selector_set_style_buttons(SPPaintSelector *psel, GtkWidget *active);
  91
  92 static GtkVBoxClass *parent_class;
  93 static guint psel_signals[LAST_SIGNAL] = {0};
  94
  95 GType sp_paint_selector_get_type(void)
  96 {
  97     static GtkType type = 0;
  98     if (!type) {
  99         GTypeInfo info = {
 100             sizeof(SPPaintSelectorClass),
 101             0, // base_init
 102             0, // base_finalize
 103             (GClassInitFunc)sp_paint_selector_class_init,
 104             0, // class_finalize
 105             0, // class_data
 106             sizeof(SPPaintSelector),
 107             0, // n_preallocs
 108             (GInstanceInitFunc)sp_paint_selector_init,
 109             0 // value_table
 110         };
 111         type = g_type_register_static(GTK_TYPE_VBOX, "SPPaintSelector", &info, static_cast<GTypeFlags>(0));
 112     }
 113     return type;
 114 }
 115
 116 static void
 117 sp_paint_selector_class_init(SPPaintSelectorClass *klass)
 118 {
 119     GtkObjectClass *object_class;
 120     GtkWidgetClass *widget_class;
 121
 122     object_class = (GtkObjectClass *) klass;
 123     widget_class = (GtkWidgetClass *) klass;
 124
 125     parent_class = (GtkVBoxClass*)gtk_type_class(GTK_TYPE_VBOX);
 126
 127     psel_signals[MODE_CHANGED] = gtk_signal_new("mode_changed",
 128                                                 (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 129                                                 GTK_CLASS_TYPE(object_class),
 130                                                 GTK_SIGNAL_OFFSET(SPPaintSelectorClass, mode_changed),
 131                                                 gtk_marshal_NONE__UINT,
 132                                                 GTK_TYPE_NONE, 1, GTK_TYPE_UINT);
 133     psel_signals[GRABBED] =  gtk_signal_new("grabbed",
 134                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 135                                             GTK_CLASS_TYPE(object_class),
 136                                             GTK_SIGNAL_OFFSET(SPPaintSelectorClass, grabbed),
 137                                             gtk_marshal_NONE__NONE,
 138                                             GTK_TYPE_NONE, 0);
 139     psel_signals[DRAGGED] =  gtk_signal_new("dragged",
 140                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 141                                             GTK_CLASS_TYPE(object_class),
 142                                             GTK_SIGNAL_OFFSET(SPPaintSelectorClass, dragged),
 143                                             gtk_marshal_NONE__NONE,
 144                                             GTK_TYPE_NONE, 0);
 145     psel_signals[RELEASED] = gtk_signal_new("released",
 146                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 147                                             GTK_CLASS_TYPE(object_class),
 148                                             GTK_SIGNAL_OFFSET(SPPaintSelectorClass, released),
 149                                             gtk_marshal_NONE__NONE,
 150                                             GTK_TYPE_NONE, 0);
 151     psel_signals[CHANGED] =  gtk_signal_new("changed",
 152                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 153                                             GTK_CLASS_TYPE(object_class),
 154                                             GTK_SIGNAL_OFFSET(SPPaintSelectorClass, changed),
 155                                             gtk_marshal_NONE__NONE,
 156                                             GTK_TYPE_NONE, 0);
 157     psel_signals[FILLRULE_CHANGED] = gtk_signal_new("fillrule_changed",
 158                                                     (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 159                                                     GTK_CLASS_TYPE(object_class),
 160                                                     GTK_SIGNAL_OFFSET(SPPaintSelectorClass, fillrule_changed),
 161                                                     gtk_marshal_NONE__UINT,
 162                                                     GTK_TYPE_NONE, 1, GTK_TYPE_UINT);
 163
 164     object_class->destroy = sp_paint_selector_destroy;
 165 }
 166
 167 #define XPAD 4
 168 #define YPAD 1
 169
 170 static void
 171 sp_paint_selector_init(SPPaintSelector *psel)
 172 {
 173     GtkTooltips *tt = gtk_tooltips_new();
 174
 175     psel->mode = (SPPaintSelectorMode)-1; // huh?  do you mean 0xff?  --  I think this means "not in the enum"
 176
 177     /* Paint style button box */
 178     psel->style = gtk_hbox_new(FALSE, 0);
 179     gtk_widget_show(psel->style);
 180     gtk_container_set_border_width(GTK_CONTAINER(psel->style), 4);
 181     gtk_box_pack_start(GTK_BOX(psel), psel->style, FALSE, FALSE, 0);
 182
 183     /* Buttons */
 184     psel->none = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_NONE,
 185                                                     SP_PAINT_SELECTOR_MODE_NONE, tt, _("No paint"));
 186     psel->solid = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_SOLID,
 187                                                      SP_PAINT_SELECTOR_MODE_COLOR_RGB, tt, _("Flat color"));
 188     psel->gradient = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_GRADIENT_LINEAR,
 189                                                         SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR, tt, _("Linear gradient"));
 190     psel->radial = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_GRADIENT_RADIAL,
 191                                                       SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL, tt, _("Radial gradient"));
 192     psel->pattern = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_PATTERN,
 193                                                        SP_PAINT_SELECTOR_MODE_PATTERN, tt, _("Pattern"));
 194     psel->swatch = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_SWATCH,
 195                                                        SP_PAINT_SELECTOR_MODE_SWATCH, tt, _("Swatch"));
 196     psel->unset = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_UNKNOWN,
 197                                                      SP_PAINT_SELECTOR_MODE_UNSET, tt, _("Unset paint (make it undefined so it can be inherited)"));
 198
 199     /* Fillrule */
 200     {
 201         psel->fillrulebox = gtk_hbox_new(FALSE, 0);
 202         gtk_box_pack_end(GTK_BOX(psel->style), psel->fillrulebox, FALSE, FALSE, 0);
 203
 204         GtkWidget *w;
 205         psel->evenodd = gtk_radio_button_new(NULL);
 206         gtk_button_set_relief(GTK_BUTTON(psel->evenodd), GTK_RELIEF_NONE);
 207         gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(psel->evenodd), FALSE);
 208         // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/painting.html#FillRuleProperty
 209         gtk_tooltips_set_tip(tt, psel->evenodd, _("Any path self-intersections or subpaths create holes in the fill (fill-rule: evenodd)"), NULL);
 210         gtk_object_set_data(GTK_OBJECT(psel->evenodd), "mode", GUINT_TO_POINTER(SP_PAINT_SELECTOR_FILLRULE_EVENODD));
 211         w = sp_icon_new(Inkscape::ICON_SIZE_DECORATION, INKSCAPE_ICON_FILL_RULE_EVEN_ODD);
 212         gtk_container_add(GTK_CONTAINER(psel->evenodd), w);
 213         gtk_box_pack_start(GTK_BOX(psel->fillrulebox), psel->evenodd, FALSE, FALSE, 0);
 214         gtk_signal_connect(GTK_OBJECT(psel->evenodd), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_fillrule_toggled), psel);
 215
 216         psel->nonzero = gtk_radio_button_new(gtk_radio_button_group(GTK_RADIO_BUTTON(psel->evenodd)));
 217         gtk_button_set_relief(GTK_BUTTON(psel->nonzero), GTK_RELIEF_NONE);
 218         gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(psel->nonzero), FALSE);
 219         // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/painting.html#FillRuleProperty
 220         gtk_tooltips_set_tip(tt, psel->nonzero, _("Fill is solid unless a subpath is counterdirectional (fill-rule: nonzero)"), NULL);
 221         gtk_object_set_data(GTK_OBJECT(psel->nonzero), "mode", GUINT_TO_POINTER(SP_PAINT_SELECTOR_FILLRULE_NONZERO));
 222         w = sp_icon_new(Inkscape::ICON_SIZE_DECORATION, INKSCAPE_ICON_FILL_RULE_NONZERO);
 223         gtk_container_add(GTK_CONTAINER(psel->nonzero), w);
 224         gtk_box_pack_start(GTK_BOX(psel->fillrulebox), psel->nonzero, FALSE, FALSE, 0);
 225         gtk_signal_connect(GTK_OBJECT(psel->nonzero), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_fillrule_toggled), psel);
 226     }
 227
 228     /* Frame */
 229     psel->frame = gtk_frame_new("");
 230     gtk_widget_show(psel->frame);
 231     gtk_container_set_border_width(GTK_CONTAINER(psel->frame), 0);
 232     gtk_box_pack_start(GTK_BOX(psel), psel->frame, TRUE, TRUE, 0);
 233
 234     /* Last used color */
 235     psel->color.set( 0.0, 0.0, 0.0 );
 236     psel->alpha = 1.0;
 237 }
 238
 239 static void
 240 sp_paint_selector_destroy(GtkObject *object)
 241 {
 242     SPPaintSelector *psel = SP_PAINT_SELECTOR(object);
 243
 244     // clean up our long-living pattern menu
 245     g_object_set_data(G_OBJECT(psel),"patternmenu",NULL);
 246
 247     if (((GtkObjectClass *) parent_class)->destroy)
 248         (* ((GtkObjectClass *) parent_class)->destroy)(object);
 249 }
 250
 251 static GtkWidget *
 252 sp_paint_selector_style_button_add(SPPaintSelector *psel,
 253                                    gchar const *pixmap, SPPaintSelectorMode mode,
 254                                    GtkTooltips *tt, gchar const *tip)
 255 {
 256     GtkWidget *b, *w;
 257
 258     b = gtk_toggle_button_new();
 259     gtk_tooltips_set_tip(tt, b, tip, NULL);
 260     gtk_widget_show(b);
 261
 262     gtk_container_set_border_width(GTK_CONTAINER(b), 0);
 263
 264     gtk_button_set_relief(GTK_BUTTON(b), GTK_RELIEF_NONE);
 265
 266     gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(b), FALSE);
 267     gtk_object_set_data(GTK_OBJECT(b), "mode", GUINT_TO_POINTER(mode));
 268
 269     w = sp_icon_new(Inkscape::ICON_SIZE_BUTTON, pixmap);
 270     gtk_widget_show(w);
 271     gtk_container_add(GTK_CONTAINER(b), w);
 272
 273     gtk_box_pack_start(GTK_BOX(psel->style), b, FALSE, FALSE, 0);
 274     gtk_signal_connect(GTK_OBJECT(b), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_style_button_toggled), psel);
 275
 276     return b;
 277 }
 278
 279 static void
 280 sp_paint_selector_style_button_toggled(GtkToggleButton *tb, SPPaintSelector *psel)
 281 {
 282     if (!psel->update && gtk_toggle_button_get_active(tb)) {
 283         sp_paint_selector_set_mode(psel, (SPPaintSelectorMode)GPOINTER_TO_UINT(gtk_object_get_data(GTK_OBJECT(tb), "mode")));
 284     }
 285 }
 286
 287 static void
 288 sp_paint_selector_fillrule_toggled(GtkToggleButton *tb, SPPaintSelector *psel)
 289 {
 290     if (!psel->update && gtk_toggle_button_get_active(tb)) {
 291         SPPaintSelectorFillRule fr = (SPPaintSelectorFillRule)GPOINTER_TO_UINT(gtk_object_get_data(GTK_OBJECT(tb), "mode"));
 292         gtk_signal_emit(GTK_OBJECT(psel), psel_signals[FILLRULE_CHANGED], fr);
 293     }
 294 }
 295
 296 void
 297 sp_paint_selector_show_fillrule(SPPaintSelector *psel, bool is_fill)
 298 {
 299     if (psel->fillrulebox) {
 300         if (is_fill) {
 301             gtk_widget_show_all(psel->fillrulebox);
 302         } else {
 303             gtk_widget_destroy(psel->fillrulebox);
 304             psel->fillrulebox = NULL;
 305         }
 306     }
 307 }
 308
 309
 310 GtkWidget *
 311 sp_paint_selector_new(bool is_fill)
 312 {
 313     SPPaintSelector *psel;
 314
 315     psel = (SPPaintSelector*)gtk_type_new(SP_TYPE_PAINT_SELECTOR);
 316
 317     sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_MULTIPLE);
 318
 319     // This silliness is here because I don't know how to pass a parameter to the
 320     // GtkObject "constructor" (sp_paint_selector_init). Remove it when paint_selector
 321     // becomes a normal class.
 322     sp_paint_selector_show_fillrule(psel, is_fill);
 323
 324     return GTK_WIDGET(psel);
 325 }
 326
 327 void
 328 sp_paint_selector_set_mode(SPPaintSelector *psel, SPPaintSelectorMode mode)
 329 {
 330     if (psel->mode != mode) {
 331         psel->update = TRUE;
 332 #ifdef SP_PS_VERBOSE
 333         g_print("Mode change %d -> %d\n", psel->mode, mode);
 334 #endif
 335         switch (mode) {
 336             case SP_PAINT_SELECTOR_MODE_EMPTY:
 337                 sp_paint_selector_set_mode_empty(psel);
 338                 break;
 339             case SP_PAINT_SELECTOR_MODE_MULTIPLE:
 340                 sp_paint_selector_set_mode_multiple(psel);
 341                 break;
 342             case SP_PAINT_SELECTOR_MODE_NONE:
 343                 sp_paint_selector_set_mode_none(psel);
 344                 break;
 345             case SP_PAINT_SELECTOR_MODE_COLOR_RGB:
 346             case SP_PAINT_SELECTOR_MODE_COLOR_CMYK:
 347                 sp_paint_selector_set_mode_color(psel, mode);
 348                 break;
 349             case SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR:
 350             case SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL:
 351                 sp_paint_selector_set_mode_gradient(psel, mode);
 352                 break;
 353             case SP_PAINT_SELECTOR_MODE_PATTERN:
 354                 sp_paint_selector_set_mode_pattern(psel, mode);
 355                 break;
 356             case SP_PAINT_SELECTOR_MODE_SWATCH:
 357                 sp_paint_selector_set_mode_swatch(psel, mode);
 358                 break;
 359             case SP_PAINT_SELECTOR_MODE_UNSET:
 360                 sp_paint_selector_set_mode_unset(psel);
 361                 break;
 362             default:
 363                 g_warning("file %s: line %d: Unknown paint mode %d", __FILE__, __LINE__, mode);
 364                 break;
 365         }
 366         psel->mode = mode;
 367         gtk_signal_emit(GTK_OBJECT(psel), psel_signals[MODE_CHANGED], psel->mode);
 368         psel->update = FALSE;
 369     }
 370 }
 371
 372 void
 373 sp_paint_selector_set_fillrule(SPPaintSelector *psel, SPPaintSelectorFillRule fillrule)
 374 {
 375     if (psel->fillrulebox) {
 376         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->evenodd), (fillrule == SP_PAINT_SELECTOR_FILLRULE_EVENODD));
 377         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->nonzero), (fillrule == SP_PAINT_SELECTOR_FILLRULE_NONZERO));
 378     }
 379 }
 380
 381 void
 382 sp_paint_selector_set_color_alpha(SPPaintSelector *psel, SPColor const *color, float alpha)
 383 {
 384     g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
 385     SPColorSelector *csel;
 386     guint32 rgba;
 387
 388 /*
 389     if ( sp_color_get_colorspace_type(color) == SP_COLORSPACE_TYPE_CMYK )
 390     {
 391 #ifdef SP_PS_VERBOSE
 392         g_print("PaintSelector set CMYKA\n");
 393 #endif
 394         sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_COLOR_CMYK);
 395     }
 396     else
 397 */
 398     {
 399 #ifdef SP_PS_VERBOSE
 400         g_print("PaintSelector set RGBA\n");
 401 #endif
 402         sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_COLOR_RGB);
 403     }
 404
 405     csel = (SPColorSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
 406     rgba = color->toRGBA32( alpha );
 407     csel->base->setColorAlpha( *color, alpha );
 408 }
 409
 410 void sp_paint_selector_set_swatch(SPPaintSelector *psel, SPPaintServer */*server*/ )
 411 {
 412 #ifdef SP_PS_VERBOSE
 413     g_print("PaintSelector set SWATCH\n");
 414 #endif
 415     sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_SWATCH);
 416 }
 417
 418 void
 419 sp_paint_selector_set_gradient_linear(SPPaintSelector *psel, SPGradient *vector)
 420 {
 421     SPGradientSelector *gsel;
 422 #ifdef SP_PS_VERBOSE
 423     g_print("PaintSelector set GRADIENT LINEAR\n");
 424 #endif
 425     sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR);
 426
 427     gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
 428
 429     sp_gradient_selector_set_mode(gsel, SP_GRADIENT_SELECTOR_MODE_LINEAR);
 430     sp_gradient_selector_set_vector(gsel, (vector) ? SP_OBJECT_DOCUMENT(vector) : NULL, vector);
 431 }
 432
 433 void
 434 sp_paint_selector_set_gradient_radial(SPPaintSelector *psel, SPGradient *vector)
 435 {
 436     SPGradientSelector *gsel;
 437 #ifdef SP_PS_VERBOSE
 438     g_print("PaintSelector set GRADIENT RADIAL\n");
 439 #endif
 440     sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL);
 441
 442     gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
 443
 444     sp_gradient_selector_set_mode(gsel, SP_GRADIENT_SELECTOR_MODE_RADIAL);
 445     sp_gradient_selector_set_vector(gsel, (vector) ? SP_OBJECT_DOCUMENT(vector) : NULL, vector);
 446 }
 447
 448 void
 449 sp_paint_selector_set_gradient_properties(SPPaintSelector *psel, SPGradientUnits units, SPGradientSpread spread)
 450 {
 451     SPGradientSelector *gsel;
 452     g_return_if_fail(SP_IS_PAINT_SELECTOR(psel));
 453     g_return_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) ||
 454                      (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL));
 455     gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
 456     sp_gradient_selector_set_units(gsel, units);
 457     sp_gradient_selector_set_spread(gsel, spread);
 458 }
 459
 460 void
 461 sp_paint_selector_get_gradient_properties(SPPaintSelector *psel, SPGradientUnits *units, SPGradientSpread *spread)
 462 {
 463     SPGradientSelector *gsel;
 464     g_return_if_fail(SP_IS_PAINT_SELECTOR(psel));
 465     g_return_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) ||
 466                      (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL));
 467     gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
 468     if (units) *units = sp_gradient_selector_get_units(gsel);
 469     if (spread) *spread = sp_gradient_selector_get_spread(gsel);
 470 }
 471
 472 /**
 473  * \post (alpha == NULL) || (*alpha in [0.0, 1.0]).
 474  */
 475 void
 476 sp_paint_selector_get_color_alpha(SPPaintSelector *psel, SPColor *color, gfloat *alpha)
 477 {
 478     SPColorSelector *csel;
 479
 480     csel = (SPColorSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
 481
 482     csel->base->getColorAlpha( *color, alpha );
 483
 484     g_assert( !alpha
 485               || ( ( 0.0 <= *alpha )
 486                    && ( *alpha <= 1.0 ) ) );
 487 }
 488
 489 SPGradient *
 490 sp_paint_selector_get_gradient_vector(SPPaintSelector *psel)
 491 {
 492     SPGradientSelector *gsel;
 493
 494     g_return_val_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) ||
 495                          (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL), NULL);
 496
 497     gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
 498
 499     return sp_gradient_selector_get_vector(gsel);
 500 }
 501
 502 void
 503 sp_gradient_selector_attrs_to_gradient(SPGradient *gr, SPPaintSelector *psel)
 504 {
 505     SPGradientUnits units;
 506     SPGradientSpread spread;
 507     sp_paint_selector_get_gradient_properties(psel, &units, &spread);
 508     sp_gradient_set_units(gr, units);
 509     sp_gradient_set_spread(gr, spread);
 510     SP_OBJECT(gr)->updateRepr();
 511 }
 512
 513 static void
 514 sp_paint_selector_clear_frame(SPPaintSelector *psel)
 515 {
 516     g_return_if_fail( psel != NULL);
 517
 518     if (psel->selector) {
 519
 520         /* before we destroy the frame contents, we must detach
 521          * the patternmenu so that Gtk doesn't gtk_widget_destroy
 522          * all the children of the menu.  (We also have a g_object_ref
 523          * count set on it too so that the gtk_container_remove doesn't
 524          * end up destroying it.
 525          */
 526         GtkWidget *patterns = (GtkWidget *)g_object_get_data(G_OBJECT(psel), "patternmenu");
 527         if (patterns != NULL) {
 528             GtkWidget * parent = gtk_widget_get_parent( GTK_WIDGET(patterns));
 529             if ( parent != NULL ) {
 530                 g_assert( GTK_IS_CONTAINER(parent) );
 531                 gtk_container_remove( GTK_CONTAINER(parent), patterns );
 532             }
 533         }
 534
 535         gtk_widget_destroy(psel->selector);
 536         psel->selector = NULL;
 537     }
 538 }
 539
 540 static void
 541 sp_paint_selector_set_mode_empty(SPPaintSelector *psel)
 542 {
 543     sp_paint_selector_set_style_buttons(psel, NULL);
 544     gtk_widget_set_sensitive(psel->style, FALSE);
 545
 546     sp_paint_selector_clear_frame(psel);
 547
 548     gtk_frame_set_label(GTK_FRAME(psel->frame), _("No objects"));
 549 }
 550
 551 static void
 552 sp_paint_selector_set_mode_multiple(SPPaintSelector *psel)
 553 {
 554     sp_paint_selector_set_style_buttons(psel, NULL);
 555     gtk_widget_set_sensitive(psel->style, TRUE);
 556
 557     sp_paint_selector_clear_frame(psel);
 558
 559     gtk_frame_set_label(GTK_FRAME(psel->frame), _("Multiple styles"));
 560 }
 561
 562 static void
 563 sp_paint_selector_set_mode_unset(SPPaintSelector *psel)
 564 {
 565     sp_paint_selector_set_style_buttons(psel, psel->unset);
 566     gtk_widget_set_sensitive(psel->style, TRUE);
 567
 568     sp_paint_selector_clear_frame(psel);
 569
 570     gtk_frame_set_label(GTK_FRAME(psel->frame), _("Paint is undefined"));
 571 }
 572
 573 static void
 574 sp_paint_selector_set_mode_none(SPPaintSelector *psel)
 575 {
 576     sp_paint_selector_set_style_buttons(psel, psel->none);
 577     gtk_widget_set_sensitive(psel->style, TRUE);
 578
 579     sp_paint_selector_clear_frame(psel);
 580
 581     gtk_frame_set_label(GTK_FRAME(psel->frame), _("No paint"));
 582 }
 583
 584 /* Color paint */
 585
 586 static void
 587 sp_paint_selector_color_grabbed(SPColorSelector *csel, SPPaintSelector *psel)
 588 {
 589     (void)csel;
 590     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[GRABBED]);
 591 }
 592
 593 static void
 594 sp_paint_selector_color_dragged(SPColorSelector *csel, SPPaintSelector *psel)
 595 {
 596     (void)csel;
 597     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[DRAGGED]);
 598 }
 599
 600 static void
 601 sp_paint_selector_color_released(SPColorSelector *csel, SPPaintSelector *psel)
 602 {
 603     (void)csel;
 604     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[RELEASED]);
 605 }
 606
 607 static void
 608 sp_paint_selector_color_changed(SPColorSelector *csel, SPPaintSelector *psel)
 609 {
 610     csel->base->getColorAlpha( psel->color, &psel->alpha );
 611
 612     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
 613 }
 614
 615 static void
 616 sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelectorMode mode)
 617 {
 618     (void)mode;
 619     GtkWidget *csel;
 620
 621     sp_paint_selector_set_style_buttons(psel, psel->solid);
 622     gtk_widget_set_sensitive(psel->style, TRUE);
 623
 624     if ((psel->mode == SP_PAINT_SELECTOR_MODE_COLOR_RGB) || (psel->mode == SP_PAINT_SELECTOR_MODE_COLOR_CMYK)) {
 625         /* Already have color selector */
 626         csel = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
 627     } else {
 628
 629         sp_paint_selector_clear_frame(psel);
 630         /* Create new color selector */
 631         /* Create vbox */
 632         GtkWidget *vb = gtk_vbox_new(FALSE, 4);
 633         gtk_widget_show(vb);
 634
 635         /* Color selector */
 636         csel = sp_color_selector_new( SP_TYPE_COLOR_NOTEBOOK );
 637         gtk_widget_show(csel);
 638         gtk_object_set_data(GTK_OBJECT(vb), "color-selector", csel);
 639         gtk_box_pack_start(GTK_BOX(vb), csel, TRUE, TRUE, 0);
 640         gtk_signal_connect(GTK_OBJECT(csel), "grabbed", GTK_SIGNAL_FUNC(sp_paint_selector_color_grabbed), psel);
 641         gtk_signal_connect(GTK_OBJECT(csel), "dragged", GTK_SIGNAL_FUNC(sp_paint_selector_color_dragged), psel);
 642         gtk_signal_connect(GTK_OBJECT(csel), "released", GTK_SIGNAL_FUNC(sp_paint_selector_color_released), psel);
 643         gtk_signal_connect(GTK_OBJECT(csel), "changed", GTK_SIGNAL_FUNC(sp_paint_selector_color_changed), psel);
 644         /* Pack everything to frame */
 645         gtk_container_add(GTK_CONTAINER(psel->frame), vb);
 646         psel->selector = vb;
 647
 648         /* Set color */
 649         SP_COLOR_SELECTOR( csel )->base->setColorAlpha( psel->color, psel->alpha );
 650
 651     }
 652
 653     gtk_frame_set_label(GTK_FRAME(psel->frame), _("Flat color"));
 654 #ifdef SP_PS_VERBOSE
 655     g_print("Color req\n");
 656 #endif
 657 }
 658
 659 /* Gradient */
 660
 661 static void
 662 sp_paint_selector_gradient_grabbed(SPColorSelector *csel, SPPaintSelector *psel)
 663 {
 664     (void)csel;
 665     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[GRABBED]);
 666 }
 667
 668 static void
 669 sp_paint_selector_gradient_dragged(SPColorSelector *csel, SPPaintSelector *psel)
 670 {
 671     (void)csel;
 672     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[DRAGGED]);
 673 }
 674
 675 static void
 676 sp_paint_selector_gradient_released(SPColorSelector *csel, SPPaintSelector *psel)
 677 {
 678     (void)csel;
 679     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[RELEASED]);
 680 }
 681
 682 static void
 683 sp_paint_selector_gradient_changed(SPColorSelector *csel, SPPaintSelector *psel)
 684 {
 685     (void)csel;
 686     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
 687 }
 688
 689 static void
 690 sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelectorMode mode)
 691 {
 692     GtkWidget *gsel;
 693
 694     /* fixme: We do not need function-wide gsel at all */
 695
 696     if (mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) {
 697         sp_paint_selector_set_style_buttons(psel, psel->gradient);
 698     } else {
 699         sp_paint_selector_set_style_buttons(psel, psel->radial);
 700     }
 701     gtk_widget_set_sensitive(psel->style, TRUE);
 702
 703     if ((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) || (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL)) {
 704         /* Already have gradient selector */
 705         gsel = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
 706     } else {
 707         sp_paint_selector_clear_frame(psel);
 708         /* Create new gradient selector */
 709         gsel = sp_gradient_selector_new();
 710         gtk_widget_show(gsel);
 711         gtk_signal_connect(GTK_OBJECT(gsel), "grabbed", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_grabbed), psel);
 712         gtk_signal_connect(GTK_OBJECT(gsel), "dragged", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_dragged), psel);
 713         gtk_signal_connect(GTK_OBJECT(gsel), "released", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_released), psel);
 714         gtk_signal_connect(GTK_OBJECT(gsel), "changed", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_changed), psel);
 715         /* Pack everything to frame */
 716         gtk_container_add(GTK_CONTAINER(psel->frame), gsel);
 717         psel->selector = gsel;
 718         gtk_object_set_data(GTK_OBJECT(psel->selector), "gradient-selector", gsel);
 719     }
 720
 721     /* Actually we have to set option menu history here */
 722     if (mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) {
 723         sp_gradient_selector_set_mode(SP_GRADIENT_SELECTOR(gsel), SP_GRADIENT_SELECTOR_MODE_LINEAR);
 724         gtk_frame_set_label(GTK_FRAME(psel->frame), _("Linear gradient"));
 725     } else {
 726         sp_gradient_selector_set_mode(SP_GRADIENT_SELECTOR(gsel), SP_GRADIENT_SELECTOR_MODE_RADIAL);
 727         gtk_frame_set_label(GTK_FRAME(psel->frame), _("Radial gradient"));
 728     }
 729 #ifdef SP_PS_VERBOSE
 730     g_print("Gradient req\n");
 731 #endif
 732 }
 733
 734 static void
 735 sp_paint_selector_set_style_buttons(SPPaintSelector *psel, GtkWidget *active)
 736 {
 737     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->none), (active == psel->none));
 738     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->solid), (active == psel->solid));
 739     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->gradient), (active == psel->gradient));
 740     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->radial), (active == psel->radial));
 741     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->pattern), (active == psel->pattern));
 742     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->swatch), (active == psel->swatch));
 743     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->unset), (active == psel->unset));
 744 }
 745
 746 static void
 747 sp_psel_pattern_destroy(GtkWidget *widget,  SPPaintSelector *psel)
 748 {
 749     (void)psel;
 750     // drop our reference to the pattern menu widget
 751     g_object_unref( G_OBJECT(widget) );
 752 }
 753
 754 static void
 755 sp_psel_pattern_change(GtkWidget *widget,  SPPaintSelector *psel)
 756 {
 757     (void)widget;
 758     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
 759 }
 760
 761
 762
 763 /**
 764  *  Returns a list of patterns in the defs of the given source document as a GSList object
 765  *  Returns NULL if there are no patterns in the document.
 766  */
 767 GSList *
 768 ink_pattern_list_get (SPDocument *source)
 769 {
 770     if (source == NULL)
 771         return NULL;
 772
 773     GSList *pl = NULL;
 774     GSList const *patterns = sp_document_get_resource_list(source, "pattern");
 775     for (GSList *l = (GSList *) patterns; l != NULL; l = l->next) {
 776         if (SP_PATTERN(l->data) == pattern_getroot(SP_PATTERN(l->data))) {  // only if this is a root pattern
 777             pl = g_slist_prepend(pl, l->data);
 778         }
 779     }
 780
 781     pl = g_slist_reverse(pl);
 782     return pl;
 783 }
 784
 785 /**
 786  * Adds menu items for pattern list - derived from marker code, left hb etc in to make addition of previews easier at some point.
 787  */
 788 static void
 789 sp_pattern_menu_build (GtkWidget *m, GSList *pattern_list, SPDocument */*source*/)
 790 {
 791
 792     for (; pattern_list != NULL; pattern_list = pattern_list->next) {
 793         Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) pattern_list->data);
 794                 GtkWidget *i = gtk_menu_item_new();
 795                 gtk_widget_show(i);
 796
 797         if (repr->attribute("inkscape:stockid"))
 798             g_object_set_data (G_OBJECT(i), "stockid", (void *) "true");
 799         else
 800             g_object_set_data (G_OBJECT(i), "stockid", (void *) "false");
 801
 802         gchar const *patid = repr->attribute("id");
 803         g_object_set_data (G_OBJECT(i), "pattern", (void *) patid);
 804
 805                 GtkWidget *hb = gtk_hbox_new(FALSE, 4);
 806                 gtk_widget_show(hb);
 807
 808         // create label
 809                 GtkWidget *l;
 810                 if (repr->attribute("inkscape:stockid"))
 811                     l = gtk_label_new(_(repr->attribute("inkscape:stockid")));
 812                 else
 813                     l = gtk_label_new(_(repr->attribute("id")));
 814                 gtk_widget_show(l);
 815                 gtk_misc_set_alignment(GTK_MISC(l), 0.0, 0.5);
 816
 817                 gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, 0);
 818
 819                 gtk_widget_show(hb);
 820                 gtk_container_add(GTK_CONTAINER(i), hb);
 821
 822                 gtk_menu_append(GTK_MENU(m), i);
 823             }
 824         }
 825
 826 /**
 827  * sp_pattern_list_from_doc()
 828  *
 829  * \brief Pick up all patterns from source, except those that are in
 830  * current_doc (if non-NULL), and add items to the pattern menu
 831  *
 832  */
 833 static void
 834 sp_pattern_list_from_doc (GtkWidget *m, SPDocument *current_doc, SPDocument *source, SPDocument *pattern_doc)
 835 {
 836     (void)current_doc;
 837     (void)pattern_doc;
 838     GSList *pl = ink_pattern_list_get(source);
 839     GSList *clean_pl = NULL;
 840
 841     for (; pl != NULL; pl = pl->next) {
 842         if (!SP_IS_PATTERN(pl->data))
 843             continue;
 844
 845         // Add to the list of patterns we really do wish to show
 846         clean_pl = g_slist_prepend (clean_pl, pl->data);
 847     }
 848
 849     sp_pattern_menu_build (m, clean_pl, source);
 850
 851     g_slist_free (pl);
 852     g_slist_free (clean_pl);
 853 }
 854
 855
 856
 857
 858 static void
 859 ink_pattern_menu_populate_menu(GtkWidget *m, SPDocument *doc)
 860 {
 861     static SPDocument *patterns_doc = NULL;
 862
 863     // find and load patterns.svg
 864     if (patterns_doc == NULL) {
 865         char *patterns_source = g_build_filename(INKSCAPE_PATTERNSDIR, "patterns.svg", NULL);
 866         if (Inkscape::IO::file_test(patterns_source, G_FILE_TEST_IS_REGULAR)) {
 867             patterns_doc = sp_document_new(patterns_source, FALSE);
 868         }
 869         g_free(patterns_source);
 870     }
 871
 872     // suck in from current doc
 873     sp_pattern_list_from_doc ( m, NULL, doc, patterns_doc );
 874
 875     // add separator
 876     {
 877         GtkWidget *i = gtk_separator_menu_item_new();
 878         gchar const *patid = "";
 879         g_object_set_data (G_OBJECT(i), "pattern", (void *) patid);
 880         gtk_widget_show(i);
 881         gtk_menu_append(GTK_MENU(m), i);
 882     }
 883
 884     // suck in from patterns.svg
 885     if (patterns_doc) {
 886         sp_document_ensure_up_to_date(doc);
 887         sp_pattern_list_from_doc ( m, doc, patterns_doc, NULL );
 888     }
 889
 890 }
 891
 892
 893 static GtkWidget*
 894 ink_pattern_menu(GtkWidget *mnu)
 895 {
 896    /* Create new menu widget */
 897     GtkWidget *m = gtk_menu_new();
 898     gtk_widget_show(m);
 899     SPDocument *doc = SP_ACTIVE_DOCUMENT;
 900
 901     if (!doc) {
 902         GtkWidget *i;
 903         i = gtk_menu_item_new_with_label(_("No document selected"));
 904         gtk_widget_show(i);
 905         gtk_menu_append(GTK_MENU(m), i);
 906         gtk_widget_set_sensitive(mnu, FALSE);
 907     } else {
 908
 909        ink_pattern_menu_populate_menu(m, doc);
 910         gtk_widget_set_sensitive(mnu, TRUE);
 911
 912     }
 913     gtk_option_menu_set_menu(GTK_OPTION_MENU(mnu), m);
 914
 915     /* Set history */
 916     gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
 917     return mnu;
 918 }
 919
 920
 921 /*update pattern list*/
 922 void
 923 sp_update_pattern_list( SPPaintSelector *psel,  SPPattern *pattern)
 924 {
 925     if (psel->update) return;
 926     GtkWidget *mnu = (GtkWidget *)g_object_get_data(G_OBJECT(psel), "patternmenu");
 927     g_assert( mnu != NULL );
 928
 929     /* Clear existing menu if any */
 930     gtk_option_menu_remove_menu(GTK_OPTION_MENU(mnu));
 931
 932     ink_pattern_menu(mnu);
 933
 934     /* Set history */
 935
 936     if (pattern && !gtk_object_get_data(GTK_OBJECT(mnu), "update")) {
 937
 938         gtk_object_set_data(GTK_OBJECT(mnu), "update", GINT_TO_POINTER(TRUE));
 939
 940         gchar *patname = (gchar *) SP_OBJECT_REPR(pattern)->attribute("id");
 941
 942         GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(mnu)));
 943
 944         GList *kids = GTK_MENU_SHELL(m)->children;
 945
 946         int patpos = 0;
 947         int i = 0;
 948
 949         for (; kids != NULL; kids = kids->next) {
 950
 951             gchar *men_pat = (gchar *) g_object_get_data(G_OBJECT(kids->data), "pattern");
 952             if ( strcmp(men_pat, patname) == 0 ) {
 953                 patpos = i;
 954             }
 955             i++;
 956         }
 957
 958
 959         gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), patpos);
 960         gtk_object_set_data(GTK_OBJECT(mnu), "update", GINT_TO_POINTER(FALSE));
 961     }
 962     //gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
 963 }
 964
 965 static void
 966 sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSelectorMode mode)
 967 {
 968     if (mode == SP_PAINT_SELECTOR_MODE_PATTERN)
 969         sp_paint_selector_set_style_buttons(psel, psel->pattern);
 970
 971     gtk_widget_set_sensitive(psel->style, TRUE);
 972
 973     GtkWidget *tbl = NULL;
 974
 975     if (psel->mode == SP_PAINT_SELECTOR_MODE_PATTERN){
 976         /* Already have pattern menu */
 977         tbl = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "pattern-selector");
 978     } else {
 979         sp_paint_selector_clear_frame(psel);
 980
 981         /* Create vbox */
 982         tbl = gtk_vbox_new(FALSE, 4);
 983         gtk_widget_show(tbl);
 984
 985         {
 986             GtkWidget *hb = gtk_hbox_new(FALSE, 1);
 987
 988             GtkWidget *mnu = gtk_option_menu_new();
 989             ink_pattern_menu(mnu);
 990             gtk_signal_connect(GTK_OBJECT(mnu), "changed", GTK_SIGNAL_FUNC(sp_psel_pattern_change), psel);
 991             gtk_signal_connect(GTK_OBJECT(mnu), "destroy", GTK_SIGNAL_FUNC(sp_psel_pattern_destroy), psel);
 992             gtk_object_set_data(GTK_OBJECT(psel), "patternmenu", mnu);
 993             g_object_ref( G_OBJECT(mnu));
 994
 995             gtk_container_add(GTK_CONTAINER(hb), mnu);
 996             gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
 997         }
 998
 999         {
1000             GtkWidget *hb = gtk_hbox_new(FALSE, 0);
1001             GtkWidget *l = gtk_label_new(NULL);
1002             gtk_label_set_markup(GTK_LABEL(l), _("Use the <b>Node tool</b> to adjust position, scale, and rotation of the pattern on canvas. Use <b>Object &gt; Pattern &gt; Objects to Pattern</b> to create a new pattern from selection."));
1003             gtk_label_set_line_wrap(GTK_LABEL(l), true);
1004             gtk_widget_set_size_request(l, 180, -1);
1005             gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, AUX_BETWEEN_BUTTON_GROUPS);
1006             gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
1007         }
1008
1009         gtk_widget_show_all(tbl);
1010
1011         gtk_container_add(GTK_CONTAINER(psel->frame), tbl);
1012         psel->selector = tbl;
1013         gtk_object_set_data(GTK_OBJECT(psel->selector), "pattern-selector", tbl);
1014
1015         gtk_frame_set_label(GTK_FRAME(psel->frame), _("Pattern fill"));
1016     }
1017 #ifdef SP_PS_VERBOSE
1018     g_print("Pattern req\n");
1019 #endif
1020 }
1021
1022 SPPattern *
1023 sp_paint_selector_get_pattern(SPPaintSelector *psel)
1024 {
1025     SPPattern *pat;
1026     g_return_val_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_PATTERN) , NULL);
1027
1028     GtkWidget *patmnu = (GtkWidget *) g_object_get_data(G_OBJECT(psel), "patternmenu");
1029     /* no pattern menu if we were just selected */
1030     if ( patmnu == NULL ) return NULL;
1031
1032     GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(patmnu)));
1033
1034     /* Get Pattern */
1035     if (!g_object_get_data(G_OBJECT(gtk_menu_get_active(m)), "pattern"))
1036     {
1037         return NULL;
1038     }
1039     gchar *patid = (gchar *) g_object_get_data(G_OBJECT(gtk_menu_get_active(m)),
1040                                                 "pattern");
1041     //gchar *pattern = "";
1042     if (strcmp(patid, "none")){
1043
1044        gchar *stockid = (gchar *) g_object_get_data(G_OBJECT(gtk_menu_get_active(m)),
1045                                                 "stockid");
1046        gchar *paturn = patid;
1047        if (!strcmp(stockid,"true")) paturn = g_strconcat("urn:inkscape:pattern:",patid,NULL);
1048        SPObject *pat_obj = get_stock_item(paturn);
1049        if (pat_obj) {
1050             pat = SP_PATTERN(pat_obj);
1051         }
1052     } else {
1053     pat = pattern_getroot(SP_PATTERN(g_object_get_data(G_OBJECT(gtk_menu_get_active(m)), "pattern")));
1054     }
1055
1056     if SP_IS_PATTERN(pat) return pat;
1057     return NULL;
1058 }
1059
1060 static void sp_paint_selector_set_mode_swatch(SPPaintSelector *psel, SPPaintSelectorMode mode)
1061 {
1062     if (mode == SP_PAINT_SELECTOR_MODE_SWATCH) {
1063         sp_paint_selector_set_style_buttons(psel, psel->swatch); // TODO swatch
1064     }
1065
1066     gtk_widget_set_sensitive(psel->style, TRUE);
1067
1068     GtkWidget *tbl = NULL;
1069
1070     if (psel->mode == SP_PAINT_SELECTOR_MODE_SWATCH){
1071         /* Already have pattern menu */
1072         tbl = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "swatch-selector");
1073     } else {
1074         sp_paint_selector_clear_frame(psel);
1075
1076         /* Create vbox */
1077         tbl = gtk_vbox_new(FALSE, 4);
1078         gtk_widget_show(tbl);
1079
1080         {
1081             GtkWidget *hb = gtk_hbox_new(FALSE, 0);
1082             GtkWidget *l = gtk_label_new(NULL);
1083             gtk_label_set_markup(GTK_LABEL(l), _("Represents a swatch fill."));
1084             gtk_label_set_line_wrap(GTK_LABEL(l), true);
1085             gtk_widget_set_size_request(l, 180, -1);
1086             gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, AUX_BETWEEN_BUTTON_GROUPS);
1087             gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
1088         }
1089
1090         gtk_widget_show_all(tbl);
1091
1092         gtk_container_add(GTK_CONTAINER(psel->frame), tbl);
1093         psel->selector = tbl;
1094         gtk_object_set_data(GTK_OBJECT(psel->selector), "swatch-selector", tbl);
1095
1096         gtk_frame_set_label(GTK_FRAME(psel->frame), _("Swatch fill"));
1097     }
1098 #ifdef SP_PS_VERBOSE
1099     g_print("Swatch req\n");
1100 #endif
1101 }
1102
1103 void
1104 sp_paint_selector_set_flat_color(SPPaintSelector *psel, SPDesktop *desktop, gchar const *color_property, gchar const *opacity_property)
1105 {
1106     SPCSSAttr *css = sp_repr_css_attr_new();
1107
1108     SPColor color;
1109     gfloat alpha;
1110     sp_paint_selector_get_color_alpha(psel, &color, &alpha);
1111
1112     std::string colorStr = color.toString();
1113
1114 #ifdef SP_PS_VERBOSE
1115     guint32 rgba = color.toRGBA32( alpha );
1116     g_message("sp_paint_selector_set_flat_color() to '%s' from 0x%08x::%s",
1117               colorStr.c_str(),
1118               rgba,
1119               (color.icc?color.icc->colorProfile.c_str():"<null>") );
1120 #endif // SP_PS_VERBOSE
1121
1122     sp_repr_css_set_property(css, color_property, colorStr.c_str());
1123     Inkscape::CSSOStringStream osalpha;
1124     osalpha << alpha;
1125     sp_repr_css_set_property(css, opacity_property, osalpha.str().c_str());
1126
1127     sp_desktop_set_style(desktop, css);
1128
1129     sp_repr_css_attr_unref(css);
1130 }
1131
1132 SPPaintSelectorMode sp_style_determine_paint_selector_mode(SPStyle *style, bool isfill)
1133 {
1134     SPPaintSelectorMode mode = SP_PAINT_SELECTOR_MODE_UNSET;
1135     SPIPaint& target = isfill ? style->fill : style->stroke;
1136
1137     if ( !target.set ) {
1138         mode = SP_PAINT_SELECTOR_MODE_UNSET;
1139     } else if ( target.isPaintserver() ) {
1140         SPPaintServer *server = isfill? SP_STYLE_FILL_SERVER(style) : SP_STYLE_STROKE_SERVER(style);
1141
1142         if (server && server->isSwatch()) {
1143             mode = SP_PAINT_SELECTOR_MODE_SWATCH;
1144         } else if (SP_IS_LINEARGRADIENT(server)) {
1145             mode = SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR;
1146         } else if (SP_IS_RADIALGRADIENT(server)) {
1147             mode = SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL;
1148         } else if (SP_IS_PATTERN(server)) {
1149             mode = SP_PAINT_SELECTOR_MODE_PATTERN;
1150         } else {
1151             g_warning( "file %s: line %d: Unknown paintserver", __FILE__, __LINE__ );
1152             mode = SP_PAINT_SELECTOR_MODE_NONE;
1153         }
1154     } else if ( target.isColor() ) {
1155         mode = SP_PAINT_SELECTOR_MODE_COLOR_RGB; // so far only rgb can be read from svg
1156     } else if ( target.isNone() ) {
1157         mode = SP_PAINT_SELECTOR_MODE_NONE;
1158     } else {
1159         g_warning( "file %s: line %d: Unknown paint type", __FILE__, __LINE__ );
1160         mode = SP_PAINT_SELECTOR_MODE_NONE;
1161     }
1162
1163     return mode;
1164 }
1165
1166 /*
1167   Local Variables:
1168   mode:c++
1169   c-file-style:"stroustrup"
1170   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1171   indent-tabs-mode:nil
1172   fill-column:99
1173   End:
1174 */
1175 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :