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     SPDocumentUndo::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 *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 = document->get_resource_list ("gradient");
 176     for (const GSList *i = gradients; i != NULL; i = i->next) {
 177         SPGradient *grad = SP_GRADIENT(i->data);
 178         if ( grad->hasStops() && !grad->isSolid() ) {
 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         // The document has no gradients
 189         GtkWidget *l = gtk_label_new("");
 190         gtk_label_set_markup (GTK_LABEL(l), _("<small>No gradients</small>"));
 191         GtkWidget *i = gtk_menu_item_new ();
 192         gtk_container_add (GTK_CONTAINER (i), l);
 193
 194         gtk_widget_show (i);
 195         gtk_menu_append (GTK_MENU (m), i);
 196         gtk_widget_set_sensitive (om, FALSE);
 197     } else if (selection_empty) {
 198         // Document has gradients, but nothing is currently selected.
 199         GtkWidget *l = gtk_label_new("");
 200         gtk_label_set_markup (GTK_LABEL(l), _("<small>Nothing selected</small>"));
 201         GtkWidget *i = gtk_menu_item_new ();
 202         gtk_container_add (GTK_CONTAINER (i), l);
 203
 204         gtk_widget_show (i);
 205         gtk_menu_append (GTK_MENU (m), i);
 206         gtk_widget_set_sensitive (om, FALSE);
 207     } else {
 208
 209         if (gr_selected == NULL) {
 210             GtkWidget *l = gtk_label_new("");
 211             gtk_label_set_markup (GTK_LABEL(l), _("<small>No gradients in selection</small>"));
 212             GtkWidget *i = gtk_menu_item_new ();
 213             gtk_container_add (GTK_CONTAINER (i), l);
 214
 215             gtk_widget_show (i);
 216             gtk_menu_append (GTK_MENU (m), i);
 217         }
 218
 219         if (gr_multi) {
 220             GtkWidget *l = gtk_label_new("");
 221             gtk_label_set_markup (GTK_LABEL(l), _("<small>Multiple gradients</small>"));
 222             GtkWidget *i = gtk_menu_item_new ();
 223             gtk_container_add (GTK_CONTAINER (i), l);
 224
 225             gtk_widget_show (i);
 226             gtk_menu_append (GTK_MENU (m), i);
 227         }
 228
 229         while (gl) {
 230             SPGradient *gradient = SP_GRADIENT (gl->data);
 231             gl = g_slist_remove (gl, gradient);
 232
 233             GtkWidget *i = gtk_menu_item_new ();
 234             g_object_set_data (G_OBJECT (i), "gradient", gradient);
 235             g_signal_connect (G_OBJECT (i), "activate", G_CALLBACK (gr_item_activate), desktop);
 236
 237             GtkWidget *image = sp_gradient_image_new (gradient);
 238
 239             GtkWidget *hb = gtk_hbox_new (FALSE, 4);
 240             GtkWidget *l = gtk_label_new ("");
 241             gchar *label = gr_prepare_label (SP_OBJECT(gradient));
 242             gtk_label_set_markup (GTK_LABEL(l), label);
 243             g_free (label);
 244             gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
 245             gtk_box_pack_start (GTK_BOX (hb), l, TRUE, TRUE, 0);
 246             gtk_box_pack_start (GTK_BOX (hb), image, FALSE, FALSE, 0);
 247
 248             gtk_widget_show_all (i);
 249
 250             gtk_container_add (GTK_CONTAINER (i), hb);
 251
 252             gtk_menu_append (GTK_MENU (m), i);
 253
 254             if (gradient == gr_selected) {
 255                 pos = idx;
 256             }
 257             idx ++;
 258         }
 259         gtk_widget_set_sensitive (om, TRUE);
 260     }
 261
 262     gtk_option_menu_set_menu (GTK_OPTION_MENU (om), m);
 263     /* Select the current gradient, or the Multi/Nothing line */
 264     if (gr_multi || gr_selected == NULL)
 265         gtk_option_menu_set_history (GTK_OPTION_MENU (om), 0);
 266     else
 267         gtk_option_menu_set_history (GTK_OPTION_MENU (om), pos);
 268
 269     return om;
 270 }
 271
 272
 273 void gr_read_selection( Inkscape::Selection *selection,
 274                         GrDrag *drag,
 275                         SPGradient *&gr_selected,
 276                         bool &gr_multi,
 277                         SPGradientSpread &spr_selected,
 278                         bool &spr_multi )
 279 {
 280     if (drag && drag->selected) {
 281         // GRADIENTFIXME: make this work for more than one selected dragger?
 282         GrDragger *dragger = static_cast<GrDragger*>(drag->selected->data);
 283         for (GSList const* i = dragger->draggables; i; i = i->next) { // for all draggables of dragger
 284             GrDraggable *draggable = static_cast<GrDraggable *>(i->data);
 285             SPGradient *gradient = sp_item_gradient_get_vector(draggable->item, draggable->fill_or_stroke);
 286             SPGradientSpread spread = sp_item_gradient_get_spread(draggable->item, draggable->fill_or_stroke);
 287
 288             if (gradient && gradient->isSolid()) {
 289                 gradient = 0;
 290             }
 291
 292             if (gradient && (gradient != gr_selected)) {
 293                 if (gr_selected) {
 294                     gr_multi = true;
 295                 } else {
 296                     gr_selected = gradient;
 297                 }
 298             }
 299             if (spread != spr_selected) {
 300                 if (spr_selected != INT_MAX) {
 301                     spr_multi = true;
 302                 } else {
 303                     spr_selected = spread;
 304                 }
 305             }
 306          }
 307         return;
 308     }
 309
 310    // If no selected dragger, read desktop selection
 311    for (GSList const* i = selection->itemList(); i; i = i->next) {
 312         SPItem *item = SP_ITEM(i->data);
 313         SPStyle *style = SP_OBJECT_STYLE (item);
 314
 315         if (style && (style->fill.isPaintserver())) {
 316             SPObject *server = SP_OBJECT_STYLE_FILL_SERVER (item);
 317             if (SP_IS_GRADIENT(server)) {
 318                 SPGradient *gradient = SP_GRADIENT(server)->getVector();
 319                 SPGradientSpread spread = SP_GRADIENT(server)->fetchSpread();
 320
 321                 if (gradient && gradient->isSolid()) {
 322                     gradient = 0;
 323                 }
 324
 325                 if (gradient && (gradient != gr_selected)) {
 326                     if (gr_selected) {
 327                         gr_multi = true;
 328                     } else {
 329                         gr_selected = gradient;
 330                     }
 331                 }
 332                 if (spread != spr_selected) {
 333                     if (spr_selected != INT_MAX) {
 334                         spr_multi = true;
 335                     } else {
 336                         spr_selected = spread;
 337                     }
 338                 }
 339             }
 340         }
 341         if (style && (style->stroke.isPaintserver())) {
 342             SPObject *server = SP_OBJECT_STYLE_STROKE_SERVER (item);
 343             if (SP_IS_GRADIENT(server)) {
 344                 SPGradient *gradient = SP_GRADIENT(server)->getVector();
 345                 SPGradientSpread spread = SP_GRADIENT(server)->fetchSpread();
 346
 347                 if (gradient && gradient->isSolid()) {
 348                     gradient = 0;
 349
 350                 }
 351
 352                 if (gradient && (gradient != gr_selected)) {
 353                     if (gr_selected) {
 354                         gr_multi = true;
 355                     } else {
 356                         gr_selected = gradient;
 357                     }
 358                 }
 359                 if (spread != spr_selected) {
 360                     if (spr_selected != INT_MAX) {
 361                         spr_multi = true;
 362                     } else {
 363                         spr_selected = spread;
 364                     }
 365                 }
 366             }
 367         }
 368     }
 369  }
 370
 371 static void gr_tb_selection_changed(Inkscape::Selection * /*selection*/, gpointer data)
 372 {
 373     GtkWidget *widget = GTK_WIDGET(data);
 374
 375     SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(G_OBJECT(widget), "desktop"));
 376     if (desktop) {
 377         Inkscape::Selection *selection = sp_desktop_selection(desktop); // take from desktop, not from args
 378         if (selection) {
 379             SPEventContext *ev = sp_desktop_event_context(desktop);
 380
 381             GtkWidget *om = (GtkWidget *) g_object_get_data(G_OBJECT(widget), "menu");
 382             if (om) {
 383                 gtk_widget_destroy(om);
 384                 om = 0;
 385             }
 386
 387             SPGradient *gr_selected = 0;
 388             bool gr_multi = false;
 389
 390             SPGradientSpread spr_selected = static_cast<SPGradientSpread>(INT_MAX); // meaning undefined
 391             bool spr_multi = false;
 392
 393             gr_read_selection(selection, ev ? ev->get_drag() : 0, gr_selected, gr_multi, spr_selected, spr_multi);
 394
 395             om = gr_vector_list(desktop, selection->isEmpty(), gr_selected, gr_multi);
 396             g_object_set_data(G_OBJECT(widget), "menu", om);
 397
 398             GtkWidget *buttons = (GtkWidget *) g_object_get_data(G_OBJECT(widget), "buttons");
 399             gtk_widget_set_sensitive(buttons, (gr_selected && !gr_multi));
 400
 401             gtk_box_pack_start(GTK_BOX(widget), om, TRUE, TRUE, 0);
 402
 403             gtk_widget_show_all(widget);
 404         }
 405     }
 406 }
 407
 408 static void
 409 gr_tb_selection_modified (Inkscape::Selection *selection, guint /*flags*/, gpointer data)
 410 {
 411     gr_tb_selection_changed (selection, data);
 412 }
 413
 414 static void
 415 gr_drag_selection_changed (gpointer /*dragger*/, gpointer data)
 416 {
 417     gr_tb_selection_changed (NULL, data);
 418 }
 419
 420 static void
 421 gr_defs_release (SPObject */*defs*/, GtkWidget *widget)
 422 {
 423     gr_tb_selection_changed (NULL, (gpointer) widget);
 424 }
 425
 426 static void
 427 gr_defs_modified (SPObject */*defs*/, guint /*flags*/, GtkWidget *widget)
 428 {
 429     gr_tb_selection_changed (NULL, (gpointer) widget);
 430 }
 431
 432 static void gr_disconnect_sigc (GObject */*obj*/, sigc::connection *connection) {
 433     connection->disconnect();
 434     delete connection;
 435 }
 436
 437 static void
 438 gr_edit (GtkWidget */*button*/, GtkWidget *widget)
 439 {
 440     GtkWidget *om = (GtkWidget *) g_object_get_data (G_OBJECT(widget), "menu");
 441
 442     spinbutton_defocus(GTK_OBJECT(widget));
 443
 444     if (om) {
 445         GtkWidget *i = gtk_menu_get_active (GTK_MENU (gtk_option_menu_get_menu (GTK_OPTION_MENU (om))));
 446         SPGradient *gr = (SPGradient *) g_object_get_data (G_OBJECT(i), "gradient");
 447
 448         if (gr) {
 449             GtkWidget *dialog = sp_gradient_vector_editor_new (gr);
 450             gtk_widget_show (dialog);
 451         }
 452     }
 453 }
 454
 455 GtkWidget * gr_change_widget(SPDesktop *desktop)
 456 {
 457     Inkscape::Selection *selection = sp_desktop_selection (desktop);
 458     SPDocument *document = sp_desktop_document (desktop);
 459     SPEventContext *ev = sp_desktop_event_context (desktop);
 460
 461     SPGradient *gr_selected = NULL;
 462     bool gr_multi = false;
 463
 464     SPGradientSpread spr_selected = (SPGradientSpread) INT_MAX; // meaning undefined
 465     bool spr_multi = false;
 466
 467     GtkTooltips *tt = gtk_tooltips_new();
 468
 469     gr_read_selection (selection, ev? ev->get_drag() : 0, gr_selected, gr_multi, spr_selected, spr_multi);
 470
 471     GtkWidget *widget = gtk_hbox_new(FALSE, FALSE);
 472     gtk_object_set_data(GTK_OBJECT(widget), "dtw", desktop->canvas);
 473     g_object_set_data (G_OBJECT (widget), "desktop", desktop);
 474
 475     GtkWidget *om = gr_vector_list (desktop, selection->isEmpty(), gr_selected, gr_multi);
 476     g_object_set_data (G_OBJECT (widget), "menu", om);
 477
 478     gtk_box_pack_start (GTK_BOX (widget), om, TRUE, TRUE, 0);
 479
 480     {
 481     GtkWidget *buttons = gtk_hbox_new(FALSE, 1);
 482
 483     /* Edit... */
 484     {
 485         GtkWidget *hb = gtk_hbox_new(FALSE, 1);
 486         GtkWidget *b = gtk_button_new_with_label(_("Edit..."));
 487         gtk_tooltips_set_tip(tt, b, _("Edit the stops of the gradient"), NULL);
 488         gtk_widget_show(b);
 489         gtk_container_add(GTK_CONTAINER(hb), b);
 490         gtk_signal_connect(GTK_OBJECT(b), "clicked", GTK_SIGNAL_FUNC(gr_edit), widget);
 491         gtk_box_pack_start (GTK_BOX(buttons), hb, FALSE, FALSE, 0);
 492     }
 493
 494     gtk_box_pack_end (GTK_BOX(widget), buttons, FALSE, FALSE, 0);
 495     g_object_set_data (G_OBJECT(widget), "buttons", buttons);
 496     gtk_widget_set_sensitive (buttons, (gr_selected && !gr_multi));
 497     }
 498
 499     // connect to selection modified and changed signals
 500     sigc::connection *conn1 = new sigc::connection (selection->connectChanged(
 501         sigc::bind (
 502             sigc::ptr_fun(&gr_tb_selection_changed),
 503             (gpointer)widget )
 504     ));
 505     sigc::connection *conn2 = new sigc::connection (selection->connectModified(
 506         sigc::bind (
 507             sigc::ptr_fun(&gr_tb_selection_modified),
 508             (gpointer)widget )
 509     ));
 510
 511     sigc::connection *conn3 = new sigc::connection (desktop->connectToolSubselectionChanged(
 512         sigc::bind (
 513             sigc::ptr_fun(&gr_drag_selection_changed),
 514             (gpointer)widget )
 515     ));
 516
 517     // when widget is destroyed, disconnect
 518     g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(gr_disconnect_sigc), conn1);
 519     g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(gr_disconnect_sigc), conn2);
 520     g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(gr_disconnect_sigc), conn3);
 521
 522     // connect to release and modified signals of the defs (i.e. when someone changes gradient)
 523     sigc::connection *release_connection = new sigc::connection();
 524     *release_connection = SP_DOCUMENT_DEFS(document)->connectRelease(sigc::bind<1>(sigc::ptr_fun(&gr_defs_release), widget));
 525     sigc::connection *modified_connection = new sigc::connection();
 526     *modified_connection = SP_DOCUMENT_DEFS(document)->connectModified(sigc::bind<2>(sigc::ptr_fun(&gr_defs_modified), widget));
 527
 528     // when widget is destroyed, disconnect
 529     g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(gr_disconnect_sigc), release_connection);
 530     g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(gr_disconnect_sigc), modified_connection);
 531
 532     gtk_widget_show_all (widget);
 533     return widget;
 534 }
 535
 536 GtkWidget *
 537 sp_gradient_toolbox_new(SPDesktop *desktop)
 538 {
 539     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 540     GtkWidget *tbl = gtk_toolbar_new();
 541
 542     gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
 543     gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop);
 544
 545     GtkTooltips *tt = gtk_tooltips_new();
 546
 547     sp_toolbox_add_label(tbl, _("<b>New:</b>"));
 548
 549     // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
 550
 551     {
 552     GtkWidget *cvbox = gtk_vbox_new (FALSE, 0);
 553     GtkWidget *cbox = gtk_hbox_new (FALSE, 0);
 554
 555     {
 556     GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION,
 557                                               SP_BUTTON_TYPE_TOGGLE,
 558                                               NULL,
 559                                               INKSCAPE_ICON_PAINT_GRADIENT_LINEAR,
 560                                               _("Create linear gradient"),
 561                                               tt);
 562     g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_type), tbl);
 563     g_object_set_data(G_OBJECT(tbl), "linear", button);
 564     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
 565               prefs->getInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR) == SP_GRADIENT_TYPE_LINEAR);
 566     gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
 567     }
 568
 569     {
 570     GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION,
 571                                               SP_BUTTON_TYPE_TOGGLE,
 572                                               NULL,
 573                                               INKSCAPE_ICON_PAINT_GRADIENT_RADIAL,
 574                                               _("Create radial (elliptic or circular) gradient"),
 575                                               tt);
 576     g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_type), tbl);
 577     g_object_set_data(G_OBJECT(tbl), "radial", button);
 578     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
 579               prefs->getInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR) == SP_GRADIENT_TYPE_RADIAL);
 580     gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
 581     }
 582
 583     gtk_box_pack_start(GTK_BOX(cvbox), cbox, TRUE, FALSE, 0);
 584     gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), cvbox, "", "" );
 585     }
 586
 587     // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
 588
 589     sp_toolbox_add_label(tbl, _("on"), false);
 590
 591     // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
 592
 593     {
 594         GtkWidget *cvbox = gtk_vbox_new (FALSE, 0);
 595     GtkWidget *cbox = gtk_hbox_new (FALSE, 0);
 596
 597     {
 598     GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION,
 599                                               SP_BUTTON_TYPE_TOGGLE,
 600                                               NULL,
 601                                               INKSCAPE_ICON_OBJECT_FILL,
 602                                               _("Create gradient in the fill"),
 603                                               tt);
 604     g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_fillstroke), tbl);
 605     g_object_set_data(G_OBJECT(tbl), "fill", button);
 606     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
 607                                   prefs->getBool("/tools/gradient/newfillorstroke", true));
 608     gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
 609     }
 610
 611     {
 612     GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION,
 613                                               SP_BUTTON_TYPE_TOGGLE,
 614                                               NULL,
 615                                               INKSCAPE_ICON_OBJECT_STROKE,
 616                                               _("Create gradient in the stroke"),
 617                                               tt);
 618     g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_fillstroke), tbl);
 619     g_object_set_data(G_OBJECT(tbl), "stroke", button);
 620     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
 621                                   !prefs->getBool("/tools/gradient/newfillorstroke", true));
 622     gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
 623     }
 624
 625     gtk_box_pack_start(GTK_BOX(cvbox), cbox, TRUE, TRUE, 3);
 626     gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), cvbox, "", "" );
 627     }
 628
 629
 630     sp_toolbox_add_label(tbl, _("<b>Change:</b>"));
 631
 632     // TODO replace aux_toolbox_space(tbl, AUX_SPACING);
 633
 634     {
 635         GtkWidget *vectors = gr_change_widget (desktop);
 636         gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), vectors, "", "" );
 637     }
 638
 639     gtk_widget_show_all(tbl);
 640     sp_set_font_size_smaller (tbl);
 641
 642     return tbl;
 643 }
 644
 645
 646
 647
 648 /*
 649   Local Variables:
 650   mode:c++
 651   c-file-style:"stroustrup"
 652   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 653   indent-tabs-mode:nil
 654   fill-column:99
 655   End:
 656 */
 657 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :