ddd9fd96a04ebe3befd53a8302fd7a8252c8db23
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
77 gr_apply_gradient_to_item (SPItem *item, SPGradient *gr, SPGradientType new_type, guint new_fill, bool do_fill, bool do_stroke)
78 {
79 SPStyle *style = SP_OBJECT_STYLE (item);
81 if (do_fill) {
82 if (style && (style->fill.isPaintserver()) &&
83 SP_IS_GRADIENT (SP_OBJECT_STYLE_FILL_SERVER (item))) {
84 SPObject *server = SP_OBJECT_STYLE_FILL_SERVER (item);
85 if (SP_IS_LINEARGRADIENT (server)) {
86 sp_item_set_gradient(item, gr, SP_GRADIENT_TYPE_LINEAR, true);
87 } else if (SP_IS_RADIALGRADIENT (server)) {
88 sp_item_set_gradient(item, gr, SP_GRADIENT_TYPE_RADIAL, true);
89 }
90 } else if (new_fill) {
91 sp_item_set_gradient(item, gr, new_type, true);
92 }
93 }
95 if (do_stroke) {
96 if (style && (style->stroke.isPaintserver()) &&
97 SP_IS_GRADIENT (SP_OBJECT_STYLE_STROKE_SERVER (item))) {
98 SPObject *server = SP_OBJECT_STYLE_STROKE_SERVER (item);
99 if (SP_IS_LINEARGRADIENT (server)) {
100 sp_item_set_gradient(item, gr, SP_GRADIENT_TYPE_LINEAR, false);
101 } else if (SP_IS_RADIALGRADIENT (server)) {
102 sp_item_set_gradient(item, gr, SP_GRADIENT_TYPE_RADIAL, false);
103 }
104 } else if (!new_fill) {
105 sp_item_set_gradient(item, gr, new_type, false);
106 }
107 }
108 }
110 /**
111 Applies gradient vector gr to the gradients attached to the selected dragger of drag, or if none,
112 to all objects in selection. If there was no previous gradient on an item, uses gradient type and
113 fill/stroke setting from preferences to create new default (linear: left/right; radial: centered)
114 gradient.
115 */
116 void
117 gr_apply_gradient (Inkscape::Selection *selection, GrDrag *drag, SPGradient *gr)
118 {
119 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
120 SPGradientType new_type = (SPGradientType) prefs->getInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR);
121 guint new_fill = prefs->getBool("/tools/gradient/newfillorstroke", true);
124 // GRADIENTFIXME: make this work for multiple selected draggers.
126 // First try selected dragger
127 if (drag && drag->selected) {
128 GrDragger *dragger = (GrDragger*) drag->selected->data;
129 for (GSList const* i = dragger->draggables; i != NULL; i = i->next) { // for all draggables of dragger
130 GrDraggable *draggable = (GrDraggable *) i->data;
131 gr_apply_gradient_to_item (draggable->item, gr, new_type, new_fill, draggable->fill_or_stroke, !draggable->fill_or_stroke);
132 }
133 return;
134 }
136 // If no drag or no dragger selected, act on selection
137 for (GSList const* i = selection->itemList(); i != NULL; i = i->next) {
138 gr_apply_gradient_to_item (SP_ITEM(i->data), gr, new_type, new_fill, new_fill, !new_fill);
139 }
140 }
142 void
143 gr_item_activate (GtkMenuItem *menuitem, gpointer data)
144 {
145 SPGradient *gr = (SPGradient *) g_object_get_data (G_OBJECT (menuitem), "gradient");
146 gr = sp_gradient_ensure_vector_normalized(gr);
148 SPDesktop *desktop = (SPDesktop *) data;
149 Inkscape::Selection *selection = sp_desktop_selection (desktop);
150 SPEventContext *ev = sp_desktop_event_context (desktop);
152 gr_apply_gradient (selection, ev? ev->get_drag() : NULL, gr);
154 sp_document_done (sp_desktop_document (desktop), SP_VERB_CONTEXT_GRADIENT,
155 _("Assign gradient to object"));
156 }
158 gchar *
159 gr_prepare_label (SPObject *obj)
160 {
161 const gchar *id = obj->defaultLabel();
162 if (strlen(id) > 15 && (!strncmp (id, "#linearGradient", 15) || !strncmp (id, "#radialGradient", 15)))
163 return g_strdup_printf ("<small>#%s</small>", id+15);
164 return g_strdup_printf ("<small>%s</small>", id);
165 }
167 GtkWidget *
168 gr_vector_list (SPDesktop *desktop, bool selection_empty, SPGradient *gr_selected, bool gr_multi)
169 {
170 SPDocument *document = sp_desktop_document (desktop);
172 GtkWidget *om = gtk_option_menu_new ();
173 GtkWidget *m = gtk_menu_new ();
175 GSList *gl = NULL;
176 const GSList *gradients = sp_document_get_resource_list (document, "gradient");
177 for (const GSList *i = gradients; i != NULL; i = i->next) {
178 if (SP_GRADIENT_HAS_STOPS (i->data)) {
179 gl = g_slist_prepend (gl, i->data);
180 }
181 }
182 gl = g_slist_reverse (gl);
184 guint pos = 0;
185 guint idx = 0;
187 if (!gl) {
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 GtkWidget *l = gtk_label_new("");
198 gtk_label_set_markup (GTK_LABEL(l), _("<small>Nothing selected</small>"));
199 GtkWidget *i = gtk_menu_item_new ();
200 gtk_container_add (GTK_CONTAINER (i), l);
202 gtk_widget_show (i);
203 gtk_menu_append (GTK_MENU (m), i);
204 gtk_widget_set_sensitive (om, FALSE);
205 } else {
207 if (gr_selected == NULL) {
208 GtkWidget *l = gtk_label_new("");
209 gtk_label_set_markup (GTK_LABEL(l), _("<small>No gradients in selection</small>"));
210 GtkWidget *i = gtk_menu_item_new ();
211 gtk_container_add (GTK_CONTAINER (i), l);
213 gtk_widget_show (i);
214 gtk_menu_append (GTK_MENU (m), i);
215 }
217 if (gr_multi) {
218 GtkWidget *l = gtk_label_new("");
219 gtk_label_set_markup (GTK_LABEL(l), _("<small>Multiple gradients</small>"));
220 GtkWidget *i = gtk_menu_item_new ();
221 gtk_container_add (GTK_CONTAINER (i), l);
223 gtk_widget_show (i);
224 gtk_menu_append (GTK_MENU (m), i);
225 }
227 while (gl) {
228 SPGradient *gradient = SP_GRADIENT (gl->data);
229 gl = g_slist_remove (gl, gradient);
231 GtkWidget *i = gtk_menu_item_new ();
232 g_object_set_data (G_OBJECT (i), "gradient", gradient);
233 g_signal_connect (G_OBJECT (i), "activate", G_CALLBACK (gr_item_activate), desktop);
235 GtkWidget *image = sp_gradient_image_new (gradient);
237 GtkWidget *hb = gtk_hbox_new (FALSE, 4);
238 GtkWidget *l = gtk_label_new ("");
239 gchar *label = gr_prepare_label (SP_OBJECT(gradient));
240 gtk_label_set_markup (GTK_LABEL(l), label);
241 g_free (label);
242 gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
243 gtk_box_pack_start (GTK_BOX (hb), l, TRUE, TRUE, 0);
244 gtk_box_pack_start (GTK_BOX (hb), image, FALSE, FALSE, 0);
246 gtk_widget_show_all (i);
248 gtk_container_add (GTK_CONTAINER (i), hb);
250 gtk_menu_append (GTK_MENU (m), i);
252 if (gradient == gr_selected) {
253 pos = idx;
254 }
255 idx ++;
256 }
257 gtk_widget_set_sensitive (om, TRUE);
258 }
260 gtk_option_menu_set_menu (GTK_OPTION_MENU (om), m);
261 /* Select the current gradient, or the Multi/Nothing line */
262 if (gr_multi || gr_selected == NULL)
263 gtk_option_menu_set_history (GTK_OPTION_MENU (om), 0);
264 else
265 gtk_option_menu_set_history (GTK_OPTION_MENU (om), pos);
267 return om;
268 }
271 void
272 gr_read_selection (Inkscape::Selection *selection, GrDrag *drag, SPGradient **gr_selected, bool *gr_multi, SPGradientSpread *spr_selected, bool *spr_multi)
273 {
274 if (drag && drag->selected) {
275 // GRADIENTFIXME: make this work for more than one selected dragger?
276 GrDragger *dragger = (GrDragger*) drag->selected->data;
277 for (GSList const* i = dragger->draggables; i != NULL; i = i->next) { // for all draggables of dragger
278 GrDraggable *draggable = (GrDraggable *) i->data;
279 SPGradient *gradient = sp_item_gradient_get_vector (draggable->item, draggable->fill_or_stroke);
280 SPGradientSpread spread = sp_item_gradient_get_spread (draggable->item, draggable->fill_or_stroke);
282 if (gradient != *gr_selected) {
283 if (*gr_selected != NULL) {
284 *gr_multi = true;
285 } else {
286 *gr_selected = gradient;
287 }
288 }
289 if (spread != *spr_selected) {
290 if (*spr_selected != INT_MAX) {
291 *spr_multi = true;
292 } else {
293 *spr_selected = spread;
294 }
295 }
296 }
297 return;
298 }
300 // If no selected dragger, read desktop selection
301 for (GSList const* i = selection->itemList(); i != NULL; i = i->next) {
302 SPItem *item = SP_ITEM(i->data);
303 SPStyle *style = SP_OBJECT_STYLE (item);
305 if (style && (style->fill.isPaintserver())) {
306 SPObject *server = SP_OBJECT_STYLE_FILL_SERVER (item);
307 if (SP_IS_GRADIENT (server)) {
308 SPGradient *gradient = sp_gradient_get_vector (SP_GRADIENT (server), false);
309 SPGradientSpread spread = sp_gradient_get_spread (SP_GRADIENT (server));
310 if (gradient != *gr_selected) {
311 if (*gr_selected != NULL) {
312 *gr_multi = true;
313 } else {
314 *gr_selected = gradient;
315 }
316 }
317 if (spread != *spr_selected) {
318 if (*spr_selected != INT_MAX) {
319 *spr_multi = true;
320 } else {
321 *spr_selected = spread;
322 }
323 }
324 }
325 }
326 if (style && (style->stroke.isPaintserver())) {
327 SPObject *server = SP_OBJECT_STYLE_STROKE_SERVER (item);
328 if (SP_IS_GRADIENT (server)) {
329 SPGradient *gradient = sp_gradient_get_vector (SP_GRADIENT (server), false);
330 SPGradientSpread spread = sp_gradient_get_spread (SP_GRADIENT (server));
331 if (gradient != *gr_selected) {
332 if (*gr_selected != NULL) {
333 *gr_multi = true;
334 } else {
335 *gr_selected = gradient;
336 }
337 }
338 if (spread != *spr_selected) {
339 if (*spr_selected != INT_MAX) {
340 *spr_multi = true;
341 } else {
342 *spr_selected = spread;
343 }
344 }
345 }
346 }
347 }
348 }
350 static void
351 gr_tb_selection_changed (Inkscape::Selection *, gpointer data)
352 {
353 GtkWidget *widget = (GtkWidget *) data;
355 SPDesktop *desktop = (SPDesktop *) g_object_get_data (G_OBJECT(widget), "desktop");
356 if (!desktop)
357 return;
359 Inkscape::Selection *selection = sp_desktop_selection (desktop); // take from desktop, not from args
360 if (!selection)
361 return;
363 SPEventContext *ev = sp_desktop_event_context (desktop);
365 GtkWidget *om = (GtkWidget *) g_object_get_data (G_OBJECT (widget), "menu");
366 if (om) gtk_widget_destroy (om);
368 SPGradient *gr_selected = NULL;
369 bool gr_multi = false;
371 SPGradientSpread spr_selected = (SPGradientSpread) INT_MAX; // meaning undefined
372 bool spr_multi = false;
374 gr_read_selection (selection, ev? ev->get_drag() : NULL, &gr_selected, &gr_multi, &spr_selected, &spr_multi);
376 om = gr_vector_list (desktop, selection->isEmpty(), gr_selected, gr_multi);
377 g_object_set_data (G_OBJECT (widget), "menu", om);
379 GtkWidget *buttons = (GtkWidget *) g_object_get_data (G_OBJECT(widget), "buttons");
380 gtk_widget_set_sensitive (buttons, (gr_selected && !gr_multi));
382 gtk_box_pack_start (GTK_BOX (widget), om, TRUE, TRUE, 0);
384 gtk_widget_show_all (widget);
385 }
387 static void
388 gr_tb_selection_modified (Inkscape::Selection *selection, guint /*flags*/, gpointer data)
389 {
390 gr_tb_selection_changed (selection, data);
391 }
393 static void
394 gr_drag_selection_changed (gpointer /*dragger*/, gpointer data)
395 {
396 gr_tb_selection_changed (NULL, data);
397 }
399 static void
400 gr_defs_release (SPObject */*defs*/, GtkWidget *widget)
401 {
402 gr_tb_selection_changed (NULL, (gpointer) widget);
403 }
405 static void
406 gr_defs_modified (SPObject */*defs*/, guint /*flags*/, GtkWidget *widget)
407 {
408 gr_tb_selection_changed (NULL, (gpointer) widget);
409 }
411 static void gr_disconnect_sigc (GObject */*obj*/, sigc::connection *connection) {
412 connection->disconnect();
413 delete connection;
414 }
416 static void
417 gr_edit (GtkWidget */*button*/, GtkWidget *widget)
418 {
419 GtkWidget *om = (GtkWidget *) g_object_get_data (G_OBJECT(widget), "menu");
421 spinbutton_defocus(GTK_OBJECT(widget));
423 if (om) {
424 GtkWidget *i = gtk_menu_get_active (GTK_MENU (gtk_option_menu_get_menu (GTK_OPTION_MENU (om))));
425 SPGradient *gr = (SPGradient *) g_object_get_data (G_OBJECT(i), "gradient");
427 if (gr) {
428 GtkWidget *dialog = sp_gradient_vector_editor_new (gr);
429 gtk_widget_show (dialog);
430 }
431 }
432 }
434 GtkWidget *
435 gr_change_widget (SPDesktop *desktop)
436 {
437 Inkscape::Selection *selection = sp_desktop_selection (desktop);
438 SPDocument *document = sp_desktop_document (desktop);
439 SPEventContext *ev = sp_desktop_event_context (desktop);
441 SPGradient *gr_selected = NULL;
442 bool gr_multi = false;
444 SPGradientSpread spr_selected = (SPGradientSpread) INT_MAX; // meaning undefined
445 bool spr_multi = false;
447 GtkTooltips *tt = gtk_tooltips_new();
449 gr_read_selection (selection, ev? ev->get_drag() : NULL, &gr_selected, &gr_multi, &spr_selected, &spr_multi);
451 GtkWidget *widget = gtk_hbox_new(FALSE, FALSE);
452 gtk_object_set_data(GTK_OBJECT(widget), "dtw", desktop->canvas);
453 g_object_set_data (G_OBJECT (widget), "desktop", desktop);
455 GtkWidget *om = gr_vector_list (desktop, selection->isEmpty(), gr_selected, gr_multi);
456 g_object_set_data (G_OBJECT (widget), "menu", om);
458 gtk_box_pack_start (GTK_BOX (widget), om, TRUE, TRUE, 0);
460 {
461 GtkWidget *buttons = gtk_hbox_new(FALSE, 1);
463 /* Edit... */
464 {
465 GtkWidget *hb = gtk_hbox_new(FALSE, 1);
466 GtkWidget *b = gtk_button_new_with_label(_("Edit..."));
467 gtk_tooltips_set_tip(tt, b, _("Edit the stops of the gradient"), NULL);
468 gtk_widget_show(b);
469 gtk_container_add(GTK_CONTAINER(hb), b);
470 gtk_signal_connect(GTK_OBJECT(b), "clicked", GTK_SIGNAL_FUNC(gr_edit), widget);
471 gtk_box_pack_start (GTK_BOX(buttons), hb, FALSE, FALSE, 0);
472 }
474 gtk_box_pack_end (GTK_BOX(widget), buttons, FALSE, FALSE, 0);
475 g_object_set_data (G_OBJECT(widget), "buttons", buttons);
476 gtk_widget_set_sensitive (buttons, (gr_selected && !gr_multi));
477 }
479 // connect to selection modified and changed signals
480 sigc::connection *conn1 = new sigc::connection (selection->connectChanged(
481 sigc::bind (
482 sigc::ptr_fun(&gr_tb_selection_changed),
483 (gpointer)widget )
484 ));
485 sigc::connection *conn2 = new sigc::connection (selection->connectModified(
486 sigc::bind (
487 sigc::ptr_fun(&gr_tb_selection_modified),
488 (gpointer)widget )
489 ));
491 sigc::connection *conn3 = new sigc::connection (desktop->connectToolSubselectionChanged(
492 sigc::bind (
493 sigc::ptr_fun(&gr_drag_selection_changed),
494 (gpointer)widget )
495 ));
497 // when widget is destroyed, disconnect
498 g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(gr_disconnect_sigc), conn1);
499 g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(gr_disconnect_sigc), conn2);
500 g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(gr_disconnect_sigc), conn3);
502 // connect to release and modified signals of the defs (i.e. when someone changes gradient)
503 sigc::connection *release_connection = new sigc::connection();
504 *release_connection = SP_DOCUMENT_DEFS(document)->connectRelease(sigc::bind<1>(sigc::ptr_fun(&gr_defs_release), widget));
505 sigc::connection *modified_connection = new sigc::connection();
506 *modified_connection = SP_DOCUMENT_DEFS(document)->connectModified(sigc::bind<2>(sigc::ptr_fun(&gr_defs_modified), widget));
508 // when widget is destroyed, disconnect
509 g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(gr_disconnect_sigc), release_connection);
510 g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(gr_disconnect_sigc), modified_connection);
512 gtk_widget_show_all (widget);
513 return widget;
514 }
516 GtkWidget *
517 sp_gradient_toolbox_new(SPDesktop *desktop)
518 {
519 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
520 GtkWidget *tbl = gtk_toolbar_new();
522 gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
523 gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop);
525 GtkTooltips *tt = gtk_tooltips_new();
527 sp_toolbox_add_label(tbl, _("<b>New:</b>"));
529 // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
531 {
532 GtkWidget *cvbox = gtk_vbox_new (FALSE, 0);
533 GtkWidget *cbox = gtk_hbox_new (FALSE, 0);
535 {
536 GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION,
537 SP_BUTTON_TYPE_TOGGLE,
538 NULL,
539 INKSCAPE_ICON_PAINT_GRADIENT_LINEAR,
540 _("Create linear gradient"),
541 tt);
542 g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_type), tbl);
543 g_object_set_data(G_OBJECT(tbl), "linear", button);
544 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
545 prefs->getInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR) == SP_GRADIENT_TYPE_LINEAR);
546 gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
547 }
549 {
550 GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION,
551 SP_BUTTON_TYPE_TOGGLE,
552 NULL,
553 INKSCAPE_ICON_PAINT_GRADIENT_RADIAL,
554 _("Create radial (elliptic or circular) gradient"),
555 tt);
556 g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_type), tbl);
557 g_object_set_data(G_OBJECT(tbl), "radial", button);
558 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
559 prefs->getInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR) == SP_GRADIENT_TYPE_RADIAL);
560 gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
561 }
563 gtk_box_pack_start(GTK_BOX(cvbox), cbox, TRUE, FALSE, 0);
564 gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), cvbox, "", "" );
565 }
567 // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
569 sp_toolbox_add_label(tbl, _("on"), false);
571 // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
573 {
574 GtkWidget *cvbox = gtk_vbox_new (FALSE, 0);
575 GtkWidget *cbox = gtk_hbox_new (FALSE, 0);
577 {
578 GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION,
579 SP_BUTTON_TYPE_TOGGLE,
580 NULL,
581 INKSCAPE_ICON_OBJECT_FILL,
582 _("Create gradient in the fill"),
583 tt);
584 g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_fillstroke), tbl);
585 g_object_set_data(G_OBJECT(tbl), "fill", button);
586 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
587 prefs->getBool("/tools/gradient/newfillorstroke", true));
588 gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
589 }
591 {
592 GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION,
593 SP_BUTTON_TYPE_TOGGLE,
594 NULL,
595 INKSCAPE_ICON_OBJECT_STROKE,
596 _("Create gradient in the stroke"),
597 tt);
598 g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_fillstroke), tbl);
599 g_object_set_data(G_OBJECT(tbl), "stroke", button);
600 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
601 !prefs->getBool("/tools/gradient/newfillorstroke", true));
602 gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
603 }
605 gtk_box_pack_start(GTK_BOX(cvbox), cbox, TRUE, TRUE, 3);
606 gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), cvbox, "", "" );
607 }
610 sp_toolbox_add_label(tbl, _("<b>Change:</b>"));
612 // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
614 {
615 GtkWidget *vectors = gr_change_widget (desktop);
616 gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), vectors, "", "" );
617 }
619 gtk_widget_show_all(tbl);
620 sp_set_font_size_smaller (tbl);
622 return tbl;
623 }
628 /*
629 Local Variables:
630 mode:c++
631 c-file-style:"stroustrup"
632 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
633 indent-tabs-mode:nil
634 fill-column:99
635 End:
636 */
637 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :