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