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
  42 #include "toolbox.h"
  43
  44
  45 //########################
  46 //##       Gradient     ##
  47 //########################
  48
  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 }
  61
  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 }
  74
  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);
  79
  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     }
  93
  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 }
 108
 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);
 121
 122
 123     // GRADIENTFIXME: make this work for multiple selected draggers.
 124
 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     }
 134
 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 }
 140
 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);
 146
 147     SPDesktop *desktop = (SPDesktop *) data;
 148     Inkscape::Selection *selection = sp_desktop_selection (desktop);
 149     SPEventContext *ev = sp_desktop_event_context (desktop);
 150
 151     gr_apply_gradient (selection, ev? ev->get_drag() : NULL, gr);
 152
 153     sp_document_done (sp_desktop_document (desktop), SP_VERB_CONTEXT_GRADIENT,
 154                       _("Assign gradient to object"));
 155 }
 156
 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 }
 165
 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);
 170
 171     GtkWidget *om = gtk_option_menu_new ();
 172     GtkWidget *m = gtk_menu_new ();
 173
 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);
 182
 183     guint pos = 0;
 184     guint idx = 0;
 185
 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);
 191
 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);
 200
 201         gtk_widget_show (i);
 202         gtk_menu_append (GTK_MENU (m), i);
 203         gtk_widget_set_sensitive (om, FALSE);
 204     } else {
 205
 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);
 211
 212             gtk_widget_show (i);
 213             gtk_menu_append (GTK_MENU (m), i);
 214         }
 215
 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);
 221
 222             gtk_widget_show (i);
 223             gtk_menu_append (GTK_MENU (m), i);
 224         }
 225
 226         while (gl) {
 227             SPGradient *gradient = SP_GRADIENT (gl->data);
 228             gl = g_slist_remove (gl, gradient);
 229
 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);
 233
 234             GtkWidget *image = sp_gradient_image_new (gradient);
 235
 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);
 244
 245             gtk_widget_show_all (i);
 246
 247             gtk_container_add (GTK_CONTAINER (i), hb);
 248
 249             gtk_menu_append (GTK_MENU (m), i);
 250
 251             if (gradient == gr_selected) {
 252                 pos = idx;
 253             }
 254             idx ++;
 255         }
 256         gtk_widget_set_sensitive (om, TRUE);
 257     }
 258
 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);
 265
 266     return om;
 267 }
 268
 269
 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);
 280
 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     }
 298
 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);
 303
 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  }
 348
 349 static void
 350 gr_tb_selection_changed (Inkscape::Selection *, gpointer data)
 351 {
 352     GtkWidget *widget = (GtkWidget *) data;
 353
 354     SPDesktop *desktop = (SPDesktop *) g_object_get_data (G_OBJECT(widget), "desktop");
 355     if (!desktop)
 356         return;
 357
 358     Inkscape::Selection *selection = sp_desktop_selection (desktop); // take from desktop, not from args
 359     if (!selection)
 360         return;
 361
 362     SPEventContext *ev = sp_desktop_event_context (desktop);
 363
 364     GtkWidget *om = (GtkWidget *) g_object_get_data (G_OBJECT (widget), "menu");
 365     if (om) gtk_widget_destroy (om);
 366
 367     SPGradient *gr_selected = NULL;
 368     bool gr_multi = false;
 369
 370     SPGradientSpread spr_selected = (SPGradientSpread) INT_MAX; // meaning undefined
 371     bool spr_multi = false;
 372
 373     gr_read_selection (selection, ev? ev->get_drag() : NULL, &gr_selected, &gr_multi, &spr_selected, &spr_multi);
 374
 375     om = gr_vector_list (desktop, selection->isEmpty(), gr_selected, gr_multi);
 376     g_object_set_data (G_OBJECT (widget), "menu", om);
 377
 378     GtkWidget *buttons = (GtkWidget *) g_object_get_data (G_OBJECT(widget), "buttons");
 379     gtk_widget_set_sensitive (buttons, (gr_selected && !gr_multi));
 380
 381     gtk_box_pack_start (GTK_BOX (widget), om, TRUE, TRUE, 0);
 382
 383     gtk_widget_show_all (widget);
 384 }
 385
 386 static void
 387 gr_tb_selection_modified (Inkscape::Selection *selection, guint /*flags*/, gpointer data)
 388 {
 389     gr_tb_selection_changed (selection, data);
 390 }
 391
 392 static void
 393 gr_drag_selection_changed (gpointer /*dragger*/, gpointer data)
 394 {
 395     gr_tb_selection_changed (NULL, data);
 396 }
 397
 398 static void
 399 gr_defs_release (SPObject */*defs*/, GtkWidget *widget)
 400 {
 401     gr_tb_selection_changed (NULL, (gpointer) widget);
 402 }
 403
 404 static void
 405 gr_defs_modified (SPObject */*defs*/, guint /*flags*/, GtkWidget *widget)
 406 {
 407     gr_tb_selection_changed (NULL, (gpointer) widget);
 408 }
 409
 410 static void gr_disconnect_sigc (GObject */*obj*/, sigc::connection *connection) {
 411     connection->disconnect();
 412     delete connection;
 413 }
 414
 415 static void
 416 gr_edit (GtkWidget */*button*/, GtkWidget *widget)
 417 {
 418     GtkWidget *om = (GtkWidget *) g_object_get_data (G_OBJECT(widget), "menu");
 419
 420     spinbutton_defocus(GTK_OBJECT(widget));
 421
 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");
 425
 426         if (gr) {
 427             GtkWidget *dialog = sp_gradient_vector_editor_new (gr);
 428             gtk_widget_show (dialog);
 429         }
 430     }
 431 }
 432
 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);
 439
 440     SPGradient *gr_selected = NULL;
 441     bool gr_multi = false;
 442
 443     SPGradientSpread spr_selected = (SPGradientSpread) INT_MAX; // meaning undefined
 444     bool spr_multi = false;
 445
 446     GtkTooltips *tt = gtk_tooltips_new();
 447
 448     gr_read_selection (selection, ev? ev->get_drag() : NULL, &gr_selected, &gr_multi, &spr_selected, &spr_multi);
 449
 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);
 453
 454     GtkWidget *om = gr_vector_list (desktop, selection->isEmpty(), gr_selected, gr_multi);
 455     g_object_set_data (G_OBJECT (widget), "menu", om);
 456
 457     gtk_box_pack_start (GTK_BOX (widget), om, TRUE, TRUE, 0);
 458
 459     {
 460     GtkWidget *buttons = gtk_hbox_new(FALSE, 1);
 461
 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     }
 472
 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     }
 477
 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     ));
 489
 490     sigc::connection *conn3 = new sigc::connection (desktop->connectToolSubselectionChanged(
 491         sigc::bind (
 492             sigc::ptr_fun(&gr_drag_selection_changed),
 493             (gpointer)widget )
 494     ));
 495
 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);
 500
 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));
 506
 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);
 510
 511     gtk_widget_show_all (widget);
 512     return widget;
 513 }
 514
 515 GtkWidget *
 516 sp_gradient_toolbox_new(SPDesktop *desktop)
 517 {
 518     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 519     GtkWidget *tbl = gtk_toolbar_new();
 520
 521     gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
 522     gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop);
 523
 524     GtkTooltips *tt = gtk_tooltips_new();
 525
 526     sp_toolbox_add_label(tbl, _("<b>New:</b>"));
 527
 528     // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
 529
 530     {
 531     GtkWidget *cvbox = gtk_vbox_new (FALSE, 0);
 532     GtkWidget *cbox = gtk_hbox_new (FALSE, 0);
 533
 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     }
 547
 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     }
 561
 562     gtk_box_pack_start(GTK_BOX(cvbox), cbox, TRUE, FALSE, 0);
 563     gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), cvbox, "", "" );
 564     }
 565
 566     // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
 567
 568     sp_toolbox_add_label(tbl, _("on"), false);
 569
 570     // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
 571
 572     {
 573         GtkWidget *cvbox = gtk_vbox_new (FALSE, 0);
 574     GtkWidget *cbox = gtk_hbox_new (FALSE, 0);
 575
 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     }
 589
 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     }
 603
 604     gtk_box_pack_start(GTK_BOX(cvbox), cbox, TRUE, TRUE, 3);
 605     gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), cvbox, "", "" );
 606     }
 607
 608
 609     sp_toolbox_add_label(tbl, _("<b>Change:</b>"));
 610
 611     // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
 612
 613     {
 614         GtkWidget *vectors = gr_change_widget (desktop);
 615         gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), vectors, "", "" );
 616     }
 617
 618     gtk_widget_show_all(tbl);
 619     sp_set_font_size_smaller (tbl);
 620
 621     return tbl;
 622 }
 623
 624
 625
 626
 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 :