src/widgets/toolbox.cpp

   1 #define __SP_MAINTOOLBOX_C__
   2
   3 /** \file
   4  * Controls bars for some of Inkscape's tools
   5  * (for some tools, they are in their own files)
   6  */
   7
   8 /*
   9 *
  10 * Authors:
  11 *   MenTaLguY <mental@rydia.net>
  12 *   Lauris Kaplinski <lauris@kaplinski.com>
  13 *   bulia byak <buliabyak@users.sf.net>
  14 *   Frank Felfe <innerspace@iname.com>
  15 *   John Cliff <simarilius@yahoo.com>
  16 *   David Turner <novalis@gnu.org>
  17 *   Josh Andler <scislac@scislac.com>
  18 *   Jon A. Cruz <jon@joncruz.org>
  19 *
  20 * Copyright (C) 2004 David Turner
  21 * Copyright (C) 2003 MenTaLguY
  22 * Copyright (C) 1999-2006 authors
  23 * Copyright (C) 2001-2002 Ximian, Inc.
  24 *
  25 * Released under GNU GPL, read the file 'COPYING' for more information
  26 */
  27
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #include <gtkmm.h>
  33 #include <gtk/gtk.h>
  34 #include <iostream>
  35 #include <sstream>
  36
  37 #include "widgets/button.h"
  38 #include "widgets/widget-sizes.h"
  39 #include "widgets/spw-utilities.h"
  40 #include "widgets/spinbutton-events.h"
  41 #include "dialogs/text-edit.h"
  42
  43 #include "ui/widget/style-swatch.h"
  44
  45 #include "prefs-utils.h"
  46 #include "verbs.h"
  47 #include "sp-namedview.h"
  48 #include "desktop.h"
  49 #include "desktop-handles.h"
  50 #include "nodepath.h"
  51 #include "xml/repr.h"
  52 #include "xml/node-event-vector.h"
  53 #include <glibmm/i18n.h>
  54 #include "helper/unit-menu.h"
  55 #include "helper/units.h"
  56
  57 #include "inkscape.h"
  58 #include "conn-avoid-ref.h"
  59
  60
  61 #include "select-toolbar.h"
  62 #include "gradient-toolbar.h"
  63
  64 #include "connector-context.h"
  65 #include "sp-rect.h"
  66 #include "sp-star.h"
  67 #include "sp-spiral.h"
  68 #include "sp-ellipse.h"
  69 #include "sp-text.h"
  70 #include "sp-flowtext.h"
  71 #include "style.h"
  72 #include "selection.h"
  73 #include "document-private.h"
  74 #include "desktop-style.h"
  75 #include "../libnrtype/font-lister.h"
  76 #include "../connection-pool.h"
  77 #include "../prefs-utils.h"
  78 #include "../inkscape-stock.h"
  79 #include "icon.h"
  80 #include "graphlayout/graphlayout.h"
  81
  82 #include "mod360.h"
  83
  84 #include "toolbox.h"
  85
  86 #include "flood-context.h"
  87
  88 #include "ink-action.h"
  89 #include "ege-adjustment-action.h"
  90
  91 typedef void (*SetupFunction)(GtkWidget *toolbox, SPDesktop *desktop);
  92 typedef void (*UpdateFunction)(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox);
  93
  94 static GtkWidget *sp_node_toolbox_new(SPDesktop *desktop);
  95 static GtkWidget *sp_zoom_toolbox_new(SPDesktop *desktop);
  96 static GtkWidget *sp_star_toolbox_new(SPDesktop *desktop);
  97 static GtkWidget *sp_arc_toolbox_new(SPDesktop *desktop);
  98 static GtkWidget *sp_rect_toolbox_new(SPDesktop *desktop);
  99 static GtkWidget *sp_spiral_toolbox_new(SPDesktop *desktop);
 100 static GtkWidget *sp_pencil_toolbox_new(SPDesktop *desktop);
 101 static GtkWidget *sp_pen_toolbox_new(SPDesktop *desktop);
 102 static GtkWidget *sp_calligraphy_toolbox_new(SPDesktop *desktop);
 103 static GtkWidget *sp_dropper_toolbox_new(SPDesktop *desktop);
 104 static GtkWidget *sp_empty_toolbox_new(SPDesktop *desktop);
 105 static GtkWidget *sp_connector_toolbox_new(SPDesktop *desktop);
 106 static GtkWidget *sp_paintbucket_toolbox_new(SPDesktop *desktop);
 107
 108 namespace { GtkWidget *sp_text_toolbox_new (SPDesktop *desktop); }
 109
 110
 111 static struct {
 112     gchar const *type_name;
 113     gchar const *data_name;
 114     sp_verb_t verb;
 115     sp_verb_t doubleclick_verb;
 116 } const tools[] = {
 117     { "SPSelectContext",   "select_tool",    SP_VERB_CONTEXT_SELECT,  SP_VERB_CONTEXT_SELECT_PREFS},
 118     { "SPNodeContext",     "node_tool",      SP_VERB_CONTEXT_NODE, SP_VERB_CONTEXT_NODE_PREFS },
 119     { "SPZoomContext",     "zoom_tool",      SP_VERB_CONTEXT_ZOOM, SP_VERB_CONTEXT_ZOOM_PREFS },
 120     { "SPRectContext",     "rect_tool",      SP_VERB_CONTEXT_RECT, SP_VERB_CONTEXT_RECT_PREFS },
 121     { "SPArcContext",      "arc_tool",       SP_VERB_CONTEXT_ARC, SP_VERB_CONTEXT_ARC_PREFS },
 122     { "SPStarContext",     "star_tool",      SP_VERB_CONTEXT_STAR, SP_VERB_CONTEXT_STAR_PREFS },
 123     { "SPSpiralContext",   "spiral_tool",    SP_VERB_CONTEXT_SPIRAL, SP_VERB_CONTEXT_SPIRAL_PREFS },
 124     { "SPPencilContext",   "pencil_tool",    SP_VERB_CONTEXT_PENCIL, SP_VERB_CONTEXT_PENCIL_PREFS },
 125     { "SPPenContext",      "pen_tool",       SP_VERB_CONTEXT_PEN, SP_VERB_CONTEXT_PEN_PREFS },
 126     { "SPDynaDrawContext", "dyna_draw_tool", SP_VERB_CONTEXT_CALLIGRAPHIC, SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS },
 127     { "SPFloodContext",    "paintbucket_tool",     SP_VERB_CONTEXT_PAINTBUCKET, SP_VERB_CONTEXT_PAINTBUCKET_PREFS },
 128     { "SPTextContext",     "text_tool",      SP_VERB_CONTEXT_TEXT, SP_VERB_CONTEXT_TEXT_PREFS },
 129     { "SPConnectorContext","connector_tool", SP_VERB_CONTEXT_CONNECTOR, SP_VERB_CONTEXT_CONNECTOR_PREFS },
 130     { "SPGradientContext", "gradient_tool",  SP_VERB_CONTEXT_GRADIENT, SP_VERB_CONTEXT_GRADIENT_PREFS },
 131     { "SPDropperContext",  "dropper_tool",   SP_VERB_CONTEXT_DROPPER, SP_VERB_CONTEXT_DROPPER_PREFS },
 132     { NULL, NULL, 0, 0 }
 133 };
 134
 135 static struct {
 136     gchar const *type_name;
 137     gchar const *data_name;
 138     GtkWidget *(*create_func)(SPDesktop *desktop);
 139 } const aux_toolboxes[] = {
 140     { "SPSelectContext", "select_toolbox", sp_select_toolbox_new },
 141     { "SPNodeContext",   "node_toolbox",   sp_node_toolbox_new },
 142     { "SPZoomContext",   "zoom_toolbox",   sp_zoom_toolbox_new },
 143     { "SPStarContext",   "star_toolbox",   sp_star_toolbox_new },
 144     { "SPRectContext",   "rect_toolbox",   sp_rect_toolbox_new },
 145     { "SPArcContext",    "arc_toolbox",    sp_arc_toolbox_new },
 146     { "SPSpiralContext", "spiral_toolbox", sp_spiral_toolbox_new },
 147     { "SPPencilContext", "pencil_toolbox", sp_pencil_toolbox_new },
 148     { "SPPenContext", "pen_toolbox", sp_pen_toolbox_new },
 149     { "SPDynaDrawContext", "calligraphy_toolbox", sp_calligraphy_toolbox_new },
 150     { "SPTextContext",   "text_toolbox",   sp_text_toolbox_new },
 151     { "SPDropperContext", "dropper_toolbox", sp_dropper_toolbox_new },
 152     { "SPGradientContext", "gradient_toolbox", sp_gradient_toolbox_new },
 153     { "SPConnectorContext", "connector_toolbox", sp_connector_toolbox_new },
 154     { "SPFloodContext",  "paintbucket_toolbox",  sp_paintbucket_toolbox_new },
 155     { NULL, NULL, NULL }
 156 };
 157
 158 static void toolbox_set_desktop (GtkWidget *toolbox, SPDesktop *desktop, SetupFunction setup_func, UpdateFunction update_func, sigc::connection*);
 159
 160 static void setup_tool_toolbox (GtkWidget *toolbox, SPDesktop *desktop);
 161 static void update_tool_toolbox (SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox);
 162
 163 static void setup_aux_toolbox (GtkWidget *toolbox, SPDesktop *desktop);
 164 static void update_aux_toolbox (SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox);
 165
 166 static void setup_commands_toolbox (GtkWidget *toolbox, SPDesktop *desktop);
 167 static void update_commands_toolbox (SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox);
 168
 169 /* Global text entry widgets necessary for update */
 170 /* GtkWidget *dropper_rgb_entry,
 171           *dropper_opacity_entry ; */
 172 // should be made a private member once this is converted to class
 173
 174 static void delete_connection(GObject *obj, sigc::connection *connection) {
 175     connection->disconnect();
 176     delete connection;
 177 }
 178
 179 static GtkWidget *
 180 sp_toolbox_button_new(GtkWidget *t, Inkscape::IconSize size, gchar const *pxname, GtkSignalFunc handler,
 181                       GtkTooltips *tt, gchar const *tip)
 182 {
 183     GtkWidget *b = sp_button_new_from_data(size, SP_BUTTON_TYPE_NORMAL, NULL, pxname, tip, tt);
 184     gtk_widget_show(b);
 185     if (handler) gtk_signal_connect(GTK_OBJECT(b), "clicked", handler, NULL);
 186     gtk_box_pack_start(GTK_BOX(t), b, FALSE, FALSE, 0);
 187
 188     return b;
 189 }
 190
 191 GtkWidget *
 192 sp_toolbox_button_new_from_verb_with_doubleclick(GtkWidget *t, Inkscape::IconSize size, SPButtonType type,
 193                                                  Inkscape::Verb *verb, Inkscape::Verb *doubleclick_verb,
 194                                                  Inkscape::UI::View::View *view, GtkTooltips *tt)
 195 {
 196     SPAction *action = verb->get_action(view);
 197     if (!action) return NULL;
 198
 199     SPAction *doubleclick_action;
 200     if (doubleclick_verb)
 201         doubleclick_action = doubleclick_verb->get_action(view);
 202     else
 203         doubleclick_action = NULL;
 204
 205     /* fixme: Handle sensitive/unsensitive */
 206     /* fixme: Implement sp_button_new_from_action */
 207     GtkWidget *b = sp_button_new(size, type, action, doubleclick_action, tt);
 208     gtk_widget_show(b);
 209     gtk_box_pack_start(GTK_BOX(t), b, FALSE, FALSE, 0);
 210
 211     return b;
 212 }
 213
 214 GtkWidget *sp_toolbox_button_new_from_verb(GtkWidget *t, Inkscape::IconSize size, SPButtonType type, Inkscape::Verb *verb,
 215                                            Inkscape::UI::View::View *view, GtkTooltips *tt)
 216 {
 217     return sp_toolbox_button_new_from_verb_with_doubleclick(t, size, type, verb, NULL, view, tt);
 218 }
 219
 220 GtkWidget * sp_toolbox_button_normal_new_from_verb(GtkWidget *t, Inkscape::IconSize size, Inkscape::Verb *verb,
 221                                                    Inkscape::UI::View::View *view, GtkTooltips *tt)
 222 {
 223     return sp_toolbox_button_new_from_verb(t, size, SP_BUTTON_TYPE_NORMAL, verb, view, tt);
 224 }
 225
 226 GtkWidget *
 227 sp_tool_toolbox_new()
 228 {
 229     GtkTooltips *tt = gtk_tooltips_new();
 230     GtkWidget *tb = gtk_vbox_new(FALSE, 0);
 231
 232     g_object_set_data(G_OBJECT(tb), "desktop", NULL);
 233     g_object_set_data(G_OBJECT(tb), "tooltips", tt);
 234
 235     gtk_widget_set_sensitive(tb, FALSE);
 236
 237     GtkWidget *hb = gtk_handle_box_new();
 238     gtk_handle_box_set_handle_position(GTK_HANDLE_BOX(hb), GTK_POS_TOP);
 239     gtk_handle_box_set_shadow_type(GTK_HANDLE_BOX(hb), GTK_SHADOW_OUT);
 240     gtk_handle_box_set_snap_edge(GTK_HANDLE_BOX(hb), GTK_POS_LEFT);
 241
 242     gtk_container_add(GTK_CONTAINER(hb), tb);
 243     gtk_widget_show(GTK_WIDGET(tb));
 244
 245     sigc::connection* conn = new sigc::connection;
 246     g_object_set_data(G_OBJECT(hb), "event_context_connection", conn);
 247
 248     return hb;
 249 }
 250
 251 static void
 252 aux_toolbox_attached(GtkHandleBox *toolbox, GtkWidget *child)
 253 {
 254     g_object_set_data(G_OBJECT(child), "is_detached", GINT_TO_POINTER(FALSE));
 255     gtk_widget_queue_resize(child);
 256 }
 257
 258 static void
 259 aux_toolbox_detached(GtkHandleBox *toolbox, GtkWidget *child)
 260 {
 261     g_object_set_data(G_OBJECT(child), "is_detached", GINT_TO_POINTER(TRUE));
 262     gtk_widget_queue_resize(child);
 263 }
 264
 265 GtkWidget *
 266 sp_aux_toolbox_new()
 267 {
 268     GtkWidget *tb = gtk_vbox_new(FALSE, 0);
 269
 270     GtkWidget *tb_s = gtk_vbox_new(FALSE, 0);
 271     GtkWidget *tb_e = gtk_vbox_new(FALSE, 0);
 272     gtk_box_set_spacing(GTK_BOX(tb), AUX_SPACING);
 273     gtk_box_pack_start(GTK_BOX(tb), GTK_WIDGET(tb_s), FALSE, FALSE, 0);
 274     gtk_box_pack_end(GTK_BOX(tb), GTK_WIDGET(tb_e), FALSE, FALSE, 0);
 275
 276     g_object_set_data(G_OBJECT(tb), "desktop", NULL);
 277     g_object_set_data(G_OBJECT(tb), "top_spacer", tb_s);
 278
 279     gtk_widget_set_sensitive(tb, FALSE);
 280
 281     GtkWidget *hb = gtk_handle_box_new();
 282     gtk_handle_box_set_handle_position(GTK_HANDLE_BOX(hb), GTK_POS_LEFT);
 283     gtk_handle_box_set_shadow_type(GTK_HANDLE_BOX(hb), GTK_SHADOW_OUT);
 284     gtk_handle_box_set_snap_edge(GTK_HANDLE_BOX(hb), GTK_POS_LEFT);
 285
 286     g_signal_connect(G_OBJECT(hb), "child_attached", G_CALLBACK(aux_toolbox_attached), (gpointer)tb);
 287     g_signal_connect(G_OBJECT(hb), "child_detached", G_CALLBACK(aux_toolbox_detached), (gpointer)tb);
 288
 289     gtk_container_add(GTK_CONTAINER(hb), tb);
 290     gtk_widget_show(GTK_WIDGET(tb));
 291
 292     sigc::connection* conn = new sigc::connection;
 293     g_object_set_data(G_OBJECT(hb), "event_context_connection", conn);
 294
 295     return hb;
 296 }
 297
 298 //####################################
 299 //# Commands Bar
 300 //####################################
 301
 302 GtkWidget *
 303 sp_commands_toolbox_new()
 304 {
 305     GtkWidget *tb = gtk_vbox_new(FALSE, 0);
 306
 307     GtkWidget *tb_s = gtk_vbox_new(FALSE, 0);
 308     GtkWidget *tb_e = gtk_vbox_new(FALSE, 0);
 309     gtk_box_set_spacing(GTK_BOX(tb), AUX_SPACING);
 310     gtk_box_pack_start(GTK_BOX(tb), GTK_WIDGET(tb_s), FALSE, FALSE, 0);
 311     gtk_box_pack_end(GTK_BOX(tb), GTK_WIDGET(tb_e), FALSE, FALSE, 0);
 312
 313     g_object_set_data(G_OBJECT(tb), "desktop", NULL);
 314     gtk_widget_set_sensitive(tb, FALSE);
 315
 316     GtkWidget *hb = gtk_handle_box_new();
 317     gtk_handle_box_set_handle_position(GTK_HANDLE_BOX(hb), GTK_POS_LEFT);
 318     gtk_handle_box_set_shadow_type(GTK_HANDLE_BOX(hb), GTK_SHADOW_OUT);
 319     gtk_handle_box_set_snap_edge(GTK_HANDLE_BOX(hb), GTK_POS_LEFT);
 320
 321     g_signal_connect(G_OBJECT(hb), "child_attached", G_CALLBACK(aux_toolbox_attached), (gpointer)tb);
 322     g_signal_connect(G_OBJECT(hb), "child_detached", G_CALLBACK(aux_toolbox_detached), (gpointer)tb);
 323
 324     gtk_container_add(GTK_CONTAINER(hb), tb);
 325     gtk_widget_show(GTK_WIDGET(tb));
 326
 327     sigc::connection* conn = new sigc::connection;
 328     g_object_set_data(G_OBJECT(hb), "event_context_connection", conn);
 329
 330     return hb;
 331 }
 332
 333
 334 //####################################
 335 //# node editing callbacks
 336 //####################################
 337
 338 void
 339 sp_node_path_edit_add(void)
 340 {
 341     sp_node_selected_add_node();
 342 }
 343
 344 void
 345 sp_node_path_edit_delete(void)
 346 {
 347     sp_node_selected_delete();
 348 }
 349
 350 void
 351 sp_node_path_edit_delete_segment(void)
 352 {
 353     sp_node_selected_delete_segment();
 354 }
 355
 356 void
 357 sp_node_path_edit_break(void)
 358 {
 359     sp_node_selected_break();
 360 }
 361
 362 void
 363 sp_node_path_edit_join(void)
 364 {
 365     sp_node_selected_join();
 366 }
 367
 368 void
 369 sp_node_path_edit_join_segment(void)
 370 {
 371     sp_node_selected_join_segment();
 372 }
 373
 374 void
 375 sp_node_path_edit_toline(void)
 376 {
 377     sp_node_selected_set_line_type(NR_LINETO);
 378 }
 379
 380 void
 381 sp_node_path_edit_tocurve(void)
 382 {
 383     sp_node_selected_set_line_type(NR_CURVETO);
 384 }
 385
 386 void
 387 sp_node_path_edit_cusp(void)
 388 {
 389     sp_node_selected_set_type(Inkscape::NodePath::NODE_CUSP);
 390 }
 391
 392 void
 393 sp_node_path_edit_smooth(void)
 394 {
 395     sp_node_selected_set_type(Inkscape::NodePath::NODE_SMOOTH);
 396 }
 397
 398 void
 399 sp_node_path_edit_symmetrical(void)
 400 {
 401     sp_node_selected_set_type(Inkscape::NodePath::NODE_SYMM);
 402 }
 403
 404 static void toggle_show_handles (GtkWidget *button, gpointer data) {
 405     bool show = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button));
 406     prefs_set_int_attribute ("tools.nodes", "show_handles",  show ? 1 : 0);
 407     sp_nodepath_show_handles(show);
 408 }
 409
 410 //################################
 411 //##    Node Editing Toolbox    ##
 412 //################################
 413
 414 static GtkWidget *
 415 sp_node_toolbox_new(SPDesktop *desktop)
 416 {
 417     Inkscape::UI::View::View *view = desktop;
 418
 419     GtkTooltips *tt = gtk_tooltips_new();
 420     GtkWidget *tb = gtk_hbox_new(FALSE, 0);
 421
 422     gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
 423
 424     sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_insert",
 425         GTK_SIGNAL_FUNC(sp_node_path_edit_add), tt, _("Insert new nodes into selected segments"));
 426     sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_delete",
 427         GTK_SIGNAL_FUNC(sp_node_path_edit_delete), tt, _("Delete selected nodes"));
 428
 429     gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
 430
 431     sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_join",
 432         GTK_SIGNAL_FUNC(sp_node_path_edit_join), tt, _("Join selected endnodes"));
 433     sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_join_segment",
 434         GTK_SIGNAL_FUNC(sp_node_path_edit_join_segment), tt, _("Join selected endnodes with a new segment"));
 435
 436     sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_delete_segment",
 437         GTK_SIGNAL_FUNC(sp_node_path_edit_delete_segment), tt, _("Split path between two non-endpoint nodes"));
 438
 439     sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_break",
 440         GTK_SIGNAL_FUNC(sp_node_path_edit_break), tt, _("Break path at selected nodes"));
 441
 442     gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
 443
 444     sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_cusp",
 445         GTK_SIGNAL_FUNC(sp_node_path_edit_cusp), tt, _("Make selected nodes corner"));
 446
 447     sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_smooth",
 448         GTK_SIGNAL_FUNC(sp_node_path_edit_smooth), tt, _("Make selected nodes smooth"));
 449
 450     sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_symmetric",
 451         GTK_SIGNAL_FUNC(sp_node_path_edit_symmetrical), tt, _("Make selected nodes symmetric"));
 452
 453     gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
 454
 455     sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_line",
 456         GTK_SIGNAL_FUNC(sp_node_path_edit_toline), tt, _("Make selected segments lines"));
 457
 458     sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_curve",
 459         GTK_SIGNAL_FUNC(sp_node_path_edit_tocurve), tt, _("Make selected segments curves"));
 460
 461     gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
 462
 463     sp_toolbox_button_normal_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, Inkscape::Verb::get(SP_VERB_OBJECT_TO_CURVE), view, tt);
 464
 465     sp_toolbox_button_normal_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, Inkscape::Verb::get(SP_VERB_SELECTION_OUTLINE), view, tt);
 466
 467     aux_toolbox_space(tb, AUX_BETWEEN_BUTTON_GROUPS);
 468
 469     GtkWidget *cvbox = gtk_vbox_new (FALSE, 0);
 470     GtkWidget *cbox = gtk_hbox_new (FALSE, 0);
 471
 472     {
 473     GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION,
 474                                               SP_BUTTON_TYPE_TOGGLE,
 475                                               NULL,
 476                                               "nodes_show_handles",
 477                                               _("Show the Bezier handles of selected nodes"),
 478                                               tt);
 479     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), prefs_get_int_attribute ("tools.nodes", "show_handles", 1));
 480     g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (toggle_show_handles), desktop);
 481     gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
 482     }
 483
 484     gtk_box_pack_start(GTK_BOX(cvbox), cbox, TRUE, FALSE, 0);
 485     gtk_box_pack_start(GTK_BOX(tb), cvbox, FALSE, FALSE, 0);
 486
 487     gtk_widget_show_all(tb);
 488
 489     return tb;
 490
 491 } // end of sp_node_toolbox_new()
 492
 493
 494 //########################
 495 //##    Zoom Toolbox    ##
 496 //########################
 497
 498 static GtkWidget *
 499 sp_zoom_toolbox_new(SPDesktop *desktop)
 500 {
 501     Inkscape::UI::View::View *view=desktop;
 502
 503     GtkTooltips *tt = gtk_tooltips_new();
 504     GtkWidget *tb = gtk_hbox_new(FALSE, 0);
 505
 506     gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0),
 507                        FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
 508
 509     sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_IN), view, tt);
 510
 511     sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_OUT), view, tt);
 512
 513     gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
 514
 515     sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_SELECTION), view, tt);
 516
 517     sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_DRAWING), view, tt);
 518
 519     sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_PAGE), view, tt);
 520
 521     sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_PAGE_WIDTH), view, tt);
 522
 523     gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
 524
 525     sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_PREV), view, tt);
 526
 527     sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_NEXT), view, tt);
 528
 529     gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
 530
 531     sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_1_1), view, tt);
 532
 533     sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_1_2), view, tt);
 534
 535     sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_2_1), view, tt);
 536
 537     gtk_widget_show_all(tb);
 538
 539     return tb;
 540
 541 } // end of sp_zoom_toolbox_new()
 542
 543 void
 544 sp_tool_toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop)
 545 {
 546     toolbox_set_desktop(gtk_bin_get_child(GTK_BIN(toolbox)), desktop, setup_tool_toolbox, update_tool_toolbox, static_cast<sigc::connection*>(g_object_get_data(G_OBJECT(toolbox), "event_context_connection")));
 547 }
 548
 549
 550 void
 551 sp_aux_toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop)
 552 {
 553     toolbox_set_desktop(gtk_bin_get_child(GTK_BIN(toolbox)), desktop, setup_aux_toolbox, update_aux_toolbox, static_cast<sigc::connection*>(g_object_get_data(G_OBJECT(toolbox), "event_context_connection")));
 554 }
 555
 556 void
 557 sp_commands_toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop)
 558 {
 559     toolbox_set_desktop(gtk_bin_get_child(GTK_BIN(toolbox)), desktop, setup_commands_toolbox, update_commands_toolbox, static_cast<sigc::connection*>(g_object_get_data(G_OBJECT(toolbox), "event_context_connection")));
 560 }
 561
 562 static void
 563 toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop, SetupFunction setup_func, UpdateFunction update_func, sigc::connection *conn)
 564 {
 565     gpointer ptr = g_object_get_data(G_OBJECT(toolbox), "desktop");
 566     SPDesktop *old_desktop = static_cast<SPDesktop*>(ptr);
 567
 568     if (old_desktop) {
 569         GList *children, *iter;
 570
 571         children = gtk_container_get_children(GTK_CONTAINER(toolbox));
 572         for ( iter = children ; iter ; iter = iter->next ) {
 573             gtk_container_remove( GTK_CONTAINER(toolbox), GTK_WIDGET(iter->data) );
 574         }
 575         g_list_free(children);
 576     }
 577
 578     g_object_set_data(G_OBJECT(toolbox), "desktop", (gpointer)desktop);
 579
 580     if (desktop) {
 581         gtk_widget_set_sensitive(toolbox, TRUE);
 582         setup_func(toolbox, desktop);
 583         update_func(desktop, desktop->event_context, toolbox);
 584         *conn = desktop->connectEventContextChanged
 585             (sigc::bind (sigc::ptr_fun(update_func), toolbox));
 586     } else {
 587         gtk_widget_set_sensitive(toolbox, FALSE);
 588     }
 589
 590 } // end of toolbox_set_desktop()
 591
 592
 593 static void
 594 setup_tool_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
 595 {
 596     GtkTooltips *tooltips=GTK_TOOLTIPS(g_object_get_data(G_OBJECT(toolbox), "tooltips"));
 597     gint shrinkLeft = prefs_get_int_attribute_limited( "toolbox.left", "small", 0, 0, 1 );
 598     Inkscape::IconSize toolboxSize = shrinkLeft ? Inkscape::ICON_SIZE_SMALL_TOOLBAR : Inkscape::ICON_SIZE_LARGE_TOOLBAR;
 599
 600     for (int i = 0 ; tools[i].type_name ; i++ ) {
 601         GtkWidget *button =
 602             sp_toolbox_button_new_from_verb_with_doubleclick( toolbox, toolboxSize,
 603                                                               SP_BUTTON_TYPE_TOGGLE,
 604                                                               Inkscape::Verb::get(tools[i].verb),
 605                                                               Inkscape::Verb::get(tools[i].doubleclick_verb),
 606                                                               desktop,
 607                                                               tooltips );
 608
 609         g_object_set_data( G_OBJECT(toolbox), tools[i].data_name,
 610                            (gpointer)button );
 611     }
 612 }
 613
 614
 615 static void
 616 update_tool_toolbox( SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox )
 617 {
 618     gchar const *const tname = ( eventcontext
 619                                  ? gtk_type_name(GTK_OBJECT_TYPE(eventcontext))
 620                                  : NULL );
 621     for (int i = 0 ; tools[i].type_name ; i++ ) {
 622         SPButton *button = SP_BUTTON(g_object_get_data(G_OBJECT(toolbox), tools[i].data_name));
 623         sp_button_toggle_set_down(button, tname && !strcmp(tname, tools[i].type_name));
 624     }
 625 }
 626
 627 static void
 628 setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
 629 {
 630     GtkSizeGroup* grouper = gtk_size_group_new( GTK_SIZE_GROUP_BOTH );
 631
 632     for (int i = 0 ; aux_toolboxes[i].type_name ; i++ ) {
 633         GtkWidget *sub_toolbox;
 634         if (aux_toolboxes[i].create_func == NULL)
 635             sub_toolbox = sp_empty_toolbox_new(desktop);
 636         else
 637             sub_toolbox = aux_toolboxes[i].create_func(desktop);
 638
 639         gtk_size_group_add_widget( grouper, sub_toolbox );
 640
 641         gtk_container_add(GTK_CONTAINER(toolbox), sub_toolbox);
 642         g_object_set_data(G_OBJECT(toolbox), aux_toolboxes[i].data_name, sub_toolbox);
 643     }
 644     g_object_unref( G_OBJECT(grouper) );
 645 }
 646
 647 static void
 648 update_aux_toolbox(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox)
 649 {
 650     gchar const *tname = ( eventcontext
 651                            ? gtk_type_name(GTK_OBJECT_TYPE(eventcontext))
 652                            : NULL );
 653     for (int i = 0 ; aux_toolboxes[i].type_name ; i++ ) {
 654         GtkWidget *sub_toolbox = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbox), aux_toolboxes[i].data_name));
 655         if (tname && !strcmp(tname, aux_toolboxes[i].type_name)) {
 656             gtk_widget_show_all(sub_toolbox);
 657             g_object_set_data(G_OBJECT(toolbox), "shows", sub_toolbox);
 658         } else {
 659             gtk_widget_hide(sub_toolbox);
 660         }
 661     }
 662 }
 663
 664 static void
 665 setup_commands_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
 666 {
 667     Inkscape::UI::View::View *view = desktop;
 668
 669     GtkTooltips *tt = gtk_tooltips_new();
 670     GtkWidget *tb = gtk_hbox_new(FALSE, 0);
 671
 672     gint shrinkTop = prefs_get_int_attribute_limited( "toolbox", "small", 1, 0, 1 );
 673     Inkscape::IconSize toolboxSize = shrinkTop ? Inkscape::ICON_SIZE_SMALL_TOOLBAR : Inkscape::ICON_SIZE_LARGE_TOOLBAR;
 674
 675     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_FILE_NEW), view, tt);
 676     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_FILE_OPEN), view, tt);
 677     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_FILE_SAVE), view, tt);
 678     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_FILE_PRINT), view, tt);
 679
 680     aux_toolbox_space(tb, AUX_BETWEEN_BUTTON_GROUPS);
 681
 682     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_FILE_IMPORT), view, tt);
 683     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_FILE_EXPORT), view, tt);
 684
 685     aux_toolbox_space(tb, AUX_BETWEEN_BUTTON_GROUPS);
 686
 687     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_EDIT_UNDO), view, tt);
 688     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_EDIT_REDO), view, tt);
 689
 690     aux_toolbox_space(tb, AUX_BETWEEN_BUTTON_GROUPS);
 691
 692     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_EDIT_COPY), view, tt);
 693     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_EDIT_CUT), view, tt);
 694     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_EDIT_PASTE), view, tt);
 695
 696     aux_toolbox_space(tb, AUX_BETWEEN_BUTTON_GROUPS);
 697
 698     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_SELECTION), view, tt);
 699     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_DRAWING), view, tt);
 700     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_PAGE), view, tt);
 701
 702     aux_toolbox_space(tb, AUX_BETWEEN_BUTTON_GROUPS);
 703
 704     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_EDIT_DUPLICATE), view, tt);
 705     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_EDIT_CLONE), view, tt);
 706     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_EDIT_UNLINK_CLONE), view, tt);
 707
 708     aux_toolbox_space(tb, AUX_BETWEEN_BUTTON_GROUPS);
 709
 710     sp_toolbox_button_normal_new_from_verb(tb, toolboxSize, Inkscape::Verb::get(SP_VERB_SELECTION_GROUP), view, tt);
 711     sp_toolbox_button_normal_new_from_verb(tb, toolboxSize, Inkscape::Verb::get(SP_VERB_SELECTION_UNGROUP), view, tt);
 712
 713     // disabled until we have icons for them:
 714
 715     //find
 716
 717     //sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_EDIT_TILE), view, tt);
 718     //sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_EDIT_UNTILE), view, tt);
 719
 720     aux_toolbox_space(tb, AUX_BETWEEN_BUTTON_GROUPS);
 721
 722     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_DIALOG_FILL_STROKE), view, tt);
 723     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_DIALOG_TEXT), view, tt);
 724     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_DIALOG_XML_EDITOR), view, tt);
 725     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_DIALOG_ALIGN_DISTRIBUTE), view, tt);
 726
 727     aux_toolbox_space(tb, AUX_BETWEEN_BUTTON_GROUPS);
 728
 729     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_DIALOG_DISPLAY), view, tt);
 730     sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_DIALOG_NAMEDVIEW), view, tt);
 731
 732     gtk_widget_show_all(tb);
 733
 734     gtk_container_add(GTK_CONTAINER(toolbox), tb);
 735 }
 736
 737 static void
 738 update_commands_toolbox(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox)
 739 {
 740 }
 741
 742 void show_aux_toolbox(GtkWidget *toolbox_toplevel)
 743 {
 744     gtk_widget_show(toolbox_toplevel);
 745     GtkWidget *toolbox = gtk_bin_get_child(GTK_BIN(toolbox_toplevel));
 746
 747     GtkWidget *shown_toolbox = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbox), "shows"));
 748     if (!shown_toolbox) {
 749         return;
 750     }
 751     gtk_widget_show(toolbox);
 752
 753     // need to show the spacer, or the padding will be off
 754     GtkWidget *spacer = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbox), "top_spacer"));
 755     gtk_widget_show(spacer);
 756
 757     gtk_widget_show_all(shown_toolbox);
 758 }
 759
 760 void
 761 aux_toolbox_space(GtkWidget *tb, gint space)
 762 {
 763     gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, space);
 764 }
 765
 766 static GtkWidget *
 767 sp_empty_toolbox_new(SPDesktop *desktop)
 768 {
 769     GtkWidget *tbl = gtk_hbox_new(FALSE, 0);
 770     gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
 771     gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop);
 772
 773     gtk_widget_show_all(tbl);
 774     sp_set_font_size_smaller (tbl);
 775
 776     return tbl;
 777 }
 778
 779 // helper UI functions
 780
 781 GtkWidget *
 782 sp_tb_spinbutton(
 783     gchar *label, gchar const *tooltip,
 784     gchar const *path, gchar const *data, gdouble def,
 785     GtkWidget *us,
 786     GtkWidget *tbl,
 787     gboolean altx, gchar const *altx_mark,
 788     gdouble lower, gdouble upper, gdouble step, gdouble page,
 789     void (*callback)(GtkAdjustment *, GtkWidget *),
 790     gdouble climb = 0.1, guint digits = 3, double factor = 1.0)
 791 {
 792     GtkTooltips *tt = gtk_tooltips_new();
 793
 794     GtkWidget *hb = gtk_hbox_new(FALSE, 1);
 795
 796     GtkWidget *l = gtk_label_new(label);
 797     gtk_widget_show(l);
 798     gtk_misc_set_alignment(GTK_MISC(l), 1.0, 0.5);
 799     gtk_container_add(GTK_CONTAINER(hb), l);
 800
 801     GtkObject *a = gtk_adjustment_new(prefs_get_double_attribute(path, data, def) * factor,
 802                                       lower, upper, step, page, page);
 803     gtk_object_set_data(GTK_OBJECT(tbl), data, a);
 804     if (us)
 805         sp_unit_selector_add_adjustment(SP_UNIT_SELECTOR(us), GTK_ADJUSTMENT(a));
 806
 807     GtkWidget *sb = gtk_spin_button_new(GTK_ADJUSTMENT(a), climb, digits);
 808     gtk_tooltips_set_tip(tt, sb, tooltip, NULL);
 809     if (altx)
 810         gtk_object_set_data(GTK_OBJECT(sb), altx_mark, sb);
 811     gtk_widget_set_size_request(sb,
 812                                 (upper <= 1.0 || digits == 0)? AUX_SPINBUTTON_WIDTH_SMALL - 10: AUX_SPINBUTTON_WIDTH_SMALL,
 813                                 AUX_SPINBUTTON_HEIGHT);
 814     gtk_widget_show(sb);
 815     gtk_signal_connect(GTK_OBJECT(sb), "focus-in-event", GTK_SIGNAL_FUNC(spinbutton_focus_in), tbl);
 816     gtk_signal_connect(GTK_OBJECT(sb), "key-press-event", GTK_SIGNAL_FUNC(spinbutton_keypress), tbl);
 817     gtk_container_add(GTK_CONTAINER(hb), sb);
 818     gtk_signal_connect(GTK_OBJECT(a), "value_changed", GTK_SIGNAL_FUNC(callback), tbl);
 819
 820     return hb;
 821 }
 822
 823 static EgeAdjustmentAction * create_adjustment_action( gchar const *name,
 824                                                        gchar const *label, gchar const *tooltip,
 825                                                        gchar const *path, gchar const *data, gdouble def,
 826                                                        GtkWidget *focusTarget,
 827                                                        GtkWidget *us,
 828                                                        GtkWidget *dataKludge,
 829                                                        gboolean altx, gchar const *altx_mark,
 830                                                        gdouble lower, gdouble upper, gdouble step, gdouble page,
 831                                                        gchar const** descrLabels, gdouble const* descrValues, guint descrCount,
 832                                                        void (*callback)(GtkAdjustment *, GtkWidget *),
 833                                                        gdouble climb = 0.1, guint digits = 3, double factor = 1.0 )
 834 {
 835     GtkAdjustment* adj = GTK_ADJUSTMENT( gtk_adjustment_new( prefs_get_double_attribute(path, data, def) * factor,
 836                                                              lower, upper, step, page, page ) );
 837     if (us) {
 838         sp_unit_selector_add_adjustment( SP_UNIT_SELECTOR(us), adj );
 839     }
 840
 841     gtk_signal_connect( GTK_OBJECT(adj), "value-changed", GTK_SIGNAL_FUNC(callback), dataKludge );
 842
 843     EgeAdjustmentAction* act = ege_adjustment_action_new( adj, name, label, tooltip, 0, climb, digits );
 844
 845     if ( (descrCount > 0) && descrLabels && descrValues ) {
 846         ege_adjustment_action_set_descriptions( act, descrLabels, descrValues, descrCount );
 847     }
 848
 849     if ( focusTarget ) {
 850         ege_adjustment_action_set_focuswidget( act, focusTarget );
 851     }
 852
 853     if ( altx && altx_mark ) {
 854         g_object_set( G_OBJECT(act), "self-id", altx_mark, NULL );
 855     }
 856
 857     if ( dataKludge ) {
 858         gtk_object_set_data( GTK_OBJECT(dataKludge), data, adj );
 859     }
 860
 861     // Using a cast just to make sure we pass in the right kind of function pointer
 862     g_object_set( G_OBJECT(act), "tool-post", static_cast<EgeWidgetFixup>(sp_set_font_size_smaller), NULL );
 863
 864     return act;
 865 }
 866
 867
 868 #define MODE_LABEL_WIDTH 70
 869
 870 //########################
 871 //##       Star         ##
 872 //########################
 873
 874 static void sp_stb_magnitude_value_changed( GtkAdjustment *adj, GtkWidget *dataKludge )
 875 {
 876     SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(dataKludge), "desktop");
 877
 878     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
 879         // do not remember prefs if this call is initiated by an undo change, because undoing object
 880         // creation sets bogus values to its attributes before it is deleted
 881         prefs_set_int_attribute("tools.shapes.star", "magnitude", (gint)adj->value);
 882     }
 883
 884     // quit if run by the attr_changed listener
 885     if (g_object_get_data(G_OBJECT(dataKludge), "freeze")) {
 886         return;
 887     }
 888
 889     // in turn, prevent listener from responding
 890     g_object_set_data(G_OBJECT(dataKludge), "freeze", GINT_TO_POINTER(TRUE));
 891
 892     bool modmade = false;
 893
 894     Inkscape::Selection *selection = sp_desktop_selection(desktop);
 895     GSList const *items = selection->itemList();
 896     for (; items != NULL; items = items->next) {
 897         if (SP_IS_STAR((SPItem *) items->data)) {
 898             Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
 899             sp_repr_set_int(repr,"sodipodi:sides",(gint)adj->value);
 900             sp_repr_set_svg_double(repr, "sodipodi:arg2",
 901                                    (sp_repr_get_double_attribute(repr, "sodipodi:arg1", 0.5)
 902                                     + M_PI / (gint)adj->value));
 903             SP_OBJECT((SPItem *) items->data)->updateRepr(repr, SP_OBJECT_WRITE_EXT);
 904             modmade = true;
 905         }
 906     }
 907     if (modmade)  sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
 908                                    _("Star: Change number of corners"));
 909
 910     g_object_set_data(G_OBJECT(dataKludge), "freeze", GINT_TO_POINTER(FALSE));
 911 }
 912
 913 static void sp_stb_proportion_value_changed( GtkAdjustment *adj, GtkWidget *dataKludge )
 914 {
 915     SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(dataKludge), "desktop");
 916
 917     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
 918         prefs_set_double_attribute("tools.shapes.star", "proportion", adj->value);
 919     }
 920
 921     // quit if run by the attr_changed listener
 922     if (g_object_get_data(G_OBJECT(dataKludge), "freeze")) {
 923         return;
 924     }
 925
 926     // in turn, prevent listener from responding
 927     g_object_set_data(G_OBJECT(dataKludge), "freeze", GINT_TO_POINTER(TRUE));
 928
 929     bool modmade = false;
 930     Inkscape::Selection *selection = sp_desktop_selection(desktop);
 931     GSList const *items = selection->itemList();
 932     for (; items != NULL; items = items->next) {
 933         if (SP_IS_STAR((SPItem *) items->data)) {
 934             Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
 935
 936             gdouble r1 = sp_repr_get_double_attribute(repr, "sodipodi:r1", 1.0);
 937             gdouble r2 = sp_repr_get_double_attribute(repr, "sodipodi:r2", 1.0);
 938             if (r2 < r1) {
 939                 sp_repr_set_svg_double(repr, "sodipodi:r2", r1*adj->value);
 940             } else {
 941                 sp_repr_set_svg_double(repr, "sodipodi:r1", r2*adj->value);
 942             }
 943
 944             SP_OBJECT((SPItem *) items->data)->updateRepr(repr, SP_OBJECT_WRITE_EXT);
 945             modmade = true;
 946         }
 947     }
 948
 949     if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
 950                                    _("Star: Change spoke ratio"));
 951
 952     g_object_set_data(G_OBJECT(dataKludge), "freeze", GINT_TO_POINTER(FALSE));
 953 }
 954
 955 static void sp_stb_sides_flat_state_changed( GtkToggleAction *act, GtkObject *dataKludge )
 956 {
 957     SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(dataKludge), "desktop");
 958     bool flat = gtk_toggle_action_get_active(act);
 959
 960     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
 961         prefs_set_string_attribute( "tools.shapes.star", "isflatsided",
 962                                     flat ? "true" : "false" );
 963     }
 964
 965     // quit if run by the attr_changed listener
 966     if (g_object_get_data(G_OBJECT(dataKludge), "freeze")) {
 967         return;
 968     }
 969
 970     // in turn, prevent listener from responding
 971     g_object_set_data(G_OBJECT(dataKludge), "freeze", GINT_TO_POINTER(TRUE));
 972
 973     Inkscape::Selection *selection = sp_desktop_selection(desktop);
 974     GSList const *items = selection->itemList();
 975     GtkAction* prop_action = GTK_ACTION( g_object_get_data(G_OBJECT(dataKludge), "prop_action") );
 976     bool modmade = false;
 977
 978     if ( prop_action ) {
 979         gtk_action_set_sensitive( prop_action, !flat );
 980     }
 981
 982     for (; items != NULL; items = items->next) {
 983         if (SP_IS_STAR((SPItem *) items->data)) {
 984             Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
 985             repr->setAttribute("inkscape:flatsided", flat ? "true" : "false" );
 986             SP_OBJECT((SPItem *) items->data)->updateRepr(repr, SP_OBJECT_WRITE_EXT);
 987             modmade = true;
 988         }
 989     }
 990
 991     if (modmade) {
 992         sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
 993                          flat ? _("Make polygon") : _("Make star"));
 994     }
 995
 996     g_object_set_data(G_OBJECT(dataKludge), "freeze", GINT_TO_POINTER(FALSE));
 997 }
 998
 999 static void sp_stb_rounded_value_changed( GtkAdjustment *adj, GtkWidget *dataKludge )
