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