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