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