1000 {
1001     SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(dataKludge), "desktop");
1002
1003     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
1004         prefs_set_double_attribute("tools.shapes.star", "rounded", (gdouble) adj->value);
1005     }
1006
1007     // quit if run by the attr_changed listener
1008     if (g_object_get_data(G_OBJECT(dataKludge), "freeze")) {
1009         return;
1010     }
1011
1012     // in turn, prevent listener from responding
1013     g_object_set_data(G_OBJECT(dataKludge), "freeze", GINT_TO_POINTER(TRUE));
1014
1015     bool modmade = false;
1016
1017     Inkscape::Selection *selection = sp_desktop_selection(desktop);
1018     GSList const *items = selection->itemList();
1019     for (; items != NULL; items = items->next) {
1020         if (SP_IS_STAR((SPItem *) items->data)) {
1021             Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
1022             sp_repr_set_svg_double(repr, "inkscape:rounded", (gdouble) adj->value);
1023             SP_OBJECT(items->data)->updateRepr(repr, SP_OBJECT_WRITE_EXT);
1024             modmade = true;
1025         }
1026     }
1027     if (modmade)  sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
1028                                    _("Star: Change rounding"));
1029
1030     g_object_set_data(G_OBJECT(dataKludge), "freeze", GINT_TO_POINTER(FALSE));
1031 }
1032
1033 static void sp_stb_randomized_value_changed( GtkAdjustment *adj, GtkWidget *dataKludge )
1034 {
1035     SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(dataKludge), "desktop");
1036
1037     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
1038         prefs_set_double_attribute("tools.shapes.star", "randomized", (gdouble) adj->value);
1039     }
1040
1041     // quit if run by the attr_changed listener
1042     if (g_object_get_data(G_OBJECT(dataKludge), "freeze")) {
1043         return;
1044     }
1045
1046     // in turn, prevent listener from responding
1047     g_object_set_data(G_OBJECT(dataKludge), "freeze", GINT_TO_POINTER(TRUE));
1048
1049     bool modmade = false;
1050
1051     Inkscape::Selection *selection = sp_desktop_selection(desktop);
1052     GSList const *items = selection->itemList();
1053     for (; items != NULL; items = items->next) {
1054         if (SP_IS_STAR((SPItem *) items->data)) {
1055             Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
1056             sp_repr_set_svg_double(repr, "inkscape:randomized", (gdouble) adj->value);
1057             SP_OBJECT(items->data)->updateRepr(repr, SP_OBJECT_WRITE_EXT);
1058             modmade = true;
1059         }
1060     }
1061     if (modmade)  sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
1062                                    _("Star: Change randomization"));
1063
1064     g_object_set_data(G_OBJECT(dataKludge), "freeze", GINT_TO_POINTER(FALSE));
1065 }
1066
1067
1068 static void star_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const *name,
1069                                        gchar const *old_value, gchar const *new_value,
1070                                        bool is_interactive, gpointer data)
1071 {
1072     GtkWidget *tbl = GTK_WIDGET(data);
1073
1074     // quit if run by the _changed callbacks
1075     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
1076         return;
1077     }
1078
1079     // in turn, prevent callbacks from responding
1080     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE));
1081
1082     GtkAdjustment *adj = 0;
1083
1084     if (!strcmp(name, "inkscape:randomized")) {
1085         adj = GTK_ADJUSTMENT( gtk_object_get_data(GTK_OBJECT(tbl), "randomized") );
1086         gtk_adjustment_set_value(adj, sp_repr_get_double_attribute(repr, "inkscape:randomized", 0.0));
1087     } else if (!strcmp(name, "inkscape:rounded")) {
1088         adj = GTK_ADJUSTMENT( gtk_object_get_data(GTK_OBJECT(tbl), "rounded") );
1089         gtk_adjustment_set_value(adj, sp_repr_get_double_attribute(repr, "inkscape:rounded", 0.0));
1090     } else if (!strcmp(name, "inkscape:flatsided")) {
1091         GtkToggleAction* flat_action = GTK_TOGGLE_ACTION( g_object_get_data( G_OBJECT(tbl), "flat_action" ) );
1092         GtkAction* prop_action = GTK_ACTION( g_object_get_data(G_OBJECT(tbl), "prop_action") );
1093         char const *flatsides = repr->attribute("inkscape:flatsided");
1094         if (flatsides && !strcmp(flatsides,"false" )) {
1095             gtk_toggle_action_set_active( flat_action, FALSE );
1096             gtk_action_set_sensitive( prop_action, TRUE );
1097         } else {
1098             gtk_toggle_action_set_active( flat_action, TRUE );
1099             gtk_action_set_sensitive( prop_action, FALSE );
1100         }
1101     } else if (!strcmp(name, "sodipodi:r1") || !strcmp(name, "sodipodi:r2")) {
1102         adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "proportion");
1103         gdouble r1 = sp_repr_get_double_attribute(repr, "sodipodi:r1", 1.0);
1104         gdouble r2 = sp_repr_get_double_attribute(repr, "sodipodi:r2", 1.0);
1105         if (r2 < r1) {
1106             gtk_adjustment_set_value(adj, r2/r1);
1107         } else {
1108             gtk_adjustment_set_value(adj, r1/r2);
1109         }
1110     } else if (!strcmp(name, "sodipodi:sides")) {
1111         adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "magnitude");
1112         gtk_adjustment_set_value(adj, sp_repr_get_int_attribute(repr, "sodipodi:sides", 0));
1113     }
1114
1115     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
1116 }
1117
1118
1119 static Inkscape::XML::NodeEventVector star_tb_repr_events =
1120 {
1121     NULL, /* child_added */
1122     NULL, /* child_removed */
1123     star_tb_event_attr_changed,
1124     NULL, /* content_changed */
1125     NULL  /* order_changed */
1126 };
1127
1128
1129 /**
1130  *  \param selection Should not be NULL.
1131  */
1132 static void
1133 sp_star_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *tbl)
1134 {
1135     int n_selected = 0;
1136     Inkscape::XML::Node *repr = NULL;
1137     Inkscape::XML::Node *oldrepr = NULL;
1138
1139     for (GSList const *items = selection->itemList();
1140          items != NULL;
1141          items = items->next)
1142     {
1143         if (SP_IS_STAR((SPItem *) items->data)) {
1144             n_selected++;
1145             repr = SP_OBJECT_REPR((SPItem *) items->data);
1146         }
1147     }
1148
1149     //GtkWidget *l = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(tbl), "mode_label"));
1150
1151     if (n_selected == 0) {
1152         //gtk_label_set_markup(GTK_LABEL(l), _("<b>New:</b>"));
1153     } else if (n_selected == 1) {
1154         //gtk_label_set_markup(GTK_LABEL(l), _("<b>Change:</b>"));
1155
1156         oldrepr = (Inkscape::XML::Node *) gtk_object_get_data(GTK_OBJECT(tbl), "repr");
1157         if (oldrepr) { // remove old listener
1158             sp_repr_remove_listener_by_data(oldrepr, tbl);
1159             Inkscape::GC::release(oldrepr);
1160             oldrepr = 0;
1161             g_object_set_data(G_OBJECT(tbl), "repr", NULL);
1162         }
1163
1164         if (repr) {
1165             g_object_set_data(G_OBJECT(tbl), "repr", repr);
1166             Inkscape::GC::anchor(repr);
1167             sp_repr_add_listener(repr, &star_tb_repr_events, tbl);
1168             sp_repr_synthesize_events(repr, &star_tb_repr_events, tbl);
1169         }
1170     } else {
1171         // FIXME: implement averaging of all parameters for multiple selected stars
1172         //gtk_label_set_markup(GTK_LABEL(l), _("<b>Average:</b>"));
1173         //gtk_label_set_markup(GTK_LABEL(l), _("<b>Change:</b>"));
1174     }
1175 }
1176
1177
1178 static void sp_stb_defaults( GtkWidget *widget, GtkWidget *dataKludge )
1179 {
1180     // FIXME: in this and all other _default functions, set some flag telling the value_changed
1181     // callbacks to lump all the changes for all selected objects in one undo step
1182
1183     GtkAdjustment *adj = 0;
1184
1185     // fixme: make settable in prefs!
1186     gint mag = 5;
1187     gdouble prop = 0.5;
1188     gboolean flat = FALSE;
1189     gdouble randomized = 0;
1190     gdouble rounded = 0;
1191
1192     GtkToggleAction* flat_action = GTK_TOGGLE_ACTION( g_object_get_data( G_OBJECT(dataKludge), "flat_action" ) );
1193     gtk_toggle_action_set_active( flat_action, flat );
1194
1195     GtkAction* sb2 = GTK_ACTION( g_object_get_data(G_OBJECT(dataKludge), "prop_action") );
1196     gtk_action_set_sensitive( sb2, !flat );
1197
1198     adj = GTK_ADJUSTMENT( gtk_object_get_data(GTK_OBJECT(dataKludge), "magnitude") );
1199     gtk_adjustment_set_value(adj, mag);
1200     gtk_adjustment_value_changed(adj);
1201
1202     adj = GTK_ADJUSTMENT( gtk_object_get_data(GTK_OBJECT(dataKludge), "proportion") );
1203     gtk_adjustment_set_value(adj, prop);
1204     gtk_adjustment_value_changed(adj);
1205
1206     adj = GTK_ADJUSTMENT( gtk_object_get_data(GTK_OBJECT(dataKludge), "rounded") );
1207     gtk_adjustment_set_value(adj, rounded);
1208     gtk_adjustment_value_changed(adj);
1209
1210     adj = GTK_ADJUSTMENT( gtk_object_get_data(GTK_OBJECT(dataKludge), "randomized") );
1211     gtk_adjustment_set_value(adj, randomized);
1212     gtk_adjustment_value_changed(adj);
1213 }
1214
1215
1216 void
1217 sp_toolbox_add_label(GtkWidget *tbl, gchar const *title, bool wide)
1218 {
1219     GtkWidget *boxl = gtk_hbox_new(FALSE, 0);
1220     if (wide) gtk_widget_set_size_request(boxl, MODE_LABEL_WIDTH, -1);
1221     GtkWidget *l = gtk_label_new(NULL);
1222     gtk_label_set_markup(GTK_LABEL(l), title);
1223     gtk_box_pack_end(GTK_BOX(boxl), l, FALSE, FALSE, 0);
1224     gtk_box_pack_start(GTK_BOX(tbl), boxl, FALSE, FALSE, 0);
1225     gtk_object_set_data(GTK_OBJECT(tbl), "mode_label", l);
1226 }
1227
1228
1229 static GtkWidget *
1230 sp_star_toolbox_new(SPDesktop *desktop)
1231 {
1232     GtkWidget *toolBar = 0;
1233     GtkWidget* holder = gtk_table_new( 1, 2, FALSE );
1234
1235     gchar const * descr =
1236         "<ui>"
1237         "  <toolbar name='StarToolbar'>"
1238         "    <separator />"
1239         "    <toolitem action='FlatAction' />"
1240         "    <toolitem action='FlatAction2' />"
1241         "    <separator />"
1242         "    <toolitem action='MagnitudeAction' />"
1243         "    <toolitem action='SpokeAction' />"
1244         "    <toolitem action='RoundednessAction' />"
1245         "    <toolitem action='RandomizationAction' />"
1246         "    <separator />"
1247         "    <toolitem action='ResetAction' />"
1248         "  </toolbar>"
1249         "</ui>";
1250     GtkUIManager* mgr = gtk_ui_manager_new();
1251     GError* errVal = 0;
1252     GtkActionGroup* mainActions = gtk_action_group_new("main");
1253 //     sp_toolbox_add_label(tbl, _("<b>New:</b>"));
1254
1255     {
1256         gtk_object_set_data(GTK_OBJECT(holder), "dtw", desktop->canvas);
1257         gtk_object_set_data(GTK_OBJECT(holder), "desktop", desktop);
1258
1259         //EgeAdjustmentAction* calligraphy_angle = 0;
1260         EgeAdjustmentAction* eact = 0;
1261         gchar const *flatsidedstr = prefs_get_string_attribute( "tools.shapes.star", "isflatsided" );
1262         bool isFlatSided = flatsidedstr ? (strcmp(flatsidedstr, "false") != 0) : true;
1263
1264         /* Flatsided checkbox */
1265         {
1266             InkRadioAction* act = ink_radio_action_new( "FlatAction",
1267                                                         _("Polygon"),
1268                                                         _("Regular polygon (with one handle) instead of a star"),
1269                                                         "star_flat",
1270                                                         Inkscape::ICON_SIZE_SMALL_TOOLBAR );
1271             gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
1272
1273             InkRadioAction* act2 = ink_radio_action_new( "FlatAction2",
1274                                                          _("Star"),
1275                                                          _("Star instead of a regular polygon (with one handle)"),
1276                                                          "star_angled",
1277                                                          Inkscape::ICON_SIZE_SMALL_TOOLBAR );
1278             gtk_action_group_add_action( mainActions, GTK_ACTION( act2 ) );
1279
1280             // Connect to be in the same radio button group.
1281             gtk_radio_action_set_group( GTK_RADIO_ACTION(act), 0 );
1282             GSList* radioGroup = gtk_radio_action_get_group( GTK_RADIO_ACTION(act) );
1283             gtk_radio_action_set_group( GTK_RADIO_ACTION(act2), radioGroup );
1284
1285             gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), isFlatSided );
1286             gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act2), !isFlatSided );
1287
1288             g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_stb_sides_flat_state_changed), holder);
1289             gtk_object_set_data( GTK_OBJECT(holder), "flat_action", act );
1290         }
1291
1292         /* Magnitude */
1293         //gchar const* labels[] = {_("tri (default)"), _("quad"), _("pent")};
1294         //gdouble values[] = {3, 4, 5};
1295         eact = create_adjustment_action( "MagnitudeAction",
1296                                          _("Corners:"), _("Number of corners of a polygon or star"),
1297                                          "tools.shapes.star", "magnitude", 3,
1298                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
1299                                          3, 1024, 1, 5,
1300                                          0, 0, 0, // labels, values, G_N_ELEMENTS(labels),
1301                                          sp_stb_magnitude_value_changed,
1302                                          1.0, 0 );
1303         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
1304         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
1305
1306         /* Spoke ratio */
1307         //gchar const* labels2[] = {_("(left edge up)"), _("(horizontal)"), _("(default)"), _("(right edge up)")};
1308         //gdouble values2[] = {-90, 0, 30, 90};
1309         eact = create_adjustment_action( "SpokeAction",
1310                                          _("Spoke ratio:"),
1311                                          // TRANSLATORS: Tip radius of a star is the distance from the center to the farthest handle.
1312                                          // Base radius is the same for the closest handle.
1313                                          _("Base radius to tip radius ratio"),
1314                                          "tools.shapes.star", "proportion", 0.5,
1315                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
1316                                          0.01, 1.0, 0.01, 0.1,
1317                                          0, 0, 0, // labels2, values2, G_N_ELEMENTS(labels2),
1318                                          sp_stb_proportion_value_changed );
1319         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
1320         g_object_set_data(G_OBJECT(holder), "prop_action", eact);
1321
1322         if ( !isFlatSided ) {
1323             gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
1324         } else {
1325             gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
1326         }
1327
1328         /* Roundedness */
1329         //gchar const* labels3[] = {_("(left edge up)"), _("(horizontal)"), _("(default)"), _("(right edge up)")};
1330         //gdouble values3[] = {-90, 0, 30, 90};
1331         eact = create_adjustment_action( "RoundednessAction",
1332                                          _("Rounded:"), _("How much rounded are the corners (0 for sharp)"),
1333                                          "tools.shapes.star", "rounded", 0.0,
1334                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
1335                                          -100.0, 100.0, 0.01, 0.1,
1336                                          0, 0, 0, // labels3, values3, G_N_ELEMENTS(labels3),
1337                                          sp_stb_rounded_value_changed );
1338         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
1339         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
1340
1341         /* Randomization */
1342         //gchar const* labels4[] = {_("(left edge up)"), _("(horizontal)"), _("(default)"), _("(right edge up)")};
1343         //gdouble values4[] = {-90, 0, 30, 90};
1344         eact = create_adjustment_action( "RandomizationAction",
1345                                          _("Randomized:"), _("Scatter randomly the corners and angles"),
1346                                          "tools.shapes.star", "randomized", 0.0,
1347                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
1348                                          -10.0, 10.0, 0.001, 0.01,
1349                                          0, 0, 0, // labels4, values4, G_N_ELEMENTS(labels4),
1350                                          sp_stb_randomized_value_changed, 0.1, 3 );
1351         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
1352         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
1353     }
1354
1355     {
1356         /* Reset */
1357         {
1358             GtkAction* act = gtk_action_new( "ResetAction",
1359                                              _("Defaults"),
1360                                              _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
1361                                              GTK_STOCK_CLEAR );
1362             g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(sp_stb_defaults), holder );
1363             gtk_action_group_add_action( mainActions, act );
1364             gtk_action_set_sensitive( act, TRUE );
1365         }
1366     }
1367
1368     gtk_ui_manager_insert_action_group( mgr, mainActions, 0 );
1369     gtk_ui_manager_add_ui_from_string( mgr, descr, -1, &errVal );
1370
1371     toolBar = gtk_ui_manager_get_widget( mgr, "/ui/StarToolbar" );
1372     gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS );
1373     gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), GTK_ICON_SIZE_SMALL_TOOLBAR );
1374
1375
1376     gtk_table_attach( GTK_TABLE(holder), toolBar, 0, 1, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0 );
1377
1378     Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL, _("Style of new stars"));
1379     swatch->setDesktop( desktop );
1380     swatch->setClickVerb( SP_VERB_CONTEXT_STAR_PREFS );
1381     swatch->setWatchedTool( "tools.shapes.star", true );
1382     GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj());
1383     gtk_table_attach( GTK_TABLE(holder), swatch_, 1, 2, 0, 1, (GtkAttachOptions)(GTK_SHRINK | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), AUX_BETWEEN_BUTTON_GROUPS, 0 );
1384
1385     gtk_widget_show_all(holder);
1386     //sp_set_font_size_smaller (tbl);
1387
1388     sigc::connection *connection = new sigc::connection(
1389         sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_star_toolbox_selection_changed), (GtkObject *)holder))
1390         );
1391     g_signal_connect(G_OBJECT(holder), "destroy", G_CALLBACK(delete_connection), connection);
1392
1393     return holder;
1394 }
1395
1396
1397 //########################
1398 //##       Rect         ##
1399 //########################
1400
1401 static void
1402 sp_rtb_sensitivize (GtkWidget *tbl)
1403 {
1404     GtkAdjustment *adj1 = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(tbl), "rx"));
1405     GtkAdjustment *adj2 = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(tbl), "ry"));
1406     GtkWidget *not_rounded = (GtkWidget*) g_object_get_data(G_OBJECT(tbl), "not_rounded");
1407
1408     if (adj1->value == 0 && adj2->value == 0 && gtk_object_get_data(GTK_OBJECT(tbl), "single")) { // only for a single selected rect (for now)
1409         gtk_widget_set_sensitive(GTK_WIDGET(not_rounded), FALSE);
1410     } else {
1411         gtk_widget_set_sensitive(GTK_WIDGET(not_rounded), TRUE);
1412     }
1413 }
1414
1415
1416 static void
1417 sp_rtb_value_changed(GtkAdjustment *adj, GtkWidget *tbl, gchar const *value_name,
1418                           void (*setter)(SPRect *, gdouble))
1419 {
1420     SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop");
1421
1422     GtkWidget *us = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(tbl), "units");
1423     SPUnit const *unit = sp_unit_selector_get_unit(SP_UNIT_SELECTOR(us));
1424
1425     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
1426         prefs_set_double_attribute("tools.shapes.rect", value_name, sp_units_get_pixels(adj->value, *unit));
1427     }
1428
1429     // quit if run by the attr_changed listener
1430     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
1431         return;
1432     }
1433
1434     // in turn, prevent listener from responding
1435     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE));
1436
1437     bool modmade = false;
1438     Inkscape::Selection *selection = sp_desktop_selection(desktop);
1439     for (GSList const *items = selection->itemList(); items != NULL; items = items->next) {
1440         if (SP_IS_RECT(items->data)) {
1441             if (adj->value != 0) {
1442                 setter(SP_RECT(items->data), sp_units_get_pixels(adj->value, *unit));
1443             } else {
1444                 SP_OBJECT_REPR(items->data)->setAttribute(value_name, NULL);
1445             }
1446             modmade = true;
1447         }
1448     }
1449
1450     sp_rtb_sensitivize (tbl);
1451
1452     if (modmade) {
1453         sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_RECT,
1454                                    _("Change rectangle"));
1455     }
1456
1457     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
1458
1459     // defocus spinbuttons by moving focus to the canvas, unless "stay" is on
1460     spinbutton_defocus(GTK_OBJECT(tbl));
1461 }
1462
1463 static void
1464 sp_rtb_rx_value_changed(GtkAdjustment *adj, GtkWidget *tbl)
1465 {
1466     sp_rtb_value_changed(adj, tbl, "rx", sp_rect_set_visible_rx);
1467 }
1468
1469 static void
1470 sp_rtb_ry_value_changed(GtkAdjustment *adj, GtkWidget *tbl)
1471 {
1472     sp_rtb_value_changed(adj, tbl, "ry", sp_rect_set_visible_ry);
1473 }
1474
1475 static void
1476 sp_rtb_width_value_changed(GtkAdjustment *adj, GtkWidget *tbl)
1477 {
1478     sp_rtb_value_changed(adj, tbl, "width", sp_rect_set_visible_width);
1479 }
1480
1481 static void
1482 sp_rtb_height_value_changed(GtkAdjustment *adj, GtkWidget *tbl)
1483 {
1484     sp_rtb_value_changed(adj, tbl, "height", sp_rect_set_visible_height);
1485 }
1486
1487
1488
1489 static void
1490 sp_rtb_defaults( GtkWidget *widget, GtkObject *obj)
1491 {
1492     GtkWidget *tbl = GTK_WIDGET(obj);
1493
1494     GtkAdjustment *adj;
1495
1496     adj = (GtkAdjustment*)gtk_object_get_data(obj, "rx");
1497     gtk_adjustment_set_value(adj, 0.0);
1498     // this is necessary if the previous value was 0, but we still need to run the callback to change all selected objects
1499     gtk_adjustment_value_changed(adj);
1500
1501     adj = (GtkAdjustment*)gtk_object_get_data(obj, "ry");
1502     gtk_adjustment_set_value(adj, 0.0);
1503     gtk_adjustment_value_changed(adj);
1504
1505     sp_rtb_sensitivize (tbl);
1506
1507     spinbutton_defocus(GTK_OBJECT(tbl));
1508 }
1509
1510 static void rect_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const *name,
1511                                        gchar const *old_value, gchar const *new_value,
1512                                        bool is_interactive, gpointer data)
1513 {
1514     GtkWidget *tbl = GTK_WIDGET(data);
1515
1516     // quit if run by the _changed callbacks
1517     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
1518         return;
1519     }
1520
1521     // in turn, prevent callbacks from responding
1522     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE));
1523
1524     GtkWidget *us = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(tbl), "units");
1525     SPUnit const *unit = sp_unit_selector_get_unit(SP_UNIT_SELECTOR(us));
1526
1527     SPItem *item = SP_ITEM(g_object_get_data(G_OBJECT(tbl), "item"));
1528     if (SP_IS_RECT(item)) {
1529         {
1530             GtkAdjustment *adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "rx");
1531             gdouble rx = sp_rect_get_visible_rx(SP_RECT(item));
1532             gtk_adjustment_set_value(adj, sp_pixels_get_units(rx, *unit));
1533         }
1534
1535         {
1536             GtkAdjustment *adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "ry");
1537             gdouble ry = sp_rect_get_visible_ry(SP_RECT(item));
1538             gtk_adjustment_set_value(adj, sp_pixels_get_units(ry, *unit));
1539         }
1540
1541         {
1542             GtkAdjustment *adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "width");
1543             gdouble width = sp_rect_get_visible_width (SP_RECT(item));
1544             gtk_adjustment_set_value(adj, sp_pixels_get_units(width, *unit));
1545         }
1546
1547         {
1548             GtkAdjustment *adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "height");
1549             gdouble height = sp_rect_get_visible_height (SP_RECT(item));
1550             gtk_adjustment_set_value(adj, sp_pixels_get_units(height, *unit));
1551         }
1552     }
1553
1554     sp_rtb_sensitivize (tbl);
1555
1556     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
1557 }
1558
1559
1560 static Inkscape::XML::NodeEventVector rect_tb_repr_events = {
1561     NULL, /* child_added */
1562     NULL, /* child_removed */
1563     rect_tb_event_attr_changed,
1564     NULL, /* content_changed */
1565     NULL  /* order_changed */
1566 };
1567
1568 /**
1569  *  \param selection should not be NULL.
1570  */
1571 static void
1572 sp_rect_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *tbl)
1573 {
1574     int n_selected = 0;
1575     Inkscape::XML::Node *repr = NULL;
1576     SPItem *item = NULL;
1577     Inkscape::XML::Node *oldrepr = NULL;
1578
1579     for (GSList const *items = selection->itemList();
1580          items != NULL;
1581          items = items->next) {
1582         if (SP_IS_RECT((SPItem *) items->data)) {
1583             n_selected++;
1584             item = (SPItem *) items->data;
1585             repr = SP_OBJECT_REPR(item);
1586         }
1587     }
1588
1589     GtkWidget *l = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(tbl), "mode_label"));
1590
1591     g_object_set_data(G_OBJECT(tbl), "single", GINT_TO_POINTER(FALSE));
1592
1593     if (n_selected == 0) {
1594         gtk_label_set_markup(GTK_LABEL(l), _("<b>New:</b>"));
1595
1596         GtkWidget *w = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(tbl), "width_sb");
1597         gtk_widget_set_sensitive(w, FALSE);
1598         GtkWidget *h = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(tbl), "height_sb");
1599         gtk_widget_set_sensitive(h, FALSE);
1600
1601     } else if (n_selected == 1) {
1602         gtk_label_set_markup(GTK_LABEL(l), _("<b>Change:</b>"));
1603         g_object_set_data(G_OBJECT(tbl), "single", GINT_TO_POINTER(TRUE));
1604
1605         GtkWidget *w = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(tbl), "width_sb");
1606         gtk_widget_set_sensitive(w, TRUE);
1607         GtkWidget *h = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(tbl), "height_sb");
1608         gtk_widget_set_sensitive(h, TRUE);
1609
1610         oldrepr = (Inkscape::XML::Node *) gtk_object_get_data(GTK_OBJECT(tbl), "repr");
1611         if (oldrepr) { // remove old listener
1612             sp_repr_remove_listener_by_data(oldrepr, tbl);
1613             Inkscape::GC::release(oldrepr);
1614             oldrepr = 0;
1615             g_object_set_data(G_OBJECT(tbl), "repr", NULL);
1616         }
1617         if (repr) {
1618             g_object_set_data(G_OBJECT(tbl), "repr", repr);
1619             g_object_set_data(G_OBJECT(tbl), "item", item);
1620             Inkscape::GC::anchor(repr);
1621             sp_repr_add_listener(repr, &rect_tb_repr_events, tbl);
1622             sp_repr_synthesize_events(repr, &rect_tb_repr_events, tbl);
1623         }
1624     } else {
1625         // FIXME: implement averaging of all parameters for multiple selected
1626         //gtk_label_set_markup(GTK_LABEL(l), _("<b>Average:</b>"));
1627         gtk_label_set_markup(GTK_LABEL(l), _("<b>Change:</b>"));
1628         sp_rtb_sensitivize (GTK_WIDGET(tbl));
1629     }
1630 }
1631
1632
1633 static GtkWidget *
1634 sp_rect_toolbox_new(SPDesktop *desktop)
1635 {
1636     GtkWidget *tbl = gtk_hbox_new(FALSE, 0);
1637
1638     gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
1639     gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop);
1640
1641     GtkTooltips *tt = gtk_tooltips_new();
1642
1643     sp_toolbox_add_label(tbl, _("<b>New:</b>"));
1644
1645     // rx/ry units menu: create
1646     GtkWidget *us = sp_unit_selector_new(SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE);
1647     sp_unit_selector_setsize(us, AUX_OPTION_MENU_WIDTH, AUX_OPTION_MENU_HEIGHT);
1648     sp_unit_selector_set_unit(SP_UNIT_SELECTOR(us), desktop->namedview->doc_units);
1649     // fixme: add % meaning per cent of the width/height
1650
1651     /* W */
1652     {
1653         GtkWidget *hb = sp_tb_spinbutton(_("W:"), _("Width of rectangle"),
1654                                          "tools.shapes.rect", "width", 0,
1655                                          us, tbl, TRUE, "altx-rect",
1656                                          0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
1657                                          sp_rtb_width_value_changed);
1658         gtk_object_set_data(GTK_OBJECT(tbl), "width_sb", hb);
1659         gtk_widget_set_sensitive(hb, FALSE);
1660         gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
1661     }
1662
1663     /* H */
1664     {
1665         GtkWidget *hb = sp_tb_spinbutton(_("H:"), _("Height of rectangle"),
1666                                          "tools.shapes.rect", "height", 0,
1667                                          us, tbl, FALSE, NULL,
1668                                          0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
1669                                          sp_rtb_height_value_changed);
1670         gtk_object_set_data(GTK_OBJECT(tbl), "height_sb", hb);
1671         gtk_widget_set_sensitive(hb, FALSE);
1672         gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
1673     }
1674
1675     /* rx */
1676     {
1677         GtkWidget *hb = sp_tb_spinbutton(_("Rx:"), _("Horizontal radius of rounded corners"),
1678                                          "tools.shapes.rect", "rx", 0,
1679                                          us, tbl, FALSE, NULL,
1680                                          0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
1681                                          sp_rtb_rx_value_changed);
1682         gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
1683     }
1684
1685     /* ry */
1686     {
1687         GtkWidget *hb = sp_tb_spinbutton(_("Ry:"), _("Vertical radius of rounded corners"),
1688                                          "tools.shapes.rect", "ry", 0,
1689                                          us, tbl, FALSE, NULL,
1690                                          0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
1691                                          sp_rtb_ry_value_changed);
1692         gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
1693     }
1694
1695     // add the units menu
1696     gtk_widget_show(us);
1697     gtk_box_pack_start(GTK_BOX(tbl), us, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
1698     gtk_object_set_data(GTK_OBJECT(tbl), "units", us);
1699
1700     /* Reset */
1701     {
1702         GtkWidget *hb = gtk_hbox_new(FALSE, 1);
1703         GtkWidget *b = gtk_button_new_with_label(_("Not rounded"));
1704         gtk_object_set_data(GTK_OBJECT(tbl), "not_rounded", b);
1705         gtk_tooltips_set_tip(tt, b, _("Make corners sharp"), NULL);
1706         gtk_widget_show(b);
1707         gtk_container_add(GTK_CONTAINER(hb), b);
1708         gtk_signal_connect(GTK_OBJECT(b), "clicked", GTK_SIGNAL_FUNC(sp_rtb_defaults), tbl);
1709         gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
1710     }
1711
1712     Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL, _("Style of new rectangles"));
1713     swatch->setDesktop (desktop);
1714     swatch->setClickVerb (SP_VERB_CONTEXT_RECT_PREFS);
1715     swatch->setWatchedTool ("tools.shapes.rect", true);
1716     GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj());
1717     gtk_box_pack_end(GTK_BOX(tbl), swatch_, FALSE, FALSE, 0);
1718
1719     g_object_set_data(G_OBJECT(tbl), "single", GINT_TO_POINTER(TRUE));
1720     sp_rtb_sensitivize (tbl);
1721
1722     gtk_widget_show_all(tbl);
1723     sp_set_font_size_smaller (tbl);
1724
1725     sigc::connection *connection = new sigc::connection(
1726         sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_rect_toolbox_selection_changed), (GtkObject *)tbl))
1727         );
1728     g_signal_connect(G_OBJECT(tbl), "destroy", G_CALLBACK(delete_connection), connection);
1729
1730     return tbl;
1731 }
1732
1733 //########################
1734 //##       Spiral       ##
1735 //########################
1736
1737 static void
1738 sp_spl_tb_value_changed(GtkAdjustment *adj, GtkWidget *tbl, gchar const *value_name)
1739 {
1740     SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop");
1741
1742     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
1743         prefs_set_double_attribute("tools.shapes.spiral", value_name, adj->value);
1744     }
1745
1746     // quit if run by the attr_changed listener
1747     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
1748         return;
1749     }
1750
1751     // in turn, prevent listener from responding
1752     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE));
1753
1754     gchar* namespaced_name = g_strconcat("sodipodi:", value_name, NULL);
1755
1756     bool modmade = false;
1757     for (GSList const *items = sp_desktop_selection(desktop)->itemList();
1758          items != NULL;
1759          items = items->next)
1760     {
1761         if (SP_IS_SPIRAL((SPItem *) items->data)) {
1762             Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
1763             sp_repr_set_svg_double( repr, namespaced_name, adj->value );
1764             SP_OBJECT((SPItem *) items->data)->updateRepr(repr, SP_OBJECT_WRITE_EXT);
1765             modmade = true;
1766         }
1767     }
1768
1769     g_free(namespaced_name);
1770
1771     if (modmade) {
1772         sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_SPIRAL,
1773                                    _("Change spiral"));
1774     }
1775
1776     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
1777
1778     spinbutton_defocus(GTK_OBJECT(tbl));
1779 }
1780
1781 static void
1782 sp_spl_tb_revolution_value_changed(GtkAdjustment *adj, GtkWidget *tbl)
1783 {
1784     sp_spl_tb_value_changed(adj, tbl, "revolution");
1785 }
1786
1787 static void
1788 sp_spl_tb_expansion_value_changed(GtkAdjustment *adj, GtkWidget *tbl)
1789 {
1790     sp_spl_tb_value_changed(adj, tbl, "expansion");
1791 }
1792
1793 static void
1794 sp_spl_tb_t0_value_changed(GtkAdjustment *adj, GtkWidget *tbl)
1795 {
1796     sp_spl_tb_value_changed(adj, tbl, "t0");
1797 }
1798
1799 static void
1800 sp_spl_tb_defaults(GtkWidget *widget, GtkObject *obj)
1801 {
1802     GtkWidget *tbl = GTK_WIDGET(obj);
1803
1804     GtkAdjustment *adj;
1805
1806     // fixme: make settable
1807     gdouble rev = 5;
1808     gdouble exp = 1.0;
1809     gdouble t0 = 0.0;
1810
1811     adj = (GtkAdjustment*)gtk_object_get_data(obj, "revolution");
1812     gtk_adjustment_set_value(adj, rev);
1813     gtk_adjustment_value_changed(adj);
1814
1815     adj = (GtkAdjustment*)gtk_object_get_data(obj, "expansion");
1816     gtk_adjustment_set_value(adj, exp);
1817     gtk_adjustment_value_changed(adj);
1818
1819     adj = (GtkAdjustment*)gtk_object_get_data(obj, "t0");
1820     gtk_adjustment_set_value(adj, t0);
1821     gtk_adjustment_value_changed(adj);
1822
1823     spinbutton_defocus(GTK_OBJECT(tbl));
1824 }
1825
1826
1827 static void spiral_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const *name,
1828                                          gchar const *old_value, gchar const *new_value,
1829                                          bool is_interactive, gpointer data)
1830 {
1831     GtkWidget *tbl = GTK_WIDGET(data);
1832
1833     // quit if run by the _changed callbacks
1834     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
1835         return;
1836     }
1837
1838     // in turn, prevent callbacks from responding
1839     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE));
1840
1841     GtkAdjustment *adj;
1842     adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "revolution");
1843     gtk_adjustment_set_value(adj, (sp_repr_get_double_attribute(repr, "sodipodi:revolution", 3.0)));
1844
1845     adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "expansion");
1846     gtk_adjustment_set_value(adj, (sp_repr_get_double_attribute(repr, "sodipodi:expansion", 1.0)));
1847
1848     adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "t0");
1849     gtk_adjustment_set_value(adj, (sp_repr_get_double_attribute(repr, "sodipodi:t0", 0.0)));
1850
1851     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
1852 }
1853
1854
1855 static Inkscape::XML::NodeEventVector spiral_tb_repr_events = {
1856     NULL, /* child_added */
1857     NULL, /* child_removed */
1858     spiral_tb_event_attr_changed,
1859     NULL, /* content_changed */
1860     NULL  /* order_changed */
1861 };
1862
1863 static void
1864 sp_spiral_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *tbl)
1865 {
1866     int n_selected = 0;
1867     Inkscape::XML::Node *repr = NULL;
1868     Inkscape::XML::Node *oldrepr = NULL;
1869
1870     for (GSList const *items = selection->itemList();
1871          items != NULL;
1872          items = items->next)
1873     {
1874         if (SP_IS_SPIRAL((SPItem *) items->data)) {
1875             n_selected++;
1876             repr = SP_OBJECT_REPR((SPItem *) items->data);
1877         }
1878     }
1879
1880     GtkWidget *l = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(tbl), "mode_label"));
1881
1882     if (n_selected == 0) {
1883         gtk_label_set_markup(GTK_LABEL(l), _("<b>New:</b>"));
1884     } else if (n_selected == 1) {
1885         gtk_label_set_markup(GTK_LABEL(l), _("<b>Change:</b>"));
1886
1887         oldrepr = (Inkscape::XML::Node *) gtk_object_get_data(GTK_OBJECT(tbl), "repr");
1888         if (oldrepr) { // remove old listener
1889             sp_repr_remove_listener_by_data(oldrepr, tbl);
1890             Inkscape::GC::release(oldrepr);
1891             oldrepr = 0;
1892             g_object_set_data(G_OBJECT(tbl), "repr", NULL);
1893         }
1894
1895         if (repr) {
1896             g_object_set_data(G_OBJECT(tbl), "repr", repr);
1897             Inkscape::GC::anchor(repr);
1898             sp_repr_add_listener(repr, &spiral_tb_repr_events, tbl);
1899             sp_repr_synthesize_events(repr, &spiral_tb_repr_events, tbl);
1900         }
1901     } else {
1902         // FIXME: implement averaging of all parameters for multiple selected
1903         //gtk_label_set_markup(GTK_LABEL(l), _("<b>Average:</b>"));
1904         gtk_label_set_markup(GTK_LABEL(l), _("<b>Change:</b>"));
1905     }
1906 }
1907
1908
1909 static GtkWidget *
1910 sp_spiral_toolbox_new(SPDesktop *desktop)
1911 {
1912     GtkWidget *tbl = gtk_hbox_new(FALSE, 0);
1913     gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
1914     gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop);
1915
1916     GtkTooltips *tt = gtk_tooltips_new();
1917
1918     sp_toolbox_add_label(tbl, _("<b>New:</b>"));
1919
1920     /* Revolution */
1921     {
1922         GtkWidget *hb = sp_tb_spinbutton(_("Turns:"), _("Number of revolutions"),
1923                                          "tools.shapes.spiral", "revolution", 3.0,
1924                                          NULL, tbl, TRUE, "altx-spiral",
1925                                          0.01, 1024.0, 0.1, 1.0,
1926                                          sp_spl_tb_revolution_value_changed, 1, 2);
1927         gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING);
1928     }
1929
1930     /* Expansion */
1931     {
1932         GtkWidget *hb = sp_tb_spinbutton(_("Divergence:"), _("How much denser/sparser are outer revolutions; 1 = uniform"),
1933                                          "tools.shapes.spiral", "expansion", 1.0,
1934                                          NULL, tbl, FALSE, NULL,
1935                                          0.0, 1000.0, 0.01, 1.0,
1936                                          sp_spl_tb_expansion_value_changed);
1937         gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING);
1938     }
1939
1940     /* T0 */
1941     {
1942         GtkWidget *hb = sp_tb_spinbutton(_("Inner radius:"), _("Radius of the innermost revolution (relative to the spiral size)"),
1943                                          "tools.shapes.spiral", "t0", 0.0,
1944                                          NULL, tbl, FALSE, NULL,
1945                                          0.0, 0.999, 0.01, 1.0,
1946                                          sp_spl_tb_t0_value_changed);
1947         gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING);
1948     }
1949
1950     aux_toolbox_space(tbl, AUX_SPACING);
1951
1952     /* Reset */
1953     {
1954         GtkWidget *hb = gtk_hbox_new(FALSE, 1);
1955         GtkWidget *b = gtk_button_new_with_label(_("Defaults"));
1956         gtk_tooltips_set_tip(tt, b, _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"), NULL);
1957         gtk_widget_show(b);
1958         gtk_container_add(GTK_CONTAINER(hb), b);
1959         gtk_signal_connect(GTK_OBJECT(b), "clicked", GTK_SIGNAL_FUNC(sp_spl_tb_defaults), tbl);
1960         gtk_box_pack_start(GTK_BOX(tbl),hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
1961     }
1962
1963     Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL, _("Style of new spirals"));
1964     swatch->setDesktop (desktop);
1965     swatch->setClickVerb (SP_VERB_CONTEXT_SPIRAL_PREFS);
1966     swatch->setWatchedTool ("tools.shapes.spiral", true);
1967     GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj());
1968     gtk_box_pack_end(GTK_BOX(tbl), swatch_, FALSE, FALSE, 0);
1969
1970     gtk_widget_show_all(tbl);
1971     sp_set_font_size_smaller (tbl);
1972
1973     sigc::connection *connection = new sigc::connection(
1974         sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_spiral_toolbox_selection_changed), (GtkObject *)tbl))
1975         );
1976     g_signal_connect(G_OBJECT(tbl), "destroy", G_CALLBACK(delete_connection), connection);
1977
1978     return tbl;
1979 }
1980
1981 //########################
1982 //##     Pen/Pencil    ##
1983 //########################
1984
1985
1986 static GtkWidget *
1987 sp_pen_toolbox_new(SPDesktop *desktop)
1988 {
1989     GtkWidget *tbl = gtk_hbox_new(FALSE, 0);
1990     gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
1991     gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop);
1992
1993     Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL, _("Style of new paths created by Pen"));
1994     swatch->setDesktop (desktop);
1995     swatch->setClickVerb (SP_VERB_CONTEXT_PEN_PREFS);
1996     swatch->setWatchedTool ("tools.freehand.pen", true);
1997     GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj());
1998     gtk_box_pack_end(GTK_BOX(tbl), swatch_, FALSE, FALSE, 0);
1999
2000     gtk_widget_show_all(tbl);
2001     sp_set_font_size_smaller (tbl);
2002
2003     return tbl;
2004 }
2005
2006 static GtkWidget *
2007 sp_pencil_toolbox_new(SPDesktop *desktop)
2008 {
2009     GtkWidget *tbl = gtk_hbox_new(FALSE, 0);
2010     gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
2011     gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop);
2012
2013     Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL, _("Style of new paths created by Pencil"));
2014     swatch->setDesktop (desktop);
2015     swatch->setClickVerb (SP_VERB_CONTEXT_PENCIL_PREFS);
2016     swatch->setWatchedTool ("tools.freehand.pencil", true);
2017     GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj());
2018     gtk_box_pack_end(GTK_BOX(tbl), swatch_, FALSE, FALSE, 0);
2019
2020     gtk_widget_show_all(tbl);
2021     sp_set_font_size_smaller (tbl);
2022
2023     return tbl;
2024 }
2025
2026
2027 //########################
2028 //##     Calligraphy    ##
2029 //########################
2030
2031 static void sp_ddc_mass_value_changed( GtkAdjustment *adj, GtkWidget *tbl )
2032 {
2033     prefs_set_double_attribute( "tools.calligraphic", "mass", adj->value );
2034 }
2035
2036 static void sp_ddc_wiggle_value_changed( GtkAdjustment *adj, GtkWidget *tbl )
2037 {
2038     prefs_set_double_attribute( "tools.calligraphic", "wiggle", adj->value );
2039 }
2040
2041 static void sp_ddc_angle_value_changed( GtkAdjustment *adj, GtkWidget *tbl )
2042 {
2043     prefs_set_double_attribute( "tools.calligraphic", "angle", adj->value );
2044 }
2045
2046 static void sp_ddc_width_value_changed( GtkAdjustment *adj, GtkWidget *tbl )
2047 {
2048     prefs_set_double_attribute( "tools.calligraphic", "width", adj->value * 0.01 );
2049 }
2050
2051 static void sp_ddc_velthin_value_changed( GtkAdjustment *adj, GtkWidget *tbl )
2052 {
2053     prefs_set_double_attribute("tools.calligraphic", "thinning", adj->value);
2054 }
2055
2056 static void sp_ddc_flatness_value_changed( GtkAdjustment *adj, GtkWidget *tbl )
2057 {
2058     prefs_set_double_attribute( "tools.calligraphic", "flatness", adj->value );
2059 }
2060
2061 static void sp_ddc_tremor_value_changed( GtkAdjustment *adj, GtkWidget *tbl )
2062 {
2063     prefs_set_double_attribute( "tools.calligraphic", "tremor", adj->value );
2064 }
2065
2066 static void sp_ddc_cap_rounding_value_changed( GtkAdjustment *adj, GtkWidget *tbl )
2067 {
2068     prefs_set_double_attribute( "tools.calligraphic", "cap_rounding", adj->value );
2069 }
2070
2071 static void sp_ddc_pressure_state_changed( GtkToggleAction *act, gpointer data )
2072 {
2073     prefs_set_int_attribute( "tools.calligraphic", "usepressure", gtk_toggle_action_get_active( act ) ? 1 : 0);
2074 }
2075
2076 static void sp_ddc_tilt_state_changed( GtkToggleAction *act, GtkAction *calligraphy_angle )
2077 {
2078     prefs_set_int_attribute( "tools.calligraphic", "usetilt", gtk_toggle_action_get_active( act ) ? 1 : 0 );
2079
2080     gtk_action_set_sensitive( calligraphy_angle, !gtk_toggle_action_get_active( act ) );
2081 }
2082
2083 static void sp_ddc_defaults(GtkWidget *, GtkWidget *dataKludge)
2084 {
2085     // FIXME: make defaults settable via Inkscape Options
2086     struct KeyValue {
2087         char const *key;
2088         double value;
2089     } const key_values[] = {
2090         {"mass", 0.02},
2091         {"wiggle", 0.0},
2092         {"angle", 30.0},
2093         {"width", 15},
2094         {"thinning", 0.1},
2095         {"tremor", 0.0},
2096         {"flatness", 0.9},
2097         {"cap_rounding", 0.0}
2098     };
2099
2100     for (unsigned i = 0; i < G_N_ELEMENTS(key_values); ++i) {
2101         KeyValue const &kv = key_values[i];
2102         GtkAdjustment* adj = static_cast<GtkAdjustment *>(gtk_object_get_data(GTK_OBJECT(dataKludge), kv.key));
2103         if ( adj ) {
2104             gtk_adjustment_set_value(adj, kv.value);
2105         }
2106     }
2107 }
2108
2109
2110 static GtkWidget *
2111 sp_calligraphy_toolbox_new(SPDesktop *desktop)
2112 {
2113     GtkWidget *toolBar = 0;
2114     GtkWidget* holder = gtk_table_new( 1, 2, FALSE );
2115
2116     gchar const * descr =
2117         "<ui>"
2118         "  <toolbar name='CalligraphyToolbar'>"
2119         "    <separator />"
2120         "    <toolitem name='Width' action='WidthAction' />"
2121         "    <toolitem name='Thinning' action='ThinningAction' />"
2122         "    <separator />"
2123         "    <toolitem name='Angle' action='AngleAction' />"
2124         "    <toolitem action='FixationAction' />"
2125         "    <toolitem action='CapRoundingAction' />"
2126         "    <separator />"
2127         "    <toolitem action='TremorAction' />"
2128         "    <toolitem action='WiggleAction' />"
2129         "    <toolitem action='MassAction' />"
2130         "    <separator />"
2131         "    <toolitem action='PressureAction' />"
2132         "    <toolitem action='TiltAction' />"
2133         "    <toolitem action='ResetAction' />"
2134         "  </toolbar>"
2135         "</ui>";
2136     GtkUIManager* mgr = gtk_ui_manager_new();
2137     GError* errVal = 0;
2138     GtkActionGroup* mainActions = gtk_action_group_new("main");
2139
2140     {
2141         EgeAdjustmentAction* calligraphy_angle = 0;
2142
2143         {
2144         /* Width */
2145         gchar const* labels[] = {_("(hairline)"), 0, 0, 0, _("(default)"), 0, 0, 0, 0, _("(broad stroke)")};
2146         gdouble values[] = {1, 3, 5, 10, 15, 20, 30, 50, 75, 100};
2147         EgeAdjustmentAction *eact = create_adjustment_action( "WidthAction",
2148                                          _("Width:"), _("The width of the calligraphic pen (relative to the visible canvas area)"),
2149                                          "tools.calligraphic", "width", 15,
2150                                          GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-calligraphy",
2151                                          1, 100, 1.0, 10.0,
2152                                          labels, values, G_N_ELEMENTS(labels),
2153                                          sp_ddc_width_value_changed,  0.01, 0, 100 );
2154         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
2155         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
2156         }
2157
2158         {
2159         /* Thinning */
2160             gchar const* labels[] = {_("(speed blows up stroke)"), 0, 0, _("(slight widening)"), _("(constant width)"), _("(slight thinning, default)"), 0, 0, _("(speed deflates stroke)")};
2161             gdouble values[] = {-1, -0.4, -0.2, -0.1, 0, 0.1, -0.2, 0.4, 1};
2162         EgeAdjustmentAction* eact = create_adjustment_action( "ThinningAction",
2163                                          _("Thinning:"), _("How much velocity thins the stroke (> 0 makes fast strokes thinner, < 0 makes them broader, 0 makes width independent of velocity)"),
2164                                          "tools.calligraphic", "thinning", 0.1,
2165                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
2166                                          -1.0, 1.0, 0.01, 0.1,
2167                                          labels, values, G_N_ELEMENTS(labels),
2168                                          sp_ddc_velthin_value_changed, 0.01, 2);
2169         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
2170         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
2171         }
2172
2173         {
2174         /* Angle */
2175         gchar const* labels[] = {_("(left edge up)"), 0, 0, _("(horizontal)"), _("(default)"), 0, _("(right edge up)")};
2176         gdouble values[] = {-90, -60, -30, 0, 30, 60, 90};
2177         EgeAdjustmentAction* eact = create_adjustment_action( "AngleAction",
2178                                          _("Angle:"), _("The angle of the pen's nib (in degrees; 0 = horizontal; has no effect if fixation = 0)"),
2179                                          "tools.calligraphic", "angle", 30,
2180                                          GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "calligraphy-angle",
2181                                          -90.0, 90.0, 1.0, 10.0,
2182                                          labels, values, G_N_ELEMENTS(labels),
2183                                          sp_ddc_angle_value_changed, 1, 0 );
2184         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
2185         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
2186         calligraphy_angle = eact;
2187         }
2188
2189         {
2190         /* Fixation */
2191             gchar const* labels[] = {_("(perpendicular to stroke, \"brush\")"), 0, 0, 0, _("(almost fixed, default)"), _("(fixed by Angle, \"pen\")")};
2192         gdouble values[] = {0, 0.2, 0.4, 0.6, 0.9, 1.0};
2193         EgeAdjustmentAction* eact = create_adjustment_action( "FixationAction",
2194                                          _("Fixation:"), _("Angle behavior (0 = nib always perpendicular to stroke direction, 1 = fixed angle)"),
2195                                          "tools.calligraphic", "flatness", 0.9,
2196                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
2197                                          0.0, 1.0, 0.01, 0.1,
2198                                          labels, values, G_N_ELEMENTS(labels),
2199                                          sp_ddc_flatness_value_changed, 0.01, 2 );
2200         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
2201         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
2202         }
2203
2204         {
2205         /* Cap Rounding */
2206             gchar const* labels[] = {_("(blunt caps, default)"), _("(slightly bulging)"), 0, 0, _("(approximately round)"), _("(long protruding caps)")};
2207         gdouble values[] = {0, 0.3, 0.5, 1.0, 1.4, 5.0};
2208         // TRANSLATORS: "cap" means "end" (both start and finish) here
2209         EgeAdjustmentAction* eact = create_adjustment_action( "CapRoundingAction",
2210                                          _("Caps:"), _("Increase to make caps at the ends of strokes protrude more (0 = no caps, 1 = round caps)"),
2211                                          "tools.calligraphic", "cap_rounding", 0.0,
2212                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
2213                                          0.0, 5.0, 0.01, 0.1,
2214                                          labels, values, G_N_ELEMENTS(labels),
2215                                          sp_ddc_cap_rounding_value_changed, 0.01, 2 );
2216         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
2217         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
2218         }
2219
2220         {
2221         /* Tremor */
2222             gchar const* labels[] = {_("(smooth line)"), _("(slight tremor)"), _("(noticeable tremor)"), 0, 0, _("(maximum tremor)")};
2223         gdouble values[] = {0, 0.1, 0.2, 0.4, 0.6, 1.0};
2224         EgeAdjustmentAction* eact = create_adjustment_action( "TremorAction",
2225                                          _("Tremor:"), _("Increase to make strokes rugged and trembling"),
2226                                          "tools.calligraphic", "tremor", 0.0,
2227                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
2228                                          0.0, 1.0, 0.01, 0.1,
2229                                          labels, values, G_N_ELEMENTS(labels),
2230                                          sp_ddc_tremor_value_changed, 0.01, 2 );
2231
2232         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
2233         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
2234         }
2235
2236         {
2237         /* Wiggle */
2238         gchar const* labels[] = {_("(no wiggle)"), _("(slight deviation)"), 0, 0, _("(wild waves and curls)")};
2239         gdouble values[] = {0, 0.2, 0.4, 0.6, 1.0};
2240         EgeAdjustmentAction* eact = create_adjustment_action( "WiggleAction",
2241                                          _("Wiggle:"), _("Increase to make the pen waver and wiggle"),
2242                                          "tools.calligraphic", "wiggle", 0.0,
2243                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
2244                                          0.0, 1.0, 0.01, 0.1,
2245                                          labels, values, G_N_ELEMENTS(labels),
2246                                          sp_ddc_wiggle_value_changed, 0.01, 2 );
2247         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
2248         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
2249         }
2250
2251         {
2252         /* Mass */
2253             gchar const* labels[] = {_("(no inertia)"), _("(slight smoothing, default)"), _("(noticeable lagging)"), 0, 0, _("(maximum inertia)")};
2254         gdouble values[] = {0.0, 0.02, 0.1, 0.2, 0.5, 1.0};
2255         EgeAdjustmentAction* eact = create_adjustment_action( "MassAction",
2256                                          _("Mass:"), _("Increase to make the pen drag behind, as if slowed by inertia"),
2257                                          "tools.calligraphic", "mass", 0.02,
2258                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
2259                                          0.0, 1.0, 0.01, 0.1,
2260                                          labels, values, G_N_ELEMENTS(labels),
2261                                          sp_ddc_mass_value_changed, 0.01, 2 );
2262         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
2263         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
2264         }
2265
2266
2267         /* Use Pressure button */
2268         {
2269             InkToggleAction* act = ink_toggle_action_new( "PressureAction",
2270                                                           _("Pressure"),
2271                                                           _("Use the pressure of the input device to alter the width of the pen"),
2272                                                           "use_pressure",
2273                                                           Inkscape::ICON_SIZE_DECORATION );
2274             gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
2275             g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_ddc_pressure_state_changed), NULL);
2276             gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs_get_int_attribute( "tools.calligraphic", "usepressure", 1 ) );
2277         }
2278
2279         /* Use Tilt button */
2280         {
2281             InkToggleAction* act = ink_toggle_action_new( "TiltAction",
2282                                                           _("Tilt"),
2283                                                           _("Use the tilt of the input device to alter the angle of the pen's nib"),
2284                                                           "use_tilt",
2285                                                           Inkscape::ICON_SIZE_DECORATION );
2286             gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
2287             g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_ddc_tilt_state_changed), calligraphy_angle );
2288             gtk_action_set_sensitive( GTK_ACTION(calligraphy_angle), !prefs_get_int_attribute( "tools.calligraphic", "usetilt", 1 ) );
2289             gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs_get_int_attribute( "tools.calligraphic", "usetilt", 1 ) );
2290         }
2291
2292         /* Reset */
2293         {
2294             GtkAction* act = gtk_action_new( "ResetAction",
2295                                              _("Defaults"),
2296                                              _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
2297                                              GTK_STOCK_CLEAR );
2298             g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(sp_ddc_defaults), holder );
2299             gtk_action_group_add_action( mainActions, act );
2300             gtk_action_set_sensitive( act, TRUE );
2301         }
2302     }
2303
2304
2305     gtk_ui_manager_insert_action_group( mgr, mainActions, 0 );
2306     gtk_ui_manager_add_ui_from_string( mgr, descr, -1, &errVal );
2307
2308     toolBar = gtk_ui_manager_get_widget( mgr, "/ui/CalligraphyToolbar" );
2309     gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS );
2310     gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), GTK_ICON_SIZE_SMALL_TOOLBAR );
2311
2312
2313     gtk_table_attach( GTK_TABLE(holder), toolBar, 0, 1, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0 );
2314
2315     Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL, _("Style of new calligraphic strokes"));
2316     swatch->setDesktop (desktop);
2317     swatch->setClickVerb (SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS);
2318     swatch->setWatchedTool ("tools.calligraphic", true);
2319     GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj());
2320     gtk_table_attach( GTK_TABLE(holder), swatch_, 1, 2, 0, 1, (GtkAttachOptions)(GTK_SHRINK | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), AUX_BETWEEN_BUTTON_GROUPS, 0 );
2321
2322     gtk_widget_show_all(holder);
2323     //sp_set_font_size_smaller (tbl);
2324
2325     return holder;
2326 }
2327
2328
2329 //########################
2330 //##    Circle / Arc    ##
2331 //########################
2332
2333 static void
2334 sp_arctb_sensitivize (GtkWidget *tbl, double v1, double v2)
2335 {
2336     GtkWidget *ocb = (GtkWidget*) g_object_get_data(G_OBJECT(tbl), "open_checkbox");
2337     GtkWidget *make_whole = (GtkWidget*) g_object_get_data(G_OBJECT(tbl), "make_whole");
2338
2339     if (v1 == 0 && v2 == 0) {
2340         if (gtk_object_get_data(GTK_OBJECT(tbl), "single")) { // only for a single selected ellipse (for now)
2341             gtk_widget_set_sensitive(GTK_WIDGET(ocb), FALSE);
2342             gtk_widget_set_sensitive(GTK_WIDGET(make_whole), FALSE);
2343         }
2344     } else {
2345         gtk_widget_set_sensitive(GTK_WIDGET(ocb), TRUE);
2346         gtk_widget_set_sensitive(GTK_WIDGET(make_whole), TRUE);
2347     }
2348 }
2349
2350 static void
2351 sp_arctb_startend_value_changed(GtkAdjustment *adj, GtkWidget *tbl, gchar const *value_name, gchar const *other_name)
2352 {
2353     SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop");
2354
2355     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
2356         prefs_set_double_attribute("tools.shapes.arc", value_name, (adj->value * M_PI)/ 180);
2357     }
2358
2359     // quit if run by the attr_changed listener
2360     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
2361         return;
2362     }
2363
2364     // in turn, prevent listener from responding
2365     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE));
2366
2367     gchar* namespaced_name = g_strconcat("sodipodi:", value_name, NULL);
2368
2369     bool modmade = false;
2370     for (GSList const *items = sp_desktop_selection(desktop)->itemList();
2371          items != NULL;
2372          items = items->next)
2373     {
2374         SPItem *item = SP_ITEM(items->data);
2375
2376         if (SP_IS_ARC(item) && SP_IS_GENERICELLIPSE(item)) {
2377
2378             SPGenericEllipse *ge = SP_GENERICELLIPSE(item);
2379             SPArc *arc = SP_ARC(item);
2380
2381             if (!strcmp(value_name, "start"))
2382                 ge->start = (adj->value * M_PI)/ 180;
2383             else
2384                 ge->end = (adj->value * M_PI)/ 180;
2385
2386             sp_genericellipse_normalize(ge);
2387             ((SPObject *)arc)->updateRepr();
2388             ((SPObject *)arc)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
2389
2390             modmade = true;
2391         }
2392     }
2393
2394     g_free(namespaced_name);
2395
2396     GtkAdjustment *other = (GtkAdjustment *)gtk_object_get_data(GTK_OBJECT(tbl), other_name);
2397
2398     sp_arctb_sensitivize (tbl, adj->value, other->value);
2399
2400     if (modmade) {
2401         sp_document_maybe_done(sp_desktop_document(desktop), value_name, SP_VERB_CONTEXT_ARC,
2402                                    _("Arc: Change start/end"));
2403     }
2404
2405     // defocus spinbuttons by moving focus to the canvas, unless "stay" is on
2406     spinbutton_defocus(GTK_OBJECT(tbl));
2407
2408     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
2409 }
2410
2411
2412 static void
2413 sp_arctb_start_value_changed(GtkAdjustment *adj,  GtkWidget *tbl)
2414 {
2415     sp_arctb_startend_value_changed(adj,  tbl, "start", "end");
2416 }
2417
2418 static void
2419 sp_arctb_end_value_changed(GtkAdjustment *adj, GtkWidget *tbl)
2420 {
2421     sp_arctb_startend_value_changed(adj,  tbl, "end", "start");
2422 }
2423
2424 static void
2425 sp_arctb_open_state_changed(GtkWidget *widget, GtkObject *tbl)
2426 {
2427     SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop");
2428
2429     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
2430         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) {
2431             prefs_set_string_attribute("tools.shapes.arc", "open", "true");
2432         } else {
2433             prefs_set_string_attribute("tools.shapes.arc", "open", NULL);
2434         }
2435     }
2436
2437     // quit if run by the attr_changed listener
2438     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
2439         return;
2440     }
2441
2442     // in turn, prevent listener from responding
2443     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE));
2444
2445     bool modmade = false;
2446
2447     if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) {
2448         for (GSList const *items = sp_desktop_selection(desktop)->itemList();
2449              items != NULL;
2450              items = items->next)
2451         {
2452             if (SP_IS_ARC((SPItem *) items->data)) {
2453                 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
2454                 repr->setAttribute("sodipodi:open", "true");
2455                 SP_OBJECT((SPItem *) items->data)->updateRepr(repr, SP_OBJECT_WRITE_EXT);
2456                 modmade = true;
2457             }
2458         }
2459     } else {
2460         for (GSList const *items = sp_desktop_selection(desktop)->itemList();
2461              items != NULL;
2462              items = items->next)
2463         {
2464             if (SP_IS_ARC((SPItem *) items->data))    {
2465                 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
2466                 repr->setAttribute("sodipodi:open", NULL);
2467                 SP_OBJECT((SPItem *) items->data)->updateRepr(repr, SP_OBJECT_WRITE_EXT);
2468                 modmade = true;
2469             }
2470         }
2471     }
2472
2473     if (modmade) {
2474         sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_ARC,
2475                                    _("Arc: Change open/closed"));
2476     }
2477
2478     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
2479
2480     spinbutton_defocus(GTK_OBJECT(tbl));
2481 }
2482
2483 static void sp_arctb_defaults(GtkWidget *, GtkObject *obj)
2484 {
2485     GtkWidget *tbl = GTK_WIDGET(obj);
2486
2487     GtkAdjustment *adj;
2488     adj = (GtkAdjustment*)gtk_object_get_data(obj, "start");
2489     gtk_adjustment_set_value(adj, 0.0);
2490     gtk_adjustment_value_changed(adj);
2491
2492     adj = (GtkAdjustment*)gtk_object_get_data(obj, "end");
2493     gtk_adjustment_set_value(adj, 0.0);
2494     gtk_adjustment_value_changed(adj);
2495
2496     spinbutton_defocus(GTK_OBJECT(tbl));
2497 }
2498
2499 static void arc_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const *name,
2500                                       gchar const *old_value, gchar const *new_value,
2501                                       bool is_interactive, gpointer data)
2502 {
2503     GtkWidget *tbl = GTK_WIDGET(data);
2504
2505     // quit if run by the _changed callbacks
2506     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
2507         return;
2508     }
2509
2510     // in turn, prevent callbacks from responding
2511     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE));
2512
2513     gdouble start = sp_repr_get_double_attribute(repr, "sodipodi:start", 0.0);
2514     gdouble end = sp_repr_get_double_attribute(repr, "sodipodi:end", 0.0);
2515
2516     GtkAdjustment *adj1,*adj2;
2517     adj1 = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "start");
2518     gtk_adjustment_set_value(adj1, mod360((start * 180)/M_PI));
2519     adj2 = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "end");
2520     gtk_adjustment_set_value(adj2, mod360((end * 180)/M_PI));
2521
2522     sp_arctb_sensitivize (tbl, adj1->value, adj2->value);
2523
2524     char const *openstr = NULL;
2525     openstr = repr->attribute("sodipodi:open");
2526     GtkWidget *ocb = (GtkWidget*) g_object_get_data(G_OBJECT(tbl), "open_checkbox");
2527
2528     if (openstr) {
2529         gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(ocb),  TRUE);
2530     } else {
2531         gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(ocb),  FALSE);
2532     }
2533
2534     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
2535 }
2536
2537 static Inkscape::XML::NodeEventVector arc_tb_repr_events = {
2538     NULL, /* child_added */
2539     NULL, /* child_removed */
2540     arc_tb_event_attr_changed,
2541     NULL, /* content_changed */
2542     NULL  /* order_changed */
2543 };
2544
2545
2546 static void
2547 sp_arc_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *tbl)
2548 {
2549     int n_selected = 0;
2550     Inkscape::XML::Node *repr = NULL;
2551     Inkscape::XML::Node *oldrepr = NULL;
2552
2553     for (GSList const *items = selection->itemList();
2554          items != NULL;
2555          items = items->next)
2556     {
2557         if (SP_IS_ARC((SPItem *) items->data)) {
2558             n_selected++;
2559             repr = SP_OBJECT_REPR((SPItem *) items->data);
2560         }
2561     }
2562
2563     GtkWidget *l = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(tbl), "mode_label"));
2564
2565     g_object_set_data(G_OBJECT(tbl), "single", GINT_TO_POINTER(FALSE));
2566     if (n_selected == 0) {
2567         gtk_label_set_markup(GTK_LABEL(l), _("<b>New:</b>"));
2568     } else if (n_selected == 1) {
2569         g_object_set_data(G_OBJECT(tbl), "single", GINT_TO_POINTER(TRUE));
2570         gtk_label_set_markup(GTK_LABEL(l), _("<b>Change:</b>"));
2571
2572         oldrepr = (Inkscape::XML::Node *) gtk_object_get_data(GTK_OBJECT(tbl), "repr");
2573
2574         if (oldrepr) { // remove old listener
2575             sp_repr_remove_listener_by_data(oldrepr, tbl);
2576             Inkscape::GC::release(oldrepr);
2577             oldrepr = 0;
2578             g_object_set_data(G_OBJECT(tbl), "repr", NULL);
2579         }
2580
2581         if (repr) {
2582             g_object_set_data(G_OBJECT(tbl), "repr", repr);
2583             Inkscape::GC::anchor(repr);
2584             sp_repr_add_listener(repr, &arc_tb_repr_events, tbl);
2585             sp_repr_synthesize_events(repr, &arc_tb_repr_events, tbl);
2586         }
2587     } else {
2588         // FIXME: implement averaging of all parameters for multiple selected
2589         //gtk_label_set_markup(GTK_LABEL(l), _("<b>Average:</b>"));
2590         gtk_label_set_markup(GTK_LABEL(l), _("<b>Change:</b>"));
2591         sp_arctb_sensitivize (GTK_WIDGET(tbl), 1, 0);
2592     }
2593 }
2594
2595
2596 static GtkWidget *
2597 sp_arc_toolbox_new(SPDesktop *desktop)
2598 {
2599     GtkWidget *tbl = gtk_hbox_new(FALSE, 0);
2600
2601     gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
2602     gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop);
2603
2604     GtkTooltips *tt = gtk_tooltips_new();
2605
2606     sp_toolbox_add_label(tbl, _("<b>New:</b>"));
2607
2608     /* Start */
2609     {
2610         GtkWidget *hb = sp_tb_spinbutton(_("Start:"), _("The angle (in degrees) from the horizontal to the arc's start point"),
2611                                          "tools.shapes.arc", "start", 0.0,
2612                                          NULL, tbl, TRUE, "altx-arc",
2613                                          -360.0, 360.0, 1.0, 10.0,
2614                                          sp_arctb_start_value_changed);
2615         gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
2616     }
2617
2618     /* End */
2619     {
2620         GtkWidget *hb = sp_tb_spinbutton(_("End:"), _("The angle (in degrees) from the horizontal to the arc's end point"),
2621                                          "tools.shapes.arc", "end", 0.0,
2622                                          NULL, tbl, FALSE, NULL,
2623                                          -360.0, 360.0, 1.0, 10.0,
2624                                          sp_arctb_end_value_changed);
2625         gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
2626     }
2627
2628     /* Segments / Pie checkbox */
2629     {
2630         GtkWidget *hb = gtk_hbox_new(FALSE, 1);
2631         GtkWidget *fscb = gtk_check_button_new_with_label(_("Open arc"));
2632         gtk_tooltips_set_tip(tt, fscb, _("Switch between arc (unclosed shape) and segment (closed shape with two radii)"), NULL);
2633
2634         gchar const *openstr = NULL;
2635         openstr = prefs_get_string_attribute("tools.shapes.arc", "open");
2636         if (!openstr || (openstr && !strcmp(openstr, "false")))
2637             gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(fscb),  FALSE);
2638         else
2639             gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(fscb),  TRUE);
2640
2641         gtk_widget_show(fscb);
2642         gtk_object_set_data(GTK_OBJECT(tbl), "open_checkbox", fscb);
2643         gtk_container_add(GTK_CONTAINER(hb), fscb);
2644         g_signal_connect(G_OBJECT(fscb), "toggled", GTK_SIGNAL_FUNC(sp_arctb_open_state_changed ), tbl);
2645         gtk_box_pack_start(GTK_BOX(tbl),hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
2646     }
2647
2648     /* Make Whole */
2649     {
2650         GtkWidget *hb = gtk_hbox_new(FALSE, 1);
2651         GtkWidget *b = gtk_button_new_with_label(_("Make whole"));
2652         gtk_object_set_data(GTK_OBJECT(tbl), "make_whole", b);
2653         gtk_tooltips_set_tip(tt, b, _("Make the shape a whole ellipse, not arc or segment"), NULL);
2654         gtk_widget_show(b);
2655         gtk_container_add(GTK_CONTAINER(hb), b);
2656         gtk_signal_connect(GTK_OBJECT(b), "clicked", GTK_SIGNAL_FUNC(sp_arctb_defaults), tbl);
2657         gtk_box_pack_start(GTK_BOX(tbl),hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
2658     }
2659
2660     g_object_set_data(G_OBJECT(tbl), "single", GINT_TO_POINTER(TRUE));
2661     // sensitivize make whole and open checkbox
2662     {
2663         GtkAdjustment *adj1 = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(tbl), "start"));
2664         GtkAdjustment *adj2 = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(tbl), "end"));
2665         sp_arctb_sensitivize (tbl, adj1->value, adj2->value);
2666     }
2667
2668     sigc::connection *connection = new sigc::connection(
2669         sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_arc_toolbox_selection_changed), (GtkObject *)tbl))
2670         );
2671     g_signal_connect(G_OBJECT(tbl), "destroy", G_CALLBACK(delete_connection), connection);
2672
2673     Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL, _("Style of new ellipses"));
2674     swatch->setDesktop (desktop);
2675     swatch->setClickVerb (SP_VERB_CONTEXT_ARC_PREFS);
2676     swatch->setWatchedTool ("tools.shapes.arc", true);
2677     GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj());
2678     gtk_box_pack_end(GTK_BOX(tbl), swatch_, FALSE, FALSE, 0);
2679
2680     gtk_widget_show_all(tbl);
2681     sp_set_font_size_smaller (tbl);
2682
2683     return tbl;
2684 }
2685
2686
2687
2688
2689 // toggle button callbacks and updaters
2690
2691 //########################
2692 //##      Dropper       ##
2693 //########################
2694
2695 static void toggle_dropper_pick_alpha (GtkWidget *button, gpointer tbl) {
2696     prefs_set_int_attribute ("tools.dropper", "pick",
2697         gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)));
2698     GtkWidget *set_checkbox = (GtkWidget*) g_object_get_data(G_OBJECT(tbl), "set_checkbox");
2699     if (set_checkbox) {
2700         if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))) {
2701             gtk_widget_set_sensitive (GTK_WIDGET (set_checkbox), TRUE);
2702         } else {
2703             gtk_widget_set_sensitive (GTK_WIDGET (set_checkbox), FALSE);
2704         }
2705     }
2706     spinbutton_defocus(GTK_OBJECT(tbl));
2707 }
2708
2709 static void toggle_dropper_set_alpha (GtkWidget *button, gpointer tbl) {
2710     prefs_set_int_attribute ("tools.dropper", "setalpha",
2711         gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)) ? 1 : 0);
2712     spinbutton_defocus(GTK_OBJECT(tbl));
2713 }
2714
2715
2716 /**
2717  * Copy the current saved desktop color to the clipboard as full hex + alpha
2718  * color representation. This is useful for passing values between various
2719  * input boxes, or directly to xml.
2720  */
2721 /* static void
2722 sp_dropper_copy( GtkWidget *widget, GtkObject *obj)
2723 {
2724     GtkWidget *tbl = GTK_WIDGET(obj);
2725
2726     SPDesktop *desktop =
2727         (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop");
2728
2729
2730     sp_dropper_c32_color_copy( sp_desktop_get_color(desktop, true) );
2731 }*/
2732
2733
2734 /**
2735  * Copies currently saved desktop color to the clipboard as a hex value. This
2736  * is useful for editing webpages and needing a value quickly for web
2737  * colors.
2738  *
2739  * TODO: When the toggle of the dropper is set to not mix color against
2740  *       page background, this still just gets the color of the page and
2741  *       doesn't get the actual mixed against background which is needed
2742  *       for the hex value ppl. want for web pages, etc.
2743  */
2744
2745 /* static void
2746 sp_dropper_copy_as_hex ( GtkWidget *widget, GtkObject *obj)
2747 {
2748     GtkWidget *tbl = GTK_WIDGET(obj);
2749
2750     SPDesktop *desktop =
2751         (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop");
2752
2753     sp_dropper_c32_color_copy_hex( sp_desktop_get_color(desktop, true) );
2754 }*/
2755
2756
2757 /**
2758  * Sets the input boxes with the changed color and opacity. This is used as a
2759  * callback for style changing.
2760  */
2761 /* static bool
2762 sp_style_changed (const SPCSSAttr *css, gpointer data)
2763 {
2764     // GrDrag *drag = (GrDrag *) data;
2765
2766     // set fill of text entry box
2767     if (css->attribute("fill"))
2768         gtk_entry_set_text((GtkEntry *)dropper_rgb_entry,
2769             css->attribute("fill"));
2770
2771     // set opacity of text entry box
2772     if (css->attribute("fill-opacity"))
2773         gtk_entry_set_text((GtkEntry *)dropper_opacity_entry,
2774             css->attribute("fill-opacity"));
2775
2776     // set fill of text entry box
2777     if (css->attribute("stroke"))
2778         gtk_entry_set_text((GtkEntry *)dropper_rgb_entry,
2779             css->attribute("stroke"));
2780
2781     // set opacity of text entry box
2782     if (css->attribute("stroke-opacity"))
2783         gtk_entry_set_text((GtkEntry *)dropper_opacity_entry,
2784             css->attribute("stroke-opacity"));
2785     return false;
2786
2787 }
2788 */
2789
2790
2791 /**
2792  * Dropper auxiliary toolbar construction and setup.
2793  *
2794  * TODO: Would like to add swatch of current color.
2795  * TODO: Add queue of last 5 or so colors selected with new swatches so that
2796  *       can drag and drop places. Will provide a nice mixing palette.
2797  */
2798 static GtkWidget *
2799 sp_dropper_toolbox_new(SPDesktop *desktop)
2800 {
2801     GtkWidget *tbl = gtk_hbox_new(FALSE, 0);
2802
2803     gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
2804     gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop);
2805
2806     GtkTooltips *tt = gtk_tooltips_new();
2807
2808
2809     gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE,
2810                        AUX_BETWEEN_BUTTON_GROUPS);
2811     // sp_toolbox_add_label(tbl, _("<b>New:</b>"));
2812
2813
2814
2815     /* RGB Input Field */
2816  /*   {
2817         GtkWidget *hb = gtk_hbox_new(FALSE, 1);
2818         GtkWidget *dropper_rgba_label = gtk_label_new ("Color:");
2819         gtk_widget_show (dropper_rgba_label);
2820         gtk_container_add(GTK_CONTAINER(hb), dropper_rgba_label);
2821
2822         dropper_rgb_entry = gtk_entry_new ();
2823         sp_dialog_defocus_on_enter (dropper_rgb_entry);
2824         gtk_entry_set_max_length (GTK_ENTRY (dropper_rgb_entry), 7);
2825         gtk_entry_set_width_chars (GTK_ENTRY (dropper_rgb_entry), 7);
2826         gtk_tooltips_set_tip(tt, dropper_rgb_entry,
2827                          _("Hexidecimal representation of last selected "
2828                            "color"),
2829                          NULL);
2830         gtk_widget_show (dropper_rgb_entry);
2831         gtk_container_add(GTK_CONTAINER(hb), dropper_rgb_entry);
2832
2833         gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE,
2834                            AUX_BETWEEN_BUTTON_GROUPS);
2835     } */
2836
2837     /* Opacity Input Field */
2838 /*    {
2839         GtkWidget *hb = gtk_hbox_new(FALSE, 1);
2840         GtkWidget *dropper_opacity_label = gtk_label_new ( _("Opacity:") );
2841         gtk_widget_show (dropper_opacity_label);
2842         gtk_container_add(GTK_CONTAINER(hb), dropper_opacity_label);
2843
2844         dropper_opacity_entry = gtk_entry_new ();
2845         sp_dialog_defocus_on_enter (dropper_opacity_entry);
2846         gtk_entry_set_max_length (GTK_ENTRY (dropper_opacity_entry), 11);
2847         gtk_entry_set_width_chars (GTK_ENTRY (dropper_opacity_entry), 11);
2848         gtk_tooltips_set_tip(tt, dropper_opacity_entry,
2849                          _("Opacity of last selected color"),
2850                          NULL);
2851         gtk_widget_show (dropper_opacity_entry);
2852         gtk_container_add(GTK_CONTAINER(hb), dropper_opacity_entry);
2853
2854         gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE,
2855                            AUX_BETWEEN_BUTTON_GROUPS);
2856     } */
2857
2858
2859     /* Copy to Clipboard */
2860 /*    {
2861         GtkWidget *hb = gtk_hbox_new(FALSE, 1);
2862         GtkWidget *b = gtk_button_new_with_label(_("Copy as RGBA"));
2863         gtk_tooltips_set_tip(tt, b, _("Copy last saved color as hexidecimal "
2864                                       "RGB + Alpha (RGBA) to "
2865                                       "clipboard"),
2866                              NULL);
2867         gtk_widget_show(b);
2868         gtk_container_add(GTK_CONTAINER(hb), b);
2869         gtk_signal_connect(GTK_OBJECT(b), "clicked",
2870             GTK_SIGNAL_FUNC(sp_dropper_copy), tbl);
2871         gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE,
2872                            AUX_BETWEEN_BUTTON_GROUPS);
2873     } */
2874
2875
2876     /* Copy to Clipboard as HEX */
2877 /*    {
2878         GtkWidget *hb = gtk_hbox_new(FALSE, 1);
2879         GtkWidget *b = gtk_button_new_with_label(_("Copy as HEX"));
2880         gtk_tooltips_set_tip(tt, b, _("Copy last saved color as "
2881                                       "hexidecimal RGB without alpha "
2882                                       "to clipboard"), NULL);
2883         gtk_widget_show(b);
2884         gtk_container_add(GTK_CONTAINER(hb), b);
2885         gtk_signal_connect(GTK_OBJECT(b), "clicked",
2886             GTK_SIGNAL_FUNC(sp_dropper_copy_as_hex), tbl);
2887         gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE,
2888                            AUX_BETWEEN_BUTTON_GROUPS);
2889     } */
2890
2891     // aux_toolbox_space(tbl, AUX_BETWEEN_BUTTON_GROUPS);
2892
2893     {
2894         GtkWidget *hb = gtk_hbox_new(FALSE, 1);
2895
2896         GtkWidget *button = gtk_check_button_new_with_label(_("Pick alpha"));
2897         gtk_tooltips_set_tip(tt, button, _("Pick both the color and the alpha (transparency) under cursor; otherwise, pick only the visible color premultiplied by alpha"), NULL);
2898         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
2899                                       prefs_get_int_attribute ("tools.dropper",
2900                                                                "pick", 1));
2901         gtk_widget_show(button);
2902         gtk_container_add (GTK_CONTAINER (hb), button);
2903         gtk_object_set_data(GTK_OBJECT(tbl), "pick_checkbox", button);
2904         g_signal_connect (G_OBJECT (button), "toggled", G_CALLBACK (toggle_dropper_pick_alpha), tbl);
2905         gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE,
2906                    AUX_BETWEEN_BUTTON_GROUPS);
2907     }
2908
2909     {
2910         GtkWidget *hb = gtk_hbox_new(FALSE, 1);
2911
2912         GtkWidget *button = gtk_check_button_new_with_label(_("Set alpha"));
2913         gtk_tooltips_set_tip(tt, button, _("If alpha was picked, assign it to selection as fill or stroke transparency"), NULL);
2914         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
2915                                       prefs_get_int_attribute ("tools.dropper",
2916                                                                "setalpha", 1));
2917         gtk_widget_show(button);
2918         gtk_container_add (GTK_CONTAINER (hb), button);
2919         gtk_object_set_data(GTK_OBJECT(tbl), "set_checkbox", button);
2920         g_signal_connect (G_OBJECT (button), "toggled", G_CALLBACK (toggle_dropper_set_alpha), tbl);
2921
2922         // make sure it's disabled if we're not picking alpha
2923         GtkWidget *pick_checkbox = (GtkWidget*) g_object_get_data(G_OBJECT(tbl), "pick_checkbox");
2924         if (pick_checkbox) {
2925             if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pick_checkbox))) {
2926                 gtk_widget_set_sensitive (GTK_WIDGET (button), TRUE);
2927             } else {
2928                 gtk_widget_set_sensitive (GTK_WIDGET (button), FALSE);
2929             }
2930         }
2931
2932         gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE,
2933                    AUX_BETWEEN_BUTTON_GROUPS);
2934     }
2935
2936     aux_toolbox_space(tbl, AUX_BETWEEN_BUTTON_GROUPS);
2937
2938
2939     // where new gtkmm stuff should go
2940
2941     gtk_widget_show_all(tbl);
2942     sp_set_font_size_smaller (tbl);
2943
2944     /*
2945     sigc::connection *connection = new sigc::connection(
2946         desktop->connectSetStyle(
2947             sigc::bind(sigc::ptr_fun(sp_style_changed),
2948                        desktop)) );
2949
2950     g_signal_connect(G_OBJECT(tbl), "destroy", G_CALLBACK(delete_connection),
2951                      connection); */
2952
2953     return tbl;
2954 }
2955
2956
2957 //########################
2958 //##    Text Toolbox    ##
2959 //########################
2960 /*
2961 static void
2962 sp_text_letter_changed(GtkAdjustment *adj, GtkWidget *tbl)
2963 {
2964     //Call back for letter sizing spinbutton
2965 }
2966
2967 static void
2968 sp_text_line_changed(GtkAdjustment *adj, GtkWidget *tbl)
2969 {
2970     //Call back for line height spinbutton
2971 }
2972
2973 static void
2974 sp_text_horiz_kern_changed(GtkAdjustment *adj, GtkWidget *tbl)
2975 {
2976     //Call back for horizontal kerning spinbutton
2977 }
2978
2979 static void
2980 sp_text_vert_kern_changed(GtkAdjustment *adj, GtkWidget *tbl)
2981 {
2982     //Call back for vertical kerning spinbutton
2983 }
2984
2985 static void
2986 sp_text_letter_rotation_changed(GtkAdjustment *adj, GtkWidget *tbl)
2987 {
2988     //Call back for letter rotation spinbutton
2989 }*/
2990
2991 namespace {
2992
2993 bool visible = false;
2994
2995 void
2996 sp_text_toolbox_selection_changed (Inkscape::Selection *selection, GObject *tbl)
2997 {
2998
2999     SPStyle *query =
3000         sp_style_new ();
3001
3002     int result_family =
3003         sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTFAMILY);
3004
3005     int result_style =
3006         sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTSTYLE);
3007
3008     int result_numbers =
3009         sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
3010
3011     gtk_widget_hide (GTK_WIDGET (g_object_get_data (G_OBJECT(tbl), "warning-image")));
3012
3013     // If querying returned nothing, read the style from the text tool prefs (default style for new texts)
3014     if (result_family == QUERY_STYLE_NOTHING || result_style == QUERY_STYLE_NOTHING || result_numbers == QUERY_STYLE_NOTHING)
3015     {
3016         Inkscape::XML::Node *repr = inkscape_get_repr (INKSCAPE, "tools.text");
3017
3018         if (repr)
3019         {
3020             sp_style_read_from_repr (query, repr);
3021         }
3022         else
3023         {
3024             return;
3025         }
3026     }
3027
3028     if (query->text)
3029     {
3030         if (result_family == QUERY_STYLE_MULTIPLE_DIFFERENT) {
3031             GtkWidget *entry = GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "family-entry"));
3032             gtk_entry_set_text (GTK_ENTRY (entry), "");
3033
3034         } else if (query->text->font_family.value) {
3035
3036             GtkWidget *entry = GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "family-entry"));
3037             gtk_entry_set_text (GTK_ENTRY (entry), query->text->font_family.value);
3038
3039             Gtk::TreePath path;
3040             try {
3041                 path = Inkscape::FontLister::get_instance()->get_row_for_font (query->text->font_family.value);
3042             } catch (...) {
3043                 return;
3044             }
3045
3046             GtkTreeSelection *tselection = GTK_TREE_SELECTION (g_object_get_data (G_OBJECT(tbl), "family-tree-selection"));
3047             GtkTreeView *treeview = GTK_TREE_VIEW (g_object_get_data (G_OBJECT(tbl), "family-tree-view"));
3048
3049             g_object_set_data (G_OBJECT (tselection), "block", gpointer(1));
3050
3051             gtk_tree_selection_select_path (tselection, path.gobj());
3052             gtk_tree_view_scroll_to_cell (treeview, path.gobj(), NULL, TRUE, 0.5, 0.0);
3053
3054             g_object_set_data (G_OBJECT (tselection), "block", gpointer(0));
3055         }
3056
3057         //Size
3058         GtkWidget *cbox = GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "combo-box-size"));
3059         char *str = g_strdup_printf ("%.5g", query->font_size.computed);
3060         g_object_set_data (tbl, "size-block", gpointer(1));
3061         gtk_entry_set_text (GTK_ENTRY(GTK_BIN (cbox)->child), str);
3062         g_object_set_data (tbl, "size-block", gpointer(0));
3063         free (str);
3064
3065         //Anchor
3066         if (query->text_align.computed == SP_CSS_TEXT_ALIGN_JUSTIFY)
3067         {
3068             GtkWidget *button = GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "text-fill"));
3069             g_object_set_data (G_OBJECT (button), "block", gpointer(1));
3070             gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
3071             g_object_set_data (G_OBJECT (button), "block", gpointer(0));
3072         }
3073         else
3074         {
3075             if (query->text_anchor.computed == SP_CSS_TEXT_ANCHOR_START)
3076             {
3077                 GtkWidget *button = GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "text-start"));
3078                 g_object_set_data (G_OBJECT (button), "block", gpointer(1));
3079                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
3080                 g_object_set_data (G_OBJECT (button), "block", gpointer(0));
3081             }
3082             else if (query->text_anchor.computed == SP_CSS_TEXT_ANCHOR_MIDDLE)
3083             {
3084                 GtkWidget *button = GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "text-middle"));
3085                 g_object_set_data (G_OBJECT (button), "block", gpointer(1));
3086                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
3087                 g_object_set_data (G_OBJECT (button), "block", gpointer(0));
3088             }
3089             else if (query->text_anchor.computed == SP_CSS_TEXT_ANCHOR_END)
3090             {
3091                 GtkWidget *button = GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "text-end"));
3092                 g_object_set_data (G_OBJECT (button), "block", gpointer(1));
3093                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
3094                 g_object_set_data (G_OBJECT (button), "block", gpointer(0));
3095             }
3096         }
3097
3098         //Style
3099         {
3100             GtkToggleButton *button = GTK_TOGGLE_BUTTON (g_object_get_data (G_OBJECT (tbl), "style-bold"));
3101
3102             gboolean active = gtk_toggle_button_get_active (button);
3103             gboolean check  = (query->font_weight.computed >= SP_CSS_FONT_WEIGHT_700);
3104
3105             if (active != check)
3106             {
3107                 g_object_set_data (G_OBJECT (button), "block", gpointer(1));
3108                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), check);
3109                 g_object_set_data (G_OBJECT (button), "block", gpointer(0));
3110             }
3111         }
3112
3113         {
3114             GtkToggleButton *button = GTK_TOGGLE_BUTTON (g_object_get_data (G_OBJECT (tbl), "style-italic"));
3115
3116             gboolean active = gtk_toggle_button_get_active (button);
3117             gboolean check  = (query->font_style.computed != SP_CSS_FONT_STYLE_NORMAL);
3118
3119             if (active != check)
3120             {
3121                 g_object_set_data (G_OBJECT (button), "block", gpointer(1));
3122                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), check);
3123                 g_object_set_data (G_OBJECT (button), "block", gpointer(0));
3124             }
3125         }
3126
3127         //Orientation
3128         //locking both buttons, changing one affect all group (both)
3129         GtkWidget *button = GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "orientation-horizontal"));
3130         g_object_set_data (G_OBJECT (button), "block", gpointer(1));
3131
3132         GtkWidget *button1 = GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "orientation-vertical"));
3133         g_object_set_data (G_OBJECT (button1), "block", gpointer(1));
3134
3135         if (query->writing_mode.computed == SP_CSS_WRITING_MODE_LR_TB)
3136         {
3137             gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
3138         }
3139         else
3140         {
3141             gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button1), TRUE);
3142         }
3143         g_object_set_data (G_OBJECT (button), "block", gpointer(0));
3144         g_object_set_data (G_OBJECT (button1), "block", gpointer(0));
3145     }
3146 }
3147
3148 void
3149 sp_text_toolbox_selection_modified (Inkscape::Selection *selection, guint flags, GObject *tbl)
3150 {
3151     sp_text_toolbox_selection_changed (selection, tbl);
3152 }
3153
3154 void
3155 sp_text_toolbox_subselection_changed (gpointer dragger, GObject *tbl)
3156 {
3157     sp_text_toolbox_selection_changed (NULL, tbl);
3158 }
3159
3160 void
3161 sp_text_toolbox_family_changed (GtkTreeSelection    *selection,
3162                                 GObject             *tbl)
3163 {
3164     SPDesktop    *desktop = SP_ACTIVE_DESKTOP;
3165     GtkTreeModel *model = 0;
3166     GtkWidget    *popdown = GTK_WIDGET (g_object_get_data (tbl, "family-popdown-window"));
3167     GtkWidget    *entry = GTK_WIDGET (g_object_get_data (tbl, "family-entry"));
3168     GtkTreeIter   iter;
3169     char         *family = 0;
3170
3171     gdk_pointer_ungrab (GDK_CURRENT_TIME);
3172     gdk_keyboard_ungrab (GDK_CURRENT_TIME);
3173
3174     if ( !gtk_tree_selection_get_selected( selection, &model, &iter ) ) {
3175         return;
3176     }
3177
3178     gtk_tree_model_get (model, &iter, 0, &family, -1);
3179
3180     if (g_object_get_data (G_OBJECT (selection), "block"))
3181     {
3182         gtk_entry_set_text (GTK_ENTRY (entry), family);
3183         return;
3184     }
3185
3186     gtk_widget_hide (popdown);
3187     visible = false;
3188
3189     gtk_entry_set_text (GTK_ENTRY (entry), family);
3190
3191     SPStyle *query =
3192         sp_style_new ();
3193
3194     int result_numbers =
3195         sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
3196
3197     SPCSSAttr *css = sp_repr_css_attr_new ();
3198     sp_repr_css_set_property (css, "font-family", family);
3199
3200     // If querying returned nothing, read the style from the text tool prefs (default style for new texts)
3201     if (result_numbers == QUERY_STYLE_NOTHING)
3202     {
3203         sp_repr_css_change (inkscape_get_repr (INKSCAPE, "tools.text"), css, "style");
3204         sp_text_edit_dialog_default_set_insensitive (); //FIXME: Replace trough a verb
3205     }
3206     else
3207     {
3208         sp_desktop_set_style (desktop, css, true, true);
3209     }
3210
3211     sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT,
3212                                    _("Text: Change font family"));
3213     sp_repr_css_attr_unref (css);
3214     free (family);
3215     gtk_widget_hide (GTK_WIDGET (g_object_get_data (G_OBJECT(tbl), "warning-image")));
3216
3217     gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas));
3218 }
3219
3220 void
3221 sp_text_toolbox_family_entry_activate (GtkEntry     *entry,
3222                                        GObject      *tbl)
3223 {
3224     const char *family = gtk_entry_get_text (entry);
3225
3226     try {
3227         Gtk::TreePath path = Inkscape::FontLister::get_instance()->get_row_for_font (family);
3228         GtkTreeSelection *selection = GTK_TREE_SELECTION (g_object_get_data (G_OBJECT(tbl), "family-tree-selection"));
3229         GtkTreeView *treeview = GTK_TREE_VIEW (g_object_get_data (G_OBJECT(tbl), "family-tree-view"));
3230         gtk_tree_selection_select_path (selection, path.gobj());
3231         gtk_tree_view_scroll_to_cell (treeview, path.gobj(), NULL, TRUE, 0.5, 0.0);
3232         gtk_widget_hide (GTK_WIDGET (g_object_get_data (G_OBJECT(tbl), "warning-image")));
3233     } catch (...) {
3234         if (family && strlen (family))
3235         {
3236             gtk_widget_show_all (GTK_WIDGET (g_object_get_data (G_OBJECT(tbl), "warning-image")));
3237         }
3238     }
3239 }
3240
3241 void
3242 sp_text_toolbox_anchoring_toggled (GtkRadioButton   *button,
3243                                    gpointer          data)
3244 {
3245     if (g_object_get_data (G_OBJECT (button), "block")) return;
3246     if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))) return;
3247     int prop = GPOINTER_TO_INT(data);
3248
3249     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
3250     SPCSSAttr *css = sp_repr_css_attr_new ();
3251
3252     switch (prop)
3253     {
3254         case 0:
3255         {
3256             sp_repr_css_set_property (css, "text-anchor", "start");
3257             sp_repr_css_set_property (css, "text-align", "start");
3258             break;
3259         }
3260         case 1:
3261         {
3262             sp_repr_css_set_property (css, "text-anchor", "middle");
3263             sp_repr_css_set_property (css, "text-align", "center");
3264             break;
3265         }
3266
3267         case 2:
3268         {
3269             sp_repr_css_set_property (css, "text-anchor", "end");
3270             sp_repr_css_set_property (css, "text-align", "end");
3271             break;
3272         }
3273
3274         case 3:
3275         {
3276             sp_repr_css_set_property (css, "text-anchor", "start");
3277             sp_repr_css_set_property (css, "text-align", "justify");
3278             break;
3279         }
3280     }
3281
3282     SPStyle *query =
3283         sp_style_new ();
3284     int result_numbers =
3285         sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
3286
3287     // If querying returned nothing, read the style from the text tool prefs (default style for new texts)
3288     if (result_numbers == QUERY_STYLE_NOTHING)
3289     {
3290         sp_repr_css_change (inkscape_get_repr (INKSCAPE, "tools.text"), css, "style");
3291     }
3292
3293     sp_desktop_set_style (desktop, css, true, true);
3294     sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT,
3295                                    _("Text: Change alignment"));
3296     sp_repr_css_attr_unref (css);
3297
3298     gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas));
3299 }
3300
3301 void
3302 sp_text_toolbox_style_toggled (GtkToggleButton  *button,
3303                                gpointer          data)
3304 {
3305     if (g_object_get_data (G_OBJECT (button), "block")) return;
3306
3307     SPDesktop   *desktop    = SP_ACTIVE_DESKTOP;
3308     SPCSSAttr   *css        = sp_repr_css_attr_new ();
3309     int          prop       = GPOINTER_TO_INT(data);
3310     bool         active     = gtk_toggle_button_get_active (button);
3311
3312
3313     switch (prop)
3314     {
3315         case 0:
3316         {
3317             sp_repr_css_set_property (css, "font-weight", active ? "bold" : "normal" );
3318             break;
3319         }
3320
3321         case 1:
3322         {
3323             sp_repr_css_set_property (css, "font-style", active ? "italic" : "normal");
3324             break;
3325         }
3326     }
3327
3328     SPStyle *query =
3329         sp_style_new ();
3330     int result_numbers =
3331         sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
3332
3333     // If querying returned nothing, read the style from the text tool prefs (default style for new texts)
3334     if (result_numbers == QUERY_STYLE_NOTHING)
3335     {
3336         sp_repr_css_change (inkscape_get_repr (INKSCAPE, "tools.text"), css, "style");
3337     }
3338
3339     sp_desktop_set_style (desktop, css, true, true);
3340     sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT,
3341                                    _("Text: Change font style"));
3342     sp_repr_css_attr_unref (css);
3343
3344     gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas));
3345 }
3346
3347 void
3348 sp_text_toolbox_orientation_toggled (GtkRadioButton  *button,
3349                                      gpointer         data)
3350 {
3351     if (g_object_get_data (G_OBJECT (button), "block")) {
3352         g_object_set_data (G_OBJECT (button), "block", gpointer(0));
3353         return;
3354     }
3355
3356     SPDesktop   *desktop    = SP_ACTIVE_DESKTOP;
3357     SPCSSAttr   *css        = sp_repr_css_attr_new ();
3358     int          prop       = GPOINTER_TO_INT(data);
3359
3360     switch (prop)
3361     {
3362         case 0:
3363         {
3364             sp_repr_css_set_property (css, "writing-mode", "lr");
3365             break;
3366         }
3367
3368         case 1:
3369         {
3370             sp_repr_css_set_property (css, "writing-mode", "tb");
3371             break;
3372         }
3373     }
3374
3375     SPStyle *query =
3376         sp_style_new ();
3377     int result_numbers =
3378         sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
3379
3380     // If querying returned nothing, read the style from the text tool prefs (default style for new texts)
3381     if (result_numbers == QUERY_STYLE_NOTHING)
3382     {
3383         sp_repr_css_change (inkscape_get_repr (INKSCAPE, "tools.text"), css, "style");
3384     }
3385
3386     sp_desktop_set_style (desktop, css, true, true);
3387     sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT,
3388                                    _("Text: Change orientation"));
3389     sp_repr_css_attr_unref (css);
3390
3391     gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas));
3392 }
3393
3394 gboolean
3395 sp_text_toolbox_size_keypress (GtkWidget *w, GdkEventKey *event, gpointer data)
3396 {
3397     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
3398     if (!desktop) return FALSE;
3399
3400     switch (get_group0_keyval (event)) {
3401         case GDK_Escape: // defocus
3402             gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas));
3403             return TRUE; // I consumed the event
3404             break;
3405         case GDK_Return: // defocus
3406         case GDK_KP_Enter:
3407             gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas));
3408             return TRUE; // I consumed the event
3409             break;
3410     }
3411     return FALSE;
3412 }
3413
3414 gboolean
3415 sp_text_toolbox_family_keypress (GtkWidget *w, GdkEventKey *event, GObject *tbl)
3416 {
3417     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
3418     if (!desktop) return FALSE;
3419
3420     switch (get_group0_keyval (event)) {
3421         case GDK_Escape: // defocus
3422             gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas));
3423             sp_text_toolbox_selection_changed (NULL, tbl); // update
3424             return TRUE; // I consumed the event
3425             break;
3426     }
3427     return FALSE;
3428 }
3429
3430 gboolean
3431 sp_text_toolbox_family_list_keypress (GtkWidget *w, GdkEventKey *event, GObject *tbl)
3432 {
3433     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
3434     if (!desktop) return FALSE;
3435
3436     switch (get_group0_keyval (event)) {
3437         case GDK_Escape: // defocus
3438             gtk_widget_hide (w);
3439             visible = false;
3440             gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas));
3441             return TRUE; // I consumed the event
3442             break;
3443     }
3444     return FALSE;
3445 }
3446
3447
3448 void
3449 sp_text_toolbox_size_changed  (GtkComboBox *cbox,
3450                                GObject     *tbl)
3451 {
3452     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
3453
3454     if (g_object_get_data (tbl, "size-block")) return;
3455
3456 #if GTK_CHECK_VERSION(2,6,0)
3457     char *text = gtk_combo_box_get_active_text (cbox);
3458 #else // GTK_CHECK_VERSION(2,6,0)
3459     GtkTreeModel *model = gtk_combo_box_get_model (cbox);
3460     GtkTreeIter iter;
3461     char *text = NULL;
3462
3463     if (gtk_combo_box_get_active_iter (cbox, &iter) && model)
3464         gtk_tree_model_get (model, &iter, 0, &text, -1);
3465 #endif // GTK_CHECK_VERSION(2,6,0)
3466
3467     SPCSSAttr *css = sp_repr_css_attr_new ();
3468     sp_repr_css_set_property (css, "font-size", text);
3469     free (text);
3470
3471     SPStyle *query =
3472         sp_style_new ();
3473     int result_numbers =
3474         sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
3475
3476     // If querying returned nothing, read the style from the text tool prefs (default style for new texts)
3477     if (result_numbers == QUERY_STYLE_NOTHING)
3478     {
3479         sp_repr_css_change (inkscape_get_repr (INKSCAPE, "tools.text"), css, "style");
3480     }
3481
3482     sp_desktop_set_style (desktop, css, true, true);
3483     sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:size", SP_VERB_NONE,
3484                                    _("Text: Change font size"));
3485     sp_repr_css_attr_unref (css);
3486
3487
3488     if (gtk_combo_box_get_active (cbox) > 0) // if this was from drop-down (as opposed to type-in), defocus
3489         gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas));
3490 }
3491
3492 void
3493 sp_text_toolbox_text_popdown_clicked    (GtkButton          *button,
3494                                          GObject            *tbl)
3495 {
3496     GtkWidget *popdown = GTK_WIDGET (g_object_get_data (tbl, "family-popdown-window"));
3497     GtkWidget *widget = GTK_WIDGET (g_object_get_data (tbl, "family-entry"));
3498     int x, y;
3499
3500     if (!visible)
3501     {
3502         gdk_window_get_origin (widget->window, &x, &y);
3503         gtk_window_move (GTK_WINDOW (popdown), x, y + widget->allocation.height + 2); //2px of grace space
3504         gtk_widget_show_all (popdown);
3505
3506         gdk_pointer_grab (widget->window, TRUE,
3507                           GdkEventMask (GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
3508                                         GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK |
3509                                         GDK_POINTER_MOTION_MASK),
3510                           NULL, NULL, GDK_CURRENT_TIME);
3511
3512         gdk_keyboard_grab (widget->window, TRUE, GDK_CURRENT_TIME);
3513
3514         visible = true;
3515     }
3516     else
3517     {
3518         gdk_pointer_ungrab (GDK_CURRENT_TIME);
3519         gdk_keyboard_ungrab (GDK_CURRENT_TIME);
3520         gtk_widget_hide (popdown);
3521         visible = false;
3522     }
3523 }
3524
3525 gboolean
3526 sp_text_toolbox_entry_focus_in  (GtkWidget        *entry,
3527                                  GdkEventFocus    *event,
3528                                  GObject          *tbl)
3529 {
3530     gtk_entry_select_region (GTK_ENTRY (entry), 0, -1);
3531     return FALSE;
3532 }
3533
3534 gboolean
3535 sp_text_toolbox_popdown_focus_out (GtkWidget        *popdown,
3536                                    GdkEventFocus    *event,
3537                                    GObject          *tbl)
3538 {
3539     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
3540
3541     gtk_widget_hide (popdown);
3542     visible = false;
3543     gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas));
3544     return TRUE;
3545 }
3546
3547 void
3548 cell_data_func  (GtkTreeViewColumn *column,
3549                  GtkCellRenderer   *cell,
3550                  GtkTreeModel      *tree_model,
3551                  GtkTreeIter       *iter,
3552                  gpointer           data)
3553 {
3554     char        *family,
3555         *family_escaped,
3556         *sample_escaped;
3557
3558     static const char *sample = _("AaBbCcIiPpQq12369$\342\202\254\302\242?.;/()");
3559
3560     gtk_tree_model_get (tree_model, iter, 0, &family, -1);
3561
3562     family_escaped = g_markup_escape_text (family, -1);
3563     sample_escaped = g_markup_escape_text (sample, -1);
3564
3565     std::stringstream markup;
3566     markup << family_escaped << "  <span foreground='darkgray' font_family='" << family_escaped << "'>" << sample_escaped << "</span>";
3567     g_object_set (G_OBJECT (cell), "markup", markup.str().c_str(), NULL);
3568
3569     free (family);
3570     free (family_escaped);
3571     free (sample_escaped);
3572 }
3573
3574 static void delete_completion(GObject *obj, GtkWidget *entry) {
3575     GObject *completion = (GObject *) gtk_object_get_data(GTK_OBJECT(entry), "completion");
3576     if (completion) {
3577         gtk_entry_set_completion (GTK_ENTRY(entry), NULL);
3578         g_object_unref (completion);
3579     }
3580 }
3581
3582 GtkWidget*
3583 sp_text_toolbox_new (SPDesktop *desktop)
3584 {
3585     GtkWidget   *tbl = gtk_hbox_new (FALSE, 0);
3586
3587     gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
3588     gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop);
3589
3590     GtkTooltips *tt = gtk_tooltips_new();
3591     Glib::RefPtr<Gtk::ListStore> store = Inkscape::FontLister::get_instance()->get_font_list();
3592
3593     ////////////Family
3594     //Window
3595     GtkWidget   *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3596     gtk_window_set_decorated (GTK_WINDOW (window), FALSE);
3597
3598     //Entry
3599     GtkWidget           *entry = gtk_entry_new ();
3600     gtk_object_set_data(GTK_OBJECT(entry), "altx-text", entry);
3601     GtkEntryCompletion  *completion = gtk_entry_completion_new ();
3602     gtk_entry_completion_set_model (completion, GTK_TREE_MODEL (Glib::unwrap(store)));
3603     gtk_entry_completion_set_text_column (completion, 0);
3604     gtk_entry_completion_set_minimum_key_length (completion, 1);
3605     g_object_set (G_OBJECT(completion), "inline-completion", TRUE, "popup-completion", TRUE, NULL);
3606     gtk_entry_set_completion (GTK_ENTRY(entry), completion);
3607     gtk_object_set_data(GTK_OBJECT(entry), "completion", completion);
3608     aux_toolbox_space (tbl, 1);
3609     gtk_box_pack_start (GTK_BOX (tbl), entry, FALSE, FALSE, 0);
3610     g_signal_connect(G_OBJECT(tbl), "destroy", G_CALLBACK(delete_completion), entry);
3611
3612     //Button
3613     GtkWidget   *button = gtk_button_new ();
3614     gtk_container_add       (GTK_CONTAINER (button), gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE));
3615     gtk_box_pack_start      (GTK_BOX (tbl), button, FALSE, FALSE, 0);
3616
3617     //Popdown
3618     GtkWidget           *sw = gtk_scrolled_window_new (NULL, NULL);
3619     GtkWidget           *treeview = gtk_tree_view_new ();
3620
3621     GtkCellRenderer     *cell = gtk_cell_renderer_text_new ();
3622     GtkTreeViewColumn   *column = gtk_tree_view_column_new ();
3623     gtk_tree_view_column_pack_start (column, cell, FALSE);
3624     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
3625     gtk_tree_view_column_set_cell_data_func (column, cell, GtkTreeCellDataFunc (cell_data_func), NULL, NULL);
3626     gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
3627
3628     gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (Glib::unwrap(store)));
3629     gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
3630 #if GTK_CHECK_VERSION(2,6,0)
3631     gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (treeview), TRUE);
3632 #endif // GTK_CHECK_VERSION(2,6,0)
3633
3634     //gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview), TRUE);
3635
3636     gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
3637     gtk_container_add (GTK_CONTAINER (sw), treeview);
3638
3639     gtk_container_add (GTK_CONTAINER (window), sw);
3640     gtk_widget_set_size_request (window, 300, 450);
3641
3642     g_signal_connect (G_OBJECT (entry),  "activate", G_CALLBACK (sp_text_toolbox_family_entry_activate), tbl);
3643     g_signal_connect (G_OBJECT (entry),  "focus-in-event", G_CALLBACK (sp_text_toolbox_entry_focus_in), tbl);
3644     g_signal_connect (G_OBJECT (entry), "key-press-event", G_CALLBACK(sp_text_toolbox_family_keypress), tbl);
3645
3646     g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (sp_text_toolbox_text_popdown_clicked), tbl);
3647
3648     g_signal_connect (G_OBJECT (window), "focus-out-event", G_CALLBACK (sp_text_toolbox_popdown_focus_out), tbl);
3649     g_signal_connect (G_OBJECT (window), "key-press-event", G_CALLBACK(sp_text_toolbox_family_list_keypress), tbl);
3650
3651     GtkTreeSelection *tselection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
3652     g_signal_connect (G_OBJECT (tselection), "changed", G_CALLBACK (sp_text_toolbox_family_changed), tbl);
3653
3654     g_object_set_data (G_OBJECT (tbl), "family-entry", entry);
3655     g_object_set_data (G_OBJECT (tbl), "family-popdown-button", button);
3656     g_object_set_data (G_OBJECT (tbl), "family-popdown-window", window);
3657     g_object_set_data (G_OBJECT (tbl), "family-tree-selection", tselection);
3658     g_object_set_data (G_OBJECT (tbl), "family-tree-view", treeview);
3659
3660     GtkWidget *image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_SMALL_TOOLBAR);
3661     aux_toolbox_space (tbl, 1);
3662     GtkWidget *box = gtk_event_box_new ();
3663     gtk_container_add (GTK_CONTAINER (box), image);
3664     gtk_box_pack_start (GTK_BOX (tbl), box, FALSE, FALSE, 4);
3665     g_object_set_data (G_OBJECT (tbl), "warning-image", box);
3666     GtkTooltips *tooltips = gtk_tooltips_new ();
3667     gtk_tooltips_set_tip (tooltips, box, _("This font is currently not installed on your system. Inkscape will use the default font instead."), "");
3668     gtk_widget_hide (GTK_WIDGET (box));
3669     g_signal_connect_swapped (G_OBJECT (tbl), "show", G_CALLBACK (gtk_widget_hide), box);
3670
3671     ////////////Size
3672     const char *sizes[] = {
3673         "4", "6", "8", "9", "10", "11", "12", "13", "14",
3674         "16", "18", "20", "22", "24", "28",
3675         "32", "36", "40", "48", "56", "64", "72", "144"
3676     };
3677
3678     GtkWidget *cbox = gtk_combo_box_entry_new_text ();
3679     for (unsigned int n = 0; n < G_N_ELEMENTS (sizes); gtk_combo_box_append_text (GTK_COMBO_BOX(cbox), sizes[n++]));
3680     gtk_widget_set_size_request (cbox, 80, -1);
3681     aux_toolbox_space (tbl, 1);
3682     gtk_box_pack_start (GTK_BOX (tbl), cbox, FALSE, FALSE, 0);
3683     g_object_set_data (G_OBJECT (tbl), "combo-box-size", cbox);
3684     g_signal_connect (G_OBJECT (cbox), "changed", G_CALLBACK (sp_text_toolbox_size_changed), tbl);
3685     gtk_signal_connect(GTK_OBJECT(cbox), "key-press-event", GTK_SIGNAL_FUNC(sp_text_toolbox_size_keypress), NULL);
3686
3687     //spacer
3688     aux_toolbox_space (tbl, 4);
3689     gtk_box_pack_start (GTK_BOX (tbl), gtk_vseparator_new (), FALSE, FALSE, 4);
3690
3691     ////////////Text anchor
3692     GtkWidget *group   = gtk_radio_button_new (NULL);
3693     GtkWidget *row     = gtk_hbox_new (FALSE, 4);
3694     g_object_set_data (G_OBJECT (tbl), "anchor-group", group);
3695
3696     // left
3697     GtkWidget *rbutton = group;
3698     gtk_button_set_relief       (GTK_BUTTON (rbutton), GTK_RELIEF_NONE);
3699     gtk_container_add           (GTK_CONTAINER (rbutton), gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_LEFT, GTK_ICON_SIZE_SMALL_TOOLBAR));
3700     gtk_toggle_button_set_mode  (GTK_TOGGLE_BUTTON (rbutton), FALSE);
3701
3702     gtk_box_pack_start  (GTK_BOX  (row), rbutton, FALSE, FALSE, 0);
3703     g_object_set_data   (G_OBJECT (tbl), "text-start", rbutton);
3704     g_signal_connect    (G_OBJECT (rbutton), "toggled", G_CALLBACK (sp_text_toolbox_anchoring_toggled), gpointer(0));
3705     gtk_tooltips_set_tip(tt, rbutton, _("Align left"), NULL);
3706
3707     // center
3708     rbutton = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
3709     gtk_button_set_relief       (GTK_BUTTON (rbutton), GTK_RELIEF_NONE);
3710     gtk_container_add           (GTK_CONTAINER (rbutton), gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_CENTER, GTK_ICON_SIZE_SMALL_TOOLBAR));
3711     gtk_toggle_button_set_mode  (GTK_TOGGLE_BUTTON (rbutton), FALSE);
3712
3713     gtk_box_pack_start  (GTK_BOX  (row), rbutton, FALSE, FALSE, 0);
3714     g_object_set_data   (G_OBJECT (tbl), "text-middle", rbutton);
3715     g_signal_connect    (G_OBJECT (rbutton), "toggled", G_CALLBACK (sp_text_toolbox_anchoring_toggled), gpointer (1));
3716     gtk_tooltips_set_tip(tt, rbutton, _("Center"), NULL);
3717
3718     // right
3719     rbutton = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
3720     gtk_button_set_relief       (GTK_BUTTON (rbutton), GTK_RELIEF_NONE);
3721     gtk_container_add           (GTK_CONTAINER (rbutton), gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_RIGHT, GTK_ICON_SIZE_SMALL_TOOLBAR));
3722     gtk_toggle_button_set_mode  (GTK_TOGGLE_BUTTON (rbutton), FALSE);
3723
3724     gtk_box_pack_start  (GTK_BOX  (row), rbutton, FALSE, FALSE, 0);
3725     g_object_set_data   (G_OBJECT (tbl), "text-end", rbutton);
3726     g_signal_connect    (G_OBJECT (rbutton), "toggled", G_CALLBACK (sp_text_toolbox_anchoring_toggled), gpointer(2));
3727     gtk_tooltips_set_tip(tt, rbutton, _("Align right"), NULL);
3728
3729     // fill
3730     rbutton = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
3731     gtk_button_set_relief       (GTK_BUTTON (rbutton), GTK_RELIEF_NONE);
3732     gtk_container_add           (GTK_CONTAINER (rbutton), gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_FILL, GTK_ICON_SIZE_SMALL_TOOLBAR));
3733     gtk_toggle_button_set_mode  (GTK_TOGGLE_BUTTON (rbutton), FALSE);
3734
3735     gtk_box_pack_start  (GTK_BOX  (row), rbutton, FALSE, FALSE, 0);
3736     g_object_set_data   (G_OBJECT (tbl), "text-fill", rbutton);
3737     g_signal_connect    (G_OBJECT (rbutton), "toggled", G_CALLBACK (sp_text_toolbox_anchoring_toggled), gpointer(3));
3738     gtk_tooltips_set_tip(tt, rbutton, _("Justify"), NULL);
3739
3740     aux_toolbox_space (tbl, 1);
3741     gtk_box_pack_start (GTK_BOX (tbl), row, FALSE, FALSE, 4);
3742
3743     //spacer
3744     gtk_box_pack_start (GTK_BOX (tbl), gtk_vseparator_new (), FALSE, FALSE, 4);
3745
3746     ////////////Text style
3747     row = gtk_hbox_new (FALSE, 4);
3748
3749     // bold
3750     rbutton = gtk_toggle_button_new ();
3751     gtk_button_set_relief       (GTK_BUTTON (rbutton), GTK_RELIEF_NONE);
3752     gtk_container_add           (GTK_CONTAINER (rbutton), gtk_image_new_from_stock (GTK_STOCK_BOLD, GTK_ICON_SIZE_SMALL_TOOLBAR));
3753     gtk_toggle_button_set_mode  (GTK_TOGGLE_BUTTON (rbutton), FALSE);
3754     gtk_tooltips_set_tip(tt, rbutton, _("Bold"), NULL);
3755
3756     gtk_box_pack_start  (GTK_BOX  (row), rbutton, FALSE, FALSE, 0);
3757     g_object_set_data   (G_OBJECT (tbl), "style-bold", rbutton);
3758     g_signal_connect    (G_OBJECT (rbutton), "toggled", G_CALLBACK (sp_text_toolbox_style_toggled), gpointer(0));
3759
3760     // italic
3761     rbutton = gtk_toggle_button_new ();
3762     gtk_button_set_relief       (GTK_BUTTON (rbutton), GTK_RELIEF_NONE);
3763     gtk_container_add           (GTK_CONTAINER (rbutton), gtk_image_new_from_stock (GTK_STOCK_ITALIC, GTK_ICON_SIZE_SMALL_TOOLBAR));
3764     gtk_toggle_button_set_mode  (GTK_TOGGLE_BUTTON (rbutton), FALSE);
3765     gtk_tooltips_set_tip(tt, rbutton, _("Italic"), NULL);
3766
3767     gtk_box_pack_start  (GTK_BOX  (row), rbutton, FALSE, FALSE, 0);
3768     g_object_set_data   (G_OBJECT (tbl), "style-italic", rbutton);
3769     g_signal_connect    (G_OBJECT (rbutton), "toggled", G_CALLBACK (sp_text_toolbox_style_toggled), gpointer (1));
3770
3771     aux_toolbox_space (tbl, 1);
3772     gtk_box_pack_start (GTK_BOX (tbl), row, FALSE, FALSE, 4);
3773
3774     //spacer
3775     gtk_box_pack_start (GTK_BOX (tbl), gtk_vseparator_new (), FALSE, FALSE, 4);
3776
3777     ////////////Text orientation
3778     group   = gtk_radio_button_new (NULL);
3779     row     = gtk_hbox_new (FALSE, 4);
3780     g_object_set_data (G_OBJECT (tbl), "orientation-group", group);
3781
3782     // horizontal
3783     rbutton = group;
3784     gtk_button_set_relief       (GTK_BUTTON (rbutton), GTK_RELIEF_NONE);
3785     gtk_container_add           (GTK_CONTAINER (rbutton), sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_WRITING_MODE_LR));
3786     gtk_toggle_button_set_mode  (GTK_TOGGLE_BUTTON (rbutton), FALSE);
3787     gtk_tooltips_set_tip(tt, rbutton, _("Horizontal text"), NULL);
3788
3789     gtk_box_pack_start  (GTK_BOX  (row), rbutton, FALSE, FALSE, 0);
3790     g_object_set_data   (G_OBJECT (tbl), "orientation-horizontal", rbutton);
3791     g_signal_connect    (G_OBJECT (rbutton), "toggled", G_CALLBACK (sp_text_toolbox_orientation_toggled), gpointer(0));
3792
3793     // vertical
3794     rbutton = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
3795     gtk_button_set_relief       (GTK_BUTTON (rbutton), GTK_RELIEF_NONE);
3796     gtk_container_add           (GTK_CONTAINER (rbutton), sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_WRITING_MODE_TB));
3797     gtk_toggle_button_set_mode  (GTK_TOGGLE_BUTTON (rbutton), FALSE);
3798     gtk_tooltips_set_tip(tt, rbutton, _("Vertical text"), NULL);
3799
3800     gtk_box_pack_start  (GTK_BOX  (row), rbutton, FALSE, FALSE, 0);
3801     g_object_set_data   (G_OBJECT (tbl), "orientation-vertical", rbutton);
3802     g_signal_connect    (G_OBJECT (rbutton), "toggled", G_CALLBACK (sp_text_toolbox_orientation_toggled), gpointer (1));
3803     gtk_box_pack_start (GTK_BOX (tbl), row, FALSE, FALSE, 4);
3804
3805
3806     //watch selection
3807     Inkscape::ConnectionPool* pool = Inkscape::ConnectionPool::new_connection_pool ("ISTextToolbox");
3808
3809     sigc::connection *c_selection_changed =
3810         new sigc::connection (sp_desktop_selection (desktop)->connectChanged
3811                               (sigc::bind (sigc::ptr_fun (sp_text_toolbox_selection_changed), (GObject*)tbl)));
3812     pool->add_connection ("selection-changed", c_selection_changed);
3813
3814     sigc::connection *c_selection_modified =
3815         new sigc::connection (sp_desktop_selection (desktop)->connectModified
3816                               (sigc::bind (sigc::ptr_fun (sp_text_toolbox_selection_modified), (GObject*)tbl)));
3817     pool->add_connection ("selection-modified", c_selection_modified);
3818
3819     sigc::connection *c_subselection_changed =
3820         new sigc::connection (desktop->connectToolSubselectionChanged
3821                               (sigc::bind (sigc::ptr_fun (sp_text_toolbox_subselection_changed), (GObject*)tbl)));
3822     pool->add_connection ("tool-subselection-changed", c_subselection_changed);
3823
3824     Inkscape::ConnectionPool::connect_destroy (G_OBJECT (tbl), pool);
3825
3826
3827 #if 0
3828     // horizontal
3829     {
3830         GtkWidget *px= sp_icon_new(Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_WRITING_MODE_LR);
3831         GtkWidget *b = group = gtk_radio_button_new (NULL);
3832         gtk_container_add (GTK_CONTAINER (b), px);
3833         gtk_tooltips_set_tip (tt, b, _("Horizontal text"), NULL);
3834         gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
3835         gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE );
3836         gtk_box_pack_start (GTK_BOX (tbl), b, FALSE, FALSE, 0);
3837     }
3838
3839     // vertical
3840     {
3841         GtkWidget *px = sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_WRITING_MODE_TB);
3842         GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
3843         gtk_container_add (GTK_CONTAINER (b), px);
3844         gtk_tooltips_set_tip (tt, b, _("Vertical text"), NULL);
3845         gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
3846         gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE );
3847         gtk_box_pack_start (GTK_BOX (tbl), b, FALSE, FALSE, 0);
3848     }
3849
3850     aux_toolbox_space(tbl, AUX_BETWEEN_BUTTON_GROUPS);
3851
3852     // letter spacing
3853     {
3854         {
3855             GtkWidget *image = sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_TEXT_LETTER_SPACING);
3856             GtkWidget *hb = gtk_hbox_new(FALSE, 1);
3857             gtk_container_add (GTK_CONTAINER (hb), image);
3858             gtk_widget_show(image);
3859             gtk_box_pack_start (GTK_BOX (tbl), hb, FALSE, FALSE, 0);
3860         }
3861
3862         {
3863             GtkWidget *hb = sp_tb_spinbutton(_(""), _("Spacing between letters"),
3864                                              "tools.text", "letter_spacing", 0.0,
3865                                              us, tbl, FALSE, NULL,
3866                                              -1000.0, 1000.0, 0.1, 0.1,
3867                                              sp_text_letter_changed, 0.1, 1);
3868             gtk_widget_set_size_request (hb, 45, 6);
3869             gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, 6);
3870         }
3871     }
3872
3873     // line spacing
3874     {
3875         {
3876             GtkWidget *image = sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_TEXT_LINE_SPACING);
3877             GtkWidget *hb = gtk_hbox_new(FALSE, 1);
3878             gtk_container_add (GTK_CONTAINER (hb), image);
3879             gtk_widget_show(image);
3880             gtk_box_pack_start (GTK_BOX (tbl), hb, FALSE, FALSE, 0);
3881         }
3882
3883         {
3884             GtkWidget *hb = sp_tb_spinbutton(_(""), _("Spacing between lines"),
3885                                              "tools.text", "line_spacing", 0,
3886                                              us, tbl, FALSE, NULL,
3887                                              -1000.0, 1000.0, 0.1, 0.1,
3888                                              sp_text_line_changed, 0.1, 1);
3889             gtk_widget_set_size_request (hb, 45, 0);
3890             gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, 3);
3891         }
3892     }
3893
3894     {
3895         // horizontal kerning/vertical kerning units menu: create
3896         GtkWidget *us = sp_unit_selector_new(SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE);
3897         sp_unit_selector_setsize(us, AUX_OPTION_MENU_WIDTH, AUX_OPTION_MENU_HEIGHT);
3898         sp_unit_selector_set_unit(SP_UNIT_SELECTOR(us), desktop->namedview->doc_units);
3899
3900         aux_toolbox_space(tbl, AUX_BETWEEN_BUTTON_GROUPS);
3901
3902         // horizontal kerning
3903         {
3904             {
3905                 GtkWidget *image = sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_TEXT_HORZ_KERN);
3906                 GtkWidget *hb = gtk_hbox_new(FALSE, 1);
3907                 gtk_container_add (GTK_CONTAINER (hb), image);
3908                 gtk_widget_show(image);
3909                 gtk_box_pack_start (GTK_BOX (tbl), hb, FALSE, FALSE, 0);
3910             }
3911
3912             {
3913                 GtkWidget *hb = sp_tb_spinbutton(_(""), _("Horizontal kerning"),
3914                                                  "tools.text", "horizontal_kerning", 0,
3915                                                  us, tbl, FALSE, NULL,
3916                                                  -100.00, 100.00, 0.01, 0.1,
3917                                                  sp_text_horiz_kern_changed);
3918                 gtk_widget_set_size_request (hb, 45, 0);
3919                 gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, 6);
3920             }
3921         }
3922
3923         // vertical kerning
3924         {
3925             {
3926                 GtkWidget *image = sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_TEXT_VERT_KERN);
3927                 GtkWidget *hb = gtk_hbox_new(FALSE, 1);
3928                 gtk_container_add (GTK_CONTAINER (hb), image);
3929                 gtk_widget_show(image);
3930                 gtk_box_pack_start (GTK_BOX (tbl), hb, FALSE, FALSE, 0);
3931             }
3932
3933             {
3934                 GtkWidget *hb = sp_tb_spinbutton(_(""), _("Vertical kerning"),
3935                                                  "tools.text", "vertical_kerning", 0,
3936                                                  us, tbl, FALSE, NULL,
3937                                                  -100.00, 100.00, 0.01, 0.1,
3938                                                  sp_text_vert_kern_changed);
3939                 gtk_widget_set_size_request (hb, 45, 0);
3940                 gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, 5);
3941             }
3942         }
3943
3944         // add the units menu
3945         gtk_widget_show(us);
3946         gtk_box_pack_start(GTK_BOX(tbl), us, FALSE, FALSE, 1);
3947         gtk_object_set_data(GTK_OBJECT(tbl), "units", us);
3948     }
3949
3950     // letter rotation
3951     aux_toolbox_space(tbl, AUX_BETWEEN_BUTTON_GROUPS);
3952     {
3953         {
3954             GtkWidget *image = sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_TEXT_ROTATION);
3955             GtkWidget *hb = gtk_hbox_new(FALSE, 1);
3956             gtk_container_add (GTK_CONTAINER (hb), image);
3957             gtk_widget_show(image);
3958             gtk_box_pack_start (GTK_BOX (tbl), hb, FALSE, FALSE, 0);
3959         }
3960         {
3961             GtkWidget *hb = sp_tb_spinbutton(_(""), _("Letter rotation"),
3962                                              "tools.text", "letter_rotation", 0,
3963                                              us, tbl, FALSE, NULL,
3964                                              -180.0, 180.0, 0.1, 0.1,
3965                                              sp_text_letter_rotation_changed, 0.1, 1);
3966             gtk_widget_set_size_request (hb, 45, 0);
3967             gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, 6);
3968         }
3969         // rotation degree label
3970         {
3971             GtkWidget *label = gtk_widget_new (GTK_TYPE_LABEL, "label", "\302\260", "xalign", 0.0, NULL);
3972             gtk_box_pack_start(GTK_BOX(tbl), label, FALSE, FALSE, 0);
3973         }
3974     }
3975
3976     // Remove Manual Kerns
3977     {
3978         GtkWidget *px = sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_TEXT_REMOVE_KERNS);
3979         GtkWidget *button = gtk_button_new ();
3980         gtk_container_add (GTK_CONTAINER (button), px);
3981         gtk_widget_show(button);
3982         gtk_tooltips_set_tip (tt, button, _("Remove manual kerns"), NULL);
3983         gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
3984         gtk_widget_set_sensitive(button, TRUE);
3985         gtk_box_pack_start (GTK_BOX (tbl), button, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
3986     }
3987 #endif
3988
3989     gtk_widget_show_all (tbl);
3990     return tbl;
3991
3992 } // end of sp_text_toolbox_new()
3993
3994 }//<unnamed> namespace
3995
3996
3997 //#########################
3998 //##  Connector Toolbox  ##
3999 //#########################
4000
4001 static void sp_connector_path_set_avoid(void)
4002 {
4003     cc_selection_set_avoid(true);
4004 }
4005
4006
4007 static void sp_connector_path_set_ignore(void)
4008 {
4009     cc_selection_set_avoid(false);
4010 }
4011
4012
4013
4014 static void connector_spacing_changed(GtkAdjustment *adj, GtkWidget *tbl)
4015 {
4016     // quit if run by the _changed callbacks
4017     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
4018         return;
4019     }
4020
4021     SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl),
4022             "desktop");
4023     SPDocument *doc = sp_desktop_document(desktop);
4024
4025     if (!sp_document_get_undo_sensitive(doc))
4026     {
4027         return;
4028     }
4029
4030     // in turn, prevent callbacks from responding
4031     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE));
4032
4033     Inkscape::XML::Node *repr = SP_OBJECT_REPR(desktop->namedview);
4034
4035     sp_repr_set_css_double(repr, "inkscape:connector-spacing", adj->value);
4036     SP_OBJECT(desktop->namedview)->updateRepr();
4037
4038     GSList *items = get_avoided_items(NULL, desktop->currentRoot(), desktop);
4039     for ( GSList const *iter = items ; iter != NULL ; iter = iter->next ) {
4040         SPItem *item = reinterpret_cast<SPItem *>(iter->data);
4041         NR::Matrix m = NR::identity();
4042         avoid_item_move(&m, item);
4043     }
4044
4045     if (items) {
4046         g_slist_free(items);
4047     }
4048
4049     sp_document_done(doc, SP_VERB_CONTEXT_CONNECTOR,
4050             _("Change connector spacing"));
4051
4052     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
4053
4054     spinbutton_defocus(GTK_OBJECT(tbl));
4055 }
4056
4057 static void sp_connector_graph_layout(void)
4058 {
4059     if (!SP_ACTIVE_DESKTOP) return;
4060
4061     // hack for clones, see comment in align-and-distribute.cpp
4062     int saved_compensation = prefs_get_int_attribute("options.clonecompensation", "value", SP_CLONE_COMPENSATION_UNMOVED);
4063     prefs_set_int_attribute("options.clonecompensation", "value", SP_CLONE_COMPENSATION_UNMOVED);
4064
4065     graphlayout(sp_desktop_selection(SP_ACTIVE_DESKTOP)->itemList());
4066
4067     prefs_set_int_attribute("options.clonecompensation", "value", saved_compensation);
4068
4069     sp_document_done(sp_desktop_document(SP_ACTIVE_DESKTOP), SP_VERB_DIALOG_ALIGN_DISTRIBUTE, _("Arrange connector network"));
4070 }
4071
4072 static void
4073 sp_directed_graph_layout_toggled(GtkWidget *widget, GtkObject *tbl)
4074 {
4075     if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) {
4076         prefs_set_string_attribute("tools.connector", "directedlayout",
4077                 "true");
4078     } else {
4079         prefs_set_string_attribute("tools.connector", "directedlayout",
4080                 "false");
4081     }
4082 }
4083 static void
4084 sp_nooverlaps_graph_layout_toggled(GtkWidget *widget, GtkObject *tbl)
4085 {
4086     if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) {
4087         prefs_set_string_attribute("tools.connector", "avoidoverlaplayout",
4088                 "true");
4089     } else {
4090         prefs_set_string_attribute("tools.connector", "avoidoverlaplayout",
4091                 "false");
4092     }
4093 }
4094
4095
4096 static void connector_length_changed(GtkAdjustment *adj, GtkWidget *tbl)
4097 {
4098     prefs_set_double_attribute("tools.connector", "length", adj->value);
4099     spinbutton_defocus(GTK_OBJECT(tbl));
4100 }
4101
4102 static void connector_tb_event_attr_changed(Inkscape::XML::Node *repr,
4103         gchar const *name, gchar const *old_value, gchar const *new_value,
4104         bool is_interactive, gpointer data)
4105 {
4106     GtkWidget *tbl = GTK_WIDGET(data);
4107
4108     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
4109         return;
4110     }
4111     if (strcmp(name, "inkscape:connector-spacing") != 0) {
4112         return;
4113     }
4114
4115     GtkAdjustment *adj = (GtkAdjustment*)
4116             gtk_object_get_data(GTK_OBJECT(tbl), "spacing");
4117     gdouble spacing = defaultConnSpacing;
4118     sp_repr_get_double(repr, "inkscape:connector-spacing", &spacing);
4119
4120     gtk_adjustment_set_value(adj, spacing);
4121 }
4122
4123
4124 static Inkscape::XML::NodeEventVector connector_tb_repr_events = {
4125     NULL, /* child_added */
4126     NULL, /* child_removed */
4127     connector_tb_event_attr_changed,
4128     NULL, /* content_changed */
4129     NULL  /* order_changed */
4130 };
4131
4132
4133 static GtkWidget *
4134 sp_connector_toolbox_new(SPDesktop *desktop)
4135 {
4136     GtkTooltips *tt = gtk_tooltips_new();
4137     GtkWidget *tbl = gtk_hbox_new(FALSE, 0);
4138
4139     gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
4140     gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop);
4141
4142     gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE,
4143             AUX_BETWEEN_BUTTON_GROUPS);
4144
4145     sp_toolbox_button_new(tbl, Inkscape::ICON_SIZE_SMALL_TOOLBAR,
4146             "connector_avoid", GTK_SIGNAL_FUNC(sp_connector_path_set_avoid),
4147             tt, _("Make connectors avoid selected objects"));
4148
4149     sp_toolbox_button_new(tbl, Inkscape::ICON_SIZE_SMALL_TOOLBAR,
4150             "connector_ignore", GTK_SIGNAL_FUNC(sp_connector_path_set_ignore),
4151             tt, _("Make connectors ignore selected objects"));
4152
4153     //  interval
4154     gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE,
4155             AUX_BETWEEN_BUTTON_GROUPS);
4156
4157     // Spacing spinbox
4158     {
4159         GtkWidget *object_spacing = sp_tb_spinbutton(_("Spacing:"),
4160                 _("The amount of space left around objects by auto-routing connectors"),
4161                 "tools.connector", "spacing", 10, NULL, tbl, TRUE,
4162                 "inkscape:connector-spacing", 0, 100, 1.0, 10.0,
4163                 connector_spacing_changed, 1, 0);
4164
4165         gtk_box_pack_start(GTK_BOX(tbl), object_spacing, FALSE, FALSE,
4166                 AUX_SPACING);
4167     }
4168     // Graph (connector network) layout
4169     sp_toolbox_button_new(tbl, Inkscape::ICON_SIZE_SMALL_TOOLBAR,
4170             "graph_layout", GTK_SIGNAL_FUNC(sp_connector_graph_layout),
4171             tt, _("Nicely arrange selected connector network"));
4172     // Default connector length spinbox
4173     {
4174         GtkWidget *connector_length = sp_tb_spinbutton(_("Length:"),
4175                 _("Ideal length for connectors when layout is applied"),
4176                 "tools.connector", "length", 100, NULL, tbl, TRUE,
4177                 "inkscape:connector-length", 10, 1000, 10.0, 100.0,
4178                 connector_length_changed, 1, 0);
4179
4180         gtk_box_pack_start(GTK_BOX(tbl), connector_length, FALSE, FALSE,
4181                 AUX_SPACING);
4182     }
4183     gchar const *tbuttonstate;
4184     // Directed edges toggle button
4185     {
4186         GtkWidget *tbutton = gtk_toggle_button_new ();
4187         gtk_button_set_relief       (GTK_BUTTON (tbutton), GTK_RELIEF_NONE);
4188         gtk_container_add           (GTK_CONTAINER (tbutton), sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, "directed_graph"));
4189         gtk_toggle_button_set_mode  (GTK_TOGGLE_BUTTON (tbutton), FALSE);
4190         gtk_tooltips_set_tip(tt, tbutton, _("Make connectors with end-markers (arrows) point downwards"), NULL);
4191
4192         gtk_box_pack_start  (GTK_BOX  (tbl), tbutton, FALSE, FALSE, 0);
4193         g_signal_connect(G_OBJECT(tbutton), "toggled", GTK_SIGNAL_FUNC(sp_directed_graph_layout_toggled), tbl);
4194         tbuttonstate = prefs_get_string_attribute("tools.connector", "directedlayout");
4195         gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(tbutton),
4196                 (tbuttonstate && !strcmp(tbuttonstate, "true"))?TRUE:FALSE );
4197     }
4198     // Avoid overlaps toggle button
4199     {
4200         GtkWidget *tbutton = gtk_toggle_button_new ();
4201         gtk_button_set_relief       (GTK_BUTTON (tbutton), GTK_RELIEF_NONE);
4202         gtk_container_add           (GTK_CONTAINER (tbutton), sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, "remove_overlaps"));
4203         gtk_toggle_button_set_mode  (GTK_TOGGLE_BUTTON (tbutton), FALSE);
4204         gtk_tooltips_set_tip(tt, tbutton, _("Do not allow overlapping shapes"), NULL);
4205
4206         gtk_box_pack_start  (GTK_BOX  (tbl), tbutton, FALSE, FALSE, 0);
4207         g_signal_connect(G_OBJECT(tbutton), "toggled", GTK_SIGNAL_FUNC(sp_nooverlaps_graph_layout_toggled), tbl);
4208         tbuttonstate = prefs_get_string_attribute("tools.connector", "avoidoverlaplayout");
4209         gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(tbutton),
4210                 (tbuttonstate && !strcmp(tbuttonstate, "true"))?TRUE:FALSE );
4211     }
4212
4213     gtk_widget_show_all(tbl);
4214     sp_set_font_size_smaller (tbl);
4215
4216     // Code to watch for changes to the connector-spacing attribute in
4217     // the XML.
4218     Inkscape::XML::Node *repr = SP_OBJECT_REPR(desktop->namedview);
4219     g_assert(repr != NULL);
4220
4221     Inkscape::XML::Node *oldrepr = (Inkscape::XML::Node *)
4222             gtk_object_get_data(GTK_OBJECT(tbl), "repr");
4223
4224     if (oldrepr) { // remove old listener
4225         sp_repr_remove_listener_by_data(oldrepr, tbl);
4226         Inkscape::GC::release(oldrepr);
4227         oldrepr = NULL;
4228         g_object_set_data(G_OBJECT(tbl), "repr", NULL);
4229     }
4230
4231     if (repr) {
4232         g_object_set_data(G_OBJECT(tbl), "repr", repr);
4233         Inkscape::GC::anchor(repr);
4234         sp_repr_add_listener(repr, &connector_tb_repr_events, tbl);
4235         sp_repr_synthesize_events(repr, &connector_tb_repr_events, tbl);
4236     }
4237
4238     return tbl;
4239
4240 } // end of sp_connector_toolbox_new()
4241
4242 static void paintbucket_threshold_changed(GtkAdjustment *adj, GtkWidget *tbl)
4243 {
4244     prefs_set_int_attribute("tools.paintbucket", "threshold", (gint)adj->value);
4245     spinbutton_defocus(GTK_OBJECT(tbl));
4246 }
4247
4248 static void paintbucket_offset_changed(GtkAdjustment *adj, GtkWidget *tbl)
4249 {
4250     GtkWidget *us = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(tbl), "units");
4251     SPUnit const *unit = sp_unit_selector_get_unit(SP_UNIT_SELECTOR(us));
4252
4253     prefs_set_double_attribute("tools.paintbucket", "offset", (gdouble)sp_units_get_pixels(adj->value, *unit));
4254     spinbutton_defocus(GTK_OBJECT(tbl));
4255 }
4256
4257 static GtkWidget *
4258 sp_paintbucket_toolbox_new(SPDesktop *desktop)
4259 {
4260     GtkWidget *tbl = gtk_hbox_new(FALSE, 0);
4261
4262     //  interval
4263     gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
4264
4265     {
4266       sp_toolbox_add_label(tbl, _("Fill by:"), false);
4267
4268       GtkWidget *channels = gtk_combo_box_new_text();
4269
4270       GList *items = flood_channels_dropdown_items_list();
4271
4272       for ( ; items ; items = items->next )
4273       {
4274           gtk_combo_box_append_text(GTK_COMBO_BOX(channels), (char*)items->data);
4275       }
4276
4277       gtk_combo_box_set_active (GTK_COMBO_BOX(channels), prefs_get_int_attribute("tools.paintbucket", "channels", 0));
4278       gtk_box_pack_start (GTK_BOX (tbl), channels, FALSE, FALSE, 0);
4279       g_signal_connect (G_OBJECT (channels), "changed", G_CALLBACK (flood_channels_changed), tbl);
4280     }
4281
4282     //  interval
4283     gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
4284
4285     // Spacing spinbox
4286     {
4287         GtkWidget *threshold = sp_tb_spinbutton(_("Threshold:"),
4288                 _("The maximum allowed difference between the clicked pixel and the neighboring pixels to be counted in the fill"),
4289                 "tools.paintbucket", "threshold", 5, NULL, tbl, TRUE,
4290                 "inkscape:paintbucket-threshold", 0, 100, 1.0, 10.0,
4291                 paintbucket_threshold_changed, 1, 0);
4292
4293         gtk_box_pack_start(GTK_BOX(tbl), threshold, FALSE, FALSE,
4294                 AUX_SPACING);
4295     }
4296
4297     //  interval
4298     gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
4299
4300     // Create the units menu.
4301     GtkWidget *us = sp_unit_selector_new(SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE);
4302     sp_unit_selector_setsize(us, AUX_OPTION_MENU_WIDTH, AUX_OPTION_MENU_HEIGHT);
4303     sp_unit_selector_set_unit (SP_UNIT_SELECTOR(us), sp_desktop_namedview(desktop)->doc_units);
4304
4305     // Offset spinbox
4306     {
4307         GtkWidget *offset = sp_tb_spinbutton(_("Grow/shrink by:"),
4308                 _("The amount to grow (positive) or shrink (negative) the created fill path"),
4309                 "tools.paintbucket", "offset", 0, us, tbl, TRUE,
4310                 "inkscape:paintbucket-offset", -1e6, 1e6, 0.1, 0.5,
4311                 paintbucket_offset_changed, 1, 2);
4312
4313         gtk_box_pack_start(GTK_BOX(tbl), offset, FALSE, FALSE,
4314                 AUX_SPACING);
4315
4316         gtk_box_pack_start(GTK_BOX(tbl), us, FALSE, FALSE, AUX_SPACING);
4317         gtk_object_set_data(GTK_OBJECT(tbl), "units", us);
4318     }
4319
4320     Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL, _("Style of Paint Bucket fill objects"));
4321     swatch->setDesktop (desktop);
4322     swatch->setClickVerb (SP_VERB_CONTEXT_PAINTBUCKET_PREFS);
4323     swatch->setWatchedTool ("tools.paintbucket", true);
4324     GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj());
4325     gtk_box_pack_end(GTK_BOX(tbl), swatch_, FALSE, FALSE, 0);
4326
4327     gtk_widget_show_all(tbl);
4328     sp_set_font_size_smaller (tbl);
4329     return tbl;
4330 }
4331
4332 /*
4333   Local Variables:
4334   mode:c++
4335   c-file-style:"stroustrup"
4336   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
4337   indent-tabs-mode:nil
4338   fill-column:99
4339   End:
4340 */
4341 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :
4342