src/widgets/toolbox.cpp

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