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