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