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 */
12 #define noSP_PS_VERBOSE
14 #ifdef HAVE_CONFIG_H
15 # include "config.h"
16 #endif
20 #include <gtk/gtkhbox.h>
21 #include <gtk/gtkradiobutton.h>
22 #include <gtk/gtkframe.h>
23 #include <gtk/gtklabel.h>
24 #include <gtk/gtkoptionmenu.h>
25 #include <gtk/gtktooltips.h>
26 #include <gtk/gtkmenuitem.h>
28 #include "../sp-pattern.h"
29 #include <glibmm/i18n.h>
30 #include "../widgets/icon.h"
31 #include "../inkscape-stock.h"
32 #include "widgets/widget-sizes.h"
33 #include "xml/repr.h"
35 #include "sp-color-notebook.h"
36 #include "sp-linear-gradient-fns.h"
37 #include "sp-radial-gradient-fns.h"
38 /* fixme: Move it from dialogs to here */
39 #include "gradient-selector.h"
40 #include <inkscape.h>
41 #include <document-private.h>
42 #include <desktop-style.h>
43 #include <style.h>
44 #include "svg/svg-color.h"
45 #include "svg/css-ostringstream.h"
47 #include "paint-selector.h"
49 enum {
50 MODE_CHANGED,
51 GRABBED,
52 DRAGGED,
53 RELEASED,
54 CHANGED,
55 FILLRULE_CHANGED,
56 LAST_SIGNAL
57 };
59 static void sp_paint_selector_class_init(SPPaintSelectorClass *klass);
60 static void sp_paint_selector_init(SPPaintSelector *slider);
61 static void sp_paint_selector_destroy(GtkObject *object);
63 static GtkWidget *sp_paint_selector_style_button_add(SPPaintSelector *psel, gchar const *px, SPPaintSelectorMode mode, GtkTooltips *tt, gchar const *tip);
64 static void sp_paint_selector_style_button_toggled(GtkToggleButton *tb, SPPaintSelector *psel);
65 static void sp_paint_selector_fillrule_toggled(GtkToggleButton *tb, SPPaintSelector *psel);
67 static void sp_paint_selector_set_mode_empty(SPPaintSelector *psel);
68 static void sp_paint_selector_set_mode_multiple(SPPaintSelector *psel);
69 static void sp_paint_selector_set_mode_none(SPPaintSelector *psel);
70 static void sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelectorMode mode);
71 static void sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelectorMode mode);
72 static void sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSelectorMode mode);
73 static void sp_paint_selector_set_mode_unset(SPPaintSelector *psel);
76 static void sp_paint_selector_set_style_buttons(SPPaintSelector *psel, GtkWidget *active);
78 static GtkVBoxClass *parent_class;
79 static guint psel_signals[LAST_SIGNAL] = {0};
81 GtkType
82 sp_paint_selector_get_type(void)
83 {
84 static GtkType type = 0;
85 if (!type) {
86 GtkTypeInfo info = {
87 "SPPaintSelector",
88 sizeof(SPPaintSelector),
89 sizeof(SPPaintSelectorClass),
90 (GtkClassInitFunc) sp_paint_selector_class_init,
91 (GtkObjectInitFunc) sp_paint_selector_init,
92 NULL, NULL, NULL
93 };
94 type = gtk_type_unique(GTK_TYPE_VBOX, &info);
95 }
96 return type;
97 }
99 static void
100 sp_paint_selector_class_init(SPPaintSelectorClass *klass)
101 {
102 GtkObjectClass *object_class;
103 GtkWidgetClass *widget_class;
105 object_class = (GtkObjectClass *) klass;
106 widget_class = (GtkWidgetClass *) klass;
108 parent_class = (GtkVBoxClass*)gtk_type_class(GTK_TYPE_VBOX);
110 psel_signals[MODE_CHANGED] = gtk_signal_new("mode_changed",
111 (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
112 GTK_CLASS_TYPE(object_class),
113 GTK_SIGNAL_OFFSET(SPPaintSelectorClass, mode_changed),
114 gtk_marshal_NONE__UINT,
115 GTK_TYPE_NONE, 1, GTK_TYPE_UINT);
116 psel_signals[GRABBED] = gtk_signal_new("grabbed",
117 (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
118 GTK_CLASS_TYPE(object_class),
119 GTK_SIGNAL_OFFSET(SPPaintSelectorClass, grabbed),
120 gtk_marshal_NONE__NONE,
121 GTK_TYPE_NONE, 0);
122 psel_signals[DRAGGED] = gtk_signal_new("dragged",
123 (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
124 GTK_CLASS_TYPE(object_class),
125 GTK_SIGNAL_OFFSET(SPPaintSelectorClass, dragged),
126 gtk_marshal_NONE__NONE,
127 GTK_TYPE_NONE, 0);
128 psel_signals[RELEASED] = gtk_signal_new("released",
129 (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
130 GTK_CLASS_TYPE(object_class),
131 GTK_SIGNAL_OFFSET(SPPaintSelectorClass, released),
132 gtk_marshal_NONE__NONE,
133 GTK_TYPE_NONE, 0);
134 psel_signals[CHANGED] = gtk_signal_new("changed",
135 (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
136 GTK_CLASS_TYPE(object_class),
137 GTK_SIGNAL_OFFSET(SPPaintSelectorClass, changed),
138 gtk_marshal_NONE__NONE,
139 GTK_TYPE_NONE, 0);
140 psel_signals[FILLRULE_CHANGED] = gtk_signal_new("fillrule_changed",
141 (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
142 GTK_CLASS_TYPE(object_class),
143 GTK_SIGNAL_OFFSET(SPPaintSelectorClass, fillrule_changed),
144 gtk_marshal_NONE__UINT,
145 GTK_TYPE_NONE, 1, GTK_TYPE_UINT);
147 object_class->destroy = sp_paint_selector_destroy;
148 }
150 #define XPAD 4
151 #define YPAD 1
153 static void
154 sp_paint_selector_init(SPPaintSelector *psel)
155 {
156 GtkTooltips *tt = gtk_tooltips_new();
158 psel->mode = (SPPaintSelectorMode)-1; // huh? do you mean 0xff? -- I think this means "not in the enum"
160 /* Paint style button box */
161 psel->style = gtk_hbox_new(FALSE, 0);
162 gtk_widget_show(psel->style);
163 gtk_container_set_border_width(GTK_CONTAINER(psel->style), 4);
164 gtk_box_pack_start(GTK_BOX(psel), psel->style, FALSE, FALSE, 0);
166 /* Buttons */
167 psel->none = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_NONE,
168 SP_PAINT_SELECTOR_MODE_NONE, tt, _("No paint"));
169 psel->solid = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_SOLID,
170 SP_PAINT_SELECTOR_MODE_COLOR_RGB, tt, _("Flat color"));
171 psel->gradient = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_GRADIENT,
172 SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR, tt, _("Linear gradient"));
173 psel->radial = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_RADIAL,
174 SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL, tt, _("Radial gradient"));
175 psel->pattern = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_PATTERN,
176 SP_PAINT_SELECTOR_MODE_PATTERN, tt, _("Pattern"));
177 psel->unset = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_UNSET,
178 SP_PAINT_SELECTOR_MODE_UNSET, tt, _("Unset paint (make it undefined so it can be inherited)"));
180 /* Fillrule */
181 {
182 psel->fillrulebox = gtk_hbox_new(FALSE, 0);
183 gtk_box_pack_end(GTK_BOX(psel->style), psel->fillrulebox, FALSE, FALSE, 0);
185 GtkWidget *w;
186 psel->evenodd = gtk_radio_button_new(NULL);
187 gtk_button_set_relief(GTK_BUTTON(psel->evenodd), GTK_RELIEF_NONE);
188 gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(psel->evenodd), FALSE);
189 // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/painting.html#FillRuleProperty
190 gtk_tooltips_set_tip(tt, psel->evenodd, _("Any path self-intersections or subpaths create holes in the fill (fill-rule: evenodd)"), NULL);
191 gtk_object_set_data(GTK_OBJECT(psel->evenodd), "mode", GUINT_TO_POINTER(SP_PAINT_SELECTOR_FILLRULE_EVENODD));
192 w = sp_icon_new(Inkscape::ICON_SIZE_DECORATION, "fillrule_evenodd");
193 gtk_container_add(GTK_CONTAINER(psel->evenodd), w);
194 gtk_box_pack_start(GTK_BOX(psel->fillrulebox), psel->evenodd, FALSE, FALSE, 0);
195 gtk_signal_connect(GTK_OBJECT(psel->evenodd), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_fillrule_toggled), psel);
197 psel->nonzero = gtk_radio_button_new(gtk_radio_button_group(GTK_RADIO_BUTTON(psel->evenodd)));
198 gtk_button_set_relief(GTK_BUTTON(psel->nonzero), GTK_RELIEF_NONE);
199 gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(psel->nonzero), FALSE);
200 // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/painting.html#FillRuleProperty
201 gtk_tooltips_set_tip(tt, psel->nonzero, _("Fill is solid unless a subpath is counterdirectional (fill-rule: nonzero)"), NULL);
202 gtk_object_set_data(GTK_OBJECT(psel->nonzero), "mode", GUINT_TO_POINTER(SP_PAINT_SELECTOR_FILLRULE_NONZERO));
203 w = sp_icon_new(Inkscape::ICON_SIZE_DECORATION, "fillrule_nonzero");
204 gtk_container_add(GTK_CONTAINER(psel->nonzero), w);
205 gtk_box_pack_start(GTK_BOX(psel->fillrulebox), psel->nonzero, FALSE, FALSE, 0);
206 gtk_signal_connect(GTK_OBJECT(psel->nonzero), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_fillrule_toggled), psel);
207 }
209 /* Frame */
210 psel->frame = gtk_frame_new("");
211 gtk_widget_show(psel->frame);
212 gtk_container_set_border_width(GTK_CONTAINER(psel->frame), 0);
213 gtk_box_pack_start(GTK_BOX(psel), psel->frame, TRUE, TRUE, 0);
215 /* Last used color */
216 sp_color_set_rgb_float(&psel->color, 0.0, 0.0, 0.0);
217 psel->alpha = 1.0;
218 }
220 static void
221 sp_paint_selector_destroy(GtkObject *object)
222 {
223 SPPaintSelector *psel = SP_PAINT_SELECTOR(object);
225 // clean up our long-living pattern menu
226 g_object_set_data(G_OBJECT(psel),"patternmenu",NULL);
228 if (((GtkObjectClass *) parent_class)->destroy)
229 (* ((GtkObjectClass *) parent_class)->destroy)(object);
230 }
232 static GtkWidget *
233 sp_paint_selector_style_button_add(SPPaintSelector *psel,
234 gchar const *pixmap, SPPaintSelectorMode mode,
235 GtkTooltips *tt, gchar const *tip)
236 {
237 GtkWidget *b, *w;
239 b = gtk_toggle_button_new();
240 gtk_tooltips_set_tip(tt, b, tip, NULL);
241 gtk_widget_show(b);
243 gtk_container_set_border_width(GTK_CONTAINER(b), 0);
245 gtk_button_set_relief(GTK_BUTTON(b), GTK_RELIEF_NONE);
247 gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(b), FALSE);
248 gtk_object_set_data(GTK_OBJECT(b), "mode", GUINT_TO_POINTER(mode));
250 w = sp_icon_new(Inkscape::ICON_SIZE_BUTTON, pixmap);
251 gtk_widget_show(w);
252 gtk_container_add(GTK_CONTAINER(b), w);
254 gtk_box_pack_start(GTK_BOX(psel->style), b, FALSE, FALSE, 0);
255 gtk_signal_connect(GTK_OBJECT(b), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_style_button_toggled), psel);
257 return b;
258 }
260 static void
261 sp_paint_selector_style_button_toggled(GtkToggleButton *tb, SPPaintSelector *psel)
262 {
263 if (!psel->update && gtk_toggle_button_get_active(tb)) {
264 sp_paint_selector_set_mode(psel, (SPPaintSelectorMode)GPOINTER_TO_UINT(gtk_object_get_data(GTK_OBJECT(tb), "mode")));
265 }
266 }
268 static void
269 sp_paint_selector_fillrule_toggled(GtkToggleButton *tb, SPPaintSelector *psel)
270 {
271 if (!psel->update && gtk_toggle_button_get_active(tb)) {
272 SPPaintSelectorFillRule fr = (SPPaintSelectorFillRule)GPOINTER_TO_UINT(gtk_object_get_data(GTK_OBJECT(tb), "mode"));
273 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[FILLRULE_CHANGED], fr);
274 }
275 }
277 void
278 sp_paint_selector_show_fillrule(SPPaintSelector *psel, bool is_fill)
279 {
280 if (psel->fillrulebox) {
281 if (is_fill) {
282 gtk_widget_show_all(psel->fillrulebox);
283 } else {
284 gtk_widget_destroy(psel->fillrulebox);
285 psel->fillrulebox = NULL;
286 }
287 }
288 }
291 GtkWidget *
292 sp_paint_selector_new(bool is_fill)
293 {
294 SPPaintSelector *psel;
296 psel = (SPPaintSelector*)gtk_type_new(SP_TYPE_PAINT_SELECTOR);
298 sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_MULTIPLE);
300 // This silliness is here because I don't know how to pass a parameter to the
301 // GtkObject "constructor" (sp_paint_selector_init). Remove it when paint_selector
302 // becomes a normal class.
303 sp_paint_selector_show_fillrule(psel, is_fill);
305 return GTK_WIDGET(psel);
306 }
308 void
309 sp_paint_selector_set_mode(SPPaintSelector *psel, SPPaintSelectorMode mode)
310 {
311 if (psel->mode != mode) {
312 psel->update = TRUE;
313 #ifdef SP_PS_VERBOSE
314 g_print("Mode change %d -> %d\n", psel->mode, mode);
315 #endif
316 switch (mode) {
317 case SP_PAINT_SELECTOR_MODE_EMPTY:
318 sp_paint_selector_set_mode_empty(psel);
319 break;
320 case SP_PAINT_SELECTOR_MODE_MULTIPLE:
321 sp_paint_selector_set_mode_multiple(psel);
322 break;
323 case SP_PAINT_SELECTOR_MODE_NONE:
324 sp_paint_selector_set_mode_none(psel);
325 break;
326 case SP_PAINT_SELECTOR_MODE_COLOR_RGB:
327 case SP_PAINT_SELECTOR_MODE_COLOR_CMYK:
328 sp_paint_selector_set_mode_color(psel, mode);
329 break;
330 case SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR:
331 case SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL:
332 sp_paint_selector_set_mode_gradient(psel, mode);
333 break;
334 case SP_PAINT_SELECTOR_MODE_PATTERN:
335 sp_paint_selector_set_mode_pattern(psel, mode);
336 break;
337 case SP_PAINT_SELECTOR_MODE_UNSET:
338 sp_paint_selector_set_mode_unset(psel);
339 break;
340 default:
341 g_warning("file %s: line %d: Unknown paint mode %d", __FILE__, __LINE__, mode);
342 break;
343 }
344 psel->mode = mode;
345 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[MODE_CHANGED], psel->mode);
346 psel->update = FALSE;
347 }
348 }
350 void
351 sp_paint_selector_set_fillrule(SPPaintSelector *psel, SPPaintSelectorFillRule fillrule)
352 {
353 if (psel->fillrulebox) {
354 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->evenodd), (fillrule == SP_PAINT_SELECTOR_FILLRULE_EVENODD));
355 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->nonzero), (fillrule == SP_PAINT_SELECTOR_FILLRULE_NONZERO));
356 }
357 }
359 void
360 sp_paint_selector_set_color_alpha(SPPaintSelector *psel, SPColor const *color, float alpha)
361 {
362 g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
363 SPColorSelector *csel;
364 guint32 rgba;
366 if ( sp_color_get_colorspace_type(color) == SP_COLORSPACE_TYPE_CMYK )
367 {
368 #ifdef SP_PS_VERBOSE
369 g_print("PaintSelector set CMYKA\n");
370 #endif
371 sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_COLOR_CMYK);
372 }
373 else
374 {
375 #ifdef SP_PS_VERBOSE
376 g_print("PaintSelector set RGBA\n");
377 #endif
378 sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_COLOR_RGB);
379 }
381 csel = (SPColorSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
382 rgba = sp_color_get_rgba32_falpha( &*color, alpha );
383 csel->base->setColorAlpha( *color, alpha );
384 }
386 void
387 sp_paint_selector_set_gradient_linear(SPPaintSelector *psel, SPGradient *vector)
388 {
389 SPGradientSelector *gsel;
390 #ifdef SP_PS_VERBOSE
391 g_print("PaintSelector set GRADIENT LINEAR\n");
392 #endif
393 sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR);
395 gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
397 sp_gradient_selector_set_mode(gsel, SP_GRADIENT_SELECTOR_MODE_LINEAR);
398 sp_gradient_selector_set_vector(gsel, (vector) ? SP_OBJECT_DOCUMENT(vector) : NULL, vector);
399 }
401 void
402 sp_paint_selector_set_gradient_radial(SPPaintSelector *psel, SPGradient *vector)
403 {
404 SPGradientSelector *gsel;
405 #ifdef SP_PS_VERBOSE
406 g_print("PaintSelector set GRADIENT RADIAL\n");
407 #endif
408 sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL);
410 gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
412 sp_gradient_selector_set_mode(gsel, SP_GRADIENT_SELECTOR_MODE_RADIAL);
413 sp_gradient_selector_set_vector(gsel, (vector) ? SP_OBJECT_DOCUMENT(vector) : NULL, vector);
414 }
416 void
417 sp_paint_selector_set_gradient_properties(SPPaintSelector *psel, SPGradientUnits units, SPGradientSpread spread)
418 {
419 SPGradientSelector *gsel;
420 g_return_if_fail(SP_IS_PAINT_SELECTOR(psel));
421 g_return_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) ||
422 (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL));
423 gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
424 sp_gradient_selector_set_units(gsel, units);
425 sp_gradient_selector_set_spread(gsel, spread);
426 }
428 void
429 sp_paint_selector_get_gradient_properties(SPPaintSelector *psel, SPGradientUnits *units, SPGradientSpread *spread)
430 {
431 SPGradientSelector *gsel;
432 g_return_if_fail(SP_IS_PAINT_SELECTOR(psel));
433 g_return_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) ||
434 (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL));
435 gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
436 if (units) *units = sp_gradient_selector_get_units(gsel);
437 if (spread) *spread = sp_gradient_selector_get_spread(gsel);
438 }
440 /**
441 * \post (alpha == NULL) || (*alpha in [0.0, 1.0]).
442 */
443 void
444 sp_paint_selector_get_color_alpha(SPPaintSelector *psel, SPColor *color, gfloat *alpha)
445 {
446 SPColorSelector *csel;
448 csel = (SPColorSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
450 csel->base->getColorAlpha( *color, alpha );
452 g_assert( !alpha
453 || ( ( 0.0 <= *alpha )
454 && ( *alpha <= 1.0 ) ) );
455 }
457 SPGradient *
458 sp_paint_selector_get_gradient_vector(SPPaintSelector *psel)
459 {
460 SPGradientSelector *gsel;
462 g_return_val_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) ||
463 (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL), NULL);
465 gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
467 return sp_gradient_selector_get_vector(gsel);
468 }
470 void
471 sp_gradient_selector_attrs_to_gradient(SPGradient *gr, SPPaintSelector *psel)
472 {
473 SPGradientUnits units;
474 SPGradientSpread spread;
475 sp_paint_selector_get_gradient_properties(psel, &units, &spread);
476 sp_gradient_set_units(gr, units);
477 sp_gradient_set_spread(gr, spread);
478 SP_OBJECT(gr)->updateRepr();
479 }
481 static void
482 sp_paint_selector_clear_frame(SPPaintSelector *psel)
483 {
484 g_return_if_fail( psel != NULL);
486 if (psel->selector) {
488 /* before we destroy the frame contents, we must detach
489 * the patternmenu so that Gtk doesn't gtk_widget_destroy
490 * all the children of the menu. (We also have a g_object_ref
491 * count set on it too so that the gtk_container_remove doesn't
492 * end up destroying it.
493 */
494 GtkWidget *patterns = (GtkWidget *)g_object_get_data(G_OBJECT(psel), "patternmenu");
495 if (patterns != NULL) {
496 GtkWidget * parent = gtk_widget_get_parent( GTK_WIDGET(patterns));
497 if ( parent != NULL ) {
498 g_assert( GTK_IS_CONTAINER(parent) );
499 gtk_container_remove( GTK_CONTAINER(parent), patterns );
500 }
501 }
503 gtk_widget_destroy(psel->selector);
504 psel->selector = NULL;
505 }
506 }
508 static void
509 sp_paint_selector_set_mode_empty(SPPaintSelector *psel)
510 {
511 sp_paint_selector_set_style_buttons(psel, NULL);
512 gtk_widget_set_sensitive(psel->style, FALSE);
514 sp_paint_selector_clear_frame(psel);
516 gtk_frame_set_label(GTK_FRAME(psel->frame), _("No objects"));
517 }
519 static void
520 sp_paint_selector_set_mode_multiple(SPPaintSelector *psel)
521 {
522 sp_paint_selector_set_style_buttons(psel, NULL);
523 gtk_widget_set_sensitive(psel->style, TRUE);
525 sp_paint_selector_clear_frame(psel);
527 gtk_frame_set_label(GTK_FRAME(psel->frame), _("Multiple styles"));
528 }
530 static void
531 sp_paint_selector_set_mode_unset(SPPaintSelector *psel)
532 {
533 sp_paint_selector_set_style_buttons(psel, psel->unset);
534 gtk_widget_set_sensitive(psel->style, TRUE);
536 sp_paint_selector_clear_frame(psel);
538 gtk_frame_set_label(GTK_FRAME(psel->frame), _("Paint is undefined"));
539 }
541 static void
542 sp_paint_selector_set_mode_none(SPPaintSelector *psel)
543 {
544 sp_paint_selector_set_style_buttons(psel, psel->none);
545 gtk_widget_set_sensitive(psel->style, TRUE);
547 sp_paint_selector_clear_frame(psel);
549 gtk_frame_set_label(GTK_FRAME(psel->frame), _("No paint"));
550 }
552 /* Color paint */
554 static void
555 sp_paint_selector_color_grabbed(SPColorSelector *csel, SPPaintSelector *psel)
556 {
557 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[GRABBED]);
558 }
560 static void
561 sp_paint_selector_color_dragged(SPColorSelector *csel, SPPaintSelector *psel)
562 {
563 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[DRAGGED]);
564 }
566 static void
567 sp_paint_selector_color_released(SPColorSelector *csel, SPPaintSelector *psel)
568 {
569 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[RELEASED]);
570 }
572 static void
573 sp_paint_selector_color_changed(SPColorSelector *csel, SPPaintSelector *psel)
574 {
575 csel->base->getColorAlpha( psel->color, &psel->alpha );
577 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
578 }
580 static void
581 sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelectorMode mode)
582 {
583 GtkWidget *csel;
585 sp_paint_selector_set_style_buttons(psel, psel->solid);
586 gtk_widget_set_sensitive(psel->style, TRUE);
588 if ((psel->mode == SP_PAINT_SELECTOR_MODE_COLOR_RGB) || (psel->mode == SP_PAINT_SELECTOR_MODE_COLOR_CMYK)) {
589 /* Already have color selector */
590 csel = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
591 } else {
593 sp_paint_selector_clear_frame(psel);
594 /* Create new color selector */
595 /* Create vbox */
596 GtkWidget *vb = gtk_vbox_new(FALSE, 4);
597 gtk_widget_show(vb);
599 /* Color selector */
600 csel = sp_color_selector_new(SP_TYPE_COLOR_NOTEBOOK, SP_COLORSPACE_TYPE_NONE);
601 gtk_widget_show(csel);
602 gtk_object_set_data(GTK_OBJECT(vb), "color-selector", csel);
603 gtk_box_pack_start(GTK_BOX(vb), csel, TRUE, TRUE, 0);
604 gtk_signal_connect(GTK_OBJECT(csel), "grabbed", GTK_SIGNAL_FUNC(sp_paint_selector_color_grabbed), psel);
605 gtk_signal_connect(GTK_OBJECT(csel), "dragged", GTK_SIGNAL_FUNC(sp_paint_selector_color_dragged), psel);
606 gtk_signal_connect(GTK_OBJECT(csel), "released", GTK_SIGNAL_FUNC(sp_paint_selector_color_released), psel);
607 gtk_signal_connect(GTK_OBJECT(csel), "changed", GTK_SIGNAL_FUNC(sp_paint_selector_color_changed), psel);
608 /* Pack everything to frame */
609 gtk_container_add(GTK_CONTAINER(psel->frame), vb);
610 psel->selector = vb;
612 /* Set color */
613 SP_COLOR_SELECTOR( csel )->base->setColorAlpha( psel->color, psel->alpha );
615 }
617 gtk_frame_set_label(GTK_FRAME(psel->frame), _("Flat color"));
618 #ifdef SP_PS_VERBOSE
619 g_print("Color req\n");
620 #endif
621 }
623 /* Gradient */
625 static void
626 sp_paint_selector_gradient_grabbed(SPColorSelector *csel, SPPaintSelector *psel)
627 {
628 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[GRABBED]);
629 }
631 static void
632 sp_paint_selector_gradient_dragged(SPColorSelector *csel, SPPaintSelector *psel)
633 {
634 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[DRAGGED]);
635 }
637 static void
638 sp_paint_selector_gradient_released(SPColorSelector *csel, SPPaintSelector *psel)
639 {
640 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[RELEASED]);
641 }
643 static void
644 sp_paint_selector_gradient_changed(SPColorSelector *csel, SPPaintSelector *psel)
645 {
646 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
647 }
649 static void
650 sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelectorMode mode)
651 {
652 GtkWidget *gsel;
654 /* fixme: We do not need function-wide gsel at all */
656 if (mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) {
657 sp_paint_selector_set_style_buttons(psel, psel->gradient);
658 } else {
659 sp_paint_selector_set_style_buttons(psel, psel->radial);
660 }
661 gtk_widget_set_sensitive(psel->style, TRUE);
663 if ((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) || (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL)) {
664 /* Already have gradient selector */
665 gsel = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
666 } else {
667 sp_paint_selector_clear_frame(psel);
668 /* Create new gradient selector */
669 gsel = sp_gradient_selector_new();
670 gtk_widget_show(gsel);
671 gtk_signal_connect(GTK_OBJECT(gsel), "grabbed", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_grabbed), psel);
672 gtk_signal_connect(GTK_OBJECT(gsel), "dragged", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_dragged), psel);
673 gtk_signal_connect(GTK_OBJECT(gsel), "released", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_released), psel);
674 gtk_signal_connect(GTK_OBJECT(gsel), "changed", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_changed), psel);
675 /* Pack everything to frame */
676 gtk_container_add(GTK_CONTAINER(psel->frame), gsel);
677 psel->selector = gsel;
678 gtk_object_set_data(GTK_OBJECT(psel->selector), "gradient-selector", gsel);
679 }
681 /* Actually we have to set optiomenu history here */
682 if (mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) {
683 sp_gradient_selector_set_mode(SP_GRADIENT_SELECTOR(gsel), SP_GRADIENT_SELECTOR_MODE_LINEAR);
684 gtk_frame_set_label(GTK_FRAME(psel->frame), _("Linear gradient"));
685 } else {
686 sp_gradient_selector_set_mode(SP_GRADIENT_SELECTOR(gsel), SP_GRADIENT_SELECTOR_MODE_RADIAL);
687 gtk_frame_set_label(GTK_FRAME(psel->frame), _("Radial gradient"));
688 }
689 #ifdef SP_PS_VERBOSE
690 g_print("Gradient req\n");
691 #endif
692 }
694 static void
695 sp_paint_selector_set_style_buttons(SPPaintSelector *psel, GtkWidget *active)
696 {
697 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->none), (active == psel->none));
698 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->solid), (active == psel->solid));
699 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->gradient), (active == psel->gradient));
700 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->radial), (active == psel->radial));
701 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->pattern), (active == psel->pattern));
702 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->unset), (active == psel->unset));
703 }
705 static void
706 sp_psel_pattern_destroy(GtkWidget *widget, SPPaintSelector *psel)
707 {
708 // drop our reference to the pattern menu widget
709 g_object_unref( G_OBJECT(widget) );
710 }
712 static void
713 sp_psel_pattern_change(GtkWidget *widget, SPPaintSelector *psel)
714 {
715 gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
716 }
718 static GtkWidget*
719 ink_pattern_menu(GtkWidget *mnu)
720 {
721 /* Create new menu widget */
722 GtkWidget *m = gtk_menu_new();
723 gtk_widget_show(m);
725 /* Pick up all patterns */
726 SPDocument *doc = SP_ACTIVE_DOCUMENT;
727 GSList *pl = NULL;
728 GSList const *patterns = sp_document_get_resource_list(doc, "pattern");
729 for (GSList *l = (GSList *) patterns; l != NULL; l = l->next) {
730 if (SP_PATTERN(l->data) == pattern_getroot(SP_PATTERN(l->data))) { // only if this is a root pattern
731 pl = g_slist_prepend(pl, l->data);
732 }
733 }
735 pl = g_slist_reverse(pl);
737 if (!doc) {
738 GtkWidget *i;
739 i = gtk_menu_item_new_with_label(_("No document selected"));
740 gtk_widget_show(i);
741 gtk_menu_append(GTK_MENU(m), i);
742 gtk_widget_set_sensitive(mnu, FALSE);
743 } else if (!pl) {
744 GtkWidget *i;
745 i = gtk_menu_item_new_with_label(_("No patterns in document"));
746 gtk_widget_show(i);
747 gtk_menu_append(GTK_MENU(m), i);
748 gtk_widget_set_sensitive(mnu, FALSE);
749 } else {
750 for (; pl != NULL; pl = pl->next){
751 if (SP_IS_PATTERN(pl->data)){
752 SPPattern *pat = SP_PATTERN(pl->data);
753 GtkWidget *i = gtk_menu_item_new();
754 gtk_widget_show(i);
755 g_object_set_data(G_OBJECT(i), "pattern", pat);
756 GtkWidget *hb = gtk_hbox_new(FALSE, 4);
757 gtk_widget_show(hb);
758 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) pl->data);
759 GtkWidget *l = gtk_label_new(repr->attribute("id"));
760 gtk_widget_show(l);
761 gtk_misc_set_alignment(GTK_MISC(l), 1.0, 0.5);
762 gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, 0);
763 gtk_widget_show(hb);
764 gtk_container_add(GTK_CONTAINER(i), hb);
765 gtk_menu_append(GTK_MENU(m), i);
766 }
767 }
769 gtk_widget_set_sensitive(mnu, TRUE);
770 }
771 gtk_option_menu_set_menu(GTK_OPTION_MENU(mnu), m);
773 /* Set history */
774 //gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
776 g_slist_free(pl);
777 return mnu;
778 }
781 /*update pattern list*/
782 void
783 sp_update_pattern_list( SPPaintSelector *psel, SPPattern *pattern)
784 {
785 if (psel->update) return;
786 GtkWidget *mnu = (GtkWidget *)g_object_get_data(G_OBJECT(psel), "patternmenu");
787 g_assert( mnu != NULL );
789 /* Clear existing menu if any */
790 gtk_option_menu_remove_menu(GTK_OPTION_MENU(mnu));
792 ink_pattern_menu(mnu);
794 /* Set history */
796 if (pattern && !gtk_object_get_data(GTK_OBJECT(mnu), "update")) {
798 gtk_object_set_data(GTK_OBJECT(mnu), "update", GINT_TO_POINTER(TRUE));
800 gchar *patname = (gchar *) SP_OBJECT_REPR(pattern)->attribute("id");
802 GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(mnu)));
803 GList *kids = GTK_MENU_SHELL(m)->children;
805 int patpos = 0;
806 int i = 0;
808 for (; kids != NULL; kids = kids->next) {
809 gchar *men_pat = (gchar *) SP_OBJECT_REPR(g_object_get_data(G_OBJECT(kids->data), "pattern"))->attribute("id");
810 if ( strcmp(men_pat, patname) == 0 ) {
811 patpos = i;
812 }
813 i++;
814 }
816 gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), patpos);
817 gtk_object_set_data(GTK_OBJECT(mnu), "update", GINT_TO_POINTER(FALSE));
818 }
819 //gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
820 }
822 static void
823 sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSelectorMode mode)
824 {
825 if (mode == SP_PAINT_SELECTOR_MODE_PATTERN)
826 sp_paint_selector_set_style_buttons(psel, psel->pattern);
828 gtk_widget_set_sensitive(psel->style, TRUE);
830 GtkWidget *tbl = NULL;
832 if (psel->mode == SP_PAINT_SELECTOR_MODE_PATTERN){
833 /* Already have pattern menu */
834 tbl = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "pattern-selector");
835 } else {
836 sp_paint_selector_clear_frame(psel);
838 /* Create vbox */
839 tbl = gtk_vbox_new(FALSE, 4);
840 gtk_widget_show(tbl);
842 {
843 GtkWidget *hb = gtk_hbox_new(FALSE, 1);
845 GtkWidget *mnu = gtk_option_menu_new();
846 ink_pattern_menu(mnu);
847 gtk_signal_connect(GTK_OBJECT(mnu), "changed", GTK_SIGNAL_FUNC(sp_psel_pattern_change), psel);
848 gtk_signal_connect(GTK_OBJECT(mnu), "destroy", GTK_SIGNAL_FUNC(sp_psel_pattern_destroy), psel);
849 gtk_object_set_data(GTK_OBJECT(psel), "patternmenu", mnu);
850 g_object_ref( G_OBJECT(mnu));
852 gtk_container_add(GTK_CONTAINER(hb), mnu);
853 gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
854 }
856 {
857 GtkWidget *hb = gtk_hbox_new(FALSE, 0);
858 GtkWidget *l = gtk_label_new(NULL);
859 gtk_label_set_markup(GTK_LABEL(l), _("Use <b>Edit > Object(s) to Pattern</b> to create a new pattern from selection."));
860 gtk_label_set_line_wrap(GTK_LABEL(l), true);
861 gtk_widget_set_size_request(l, 180, -1);
862 gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, AUX_BETWEEN_BUTTON_GROUPS);
863 gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
864 }
866 gtk_widget_show_all(tbl);
868 gtk_container_add(GTK_CONTAINER(psel->frame), tbl);
869 psel->selector = tbl;
870 gtk_object_set_data(GTK_OBJECT(psel->selector), "pattern-selector", tbl);
872 gtk_frame_set_label(GTK_FRAME(psel->frame), _("Pattern fill"));
873 }
874 #ifdef SP_PS_VERBOSE
875 g_print("Pattern req\n");
876 #endif
877 }
879 SPPattern *
880 sp_paint_selector_get_pattern(SPPaintSelector *psel)
881 {
882 SPPattern *pat;
884 g_return_val_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_PATTERN) , NULL);
886 GtkWidget *patmnu = (GtkWidget *) g_object_get_data(G_OBJECT(psel), "patternmenu");
887 /* no pattern menu if we were just selected */
888 if ( patmnu == NULL ) return NULL;
890 GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(patmnu)));
892 pat = pattern_getroot(SP_PATTERN(g_object_get_data(G_OBJECT(gtk_menu_get_active(m)), "pattern")));
894 return pat;
895 }
897 void
898 sp_paint_selector_set_flat_color(SPPaintSelector *psel, SPDesktop *desktop, gchar const *color_property, gchar const *opacity_property)
899 {
900 SPCSSAttr *css = sp_repr_css_attr_new();
902 SPColor color;
903 gfloat alpha;
904 sp_paint_selector_get_color_alpha(psel, &color, &alpha);
905 guint32 rgba = sp_color_get_rgba32_falpha(&color, alpha);
907 gchar b[64];
908 sp_svg_write_color(b, 64, rgba);
910 sp_repr_css_set_property(css, color_property, b);
911 Inkscape::CSSOStringStream osalpha;
912 osalpha << alpha;
913 sp_repr_css_set_property(css, opacity_property, osalpha.str().c_str());
915 sp_desktop_set_style(desktop, css);
917 sp_repr_css_attr_unref(css);
918 }
920 SPPaintSelectorMode
921 sp_style_determine_paint_selector_mode(SPStyle *style, bool isfill)
922 {
923 unsigned set = isfill? style->fill.set : style->stroke.set;
924 if (!set)
925 return SP_PAINT_SELECTOR_MODE_UNSET;
927 unsigned type = isfill? style->fill.type : style->stroke.type;
928 switch (type) {
930 case SP_PAINT_TYPE_NONE:
931 {
932 return SP_PAINT_SELECTOR_MODE_NONE;
933 }
935 case SP_PAINT_TYPE_COLOR:
936 {
937 return SP_PAINT_SELECTOR_MODE_COLOR_RGB; // so far only rgb can be read from svg
938 }
940 case SP_PAINT_TYPE_PAINTSERVER:
941 {
942 SPPaintServer *server = isfill? SP_STYLE_FILL_SERVER(style) : SP_STYLE_STROKE_SERVER(style);
944 if (SP_IS_LINEARGRADIENT(server)) {
945 return SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR;
946 } else if (SP_IS_RADIALGRADIENT(server)) {
947 return SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL;
948 } else if (SP_IS_PATTERN(server)) {
949 return SP_PAINT_SELECTOR_MODE_PATTERN;
950 }
952 g_warning( "file %s: line %d: Unknown paintserver",
953 __FILE__, __LINE__ );
954 return SP_PAINT_SELECTOR_MODE_NONE;
955 }
957 default:
958 g_warning( "file %s: line %d: Unknown paint type %d",
959 __FILE__, __LINE__, type );
960 break;
961 }
963 return SP_PAINT_SELECTOR_MODE_NONE;
964 }
966 /*
967 Local Variables:
968 mode:c++
969 c-file-style:"stroustrup"
970 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
971 indent-tabs-mode:nil
972 fill-column:99
973 End:
974 */
975 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :