src/widgets/paint-selector.cpp

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