src/widgets/toolbox.cpp

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