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