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 GType sp_paint_selector_get_type(void)
92 {
93 static GtkType type = 0;
94 if (!type) {
95 GTypeInfo info = {
96 sizeof(SPPaintSelectorClass),
97 0, // base_init
98 0, // base_finalize
99 (GClassInitFunc)sp_paint_selector_class_init,
100 0, // class_finalize
101 0, // class_data
102 sizeof(SPPaintSelector),
103 0, // n_preallocs
104 (GInstanceInitFunc)sp_paint_selector_init,
105 0 // value_table
106 };
107 type = g_type_register_static(GTK_TYPE_VBOX, "SPPaintSelector", &info, static_cast<GTypeFlags>(0));
108 }
109 return type;
110 }
112 static void
113 sp_paint_selector_class_init(SPPaintSelectorClass *klass)
114 {
115 GtkObjectClass *object_class;
116 GtkWidgetClass *widget_class;
118 object_class = (GtkObjectClass *) klass;
119 widget_class = (GtkWidgetClass *) klass;
121 parent_class = (GtkVBoxClass*)gtk_type_class(GTK_TYPE_VBOX);
123 psel_signals[MODE_CHANGED] = gtk_signal_new("mode_changed",
124 (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
125 GTK_CLASS_TYPE(object_class),
126 GTK_SIGNAL_OFFSET(SPPaintSelectorClass, mode_changed),
127 gtk_marshal_NONE__UINT,
128 GTK_TYPE_NONE, 1, GTK_TYPE_UINT);
129 psel_signals[GRABBED] = gtk_signal_new("grabbed",
130 (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
131 GTK_CLASS_TYPE(object_class),
132 GTK_SIGNAL_OFFSET(SPPaintSelectorClass, grabbed),
133 gtk_marshal_NONE__NONE,
134 GTK_TYPE_NONE, 0);
135 psel_signals[DRAGGED] = gtk_signal_new("dragged",
136 (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
137 GTK_CLASS_TYPE(object_class),
138 GTK_SIGNAL_OFFSET(SPPaintSelectorClass, dragged),
139 gtk_marshal_NONE__NONE,
140 GTK_TYPE_NONE, 0);
141 psel_signals[RELEASED] = gtk_signal_new("released",
142 (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
143 GTK_CLASS_TYPE(object_class),
144 GTK_SIGNAL_OFFSET(SPPaintSelectorClass, released),
145 gtk_marshal_NONE__NONE,
146 GTK_TYPE_NONE, 0);
147 psel_signals[CHANGED] = gtk_signal_new("changed",
148 (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
149 GTK_CLASS_TYPE(object_class),
150 GTK_SIGNAL_OFFSET(SPPaintSelectorClass, changed),
151 gtk_marshal_NONE__NONE,
152 GTK_TYPE_NONE, 0);
153 psel_signals[FILLRULE_CHANGED] = gtk_signal_new("fillrule_changed",
154 (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
155 GTK_CLASS_TYPE(object_class),
156 GTK_SIGNAL_OFFSET(SPPaintSelectorClass, fillrule_changed),
157 gtk_marshal_NONE__UINT,
158 GTK_TYPE_NONE, 1, GTK_TYPE_UINT);
160 object_class->destroy = sp_paint_selector_destroy;
161 }
163 #define XPAD 4
164 #define YPAD 1
166 static void
167 sp_paint_selector_init(SPPaintSelector *psel)
168 {
169 GtkTooltips *tt = gtk_tooltips_new();
171 psel->mode = (SPPaintSelectorMode)-1; // huh? do you mean 0xff? -- I think this means "not in the enum"
173 /* Paint style button box */
174 psel->style = gtk_hbox_new(FALSE, 0);
175 gtk_widget_show(psel->style);
176 gtk_container_set_border_width(GTK_CONTAINER(psel->style), 4);
177 gtk_box_pack_start(GTK_BOX(psel), psel->style, FALSE, FALSE, 0);
179 /* Buttons */
180 psel->none = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_NONE,
181 SP_PAINT_SELECTOR_MODE_NONE, tt, _("No paint"));
182 psel->solid = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_SOLID,
183 SP_PAINT_SELECTOR_MODE_COLOR_RGB, tt, _("Flat color"));
184 psel->gradient = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_GRADIENT,
185 SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR, tt, _("Linear gradient"));
186 psel->radial = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_RADIAL,
187 SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL, tt, _("Radial gradient"));
188 psel->pattern = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_PATTERN,
189 SP_PAINT_SELECTOR_MODE_PATTERN, tt, _("Pattern"));
190 psel->unset = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_UNSET,
191 SP_PAINT_SELECTOR_MODE_UNSET, tt, _("Unset paint (make it undefined so it can be inherited)"));
193 /* Fillrule */
194 {
195 psel->fillrulebox = gtk_hbox_new(FALSE, 0);
196 gtk_box_pack_end(GTK_BOX(psel->style), psel->fillrulebox, FALSE, FALSE, 0);
198 GtkWidget *w;
199 psel->evenodd = gtk_radio_button_new(NULL);
200 gtk_button_set_relief(GTK_BUTTON(psel->evenodd), GTK_RELIEF_NONE);
201 gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(psel->evenodd), FALSE);
202 // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/painting.html#FillRuleProperty
203 gtk_tooltips_set_tip(tt, psel->evenodd, _("Any path self-intersections or subpaths create holes in the fill (fill-rule: evenodd)"), NULL);
204 gtk_object_set_data(GTK_OBJECT(psel->evenodd), "mode", GUINT_TO_POINTER(SP_PAINT_SELECTOR_FILLRULE_EVENODD));
205 w = sp_icon_new(Inkscape::ICON_SIZE_DECORATION, "fillrule_evenodd");
206 gtk_container_add(GTK_CONTAINER(psel->evenodd), w);
207 gtk_box_pack_start(GTK_BOX(psel->fillrulebox), psel->evenodd, FALSE, FALSE, 0);
208 gtk_signal_connect(GTK_OBJECT(psel->evenodd), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_fillrule_toggled), psel);
210 psel->nonzero = gtk_radio_button_new(gtk_radio_button_group(GTK_RADIO_BUTTON(psel->evenodd)));
211 gtk_button_set_relief(GTK_BUTTON(psel->nonzero), GTK_RELIEF_NONE);
212 gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(psel->nonzero), FALSE);
213 // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/painting.html#FillRuleProperty
214 gtk_tooltips_set_tip(tt, psel->nonzero, _("Fill is solid unless a subpath is counterdirectional (fill-rule: nonzero)"), NULL);
215 gtk_object_set_data(GTK_OBJECT(psel->nonzero), "mode", GUINT_TO_POINTER(SP_PAINT_SELECTOR_FILLRULE_NONZERO));
216 w = sp_icon_new(Inkscape::ICON_SIZE_DECORATION, "fillrule_nonzero");
217 gtk_container_add(GTK_CONTAINER(psel->nonzero), w);
218 gtk_box_pack_start(GTK_BOX(psel->fillrulebox), psel->nonzero, FALSE, FALSE, 0);
219 gtk_signal_connect(GTK_OBJECT(psel->nonzero), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_fillrule_toggled), psel);
220 }
222 /* Frame */
223 psel->frame = gtk_frame_new("");
224 gtk_widget_show(psel->frame);
225 gtk_container_set_border_width(GTK_CONTAINER(psel->frame), 0);
226 gtk_box_pack_start(GTK_BOX(psel), psel->frame, TRUE, TRUE, 0);
228 /* Last used color */
229 psel->color.set( 0.0, 0.0, 0.0 );
230 psel->alpha = 1.0;
231 }
233 static void
234 sp_paint_selector_destroy(GtkObject *object)
235 {
236 SPPaintSelector *psel = SP_PAINT_SELECTOR(object);
238 // clean up our long-living pattern menu
239 g_object_set_data(G_OBJECT(psel),"patternmenu",NULL);
241 if (((GtkObjectClass *) parent_class)->destroy)
242 (* ((GtkObjectClass *) parent_class)->destroy)(object);
243 }
245 static GtkWidget *
246 sp_paint_selector_style_button_add(SPPaintSelector *psel,
247 gchar const *pixmap, SPPaintSelectorMode mode,
248 GtkTooltips *tt, gchar const *tip)
249 {
250 GtkWidget *b, *w;
252 b = gtk_toggle_button_new();
253 gtk_tooltips_set_tip(tt, b, tip, NULL);
254 gtk_widget_show(b);
256 gtk_container_set_border_width(GTK_CONTAINER(b), 0);
258 gtk_button_set_relief(GTK_BUTTON(b), GTK_RELIEF_NONE);
260 gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(b), FALSE);
261 gtk_object_set_data(GTK_OBJECT(b), "mode", GUINT_TO_POINTER(mode));
263 w = sp_icon_new(Inkscape::ICON_SIZE_BUTTON, pixmap);
264 gtk_widget_show(w);
265 gtk_container_add(GTK_CONTAINER(b), w);
267 gtk_box_pack_start(GTK_BOX(psel->style), b, FALSE, FALSE, 0);
268 gtk_signal_connect(GTK_OBJECT(b), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_style_button_toggled), psel);
270 return b;
271 }
273 static void
274 sp_paint_selector_style_button_toggled(GtkToggleButton *tb, SPPaintSelector *psel)
275 {
276 if (!psel->update && gtk_toggle_button_get_active(tb)) {
277 sp_paint_selector_set_mode(psel, (SPPaintSelectorMode)GPOINTER_TO_UINT(gtk_object_get_data(GTK_OBJECT(tb), "mode")));
278 }
279 }
281 static void
282 sp_paint_selector_fillrule_toggled(GtkToggleButton *tb, SPPaintSelector *psel)
283 {
284 if (!psel->update && gtk_toggle_button_get_active(tb)) {
285 SPPaintSelectorFillRule fr = (SPPaintSelectorFillRule)GPOINTER_TO_UINT(gtk_object_get_data(GTK_OBJECT(tb), "mode"));
286 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[FILLRULE_CHANGED], fr);
287 }
288 }
290 void
291 sp_paint_selector_show_fillrule(SPPaintSelector *psel, bool is_fill)
292 {
293 if (psel->fillrulebox) {
294 if (is_fill) {
295 gtk_widget_show_all(psel->fillrulebox);
296 } else {
297 gtk_widget_destroy(psel->fillrulebox);
298 psel->fillrulebox = NULL;
299 }
300 }
301 }
304 GtkWidget *
305 sp_paint_selector_new(bool is_fill)
306 {
307 SPPaintSelector *psel;
309 psel = (SPPaintSelector*)gtk_type_new(SP_TYPE_PAINT_SELECTOR);
311 sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_MULTIPLE);
313 // This silliness is here because I don't know how to pass a parameter to the
314 // GtkObject "constructor" (sp_paint_selector_init). Remove it when paint_selector
315 // becomes a normal class.
316 sp_paint_selector_show_fillrule(psel, is_fill);
318 return GTK_WIDGET(psel);
319 }
321 void
322 sp_paint_selector_set_mode(SPPaintSelector *psel, SPPaintSelectorMode mode)
323 {
324 if (psel->mode != mode) {
325 psel->update = TRUE;
326 #ifdef SP_PS_VERBOSE
327 g_print("Mode change %d -> %d\n", psel->mode, mode);
328 #endif
329 switch (mode) {
330 case SP_PAINT_SELECTOR_MODE_EMPTY:
331 sp_paint_selector_set_mode_empty(psel);
332 break;
333 case SP_PAINT_SELECTOR_MODE_MULTIPLE:
334 sp_paint_selector_set_mode_multiple(psel);
335 break;
336 case SP_PAINT_SELECTOR_MODE_NONE:
337 sp_paint_selector_set_mode_none(psel);
338 break;
339 case SP_PAINT_SELECTOR_MODE_COLOR_RGB:
340 case SP_PAINT_SELECTOR_MODE_COLOR_CMYK:
341 sp_paint_selector_set_mode_color(psel, mode);
342 break;
343 case SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR:
344 case SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL:
345 sp_paint_selector_set_mode_gradient(psel, mode);
346 break;
347 case SP_PAINT_SELECTOR_MODE_PATTERN:
348 sp_paint_selector_set_mode_pattern(psel, mode);
349 break;
350 case SP_PAINT_SELECTOR_MODE_UNSET:
351 sp_paint_selector_set_mode_unset(psel);
352 break;
353 default:
354 g_warning("file %s: line %d: Unknown paint mode %d", __FILE__, __LINE__, mode);
355 break;
356 }
357 psel->mode = mode;
358 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[MODE_CHANGED], psel->mode);
359 psel->update = FALSE;
360 }
361 }
363 void
364 sp_paint_selector_set_fillrule(SPPaintSelector *psel, SPPaintSelectorFillRule fillrule)
365 {
366 if (psel->fillrulebox) {
367 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->evenodd), (fillrule == SP_PAINT_SELECTOR_FILLRULE_EVENODD));
368 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->nonzero), (fillrule == SP_PAINT_SELECTOR_FILLRULE_NONZERO));
369 }
370 }
372 void
373 sp_paint_selector_set_color_alpha(SPPaintSelector *psel, SPColor const *color, float alpha)
374 {
375 g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
376 SPColorSelector *csel;
377 guint32 rgba;
379 /*
380 if ( sp_color_get_colorspace_type(color) == SP_COLORSPACE_TYPE_CMYK )
381 {
382 #ifdef SP_PS_VERBOSE
383 g_print("PaintSelector set CMYKA\n");
384 #endif
385 sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_COLOR_CMYK);
386 }
387 else
388 */
389 {
390 #ifdef SP_PS_VERBOSE
391 g_print("PaintSelector set RGBA\n");
392 #endif
393 sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_COLOR_RGB);
394 }
396 csel = (SPColorSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
397 rgba = color->toRGBA32( alpha );
398 csel->base->setColorAlpha( *color, alpha );
399 }
401 void
402 sp_paint_selector_set_gradient_linear(SPPaintSelector *psel, SPGradient *vector)
403 {
404 SPGradientSelector *gsel;
405 #ifdef SP_PS_VERBOSE
406 g_print("PaintSelector set GRADIENT LINEAR\n");
407 #endif
408 sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR);
410 gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
412 sp_gradient_selector_set_mode(gsel, SP_GRADIENT_SELECTOR_MODE_LINEAR);
413 sp_gradient_selector_set_vector(gsel, (vector) ? SP_OBJECT_DOCUMENT(vector) : NULL, vector);
414 }
416 void
417 sp_paint_selector_set_gradient_radial(SPPaintSelector *psel, SPGradient *vector)
418 {
419 SPGradientSelector *gsel;
420 #ifdef SP_PS_VERBOSE
421 g_print("PaintSelector set GRADIENT RADIAL\n");
422 #endif
423 sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL);
425 gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
427 sp_gradient_selector_set_mode(gsel, SP_GRADIENT_SELECTOR_MODE_RADIAL);
428 sp_gradient_selector_set_vector(gsel, (vector) ? SP_OBJECT_DOCUMENT(vector) : NULL, vector);
429 }
431 void
432 sp_paint_selector_set_gradient_properties(SPPaintSelector *psel, SPGradientUnits units, SPGradientSpread spread)
433 {
434 SPGradientSelector *gsel;
435 g_return_if_fail(SP_IS_PAINT_SELECTOR(psel));
436 g_return_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) ||
437 (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL));
438 gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
439 sp_gradient_selector_set_units(gsel, units);
440 sp_gradient_selector_set_spread(gsel, spread);
441 }
443 void
444 sp_paint_selector_get_gradient_properties(SPPaintSelector *psel, SPGradientUnits *units, SPGradientSpread *spread)
445 {
446 SPGradientSelector *gsel;
447 g_return_if_fail(SP_IS_PAINT_SELECTOR(psel));
448 g_return_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) ||
449 (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL));
450 gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
451 if (units) *units = sp_gradient_selector_get_units(gsel);
452 if (spread) *spread = sp_gradient_selector_get_spread(gsel);
453 }
455 /**
456 * \post (alpha == NULL) || (*alpha in [0.0, 1.0]).
457 */
458 void
459 sp_paint_selector_get_color_alpha(SPPaintSelector *psel, SPColor *color, gfloat *alpha)
460 {
461 SPColorSelector *csel;
463 csel = (SPColorSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
465 csel->base->getColorAlpha( *color, alpha );
467 g_assert( !alpha
468 || ( ( 0.0 <= *alpha )
469 && ( *alpha <= 1.0 ) ) );
470 }
472 SPGradient *
473 sp_paint_selector_get_gradient_vector(SPPaintSelector *psel)
474 {
475 SPGradientSelector *gsel;
477 g_return_val_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) ||
478 (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL), NULL);
480 gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
482 return sp_gradient_selector_get_vector(gsel);
483 }
485 void
486 sp_gradient_selector_attrs_to_gradient(SPGradient *gr, SPPaintSelector *psel)
487 {
488 SPGradientUnits units;
489 SPGradientSpread spread;
490 sp_paint_selector_get_gradient_properties(psel, &units, &spread);
491 sp_gradient_set_units(gr, units);
492 sp_gradient_set_spread(gr, spread);
493 SP_OBJECT(gr)->updateRepr();
494 }
496 static void
497 sp_paint_selector_clear_frame(SPPaintSelector *psel)
498 {
499 g_return_if_fail( psel != NULL);
501 if (psel->selector) {
503 /* before we destroy the frame contents, we must detach
504 * the patternmenu so that Gtk doesn't gtk_widget_destroy
505 * all the children of the menu. (We also have a g_object_ref
506 * count set on it too so that the gtk_container_remove doesn't
507 * end up destroying it.
508 */
509 GtkWidget *patterns = (GtkWidget *)g_object_get_data(G_OBJECT(psel), "patternmenu");
510 if (patterns != NULL) {
511 GtkWidget * parent = gtk_widget_get_parent( GTK_WIDGET(patterns));
512 if ( parent != NULL ) {
513 g_assert( GTK_IS_CONTAINER(parent) );
514 gtk_container_remove( GTK_CONTAINER(parent), patterns );
515 }
516 }
518 gtk_widget_destroy(psel->selector);
519 psel->selector = NULL;
520 }
521 }
523 static void
524 sp_paint_selector_set_mode_empty(SPPaintSelector *psel)
525 {
526 sp_paint_selector_set_style_buttons(psel, NULL);
527 gtk_widget_set_sensitive(psel->style, FALSE);
529 sp_paint_selector_clear_frame(psel);
531 gtk_frame_set_label(GTK_FRAME(psel->frame), _("No objects"));
532 }
534 static void
535 sp_paint_selector_set_mode_multiple(SPPaintSelector *psel)
536 {
537 sp_paint_selector_set_style_buttons(psel, NULL);
538 gtk_widget_set_sensitive(psel->style, TRUE);
540 sp_paint_selector_clear_frame(psel);
542 gtk_frame_set_label(GTK_FRAME(psel->frame), _("Multiple styles"));
543 }
545 static void
546 sp_paint_selector_set_mode_unset(SPPaintSelector *psel)
547 {
548 sp_paint_selector_set_style_buttons(psel, psel->unset);
549 gtk_widget_set_sensitive(psel->style, TRUE);
551 sp_paint_selector_clear_frame(psel);
553 gtk_frame_set_label(GTK_FRAME(psel->frame), _("Paint is undefined"));
554 }
556 static void
557 sp_paint_selector_set_mode_none(SPPaintSelector *psel)
558 {
559 sp_paint_selector_set_style_buttons(psel, psel->none);
560 gtk_widget_set_sensitive(psel->style, TRUE);
562 sp_paint_selector_clear_frame(psel);
564 gtk_frame_set_label(GTK_FRAME(psel->frame), _("No paint"));
565 }
567 /* Color paint */
569 static void
570 sp_paint_selector_color_grabbed(SPColorSelector *csel, SPPaintSelector *psel)
571 {
572 (void)csel;
573 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[GRABBED]);
574 }
576 static void
577 sp_paint_selector_color_dragged(SPColorSelector *csel, SPPaintSelector *psel)
578 {
579 (void)csel;
580 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[DRAGGED]);
581 }
583 static void
584 sp_paint_selector_color_released(SPColorSelector *csel, SPPaintSelector *psel)
585 {
586 (void)csel;
587 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[RELEASED]);
588 }
590 static void
591 sp_paint_selector_color_changed(SPColorSelector *csel, SPPaintSelector *psel)
592 {
593 csel->base->getColorAlpha( psel->color, &psel->alpha );
595 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
596 }
598 static void
599 sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelectorMode mode)
600 {
601 (void)mode;
602 GtkWidget *csel;
604 sp_paint_selector_set_style_buttons(psel, psel->solid);
605 gtk_widget_set_sensitive(psel->style, TRUE);
607 if ((psel->mode == SP_PAINT_SELECTOR_MODE_COLOR_RGB) || (psel->mode == SP_PAINT_SELECTOR_MODE_COLOR_CMYK)) {
608 /* Already have color selector */
609 csel = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
610 } else {
612 sp_paint_selector_clear_frame(psel);
613 /* Create new color selector */
614 /* Create vbox */
615 GtkWidget *vb = gtk_vbox_new(FALSE, 4);
616 gtk_widget_show(vb);
618 /* Color selector */
619 csel = sp_color_selector_new( SP_TYPE_COLOR_NOTEBOOK );
620 gtk_widget_show(csel);
621 gtk_object_set_data(GTK_OBJECT(vb), "color-selector", csel);
622 gtk_box_pack_start(GTK_BOX(vb), csel, TRUE, TRUE, 0);
623 gtk_signal_connect(GTK_OBJECT(csel), "grabbed", GTK_SIGNAL_FUNC(sp_paint_selector_color_grabbed), psel);
624 gtk_signal_connect(GTK_OBJECT(csel), "dragged", GTK_SIGNAL_FUNC(sp_paint_selector_color_dragged), psel);
625 gtk_signal_connect(GTK_OBJECT(csel), "released", GTK_SIGNAL_FUNC(sp_paint_selector_color_released), psel);
626 gtk_signal_connect(GTK_OBJECT(csel), "changed", GTK_SIGNAL_FUNC(sp_paint_selector_color_changed), psel);
627 /* Pack everything to frame */
628 gtk_container_add(GTK_CONTAINER(psel->frame), vb);
629 psel->selector = vb;
631 /* Set color */
632 SP_COLOR_SELECTOR( csel )->base->setColorAlpha( psel->color, psel->alpha );
634 }
636 gtk_frame_set_label(GTK_FRAME(psel->frame), _("Flat color"));
637 #ifdef SP_PS_VERBOSE
638 g_print("Color req\n");
639 #endif
640 }
642 /* Gradient */
644 static void
645 sp_paint_selector_gradient_grabbed(SPColorSelector *csel, SPPaintSelector *psel)
646 {
647 (void)csel;
648 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[GRABBED]);
649 }
651 static void
652 sp_paint_selector_gradient_dragged(SPColorSelector *csel, SPPaintSelector *psel)
653 {
654 (void)csel;
655 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[DRAGGED]);
656 }
658 static void
659 sp_paint_selector_gradient_released(SPColorSelector *csel, SPPaintSelector *psel)
660 {
661 (void)csel;
662 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[RELEASED]);
663 }
665 static void
666 sp_paint_selector_gradient_changed(SPColorSelector *csel, SPPaintSelector *psel)
667 {
668 (void)csel;
669 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
670 }
672 static void
673 sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelectorMode mode)
674 {
675 GtkWidget *gsel;
677 /* fixme: We do not need function-wide gsel at all */
679 if (mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) {
680 sp_paint_selector_set_style_buttons(psel, psel->gradient);
681 } else {
682 sp_paint_selector_set_style_buttons(psel, psel->radial);
683 }
684 gtk_widget_set_sensitive(psel->style, TRUE);
686 if ((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) || (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL)) {
687 /* Already have gradient selector */
688 gsel = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
689 } else {
690 sp_paint_selector_clear_frame(psel);
691 /* Create new gradient selector */
692 gsel = sp_gradient_selector_new();
693 gtk_widget_show(gsel);
694 gtk_signal_connect(GTK_OBJECT(gsel), "grabbed", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_grabbed), psel);
695 gtk_signal_connect(GTK_OBJECT(gsel), "dragged", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_dragged), psel);
696 gtk_signal_connect(GTK_OBJECT(gsel), "released", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_released), psel);
697 gtk_signal_connect(GTK_OBJECT(gsel), "changed", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_changed), psel);
698 /* Pack everything to frame */
699 gtk_container_add(GTK_CONTAINER(psel->frame), gsel);
700 psel->selector = gsel;
701 gtk_object_set_data(GTK_OBJECT(psel->selector), "gradient-selector", gsel);
702 }
704 /* Actually we have to set option menu history here */
705 if (mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) {
706 sp_gradient_selector_set_mode(SP_GRADIENT_SELECTOR(gsel), SP_GRADIENT_SELECTOR_MODE_LINEAR);
707 gtk_frame_set_label(GTK_FRAME(psel->frame), _("Linear gradient"));
708 } else {
709 sp_gradient_selector_set_mode(SP_GRADIENT_SELECTOR(gsel), SP_GRADIENT_SELECTOR_MODE_RADIAL);
710 gtk_frame_set_label(GTK_FRAME(psel->frame), _("Radial gradient"));
711 }
712 #ifdef SP_PS_VERBOSE
713 g_print("Gradient req\n");
714 #endif
715 }
717 static void
718 sp_paint_selector_set_style_buttons(SPPaintSelector *psel, GtkWidget *active)
719 {
720 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->none), (active == psel->none));
721 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->solid), (active == psel->solid));
722 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->gradient), (active == psel->gradient));
723 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->radial), (active == psel->radial));
724 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->pattern), (active == psel->pattern));
725 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->unset), (active == psel->unset));
726 }
728 static void
729 sp_psel_pattern_destroy(GtkWidget *widget, SPPaintSelector *psel)
730 {
731 (void)psel;
732 // drop our reference to the pattern menu widget
733 g_object_unref( G_OBJECT(widget) );
734 }
736 static void
737 sp_psel_pattern_change(GtkWidget *widget, SPPaintSelector *psel)
738 {
739 (void)widget;
740 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
741 }
745 /**
746 * Returns a list of patterns in the defs of the given source document as a GSList object
747 * Returns NULL if there are no patterns in the document.
748 */
749 GSList *
750 ink_pattern_list_get (SPDocument *source)
751 {
752 if (source == NULL)
753 return NULL;
755 GSList *pl = NULL;
756 GSList const *patterns = sp_document_get_resource_list(source, "pattern");
757 for (GSList *l = (GSList *) patterns; l != NULL; l = l->next) {
758 if (SP_PATTERN(l->data) == pattern_getroot(SP_PATTERN(l->data))) { // only if this is a root pattern
759 pl = g_slist_prepend(pl, l->data);
760 }
761 }
763 pl = g_slist_reverse(pl);
764 return pl;
765 }
767 /**
768 * Adds menu items for pattern list - derived from marker code, left hb etc in to make addition of previews easier at some point.
769 */
770 static void
771 sp_pattern_menu_build (GtkWidget *m, GSList *pattern_list, SPDocument */*source*/)
772 {
774 for (; pattern_list != NULL; pattern_list = pattern_list->next) {
775 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) pattern_list->data);
776 GtkWidget *i = gtk_menu_item_new();
777 gtk_widget_show(i);
779 if (repr->attribute("inkscape:stockid"))
780 g_object_set_data (G_OBJECT(i), "stockid", (void *) "true");
781 else
782 g_object_set_data (G_OBJECT(i), "stockid", (void *) "false");
784 gchar const *patid = repr->attribute("id");
785 g_object_set_data (G_OBJECT(i), "pattern", (void *) patid);
787 GtkWidget *hb = gtk_hbox_new(FALSE, 4);
788 gtk_widget_show(hb);
790 // create label
791 GtkWidget *l;
792 if (repr->attribute("inkscape:stockid"))
793 l = gtk_label_new(repr->attribute("inkscape:stockid"));
794 else
795 l = gtk_label_new(repr->attribute("id"));
796 gtk_widget_show(l);
797 gtk_misc_set_alignment(GTK_MISC(l), 0.0, 0.5);
799 gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, 0);
801 gtk_widget_show(hb);
802 gtk_container_add(GTK_CONTAINER(i), hb);
804 gtk_menu_append(GTK_MENU(m), i);
805 }
806 }
808 /**
809 * sp_pattern_list_from_doc()
810 *
811 * \brief Pick up all patterns from source, except those that are in
812 * current_doc (if non-NULL), and add items to the pattern menu
813 *
814 */
815 static void
816 sp_pattern_list_from_doc (GtkWidget *m, SPDocument *current_doc, SPDocument *source, SPDocument *pattern_doc)
817 {
818 (void)current_doc;
819 (void)pattern_doc;
820 GSList *pl = ink_pattern_list_get(source);
821 GSList *clean_pl = NULL;
823 for (; pl != NULL; pl = pl->next) {
824 if (!SP_IS_PATTERN(pl->data))
825 continue;
827 // Add to the list of patterns we really do wish to show
828 clean_pl = g_slist_prepend (clean_pl, pl->data);
829 }
831 sp_pattern_menu_build (m, clean_pl, source);
833 g_slist_free (pl);
834 g_slist_free (clean_pl);
835 }
840 static void
841 ink_pattern_menu_populate_menu(GtkWidget *m, SPDocument *doc)
842 {
843 static SPDocument *patterns_doc = NULL;
845 // find and load patterns.svg
846 if (patterns_doc == NULL) {
847 char *patterns_source = g_build_filename(INKSCAPE_PATTERNSDIR, "patterns.svg", NULL);
848 if (Inkscape::IO::file_test(patterns_source, G_FILE_TEST_IS_REGULAR)) {
849 patterns_doc = sp_document_new(patterns_source, FALSE);
850 }
851 g_free(patterns_source);
852 }
854 // suck in from current doc
855 sp_pattern_list_from_doc ( m, NULL, doc, patterns_doc );
857 // add separator
858 {
859 GtkWidget *i = gtk_separator_menu_item_new();
860 gchar const *patid = "";
861 g_object_set_data (G_OBJECT(i), "pattern", (void *) patid);
862 gtk_widget_show(i);
863 gtk_menu_append(GTK_MENU(m), i);
864 }
866 // suck in from patterns.svg
867 if (patterns_doc) {
868 sp_document_ensure_up_to_date(doc);
869 sp_pattern_list_from_doc ( m, doc, patterns_doc, NULL );
870 }
872 }
875 static GtkWidget*
876 ink_pattern_menu(GtkWidget *mnu)
877 {
878 /* Create new menu widget */
879 GtkWidget *m = gtk_menu_new();
880 gtk_widget_show(m);
881 SPDocument *doc = SP_ACTIVE_DOCUMENT;
883 if (!doc) {
884 GtkWidget *i;
885 i = gtk_menu_item_new_with_label(_("No document selected"));
886 gtk_widget_show(i);
887 gtk_menu_append(GTK_MENU(m), i);
888 gtk_widget_set_sensitive(mnu, FALSE);
889 } else {
891 ink_pattern_menu_populate_menu(m, doc);
892 gtk_widget_set_sensitive(mnu, TRUE);
894 }
895 gtk_option_menu_set_menu(GTK_OPTION_MENU(mnu), m);
897 /* Set history */
898 gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
899 return mnu;
900 }
903 /*update pattern list*/
904 void
905 sp_update_pattern_list( SPPaintSelector *psel, SPPattern *pattern)
906 {
907 if (psel->update) return;
908 GtkWidget *mnu = (GtkWidget *)g_object_get_data(G_OBJECT(psel), "patternmenu");
909 g_assert( mnu != NULL );
911 /* Clear existing menu if any */
912 gtk_option_menu_remove_menu(GTK_OPTION_MENU(mnu));
914 ink_pattern_menu(mnu);
916 /* Set history */
918 if (pattern && !gtk_object_get_data(GTK_OBJECT(mnu), "update")) {
920 gtk_object_set_data(GTK_OBJECT(mnu), "update", GINT_TO_POINTER(TRUE));
922 gchar *patname = (gchar *) SP_OBJECT_REPR(pattern)->attribute("id");
924 GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(mnu)));
926 GList *kids = GTK_MENU_SHELL(m)->children;
928 int patpos = 0;
929 int i = 0;
931 for (; kids != NULL; kids = kids->next) {
933 gchar *men_pat = (gchar *) g_object_get_data(G_OBJECT(kids->data), "pattern");
934 if ( strcmp(men_pat, patname) == 0 ) {
935 patpos = i;
936 }
937 i++;
938 }
941 gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), patpos);
942 gtk_object_set_data(GTK_OBJECT(mnu), "update", GINT_TO_POINTER(FALSE));
943 }
944 //gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
945 }
947 static void
948 sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSelectorMode mode)
949 {
950 if (mode == SP_PAINT_SELECTOR_MODE_PATTERN)
951 sp_paint_selector_set_style_buttons(psel, psel->pattern);
953 gtk_widget_set_sensitive(psel->style, TRUE);
955 GtkWidget *tbl = NULL;
957 if (psel->mode == SP_PAINT_SELECTOR_MODE_PATTERN){
958 /* Already have pattern menu */
959 tbl = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "pattern-selector");
960 } else {
961 sp_paint_selector_clear_frame(psel);
963 /* Create vbox */
964 tbl = gtk_vbox_new(FALSE, 4);
965 gtk_widget_show(tbl);
967 {
968 GtkWidget *hb = gtk_hbox_new(FALSE, 1);
970 GtkWidget *mnu = gtk_option_menu_new();
971 ink_pattern_menu(mnu);
972 gtk_signal_connect(GTK_OBJECT(mnu), "changed", GTK_SIGNAL_FUNC(sp_psel_pattern_change), psel);
973 gtk_signal_connect(GTK_OBJECT(mnu), "destroy", GTK_SIGNAL_FUNC(sp_psel_pattern_destroy), psel);
974 gtk_object_set_data(GTK_OBJECT(psel), "patternmenu", mnu);
975 g_object_ref( G_OBJECT(mnu));
977 gtk_container_add(GTK_CONTAINER(hb), mnu);
978 gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
979 }
981 {
982 GtkWidget *hb = gtk_hbox_new(FALSE, 0);
983 GtkWidget *l = gtk_label_new(NULL);
984 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."));
985 gtk_label_set_line_wrap(GTK_LABEL(l), true);
986 gtk_widget_set_size_request(l, 180, -1);
987 gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, AUX_BETWEEN_BUTTON_GROUPS);
988 gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
989 }
991 gtk_widget_show_all(tbl);
993 gtk_container_add(GTK_CONTAINER(psel->frame), tbl);
994 psel->selector = tbl;
995 gtk_object_set_data(GTK_OBJECT(psel->selector), "pattern-selector", tbl);
997 gtk_frame_set_label(GTK_FRAME(psel->frame), _("Pattern fill"));
998 }
999 #ifdef SP_PS_VERBOSE
1000 g_print("Pattern req\n");
1001 #endif
1002 }
1004 SPPattern *
1005 sp_paint_selector_get_pattern(SPPaintSelector *psel)
1006 {
1007 SPPattern *pat;
1008 g_return_val_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_PATTERN) , NULL);
1010 GtkWidget *patmnu = (GtkWidget *) g_object_get_data(G_OBJECT(psel), "patternmenu");
1011 /* no pattern menu if we were just selected */
1012 if ( patmnu == NULL ) return NULL;
1014 GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(patmnu)));
1016 /* Get Pattern */
1017 if (!g_object_get_data(G_OBJECT(gtk_menu_get_active(m)), "pattern"))
1018 {
1019 return NULL;
1020 }
1021 gchar *patid = (gchar *) g_object_get_data(G_OBJECT(gtk_menu_get_active(m)),
1022 "pattern");
1023 //gchar *pattern = "";
1024 if (strcmp(patid, "none")){
1026 gchar *stockid = (gchar *) g_object_get_data(G_OBJECT(gtk_menu_get_active(m)),
1027 "stockid");
1028 gchar *paturn = patid;
1029 if (!strcmp(stockid,"true")) paturn = g_strconcat("urn:inkscape:pattern:",patid,NULL);
1030 SPObject *pat_obj = get_stock_item(paturn);
1031 if (pat_obj) {
1032 pat = SP_PATTERN(pat_obj);
1033 }
1034 } else {
1035 pat = pattern_getroot(SP_PATTERN(g_object_get_data(G_OBJECT(gtk_menu_get_active(m)), "pattern")));
1036 }
1038 if SP_IS_PATTERN(pat) return pat;
1039 return NULL;
1040 }
1042 void
1043 sp_paint_selector_set_flat_color(SPPaintSelector *psel, SPDesktop *desktop, gchar const *color_property, gchar const *opacity_property)
1044 {
1045 SPCSSAttr *css = sp_repr_css_attr_new();
1047 SPColor color;
1048 gfloat alpha;
1049 sp_paint_selector_get_color_alpha(psel, &color, &alpha);
1051 std::string colorStr = color.toString();
1053 #ifdef SP_PS_VERBOSE
1054 guint32 rgba = color.toRGBA32( alpha );
1055 g_message("sp_paint_selector_set_flat_color() to '%s' from 0x%08x::%s",
1056 colorStr.c_str(),
1057 rgba,
1058 (color.icc?color.icc->colorProfile.c_str():"<null>") );
1059 #endif // SP_PS_VERBOSE
1061 sp_repr_css_set_property(css, color_property, colorStr.c_str());
1062 Inkscape::CSSOStringStream osalpha;
1063 osalpha << alpha;
1064 sp_repr_css_set_property(css, opacity_property, osalpha.str().c_str());
1066 sp_desktop_set_style(desktop, css);
1068 sp_repr_css_attr_unref(css);
1069 }
1071 SPPaintSelectorMode
1072 sp_style_determine_paint_selector_mode(SPStyle *style, bool isfill)
1073 {
1074 SPPaintSelectorMode mode = SP_PAINT_SELECTOR_MODE_UNSET;
1075 SPIPaint& target = isfill ? style->fill : style->stroke;
1077 if ( !target.set ) {
1078 mode = SP_PAINT_SELECTOR_MODE_UNSET;
1079 } else if ( target.isPaintserver() ) {
1080 SPPaintServer *server = isfill? SP_STYLE_FILL_SERVER(style) : SP_STYLE_STROKE_SERVER(style);
1082 if (SP_IS_LINEARGRADIENT(server)) {
1083 mode = SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR;
1084 } else if (SP_IS_RADIALGRADIENT(server)) {
1085 mode = SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL;
1086 } else if (SP_IS_PATTERN(server)) {
1087 mode = SP_PAINT_SELECTOR_MODE_PATTERN;
1088 } else {
1089 g_warning( "file %s: line %d: Unknown paintserver", __FILE__, __LINE__ );
1090 mode = SP_PAINT_SELECTOR_MODE_NONE;
1091 }
1092 } else if ( target.isColor() ) {
1093 mode = SP_PAINT_SELECTOR_MODE_COLOR_RGB; // so far only rgb can be read from svg
1094 } else if ( target.isNone() ) {
1095 mode = SP_PAINT_SELECTOR_MODE_NONE;
1096 } else {
1097 g_warning( "file %s: line %d: Unknown paint type", __FILE__, __LINE__ );
1098 mode = SP_PAINT_SELECTOR_MODE_NONE;
1099 }
1101 return mode;
1102 }
1104 /*
1105 Local Variables:
1106 mode:c++
1107 c-file-style:"stroustrup"
1108 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1109 indent-tabs-mode:nil
1110 fill-column:99
1111 End:
1112 */
1113 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :