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"
42 #include "toolbox.h"
45 //########################
46 //## Gradient ##
47 //########################
49 static void gr_toggle_type (GtkWidget *button, gpointer data) {
50 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
51 GtkWidget *linear = (GtkWidget *) g_object_get_data (G_OBJECT(data), "linear");
52 GtkWidget *radial = (GtkWidget *) g_object_get_data (G_OBJECT(data), "radial");
53 if (button == linear && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (linear))) {
54 prefs->setInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR);
55 if (radial) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radial), FALSE);
56 } else if (button == radial && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (radial))) {
57 prefs->setInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_RADIAL);
58 if (linear) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (linear), FALSE);
59 }
60 }
62 static void gr_toggle_fillstroke (GtkWidget *button, gpointer data) {
63 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
64 GtkWidget *fill = (GtkWidget *) g_object_get_data (G_OBJECT(data), "fill");
65 GtkWidget *stroke = (GtkWidget *) g_object_get_data (G_OBJECT(data), "stroke");
66 if (button == fill && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (fill))) {
67 prefs->setBool("/tools/gradient/newfillorstroke", true);
68 if (stroke) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (stroke), FALSE);
69 } else if (button == stroke && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (stroke))) {
70 prefs->setBool("/tools/gradient/newfillorstroke", false);
71 if (fill) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fill), FALSE);
72 }
73 }
75 void
76 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 = SP_OBJECT_STYLE (item);
80 if (do_fill) {
81 if (style && (style->fill.isPaintserver()) &&
82 SP_IS_GRADIENT (SP_OBJECT_STYLE_FILL_SERVER (item))) {
83 SPObject *server = SP_OBJECT_STYLE_FILL_SERVER (item);
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 (SP_OBJECT_STYLE_STROKE_SERVER (item))) {
97 SPObject *server = SP_OBJECT_STYLE_STROKE_SERVER (item);
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 *
167 gr_vector_list (SPDesktop *desktop, bool selection_empty, SPGradient *gr_selected, bool gr_multi)
168 {
169 SPDocument *document = sp_desktop_document (desktop);
171 GtkWidget *om = gtk_option_menu_new ();
172 GtkWidget *m = gtk_menu_new ();
174 GSList *gl = NULL;
175 const GSList *gradients = sp_document_get_resource_list (document, "gradient");
176 for (const GSList *i = gradients; i != NULL; i = i->next) {
177 if (SP_GRADIENT_HAS_STOPS (i->data)) {
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 GtkWidget *l = gtk_label_new("");
188 gtk_label_set_markup (GTK_LABEL(l), _("<small>No gradients</small>"));
189 GtkWidget *i = gtk_menu_item_new ();
190 gtk_container_add (GTK_CONTAINER (i), l);
192 gtk_widget_show (i);
193 gtk_menu_append (GTK_MENU (m), i);
194 gtk_widget_set_sensitive (om, FALSE);
195 } else if (selection_empty) {
196 GtkWidget *l = gtk_label_new("");
197 gtk_label_set_markup (GTK_LABEL(l), _("<small>Nothing selected</small>"));
198 GtkWidget *i = gtk_menu_item_new ();
199 gtk_container_add (GTK_CONTAINER (i), l);
201 gtk_widget_show (i);
202 gtk_menu_append (GTK_MENU (m), i);
203 gtk_widget_set_sensitive (om, FALSE);
204 } else {
206 if (gr_selected == NULL) {
207 GtkWidget *l = gtk_label_new("");
208 gtk_label_set_markup (GTK_LABEL(l), _("<small>No gradients in selection</small>"));
209 GtkWidget *i = gtk_menu_item_new ();
210 gtk_container_add (GTK_CONTAINER (i), l);
212 gtk_widget_show (i);
213 gtk_menu_append (GTK_MENU (m), i);
214 }
216 if (gr_multi) {
217 GtkWidget *l = gtk_label_new("");
218 gtk_label_set_markup (GTK_LABEL(l), _("<small>Multiple gradients</small>"));
219 GtkWidget *i = gtk_menu_item_new ();
220 gtk_container_add (GTK_CONTAINER (i), l);
222 gtk_widget_show (i);
223 gtk_menu_append (GTK_MENU (m), i);
224 }
226 while (gl) {
227 SPGradient *gradient = SP_GRADIENT (gl->data);
228 gl = g_slist_remove (gl, gradient);
230 GtkWidget *i = gtk_menu_item_new ();
231 g_object_set_data (G_OBJECT (i), "gradient", gradient);
232 g_signal_connect (G_OBJECT (i), "activate", G_CALLBACK (gr_item_activate), desktop);
234 GtkWidget *image = sp_gradient_image_new (gradient);
236 GtkWidget *hb = gtk_hbox_new (FALSE, 4);
237 GtkWidget *l = gtk_label_new ("");
238 gchar *label = gr_prepare_label (SP_OBJECT(gradient));
239 gtk_label_set_markup (GTK_LABEL(l), label);
240 g_free (label);
241 gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
242 gtk_box_pack_start (GTK_BOX (hb), l, TRUE, TRUE, 0);
243 gtk_box_pack_start (GTK_BOX (hb), image, FALSE, FALSE, 0);
245 gtk_widget_show_all (i);
247 gtk_container_add (GTK_CONTAINER (i), hb);
249 gtk_menu_append (GTK_MENU (m), i);
251 if (gradient == gr_selected) {
252 pos = idx;
253 }
254 idx ++;
255 }
256 gtk_widget_set_sensitive (om, TRUE);
257 }
259 gtk_option_menu_set_menu (GTK_OPTION_MENU (om), m);
260 /* Select the current gradient, or the Multi/Nothing line */
261 if (gr_multi || gr_selected == NULL)
262 gtk_option_menu_set_history (GTK_OPTION_MENU (om), 0);
263 else
264 gtk_option_menu_set_history (GTK_OPTION_MENU (om), pos);
266 return om;
267 }
270 void
271 gr_read_selection (Inkscape::Selection *selection, GrDrag *drag, SPGradient **gr_selected, bool *gr_multi, SPGradientSpread *spr_selected, bool *spr_multi)
272 {
273 if (drag && drag->selected) {
274 // GRADIENTFIXME: make this work for more than one selected dragger?
275 GrDragger *dragger = (GrDragger*) drag->selected->data;
276 for (GSList const* i = dragger->draggables; i != NULL; i = i->next) { // for all draggables of dragger
277 GrDraggable *draggable = (GrDraggable *) i->data;
278 SPGradient *gradient = sp_item_gradient_get_vector (draggable->item, draggable->fill_or_stroke);
279 SPGradientSpread spread = sp_item_gradient_get_spread (draggable->item, draggable->fill_or_stroke);
281 if (gradient != *gr_selected) {
282 if (*gr_selected != NULL) {
283 *gr_multi = true;
284 } else {
285 *gr_selected = gradient;
286 }
287 }
288 if (spread != *spr_selected) {
289 if (*spr_selected != INT_MAX) {
290 *spr_multi = true;
291 } else {
292 *spr_selected = spread;
293 }
294 }
295 }
296 return;
297 }
299 // If no selected dragger, read desktop selection
300 for (GSList const* i = selection->itemList(); i != NULL; i = i->next) {
301 SPItem *item = SP_ITEM(i->data);
302 SPStyle *style = SP_OBJECT_STYLE (item);
304 if (style && (style->fill.isPaintserver())) {
305 SPObject *server = SP_OBJECT_STYLE_FILL_SERVER (item);
306 if (SP_IS_GRADIENT (server)) {
307 SPGradient *gradient = sp_gradient_get_vector (SP_GRADIENT (server), false);
308 SPGradientSpread spread = sp_gradient_get_spread (SP_GRADIENT (server));
309 if (gradient != *gr_selected) {
310 if (*gr_selected != NULL) {
311 *gr_multi = true;
312 } else {
313 *gr_selected = gradient;
314 }
315 }
316 if (spread != *spr_selected) {
317 if (*spr_selected != INT_MAX) {
318 *spr_multi = true;
319 } else {
320 *spr_selected = spread;
321 }
322 }
323 }
324 }
325 if (style && (style->stroke.isPaintserver())) {
326 SPObject *server = SP_OBJECT_STYLE_STROKE_SERVER (item);
327 if (SP_IS_GRADIENT (server)) {
328 SPGradient *gradient = sp_gradient_get_vector (SP_GRADIENT (server), false);
329 SPGradientSpread spread = sp_gradient_get_spread (SP_GRADIENT (server));
330 if (gradient != *gr_selected) {
331 if (*gr_selected != NULL) {
332 *gr_multi = true;
333 } else {
334 *gr_selected = gradient;
335 }
336 }
337 if (spread != *spr_selected) {
338 if (*spr_selected != INT_MAX) {
339 *spr_multi = true;
340 } else {
341 *spr_selected = spread;
342 }
343 }
344 }
345 }
346 }
347 }
349 static void
350 gr_tb_selection_changed (Inkscape::Selection *, gpointer data)
351 {
352 GtkWidget *widget = (GtkWidget *) data;
354 SPDesktop *desktop = (SPDesktop *) g_object_get_data (G_OBJECT(widget), "desktop");
355 if (!desktop)
356 return;
358 Inkscape::Selection *selection = sp_desktop_selection (desktop); // take from desktop, not from args
359 if (!selection)
360 return;
362 SPEventContext *ev = sp_desktop_event_context (desktop);
364 GtkWidget *om = (GtkWidget *) g_object_get_data (G_OBJECT (widget), "menu");
365 if (om) gtk_widget_destroy (om);
367 SPGradient *gr_selected = NULL;
368 bool gr_multi = false;
370 SPGradientSpread spr_selected = (SPGradientSpread) INT_MAX; // meaning undefined
371 bool spr_multi = false;
373 gr_read_selection (selection, ev? ev->get_drag() : NULL, &gr_selected, &gr_multi, &spr_selected, &spr_multi);
375 om = gr_vector_list (desktop, selection->isEmpty(), gr_selected, gr_multi);
376 g_object_set_data (G_OBJECT (widget), "menu", om);
378 GtkWidget *buttons = (GtkWidget *) g_object_get_data (G_OBJECT(widget), "buttons");
379 gtk_widget_set_sensitive (buttons, (gr_selected && !gr_multi));
381 gtk_box_pack_start (GTK_BOX (widget), om, TRUE, TRUE, 0);
383 gtk_widget_show_all (widget);
384 }
386 static void
387 gr_tb_selection_modified (Inkscape::Selection *selection, guint flags, gpointer data)
388 {
389 gr_tb_selection_changed (selection, data);
390 }
392 static void
393 gr_drag_selection_changed (gpointer dragger, gpointer data)
394 {
395 gr_tb_selection_changed (NULL, data);
396 }
398 static void
399 gr_defs_release (SPObject *defs, GtkWidget *widget)
400 {
401 gr_tb_selection_changed (NULL, (gpointer) widget);
402 }
404 static void
405 gr_defs_modified (SPObject *defs, guint flags, GtkWidget *widget)
406 {
407 gr_tb_selection_changed (NULL, (gpointer) widget);
408 }
410 static void gr_disconnect_sigc (GObject *obj, sigc::connection *connection) {
411 connection->disconnect();
412 delete connection;
413 }
415 static void
416 gr_edit (GtkWidget *button, GtkWidget *widget)
417 {
418 GtkWidget *om = (GtkWidget *) g_object_get_data (G_OBJECT(widget), "menu");
420 spinbutton_defocus(GTK_OBJECT(widget));
422 if (om) {
423 GtkWidget *i = gtk_menu_get_active (GTK_MENU (gtk_option_menu_get_menu (GTK_OPTION_MENU (om))));
424 SPGradient *gr = (SPGradient *) g_object_get_data (G_OBJECT(i), "gradient");
426 if (gr) {
427 GtkWidget *dialog = sp_gradient_vector_editor_new (gr);
428 gtk_widget_show (dialog);
429 }
430 }
431 }
433 GtkWidget *
434 gr_change_widget (SPDesktop *desktop)
435 {
436 Inkscape::Selection *selection = sp_desktop_selection (desktop);
437 SPDocument *document = sp_desktop_document (desktop);
438 SPEventContext *ev = sp_desktop_event_context (desktop);
440 SPGradient *gr_selected = NULL;
441 bool gr_multi = false;
443 SPGradientSpread spr_selected = (SPGradientSpread) INT_MAX; // meaning undefined
444 bool spr_multi = false;
446 GtkTooltips *tt = gtk_tooltips_new();
448 gr_read_selection (selection, ev? ev->get_drag() : NULL, &gr_selected, &gr_multi, &spr_selected, &spr_multi);
450 GtkWidget *widget = gtk_hbox_new(FALSE, FALSE);
451 gtk_object_set_data(GTK_OBJECT(widget), "dtw", desktop->canvas);
452 g_object_set_data (G_OBJECT (widget), "desktop", desktop);
454 GtkWidget *om = gr_vector_list (desktop, selection->isEmpty(), gr_selected, gr_multi);
455 g_object_set_data (G_OBJECT (widget), "menu", om);
457 gtk_box_pack_start (GTK_BOX (widget), om, TRUE, TRUE, 0);
459 {
460 GtkWidget *buttons = gtk_hbox_new(FALSE, 1);
462 /* Edit... */
463 {
464 GtkWidget *hb = gtk_hbox_new(FALSE, 1);
465 GtkWidget *b = gtk_button_new_with_label(_("Edit..."));
466 gtk_tooltips_set_tip(tt, b, _("Edit the stops of the gradient"), NULL);
467 gtk_widget_show(b);
468 gtk_container_add(GTK_CONTAINER(hb), b);
469 gtk_signal_connect(GTK_OBJECT(b), "clicked", GTK_SIGNAL_FUNC(gr_edit), widget);
470 gtk_box_pack_start (GTK_BOX(buttons), hb, FALSE, FALSE, 0);
471 }
473 gtk_box_pack_end (GTK_BOX(widget), buttons, FALSE, FALSE, 0);
474 g_object_set_data (G_OBJECT(widget), "buttons", buttons);
475 gtk_widget_set_sensitive (buttons, (gr_selected && !gr_multi));
476 }
478 // connect to selection modified and changed signals
479 sigc::connection *conn1 = new sigc::connection (selection->connectChanged(
480 sigc::bind (
481 sigc::ptr_fun(&gr_tb_selection_changed),
482 (gpointer)widget )
483 ));
484 sigc::connection *conn2 = new sigc::connection (selection->connectModified(
485 sigc::bind (
486 sigc::ptr_fun(&gr_tb_selection_modified),
487 (gpointer)widget )
488 ));
490 sigc::connection *conn3 = new sigc::connection (desktop->connectToolSubselectionChanged(
491 sigc::bind (
492 sigc::ptr_fun(&gr_drag_selection_changed),
493 (gpointer)widget )
494 ));
496 // when widget is destroyed, disconnect
497 g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(gr_disconnect_sigc), conn1);
498 g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(gr_disconnect_sigc), conn2);
499 g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(gr_disconnect_sigc), conn3);
501 // connect to release and modified signals of the defs (i.e. when someone changes gradient)
502 sigc::connection *release_connection = new sigc::connection();
503 *release_connection = SP_DOCUMENT_DEFS(document)->connectRelease(sigc::bind<1>(sigc::ptr_fun(&gr_defs_release), widget));
504 sigc::connection *modified_connection = new sigc::connection();
505 *modified_connection = SP_DOCUMENT_DEFS(document)->connectModified(sigc::bind<2>(sigc::ptr_fun(&gr_defs_modified), widget));
507 // when widget is destroyed, disconnect
508 g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(gr_disconnect_sigc), release_connection);
509 g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(gr_disconnect_sigc), modified_connection);
511 gtk_widget_show_all (widget);
512 return widget;
513 }
515 GtkWidget *
516 sp_gradient_toolbox_new(SPDesktop *desktop)
517 {
518 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
519 GtkWidget *tbl = gtk_toolbar_new();
521 gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
522 gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop);
524 GtkTooltips *tt = gtk_tooltips_new();
526 sp_toolbox_add_label(tbl, _("<b>New:</b>"));
528 // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
530 {
531 GtkWidget *cvbox = gtk_vbox_new (FALSE, 0);
532 GtkWidget *cbox = gtk_hbox_new (FALSE, 0);
534 {
535 GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION,
536 SP_BUTTON_TYPE_TOGGLE,
537 NULL,
538 "fill_gradient",
539 _("Create linear gradient"),
540 tt);
541 g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_type), tbl);
542 g_object_set_data(G_OBJECT(tbl), "linear", button);
543 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
544 prefs->getInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR) == SP_GRADIENT_TYPE_LINEAR);
545 gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
546 }
548 {
549 GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION,
550 SP_BUTTON_TYPE_TOGGLE,
551 NULL,
552 "fill_radial",
553 _("Create radial (elliptic or circular) gradient"),
554 tt);
555 g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_type), tbl);
556 g_object_set_data(G_OBJECT(tbl), "radial", button);
557 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
558 prefs->getInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR) == SP_GRADIENT_TYPE_RADIAL);
559 gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
560 }
562 gtk_box_pack_start(GTK_BOX(cvbox), cbox, TRUE, FALSE, 0);
563 gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), cvbox, "", "" );
564 }
566 // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
568 sp_toolbox_add_label(tbl, _("on"), false);
570 // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
572 {
573 GtkWidget *cvbox = gtk_vbox_new (FALSE, 0);
574 GtkWidget *cbox = gtk_hbox_new (FALSE, 0);
576 {
577 GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION,
578 SP_BUTTON_TYPE_TOGGLE,
579 NULL,
580 "controls_fill",
581 _("Create gradient in the fill"),
582 tt);
583 g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_fillstroke), tbl);
584 g_object_set_data(G_OBJECT(tbl), "fill", button);
585 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
586 prefs->getBool("/tools/gradient/newfillorstroke", true));
587 gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
588 }
590 {
591 GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION,
592 SP_BUTTON_TYPE_TOGGLE,
593 NULL,
594 "controls_stroke",
595 _("Create gradient in the stroke"),
596 tt);
597 g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_fillstroke), tbl);
598 g_object_set_data(G_OBJECT(tbl), "stroke", button);
599 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
600 !prefs->getBool("/tools/gradient/newfillorstroke", true));
601 gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
602 }
604 gtk_box_pack_start(GTK_BOX(cvbox), cbox, TRUE, TRUE, 3);
605 gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), cvbox, "", "" );
606 }
609 sp_toolbox_add_label(tbl, _("<b>Change:</b>"));
611 // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
613 {
614 GtkWidget *vectors = gr_change_widget (desktop);
615 gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), vectors, "", "" );
616 }
618 gtk_widget_show_all(tbl);
619 sp_set_font_size_smaller (tbl);
621 return tbl;
622 }
627 /*
628 Local Variables:
629 mode:c++
630 c-file-style:"stroustrup"
631 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
632 indent-tabs-mode:nil
633 fill-column:99
634 End:
635 */
636 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :