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