1 /** \file
2 * SPPaintSelector: Generic paint selector widget.
3 */
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 */
16 #define noSP_PS_VERBOSE
18 #ifdef HAVE_CONFIG_H
19 # include "config.h"
20 #endif
22 #include <cstring>
23 #include <string>
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>
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"
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"
57 #include "paint-selector.h"
59 #ifdef SP_PS_VERBOSE
60 #include "svg/svg-icc-color.h"
61 #endif // SP_PS_VERBOSE
64 using Inkscape::Widgets::SwatchSelector;
66 enum {
67 MODE_CHANGED,
68 GRABBED,
69 DRAGGED,
70 RELEASED,
71 CHANGED,
72 FILLRULE_CHANGED,
73 LAST_SIGNAL
74 };
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);
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);
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);
94 static void sp_paint_selector_set_style_buttons(SPPaintSelector *psel, GtkWidget *active);
96 static GtkVBoxClass *parent_class;
97 static guint psel_signals[LAST_SIGNAL] = {0};
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
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);
124 return isGrad;
125 }
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 }
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 }
162 static void
163 sp_paint_selector_class_init(SPPaintSelectorClass *klass)
164 {
165 GtkObjectClass *object_class;
166 GtkWidgetClass *widget_class;
168 object_class = (GtkObjectClass *) klass;
169 widget_class = (GtkWidgetClass *) klass;
171 parent_class = (GtkVBoxClass*)gtk_type_class(GTK_TYPE_VBOX);
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);
210 object_class->destroy = sp_paint_selector_destroy;
211 }
213 #define XPAD 4
214 #define YPAD 1
216 static void
217 sp_paint_selector_init(SPPaintSelector *psel)
218 {
219 GtkTooltips *tt = gtk_tooltips_new();
221 psel->mode = static_cast<SPPaintSelector::Mode>(-1); // huh? do you mean 0xff? -- I think this means "not in the enum"
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);
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)"));
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);
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);
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 }
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);
280 /* Last used color */
281 psel->color.set( 0.0, 0.0, 0.0 );
282 psel->alpha = 1.0;
283 }
285 static void
286 sp_paint_selector_destroy(GtkObject *object)
287 {
288 SPPaintSelector *psel = SP_PAINT_SELECTOR(object);
290 // clean up our long-living pattern menu
291 g_object_set_data(G_OBJECT(psel),"patternmenu",NULL);
293 if (((GtkObjectClass *) parent_class)->destroy)
294 (* ((GtkObjectClass *) parent_class)->destroy)(object);
295 }
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;
303 b = gtk_toggle_button_new();
304 gtk_tooltips_set_tip(tt, b, tip, NULL);
305 gtk_widget_show(b);
307 gtk_container_set_border_width(GTK_CONTAINER(b), 0);
309 gtk_button_set_relief(GTK_BUTTON(b), GTK_RELIEF_NONE);
311 gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(b), FALSE);
312 gtk_object_set_data(GTK_OBJECT(b), "mode", GUINT_TO_POINTER(mode));
314 w = sp_icon_new(Inkscape::ICON_SIZE_BUTTON, pixmap);
315 gtk_widget_show(w);
316 gtk_container_add(GTK_CONTAINER(b), w);
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);
321 return b;
322 }
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 }
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 }
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 }
355 GtkWidget *
356 sp_paint_selector_new(bool is_fill)
357 {
358 SPPaintSelector *psel = static_cast<SPPaintSelector*>(gtk_type_new(SP_TYPE_PAINT_SELECTOR));
360 psel->setMode(SPPaintSelector::MODE_MULTIPLE);
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, is_fill);
367 return GTK_WIDGET(psel);
368 }
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 }
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 }
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;
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 }
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 }
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);
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 }
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);
471 SPGradientSelector *gsel = getGradientFromData(this);
473 gsel->setMode(SPGradientSelector::MODE_LINEAR);
474 gsel->setVector((vector) ? SP_OBJECT_DOCUMENT(vector) : 0, vector);
475 }
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);
484 SPGradientSelector *gsel = getGradientFromData(this);
486 gsel->setMode(SPGradientSelector::MODE_RADIAL);
488 gsel->setVector((vector) ? SP_OBJECT_DOCUMENT(vector) : 0, vector);
489 }
491 void SPPaintSelector::setGradientProperties( SPGradientUnits units, SPGradientSpread spread )
492 {
493 g_return_if_fail(isPaintModeGradient(mode));
495 SPGradientSelector *gsel = getGradientFromData(this);
496 gsel->setUnits(units);
497 gsel->setSpread(spread);
498 }
500 void SPPaintSelector::getGradientProperties( SPGradientUnits &units, SPGradientSpread &spread) const
501 {
502 g_return_if_fail(isPaintModeGradient(mode));
504 SPGradientSelector *gsel = getGradientFromData(this);
505 units = gsel->getUnits();
506 spread = gsel->getSpread();
507 }
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;
516 csel = reinterpret_cast<SPColorSelector*>(g_object_get_data(G_OBJECT(selector), "color-selector"));
518 csel->base->getColorAlpha( color, alpha );
520 g_assert( ( 0.0 <= alpha )
521 && ( alpha <= 1.0 ) );
522 }
524 SPGradient *SPPaintSelector::getGradientVector()
525 {
526 SPGradient* vect = 0;
528 if (isPaintModeGradient(mode)) {
529 SPGradientSelector *gsel = getGradientFromData(this);
530 vect = gsel->getVector();
531 }
533 return vect;
534 }
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 sp_gradient_set_units(gr, units);
543 sp_gradient_set_spread(gr, spread);
544 SP_OBJECT(gr)->updateRepr();
545 }
547 static void
548 sp_paint_selector_clear_frame(SPPaintSelector *psel)
549 {
550 g_return_if_fail( psel != NULL);
552 if (psel->selector) {
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 }
569 gtk_widget_destroy(psel->selector);
570 psel->selector = NULL;
571 }
572 }
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);
580 sp_paint_selector_clear_frame(psel);
582 gtk_frame_set_label(GTK_FRAME(psel->frame), _("No objects"));
583 }
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);
591 sp_paint_selector_clear_frame(psel);
593 gtk_frame_set_label(GTK_FRAME(psel->frame), _("Multiple styles"));
594 }
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);
602 sp_paint_selector_clear_frame(psel);
604 gtk_frame_set_label(GTK_FRAME(psel->frame), _("Paint is undefined"));
605 }
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);
613 sp_paint_selector_clear_frame(psel);
615 gtk_frame_set_label(GTK_FRAME(psel->frame), _("No paint"));
616 }
618 /* Color paint */
620 static void sp_paint_selector_color_grabbed(SPColorSelector * /*csel*/, SPPaintSelector *psel)
621 {
622 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[GRABBED]);
623 }
625 static void sp_paint_selector_color_dragged(SPColorSelector * /*csel*/, SPPaintSelector *psel)
626 {
627 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[DRAGGED]);
628 }
630 static void sp_paint_selector_color_released(SPColorSelector * /*csel*/, SPPaintSelector *psel)
631 {
632 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[RELEASED]);
633 }
635 static void
636 sp_paint_selector_color_changed(SPColorSelector *csel, SPPaintSelector *psel)
637 {
638 csel->base->getColorAlpha( psel->color, psel->alpha );
640 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
641 }
643 static void sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelector::Mode /*mode*/)
644 {
645 GtkWidget *csel;
647 sp_paint_selector_set_style_buttons(psel, psel->solid);
648 gtk_widget_set_sensitive(psel->style, TRUE);
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 {
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);
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;
674 /* Set color */
675 SP_COLOR_SELECTOR( csel )->base->setColorAlpha( psel->color, psel->alpha );
677 }
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 }
685 /* Gradient */
687 static void sp_paint_selector_gradient_grabbed(SPColorSelector * /*csel*/, SPPaintSelector *psel)
688 {
689 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[GRABBED]);
690 }
692 static void sp_paint_selector_gradient_dragged(SPColorSelector * /*csel*/, SPPaintSelector *psel)
693 {
694 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[DRAGGED]);
695 }
697 static void sp_paint_selector_gradient_released(SPColorSelector * /*csel*/, SPPaintSelector *psel)
698 {
699 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[RELEASED]);
700 }
702 static void sp_paint_selector_gradient_changed(SPColorSelector * /*csel*/, SPPaintSelector *psel)
703 {
704 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
705 }
707 static void sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelector::Mode mode)
708 {
709 GtkWidget *gsel;
711 /* fixme: We do not need function-wide gsel at all */
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);
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 }
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 }
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 }
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 }
770 static void sp_psel_pattern_change(GtkWidget * /*widget*/, SPPaintSelector *psel)
771 {
772 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
773 }
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;
787 GSList *pl = NULL;
788 GSList const *patterns = sp_document_get_resource_list(source, "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 }
795 pl = g_slist_reverse(pl);
796 return pl;
797 }
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 {
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);
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");
816 gchar const *patid = repr->attribute("id");
817 g_object_set_data (G_OBJECT(i), "pattern", (void *) patid);
819 GtkWidget *hb = gtk_hbox_new(FALSE, 4);
820 gtk_widget_show(hb);
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);
831 gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, 0);
833 gtk_widget_show(hb);
834 gtk_container_add(GTK_CONTAINER(i), hb);
836 gtk_menu_append(GTK_MENU(m), i);
837 }
838 }
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;
852 for (; pl != NULL; pl = pl->next) {
853 if (!SP_IS_PATTERN(pl->data)) {
854 continue;
855 }
857 // Add to the list of patterns we really do wish to show
858 clean_pl = g_slist_prepend (clean_pl, pl->data);
859 }
861 sp_pattern_menu_build (m, clean_pl, source);
863 g_slist_free (pl);
864 g_slist_free (clean_pl);
865 }
870 static void
871 ink_pattern_menu_populate_menu(GtkWidget *m, SPDocument *doc)
872 {
873 static SPDocument *patterns_doc = NULL;
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 = sp_document_new(patterns_source, FALSE);
880 }
881 g_free(patterns_source);
882 }
884 // suck in from current doc
885 sp_pattern_list_from_doc ( m, NULL, doc, patterns_doc );
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 }
896 // suck in from patterns.svg
897 if (patterns_doc) {
898 sp_document_ensure_up_to_date(doc);
899 sp_pattern_list_from_doc ( m, doc, patterns_doc, NULL );
900 }
902 }
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;
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 {
921 ink_pattern_menu_populate_menu(m, doc);
922 gtk_widget_set_sensitive(mnu, TRUE);
924 }
925 gtk_option_menu_set_menu(GTK_OPTION_MENU(mnu), m);
927 /* Set history */
928 gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
929 return mnu;
930 }
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 );
942 /* Clear existing menu if any */
943 gtk_option_menu_remove_menu(GTK_OPTION_MENU(mnu));
945 ink_pattern_menu(mnu);
947 /* Set history */
949 if (pattern && !gtk_object_get_data(GTK_OBJECT(mnu), "update")) {
951 gtk_object_set_data(GTK_OBJECT(mnu), "update", GINT_TO_POINTER(TRUE));
953 gchar *patname = (gchar *) SP_OBJECT_REPR(pattern)->attribute("id");
955 GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(mnu)));
957 GList *kids = GTK_MENU_SHELL(m)->children;
959 int patpos = 0;
960 int i = 0;
962 for (; kids != NULL; kids = kids->next) {
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 }
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 }
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 }
984 gtk_widget_set_sensitive(psel->style, TRUE);
986 GtkWidget *tbl = NULL;
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);
994 /* Create vbox */
995 tbl = gtk_vbox_new(FALSE, 4);
996 gtk_widget_show(tbl);
998 {
999 GtkWidget *hb = gtk_hbox_new(FALSE, 1);
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));
1008 gtk_container_add(GTK_CONTAINER(hb), mnu);
1009 gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
1010 }
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 > Pattern > 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 }
1022 gtk_widget_show_all(tbl);
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);
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 }
1035 SPPattern *SPPaintSelector::getPattern()
1036 {
1037 SPPattern *pat = 0;
1038 g_return_val_if_fail((mode == MODE_PATTERN) , NULL);
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;
1044 GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(patmnu)));
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")){
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 }
1068 if (pat && !SP_IS_PATTERN(pat)) {
1069 pat = 0;
1070 }
1072 return pat;
1073 }
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 }
1081 gtk_widget_set_sensitive(psel->style, TRUE);
1083 SwatchSelector *swatchsel = 0;
1085 if (psel->mode == SPPaintSelector::MODE_SWATCH){
1086 /* Already have pattern menu */
1087 swatchsel = static_cast<SwatchSelector*>(g_object_get_data(G_OBJECT(psel->selector), "swatch-selector"));
1088 } else {
1089 sp_paint_selector_clear_frame(psel);
1090 /* Create new gradient selector */
1091 SwatchSelector *swatchsel = new SwatchSelector();
1092 swatchsel->show();
1094 swatchsel->connectGrabbedHandler( G_CALLBACK(sp_paint_selector_gradient_grabbed), psel );
1095 swatchsel->connectDraggedHandler( G_CALLBACK(sp_paint_selector_gradient_dragged), psel );
1096 swatchsel->connectReleasedHandler( G_CALLBACK(sp_paint_selector_gradient_released), psel );
1097 swatchsel->connectchangedHandler( G_CALLBACK(sp_paint_selector_gradient_changed), psel );
1099 // Pack everything to frame
1100 gtk_container_add(GTK_CONTAINER(psel->frame), GTK_WIDGET(swatchsel->gobj()));
1101 psel->selector = GTK_WIDGET(swatchsel->gobj());
1102 gtk_object_set_data(GTK_OBJECT(psel->selector), "swatch-selector", swatchsel);
1104 gtk_frame_set_label(GTK_FRAME(psel->frame), _("Swatch fill"));
1105 }
1106 #ifdef SP_PS_VERBOSE
1107 g_print("Swatch req\n");
1108 #endif
1109 }
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();
1116 SPColor color;
1117 gfloat alpha = 0;
1118 getColorAlpha( color, alpha );
1120 std::string colorStr = color.toString();
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
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());
1135 sp_desktop_set_style(desktop, css);
1137 sp_repr_css_attr_unref(css);
1138 }
1140 SPPaintSelector::Mode SPPaintSelector::getModeForStyle(SPStyle const & style, bool isfill)
1141 {
1142 Mode mode = MODE_UNSET;
1143 SPIPaint const & target = isfill ? style.fill : style.stroke;
1145 if ( !target.set ) {
1146 mode = MODE_UNSET;
1147 } else if ( target.isPaintserver() ) {
1148 SPPaintServer const *server = isfill ? style.getFillPaintServer() : style.getStrokePaintServer();
1150 #ifdef SP_PS_VERBOSE
1151 g_message("SPPaintSelector::getModeForStyle(%p, %d)", &style, isfill);
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
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 }
1178 return mode;
1179 }
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:encoding=utf-8:textwidth=99 :