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