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