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