1 /*
2 * Gradient aux toolbar
3 *
4 * Authors:
5 * bulia byak <bulia@dr.com>
6 * Johan Engelen <j.b.c.engelen@ewi.utwente.nl>
7 *
8 * Copyright (C) 2007 Johan Engelen
9 * Copyright (C) 2005 authors
10 *
11 * Released under GNU GPL, read the file 'COPYING' for more information
12 */
14 #ifdef HAVE_CONFIG_H
15 # include "config.h"
16 #endif
18 #include <gtk/gtk.h>
20 #include "macros.h"
21 #include "widgets/button.h"
22 #include "widgets/widget-sizes.h"
23 #include "widgets/spw-utilities.h"
24 #include "widgets/spinbutton-events.h"
25 #include "widgets/gradient-vector.h"
26 #include "widgets/gradient-image.h"
27 #include "style.h"
29 #include "preferences.h"
30 #include "document-private.h"
31 #include "desktop.h"
32 #include "desktop-handles.h"
33 #include <glibmm/i18n.h>
35 #include "gradient-context.h"
36 #include "gradient-drag.h"
37 #include "sp-linear-gradient.h"
38 #include "sp-radial-gradient.h"
39 #include "gradient-chemistry.h"
40 #include "selection.h"
41 #include "ui/icon-names.h"
43 #include "toolbox.h"
46 //########################
47 //## Gradient ##
48 //########################
50 static void gr_toggle_type (GtkWidget *button, gpointer data) {
51 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
52 GtkWidget *linear = (GtkWidget *) g_object_get_data (G_OBJECT(data), "linear");
53 GtkWidget *radial = (GtkWidget *) g_object_get_data (G_OBJECT(data), "radial");
54 if (button == linear && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (linear))) {
55 prefs->setInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR);
56 if (radial) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radial), FALSE);
57 } else if (button == radial && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (radial))) {
58 prefs->setInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_RADIAL);
59 if (linear) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (linear), FALSE);
60 }
61 }
63 static void gr_toggle_fillstroke (GtkWidget *button, gpointer data) {
64 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
65 GtkWidget *fill = (GtkWidget *) g_object_get_data (G_OBJECT(data), "fill");
66 GtkWidget *stroke = (GtkWidget *) g_object_get_data (G_OBJECT(data), "stroke");
67 if (button == fill && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (fill))) {
68 prefs->setBool("/tools/gradient/newfillorstroke", true);
69 if (stroke) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (stroke), FALSE);
70 } else if (button == stroke && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (stroke))) {
71 prefs->setBool("/tools/gradient/newfillorstroke", false);
72 if (fill) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fill), FALSE);
73 }
74 }
76 void gr_apply_gradient_to_item( SPItem *item, SPGradient *gr, SPGradientType new_type, guint new_fill, bool do_fill, bool do_stroke )
77 {
78 SPStyle *style = item->style;
80 if (do_fill) {
81 if (style && (style->fill.isPaintserver()) &&
82 SP_IS_GRADIENT( item->style->getFillPaintServer() )) {
83 SPPaintServer *server = item->style->getFillPaintServer();
84 if ( SP_IS_LINEARGRADIENT(server) ) {
85 sp_item_set_gradient(item, gr, SP_GRADIENT_TYPE_LINEAR, true);
86 } else if ( SP_IS_RADIALGRADIENT(server) ) {
87 sp_item_set_gradient(item, gr, SP_GRADIENT_TYPE_RADIAL, true);
88 }
89 } else if (new_fill) {
90 sp_item_set_gradient(item, gr, new_type, true);
91 }
92 }
94 if (do_stroke) {
95 if (style && (style->stroke.isPaintserver()) &&
96 SP_IS_GRADIENT( item->style->getStrokePaintServer() )) {
97 SPPaintServer *server = item->style->getStrokePaintServer();
98 if ( SP_IS_LINEARGRADIENT(server) ) {
99 sp_item_set_gradient(item, gr, SP_GRADIENT_TYPE_LINEAR, false);
100 } else if ( SP_IS_RADIALGRADIENT(server) ) {
101 sp_item_set_gradient(item, gr, SP_GRADIENT_TYPE_RADIAL, false);
102 }
103 } else if (!new_fill) {
104 sp_item_set_gradient(item, gr, new_type, false);
105 }
106 }
107 }
109 /**
110 Applies gradient vector gr to the gradients attached to the selected dragger of drag, or if none,
111 to all objects in selection. If there was no previous gradient on an item, uses gradient type and
112 fill/stroke setting from preferences to create new default (linear: left/right; radial: centered)
113 gradient.
114 */
115 void
116 gr_apply_gradient (Inkscape::Selection *selection, GrDrag *drag, SPGradient *gr)
117 {
118 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
119 SPGradientType new_type = (SPGradientType) prefs->getInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR);
120 guint new_fill = prefs->getBool("/tools/gradient/newfillorstroke", true);
123 // GRADIENTFIXME: make this work for multiple selected draggers.
125 // First try selected dragger
126 if (drag && drag->selected) {
127 GrDragger *dragger = (GrDragger*) drag->selected->data;
128 for (GSList const* i = dragger->draggables; i != NULL; i = i->next) { // for all draggables of dragger
129 GrDraggable *draggable = (GrDraggable *) i->data;
130 gr_apply_gradient_to_item (draggable->item, gr, new_type, new_fill, draggable->fill_or_stroke, !draggable->fill_or_stroke);
131 }
132 return;
133 }
135 // If no drag or no dragger selected, act on selection
136 for (GSList const* i = selection->itemList(); i != NULL; i = i->next) {
137 gr_apply_gradient_to_item (SP_ITEM(i->data), gr, new_type, new_fill, new_fill, !new_fill);
138 }
139 }
141 void
142 gr_item_activate (GtkMenuItem *menuitem, gpointer data)
143 {
144 SPGradient *gr = (SPGradient *) g_object_get_data (G_OBJECT (menuitem), "gradient");
145 gr = sp_gradient_ensure_vector_normalized(gr);
147 SPDesktop *desktop = (SPDesktop *) data;
148 Inkscape::Selection *selection = sp_desktop_selection (desktop);
149 SPEventContext *ev = sp_desktop_event_context (desktop);
151 gr_apply_gradient (selection, ev? ev->get_drag() : NULL, gr);
153 sp_document_done (sp_desktop_document (desktop), SP_VERB_CONTEXT_GRADIENT,
154 _("Assign gradient to object"));
155 }
157 gchar *
158 gr_prepare_label (SPObject *obj)
159 {
160 const gchar *id = obj->defaultLabel();
161 if (strlen(id) > 15 && (!strncmp (id, "#linearGradient", 15) || !strncmp (id, "#radialGradient", 15)))
162 return g_strdup_printf ("<small>#%s</small>", id+15);
163 return g_strdup_printf ("<small>%s</small>", id);
164 }
166 GtkWidget *gr_vector_list(SPDesktop *desktop, bool selection_empty, SPGradient *gr_selected, bool gr_multi)
167 {
168 SPDocument *document = sp_desktop_document (desktop);
170 GtkWidget *om = gtk_option_menu_new ();
171 GtkWidget *m = gtk_menu_new ();
173 GSList *gl = NULL;
174 const GSList *gradients = sp_document_get_resource_list (document, "gradient");
175 for (const GSList *i = gradients; i != NULL; i = i->next) {
176 SPGradient *grad = SP_GRADIENT(i->data);
177 if ( grad->hasStops() && !grad->isSolid() ) {
178 gl = g_slist_prepend (gl, i->data);
179 }
180 }
181 gl = g_slist_reverse (gl);
183 guint pos = 0;
184 guint idx = 0;
186 if (!gl) {
187 // The document has no gradients
188 GtkWidget *l = gtk_label_new("");
189 gtk_label_set_markup (GTK_LABEL(l), _("<small>No gradients</small>"));
190 GtkWidget *i = gtk_menu_item_new ();
191 gtk_container_add (GTK_CONTAINER (i), l);
193 gtk_widget_show (i);
194 gtk_menu_append (GTK_MENU (m), i);
195 gtk_widget_set_sensitive (om, FALSE);
196 } else if (selection_empty) {
197 // Document has gradients, but nothing is currently selected.
198 GtkWidget *l = gtk_label_new("");
199 gtk_label_set_markup (GTK_LABEL(l), _("<small>Nothing selected</small>"));
200 GtkWidget *i = gtk_menu_item_new ();
201 gtk_container_add (GTK_CONTAINER (i), l);
203 gtk_widget_show (i);
204 gtk_menu_append (GTK_MENU (m), i);
205 gtk_widget_set_sensitive (om, FALSE);
206 } else {
208 if (gr_selected == NULL) {
209 GtkWidget *l = gtk_label_new("");
210 gtk_label_set_markup (GTK_LABEL(l), _("<small>No gradients in selection</small>"));
211 GtkWidget *i = gtk_menu_item_new ();
212 gtk_container_add (GTK_CONTAINER (i), l);
214 gtk_widget_show (i);
215 gtk_menu_append (GTK_MENU (m), i);
216 }
218 if (gr_multi) {
219 GtkWidget *l = gtk_label_new("");
220 gtk_label_set_markup (GTK_LABEL(l), _("<small>Multiple gradients</small>"));
221 GtkWidget *i = gtk_menu_item_new ();
222 gtk_container_add (GTK_CONTAINER (i), l);
224 gtk_widget_show (i);
225 gtk_menu_append (GTK_MENU (m), i);
226 }
228 while (gl) {
229 SPGradient *gradient = SP_GRADIENT (gl->data);
230 gl = g_slist_remove (gl, gradient);
232 GtkWidget *i = gtk_menu_item_new ();
233 g_object_set_data (G_OBJECT (i), "gradient", gradient);
234 g_signal_connect (G_OBJECT (i), "activate", G_CALLBACK (gr_item_activate), desktop);
236 GtkWidget *image = sp_gradient_image_new (gradient);
238 GtkWidget *hb = gtk_hbox_new (FALSE, 4);
239 GtkWidget *l = gtk_label_new ("");
240 gchar *label = gr_prepare_label(gradient);
241 gtk_label_set_markup (GTK_LABEL(l), label);
242 g_free (label);
243 gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
244 gtk_box_pack_start (GTK_BOX (hb), l, TRUE, TRUE, 0);
245 gtk_box_pack_start (GTK_BOX (hb), image, FALSE, FALSE, 0);
247 gtk_widget_show_all (i);
249 gtk_container_add (GTK_CONTAINER (i), hb);
251 gtk_menu_append (GTK_MENU (m), i);
253 if (gradient == gr_selected) {
254 pos = idx;
255 }
256 idx ++;
257 }
258 gtk_widget_set_sensitive (om, TRUE);
259 }
261 gtk_option_menu_set_menu (GTK_OPTION_MENU (om), m);
262 /* Select the current gradient, or the Multi/Nothing line */
263 if (gr_multi || gr_selected == NULL)
264 gtk_option_menu_set_history (GTK_OPTION_MENU (om), 0);
265 else
266 gtk_option_menu_set_history (GTK_OPTION_MENU (om), pos);
268 return om;
269 }
272 void gr_read_selection( Inkscape::Selection *selection,
273 GrDrag *drag,
274 SPGradient *&gr_selected,
275 bool &gr_multi,
276 SPGradientSpread &spr_selected,
277 bool &spr_multi )
278 {
279 if (drag && drag->selected) {
280 // GRADIENTFIXME: make this work for more than one selected dragger?
281 GrDragger *dragger = static_cast<GrDragger*>(drag->selected->data);
282 for (GSList const* i = dragger->draggables; i; i = i->next) { // for all draggables of dragger
283 GrDraggable *draggable = static_cast<GrDraggable *>(i->data);
284 SPGradient *gradient = sp_item_gradient_get_vector(draggable->item, draggable->fill_or_stroke);
285 SPGradientSpread spread = sp_item_gradient_get_spread(draggable->item, draggable->fill_or_stroke);
287 if (gradient && gradient->isSolid()) {
288 gradient = 0;
289 }
291 if (gradient && (gradient != gr_selected)) {
292 if (gr_selected) {
293 gr_multi = true;
294 } else {
295 gr_selected = gradient;
296 }
297 }
298 if (spread != spr_selected) {
299 if (spr_selected != INT_MAX) {
300 spr_multi = true;
301 } else {
302 spr_selected = spread;
303 }
304 }
305 }
306 return;
307 }
309 // If no selected dragger, read desktop selection
310 for (GSList const* i = selection->itemList(); i; i = i->next) {
311 SPItem *item = SP_ITEM(i->data);
312 SPStyle *style = item->style;
314 if (style && (style->fill.isPaintserver())) {
315 SPPaintServer *server = item->style->getFillPaintServer();
316 if ( SP_IS_GRADIENT(server) ) {
317 SPGradient *gradient = SP_GRADIENT(server)->getVector();
318 SPGradientSpread spread = SP_GRADIENT(server)->fetchSpread();
320 if (gradient && gradient->isSolid()) {
321 gradient = 0;
322 }
324 if (gradient && (gradient != gr_selected)) {
325 if (gr_selected) {
326 gr_multi = true;
327 } else {
328 gr_selected = gradient;
329 }
330 }
331 if (spread != spr_selected) {
332 if (spr_selected != INT_MAX) {
333 spr_multi = true;
334 } else {
335 spr_selected = spread;
336 }
337 }
338 }
339 }
340 if (style && (style->stroke.isPaintserver())) {
341 SPPaintServer *server = item->style->getStrokePaintServer();
342 if ( SP_IS_GRADIENT(server) ) {
343 SPGradient *gradient = SP_GRADIENT(server)->getVector();
344 SPGradientSpread spread = SP_GRADIENT(server)->fetchSpread();
346 if (gradient && gradient->isSolid()) {
347 gradient = 0;
348 }
350 if (gradient && (gradient != gr_selected)) {
351 if (gr_selected) {
352 gr_multi = true;
353 } else {
354 gr_selected = gradient;
355 }
356 }
357 if (spread != spr_selected) {
358 if (spr_selected != INT_MAX) {
359 spr_multi = true;
360 } else {
361 spr_selected = spread;
362 }
363 }
364 }
365 }
366 }
367 }
369 static void gr_tb_selection_changed(Inkscape::Selection * /*selection*/, gpointer data)
370 {
371 GtkWidget *widget = GTK_WIDGET(data);
373 SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(G_OBJECT(widget), "desktop"));
374 if (desktop) {
375 Inkscape::Selection *selection = sp_desktop_selection(desktop); // take from desktop, not from args
376 if (selection) {
377 SPEventContext *ev = sp_desktop_event_context(desktop);
379 GtkWidget *om = (GtkWidget *) g_object_get_data(G_OBJECT(widget), "menu");
380 if (om) {
381 gtk_widget_destroy(om);
382 om = 0;
383 }
385 SPGradient *gr_selected = 0;
386 bool gr_multi = false;
388 SPGradientSpread spr_selected = static_cast<SPGradientSpread>(INT_MAX); // meaning undefined
389 bool spr_multi = false;
391 gr_read_selection(selection, ev ? ev->get_drag() : 0, gr_selected, gr_multi, spr_selected, spr_multi);
393 om = gr_vector_list(desktop, selection->isEmpty(), gr_selected, gr_multi);
394 g_object_set_data(G_OBJECT(widget), "menu", om);
396 GtkWidget *buttons = (GtkWidget *) g_object_get_data(G_OBJECT(widget), "buttons");
397 gtk_widget_set_sensitive(buttons, (gr_selected && !gr_multi));
399 gtk_box_pack_start(GTK_BOX(widget), om, TRUE, TRUE, 0);
401 gtk_widget_show_all(widget);
402 }
403 }
404 }
406 static void
407 gr_tb_selection_modified (Inkscape::Selection *selection, guint /*flags*/, gpointer data)
408 {
409 gr_tb_selection_changed (selection, data);
410 }
412 static void
413 gr_drag_selection_changed (gpointer /*dragger*/, gpointer data)
414 {
415 gr_tb_selection_changed (NULL, data);
416 }
418 static void
419 gr_defs_release (SPObject */*defs*/, GtkWidget *widget)
420 {
421 gr_tb_selection_changed (NULL, (gpointer) widget);
422 }
424 static void
425 gr_defs_modified (SPObject */*defs*/, guint /*flags*/, GtkWidget *widget)
426 {
427 gr_tb_selection_changed (NULL, (gpointer) widget);
428 }
430 static void gr_disconnect_sigc (GObject */*obj*/, sigc::connection *connection) {
431 connection->disconnect();
432 delete connection;
433 }
435 static void
436 gr_edit (GtkWidget */*button*/, GtkWidget *widget)
437 {
438 GtkWidget *om = (GtkWidget *) g_object_get_data (G_OBJECT(widget), "menu");
440 spinbutton_defocus(GTK_OBJECT(widget));
442 if (om) {
443 GtkWidget *i = gtk_menu_get_active (GTK_MENU (gtk_option_menu_get_menu (GTK_OPTION_MENU (om))));
444 SPGradient *gr = (SPGradient *) g_object_get_data (G_OBJECT(i), "gradient");
446 if (gr) {
447 GtkWidget *dialog = sp_gradient_vector_editor_new (gr);
448 gtk_widget_show (dialog);
449 }
450 }
451 }
453 GtkWidget * gr_change_widget(SPDesktop *desktop)
454 {
455 Inkscape::Selection *selection = sp_desktop_selection (desktop);
456 SPDocument *document = sp_desktop_document (desktop);
457 SPEventContext *ev = sp_desktop_event_context (desktop);
459 SPGradient *gr_selected = NULL;
460 bool gr_multi = false;
462 SPGradientSpread spr_selected = (SPGradientSpread) INT_MAX; // meaning undefined
463 bool spr_multi = false;
465 GtkTooltips *tt = gtk_tooltips_new();
467 gr_read_selection (selection, ev? ev->get_drag() : 0, gr_selected, gr_multi, spr_selected, spr_multi);
469 GtkWidget *widget = gtk_hbox_new(FALSE, FALSE);
470 gtk_object_set_data(GTK_OBJECT(widget), "dtw", desktop->canvas);
471 g_object_set_data (G_OBJECT (widget), "desktop", desktop);
473 GtkWidget *om = gr_vector_list (desktop, selection->isEmpty(), gr_selected, gr_multi);
474 g_object_set_data (G_OBJECT (widget), "menu", om);
476 gtk_box_pack_start (GTK_BOX (widget), om, TRUE, TRUE, 0);
478 {
479 GtkWidget *buttons = gtk_hbox_new(FALSE, 1);
481 /* Edit... */
482 {
483 GtkWidget *hb = gtk_hbox_new(FALSE, 1);
484 GtkWidget *b = gtk_button_new_with_label(_("Edit..."));
485 gtk_tooltips_set_tip(tt, b, _("Edit the stops of the gradient"), NULL);
486 gtk_widget_show(b);
487 gtk_container_add(GTK_CONTAINER(hb), b);
488 gtk_signal_connect(GTK_OBJECT(b), "clicked", GTK_SIGNAL_FUNC(gr_edit), widget);
489 gtk_box_pack_start (GTK_BOX(buttons), hb, FALSE, FALSE, 0);
490 }
492 gtk_box_pack_end (GTK_BOX(widget), buttons, FALSE, FALSE, 0);
493 g_object_set_data (G_OBJECT(widget), "buttons", buttons);
494 gtk_widget_set_sensitive (buttons, (gr_selected && !gr_multi));
495 }
497 // connect to selection modified and changed signals
498 sigc::connection *conn1 = new sigc::connection (selection->connectChanged(
499 sigc::bind (
500 sigc::ptr_fun(&gr_tb_selection_changed),
501 (gpointer)widget )
502 ));
503 sigc::connection *conn2 = new sigc::connection (selection->connectModified(
504 sigc::bind (
505 sigc::ptr_fun(&gr_tb_selection_modified),
506 (gpointer)widget )
507 ));
509 sigc::connection *conn3 = new sigc::connection (desktop->connectToolSubselectionChanged(
510 sigc::bind (
511 sigc::ptr_fun(&gr_drag_selection_changed),
512 (gpointer)widget )
513 ));
515 // when widget is destroyed, disconnect
516 g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(gr_disconnect_sigc), conn1);
517 g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(gr_disconnect_sigc), conn2);
518 g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(gr_disconnect_sigc), conn3);
520 // connect to release and modified signals of the defs (i.e. when someone changes gradient)
521 sigc::connection *release_connection = new sigc::connection();
522 *release_connection = SP_DOCUMENT_DEFS(document)->connectRelease(sigc::bind<1>(sigc::ptr_fun(&gr_defs_release), widget));
523 sigc::connection *modified_connection = new sigc::connection();
524 *modified_connection = SP_DOCUMENT_DEFS(document)->connectModified(sigc::bind<2>(sigc::ptr_fun(&gr_defs_modified), widget));
526 // when widget is destroyed, disconnect
527 g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(gr_disconnect_sigc), release_connection);
528 g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(gr_disconnect_sigc), modified_connection);
530 gtk_widget_show_all (widget);
531 return widget;
532 }
534 GtkWidget *
535 sp_gradient_toolbox_new(SPDesktop *desktop)
536 {
537 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
538 GtkWidget *tbl = gtk_toolbar_new();
540 gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
541 gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop);
543 GtkTooltips *tt = gtk_tooltips_new();
545 sp_toolbox_add_label(tbl, _("<b>New:</b>"));
547 // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
549 {
550 GtkWidget *cvbox = gtk_vbox_new (FALSE, 0);
551 GtkWidget *cbox = gtk_hbox_new (FALSE, 0);
553 {
554 GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION,
555 SP_BUTTON_TYPE_TOGGLE,
556 NULL,
557 INKSCAPE_ICON_PAINT_GRADIENT_LINEAR,
558 _("Create linear gradient"),
559 tt);
560 g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_type), tbl);
561 g_object_set_data(G_OBJECT(tbl), "linear", button);
562 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
563 prefs->getInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR) == SP_GRADIENT_TYPE_LINEAR);
564 gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
565 }
567 {
568 GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION,
569 SP_BUTTON_TYPE_TOGGLE,
570 NULL,
571 INKSCAPE_ICON_PAINT_GRADIENT_RADIAL,
572 _("Create radial (elliptic or circular) gradient"),
573 tt);
574 g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_type), tbl);
575 g_object_set_data(G_OBJECT(tbl), "radial", button);
576 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
577 prefs->getInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR) == SP_GRADIENT_TYPE_RADIAL);
578 gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
579 }
581 gtk_box_pack_start(GTK_BOX(cvbox), cbox, TRUE, FALSE, 0);
582 gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), cvbox, "", "" );
583 }
585 // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
587 sp_toolbox_add_label(tbl, _("on"), false);
589 // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
591 {
592 GtkWidget *cvbox = gtk_vbox_new (FALSE, 0);
593 GtkWidget *cbox = gtk_hbox_new (FALSE, 0);
595 {
596 GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION,
597 SP_BUTTON_TYPE_TOGGLE,
598 NULL,
599 INKSCAPE_ICON_OBJECT_FILL,
600 _("Create gradient in the fill"),
601 tt);
602 g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_fillstroke), tbl);
603 g_object_set_data(G_OBJECT(tbl), "fill", button);
604 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
605 prefs->getBool("/tools/gradient/newfillorstroke", true));
606 gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
607 }
609 {
610 GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION,
611 SP_BUTTON_TYPE_TOGGLE,
612 NULL,
613 INKSCAPE_ICON_OBJECT_STROKE,
614 _("Create gradient in the stroke"),
615 tt);
616 g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_fillstroke), tbl);
617 g_object_set_data(G_OBJECT(tbl), "stroke", button);
618 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
619 !prefs->getBool("/tools/gradient/newfillorstroke", true));
620 gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
621 }
623 gtk_box_pack_start(GTK_BOX(cvbox), cbox, TRUE, TRUE, 3);
624 gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), cvbox, "", "" );
625 }
628 sp_toolbox_add_label(tbl, _("<b>Change:</b>"));
630 // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
632 {
633 GtkWidget *vectors = gr_change_widget (desktop);
634 gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), vectors, "", "" );
635 }
637 gtk_widget_show_all(tbl);
638 sp_set_font_size_smaller (tbl);
640 return tbl;
641 }
646 /*
647 Local Variables:
648 mode:c++
649 c-file-style:"stroustrup"
650 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
651 indent-tabs-mode:nil
652 fill-column:99
653 End:
654 */
655 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :