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