src/widgets/gradient-toolbar.cpp

   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  */
  13
  14 #ifdef HAVE_CONFIG_H
  15 # include "config.h"
  16 #endif
  17
  18 #include <gtk/gtk.h>
  19
  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"
  28
  29 #include "preferences.h"
  30 #include "document-private.h"
  31 #include "desktop.h"
  32 #include "desktop-handles.h"
  33 #include <glibmm/i18n.h>
  34
  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"
  42
  43 #include "toolbox.h"
  44
  45
  46 //########################
  47 //##       Gradient     ##
  48 //########################
  49
  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 }
  62
  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 }
  75
  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);
  80
  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     }
  94
  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 }
 109
 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);
 122
 123
 124     // GRADIENTFIXME: make this work for multiple selected draggers.
 125
 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     }
 135
 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 }
 141
 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);
 147
 148     SPDesktop *desktop = (SPDesktop *) data;
 149     Inkscape::Selection *selection = sp_desktop_selection (desktop);
 150     SPEventContext *ev = sp_desktop_event_context (desktop);
 151
 152     gr_apply_gradient (selection, ev? ev->get_drag() : NULL, gr);
 153
 154     sp_document_done (sp_desktop_document (desktop), SP_VERB_CONTEXT_GRADIENT,
 155                       _("Assign gradient to object"));
 156 }
 157
 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 }
 166
 167 GtkWidget *
 168 gr_vector_list (SPDesktop *desktop, bool selection_empty, SPGradient *gr_selected, bool gr_multi)
 169 {
 170     Document *document = sp_desktop_document (desktop);
 171
 172     GtkWidget *om = gtk_option_menu_new ();
 173     GtkWidget *m = gtk_menu_new ();
 174
 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);
 183
 184     guint pos = 0;
 185     guint idx = 0;
 186
 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);
 192
 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);
 201
 202         gtk_widget_show (i);
 203         gtk_menu_append (GTK_MENU (m), i);
 204         gtk_widget_set_sensitive (om, FALSE);
 205     } else {
 206
 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);
 212
 213             gtk_widget_show (i);
 214             gtk_menu_append (GTK_MENU (m), i);
 215         }
 216
 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);
 222
 223             gtk_widget_show (i);
 224             gtk_menu_append (GTK_MENU (m), i);
 225         }
 226
 227         while (gl) {
 228             SPGradient *gradient = SP_GRADIENT (gl->data);
 229             gl = g_slist_remove (gl, gradient);
 230
 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);
 234
 235             GtkWidget *image = sp_gradient_image_new (gradient);
 236
 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);
 245
 246             gtk_widget_show_all (i);
 247
 248             gtk_container_add (GTK_CONTAINER (i), hb);
 249
 250             gtk_menu_append (GTK_MENU (m), i);
 251
 252             if (gradient == gr_selected) {
 253                 pos = idx;
 254             }
 255             idx ++;
 256         }
 257         gtk_widget_set_sensitive (om, TRUE);
 258     }
 259
 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);
 266
 267     return om;
 268 }
 269
 270
 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);
 281
 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     }
 299
 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);
 304
 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  }
 349
 350 static void
 351 gr_tb_selection_changed (Inkscape::Selection *, gpointer data)
 352 {
 353     GtkWidget *widget = (GtkWidget *) data;
 354
 355     SPDesktop *desktop = (SPDesktop *) g_object_get_data (G_OBJECT(widget), "desktop");
 356     if (!desktop)
 357         return;
 358
 359     Inkscape::Selection *selection = sp_desktop_selection (desktop); // take from desktop, not from args
 360     if (!selection)
 361         return;
 362
 363     SPEventContext *ev = sp_desktop_event_context (desktop);
 364
 365     GtkWidget *om = (GtkWidget *) g_object_get_data (G_OBJECT (widget), "menu");
 366     if (om) gtk_widget_destroy (om);
 367
 368     SPGradient *gr_selected = NULL;
 369     bool gr_multi = false;
 370
 371     SPGradientSpread spr_selected = (SPGradientSpread) INT_MAX; // meaning undefined
 372     bool spr_multi = false;
 373
 374     gr_read_selection (selection, ev? ev->get_drag() : NULL, &gr_selected, &gr_multi, &spr_selected, &spr_multi);
 375
 376     om = gr_vector_list (desktop, selection->isEmpty(), gr_selected, gr_multi);
 377     g_object_set_data (G_OBJECT (widget), "menu", om);
 378
 379     GtkWidget *buttons = (GtkWidget *) g_object_get_data (G_OBJECT(widget), "buttons");
 380     gtk_widget_set_sensitive (buttons, (gr_selected && !gr_multi));
 381
 382     gtk_box_pack_start (GTK_BOX (widget), om, TRUE, TRUE, 0);
 383
 384     gtk_widget_show_all (widget);
 385 }
 386
 387 static void
 388 gr_tb_selection_modified (Inkscape::Selection *selection, guint /*flags*/, gpointer data)
 389 {
 390     gr_tb_selection_changed (selection, data);
 391 }
 392
 393 static void
 394 gr_drag_selection_changed (gpointer /*dragger*/, gpointer data)
 395 {
 396     gr_tb_selection_changed (NULL, data);
 397 }
 398
 399 static void
 400 gr_defs_release (SPObject */*defs*/, GtkWidget *widget)
 401 {
 402     gr_tb_selection_changed (NULL, (gpointer) widget);
 403 }
 404
 405 static void
 406 gr_defs_modified (SPObject */*defs*/, guint /*flags*/, GtkWidget *widget)
 407 {
 408     gr_tb_selection_changed (NULL, (gpointer) widget);
 409 }
 410
 411 static void gr_disconnect_sigc (GObject */*obj*/, sigc::connection *connection) {
 412     connection->disconnect();
 413     delete connection;
 414 }
 415
 416 static void
 417 gr_edit (GtkWidget */*button*/, GtkWidget *widget)
 418 {
 419     GtkWidget *om = (GtkWidget *) g_object_get_data (G_OBJECT(widget), "menu");
 420
 421     spinbutton_defocus(GTK_OBJECT(widget));
 422
 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");
 426
 427         if (gr) {
 428             GtkWidget *dialog = sp_gradient_vector_editor_new (gr);
 429             gtk_widget_show (dialog);
 430         }
 431     }
 432 }
 433
 434 GtkWidget *
 435 gr_change_widget (SPDesktop *desktop)
 436 {
 437     Inkscape::Selection *selection = sp_desktop_selection (desktop);
 438     Document *document = sp_desktop_document (desktop);
 439     SPEventContext *ev = sp_desktop_event_context (desktop);
 440
 441     SPGradient *gr_selected = NULL;
 442     bool gr_multi = false;
 443
 444     SPGradientSpread spr_selected = (SPGradientSpread) INT_MAX; // meaning undefined
 445     bool spr_multi = false;
 446
 447     GtkTooltips *tt = gtk_tooltips_new();
 448
 449     gr_read_selection (selection, ev? ev->get_drag() : NULL, &gr_selected, &gr_multi, &spr_selected, &spr_multi);
 450
 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);
 454
 455     GtkWidget *om = gr_vector_list (desktop, selection->isEmpty(), gr_selected, gr_multi);
 456     g_object_set_data (G_OBJECT (widget), "menu", om);
 457
 458     gtk_box_pack_start (GTK_BOX (widget), om, TRUE, TRUE, 0);
 459
 460     {
 461     GtkWidget *buttons = gtk_hbox_new(FALSE, 1);
 462
 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     }
 473
 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     }
 478
 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     ));
 490
 491     sigc::connection *conn3 = new sigc::connection (desktop->connectToolSubselectionChanged(
 492         sigc::bind (
 493             sigc::ptr_fun(&gr_drag_selection_changed),
 494             (gpointer)widget )
 495     ));
 496
 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);
 501
 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));
 507
 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);
 511
 512     gtk_widget_show_all (widget);
 513     return widget;
 514 }
 515
 516 GtkWidget *
 517 sp_gradient_toolbox_new(SPDesktop *desktop)
 518 {
 519     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 520     GtkWidget *tbl = gtk_toolbar_new();
 521
 522     gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
 523     gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop);
 524
 525     GtkTooltips *tt = gtk_tooltips_new();
 526
 527     sp_toolbox_add_label(tbl, _("<b>New:</b>"));
 528
 529     // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
 530
 531     {
 532     GtkWidget *cvbox = gtk_vbox_new (FALSE, 0);
 533     GtkWidget *cbox = gtk_hbox_new (FALSE, 0);
 534
 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     }
 548
 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     }
 562
 563     gtk_box_pack_start(GTK_BOX(cvbox), cbox, TRUE, FALSE, 0);
 564     gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), cvbox, "", "" );
 565     }
 566
 567     // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
 568
 569     sp_toolbox_add_label(tbl, _("on"), false);
 570
 571     // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
 572
 573     {
 574         GtkWidget *cvbox = gtk_vbox_new (FALSE, 0);
 575     GtkWidget *cbox = gtk_hbox_new (FALSE, 0);
 576
 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     }
 590
 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     }
 604
 605     gtk_box_pack_start(GTK_BOX(cvbox), cbox, TRUE, TRUE, 3);
 606     gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), cvbox, "", "" );
 607     }
 608
 609
 610     sp_toolbox_add_label(tbl, _("<b>Change:</b>"));
 611
 612     // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
 613
 614     {
 615         GtkWidget *vectors = gr_change_widget (desktop);
 616         gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), vectors, "", "" );
 617     }
 618
 619     gtk_widget_show_all(tbl);
 620     sp_set_font_size_smaller (tbl);
 621
 622     return tbl;
 623 }
 624
 625
 626
 627
 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 :