src/widgets/toolbox.cpp

   1 /** @file
   2  * @brief Controls bars for some of Inkscape's tools (for some tools,
   3  * they are in their own files)
   4  */
   5 /* Authors:
   6  *   MenTaLguY <mental@rydia.net>
   7  *   Lauris Kaplinski <lauris@kaplinski.com>
   8  *   bulia byak <buliabyak@users.sf.net>
   9  *   Frank Felfe <innerspace@iname.com>
  10  *   John Cliff <simarilius@yahoo.com>
  11  *   David Turner <novalis@gnu.org>
  12  *   Josh Andler <scislac@scislac.com>
  13  *   Jon A. Cruz <jon@joncruz.org>
  14  *   Maximilian Albert <maximilian.albert@gmail.com>
  15  *   Tavmjong Bah <tavmjong@free.fr>
  16  *
  17  * Copyright (C) 2004 David Turner
  18  * Copyright (C) 2003 MenTaLguY
  19  * Copyright (C) 1999-2010 authors
  20  * Copyright (C) 2001-2002 Ximian, Inc.
  21  *
  22  * Released under GNU GPL, read the file 'COPYING' for more information
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 # include "config.h"
  27 #endif
  28
  29 #include <cstring>
  30 #include <string>
  31
  32 #include <gtkmm.h>
  33 #include <gtk/gtk.h>
  34 #include <iostream>
  35 #include <sstream>
  36 #include <glibmm/i18n.h>
  37
  38 #include "../box3d-context.h"
  39 #include "../box3d.h"
  40 #include "../conn-avoid-ref.h"
  41 #include "../connection-pool.h"
  42 #include "../connector-context.h"
  43 #include "../desktop.h"
  44 #include "../desktop-handles.h"
  45 #include "../desktop-style.h"
  46 #include "../dialogs/dialog-events.h"
  47 #include "../dialogs/text-edit.h"
  48 #include "../document-private.h"
  49 #include "../ege-adjustment-action.h"
  50 #include "../ege-output-action.h"
  51 #include "../ege-select-one-action.h"
  52 #include "../flood-context.h"
  53 #include "gradient-toolbar.h"
  54 #include "../graphlayout.h"
  55 #include "../helper/unit-menu.h"
  56 #include "../helper/units.h"
  57 #include "../helper/unit-tracker.h"
  58 #include "icon.h"
  59 #include "../ink-action.h"
  60 #include "../ink-comboboxentry-action.h"
  61 #include "../inkscape.h"
  62 #include "../interface.h"
  63 #include "../libnrtype/font-instance.h"
  64 #include "../libnrtype/font-lister.h"
  65 #include "../live_effects/effect.h"
  66 #include "../live_effects/lpe-angle_bisector.h"
  67 #include "../live_effects/lpe-line_segment.h"
  68 #include "../lpe-tool-context.h"
  69 #include "../mod360.h"
  70 #include "../pen-context.h"
  71 #include "../preferences.h"
  72 #include "../selection-chemistry.h"
  73 #include "../selection.h"
  74 #include "select-toolbar.h"
  75 #include "../shape-editor.h"
  76 #include "../shortcuts.h"
  77 #include "../sp-clippath.h"
  78 #include "../sp-ellipse.h"
  79 #include "../sp-flowtext.h"
  80 #include "../sp-mask.h"
  81 #include "../sp-namedview.h"
  82 #include "../sp-rect.h"
  83 #include "../sp-spiral.h"
  84 #include "../sp-star.h"
  85 #include "../sp-text.h"
  86 #include "../style.h"
  87 #include "../svg/css-ostringstream.h"
  88 #include "../text-context.h"
  89 #include "../text-editing.h"
  90 #include "../tools-switch.h"
  91 #include "../tweak-context.h"
  92 #include "../spray-context.h"
  93 #include "../ui/dialog/calligraphic-profile-rename.h"
  94 #include "../ui/icon-names.h"
  95 #include "../ui/tool/control-point-selection.h"
  96 #include "../ui/tool/node-tool.h"
  97 #include "../ui/tool/multi-path-manipulator.h"
  98 #include "../ui/widget/style-swatch.h"
  99 #include "../verbs.h"
 100 #include "../widgets/button.h"
 101 #include "../widgets/spinbutton-events.h"
 102 #include "../widgets/spw-utilities.h"
 103 #include "../widgets/widget-sizes.h"
 104 #include "../xml/attribute-record.h"
 105 #include "../xml/node-event-vector.h"
 106 #include "../xml/repr.h"
 107 #include "ui/uxmanager.h"
 108
 109 #include "toolbox.h"
 110
 111 //#define DEBUG_TEXT
 112
 113 using Inkscape::UnitTracker;
 114 using Inkscape::UI::UXManager;
 115
 116 typedef void (*SetupFunction)(GtkWidget *toolbox, SPDesktop *desktop);
 117 typedef void (*UpdateFunction)(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox);
 118
 119 enum BarId {
 120     BAR_TOOL = 0,
 121     BAR_AUX,
 122     BAR_COMMANDS,
 123     BAR_SNAP,
 124 };
 125
 126 #define BAR_ID_KEY "BarIdValue"
 127 #define HANDLE_POS_MARK "x-inkscape-pos"
 128
 129 static void       sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 130 static void       sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 131 static void       sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 132 static void       sp_zoom_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 133 static void       sp_star_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 134 static void       sp_arc_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 135 static void       sp_rect_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 136 static void       box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 137 static void       sp_spiral_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 138 static void       sp_pencil_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 139 static void       sp_pen_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 140 static void       sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 141 static void       sp_dropper_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 142 static GtkWidget *sp_empty_toolbox_new(SPDesktop *desktop);
 143 static void       sp_connector_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 144 static void       sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 145 static void       sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 146 static void       sp_text_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 147 static void       sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 148
 149 using Inkscape::UI::ToolboxFactory;
 150
 151
 152 Inkscape::IconSize ToolboxFactory::prefToSize( Glib::ustring const &path, int base ) {
 153     static Inkscape::IconSize sizeChoices[] = {
 154         Inkscape::ICON_SIZE_LARGE_TOOLBAR,
 155         Inkscape::ICON_SIZE_SMALL_TOOLBAR,
 156         Inkscape::ICON_SIZE_MENU
 157     };
 158     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 159     int index = prefs->getIntLimited( path, base, 0, G_N_ELEMENTS(sizeChoices) );
 160     return sizeChoices[index];
 161 }
 162
 163 static struct {
 164     gchar const *type_name;
 165     gchar const *data_name;
 166     sp_verb_t verb;
 167     sp_verb_t doubleclick_verb;
 168 } const tools[] = {
 169     { "SPSelectContext",   "select_tool",    SP_VERB_CONTEXT_SELECT,  SP_VERB_CONTEXT_SELECT_PREFS},
 170     { "InkNodeTool",     "node_tool",      SP_VERB_CONTEXT_NODE, SP_VERB_CONTEXT_NODE_PREFS },
 171     { "SPTweakContext",    "tweak_tool",     SP_VERB_CONTEXT_TWEAK, SP_VERB_CONTEXT_TWEAK_PREFS },
 172     { "SPSprayContext",    "spray_tool",     SP_VERB_CONTEXT_SPRAY, SP_VERB_CONTEXT_SPRAY_PREFS },
 173     { "SPZoomContext",     "zoom_tool",      SP_VERB_CONTEXT_ZOOM, SP_VERB_CONTEXT_ZOOM_PREFS },
 174     { "SPRectContext",     "rect_tool",      SP_VERB_CONTEXT_RECT, SP_VERB_CONTEXT_RECT_PREFS },
 175     { "Box3DContext",      "3dbox_tool",     SP_VERB_CONTEXT_3DBOX, SP_VERB_CONTEXT_3DBOX_PREFS },
 176     { "SPArcContext",      "arc_tool",       SP_VERB_CONTEXT_ARC, SP_VERB_CONTEXT_ARC_PREFS },
 177     { "SPStarContext",     "star_tool",      SP_VERB_CONTEXT_STAR, SP_VERB_CONTEXT_STAR_PREFS },
 178     { "SPSpiralContext",   "spiral_tool",    SP_VERB_CONTEXT_SPIRAL, SP_VERB_CONTEXT_SPIRAL_PREFS },
 179     { "SPPencilContext",   "pencil_tool",    SP_VERB_CONTEXT_PENCIL, SP_VERB_CONTEXT_PENCIL_PREFS },
 180     { "SPPenContext",      "pen_tool",       SP_VERB_CONTEXT_PEN, SP_VERB_CONTEXT_PEN_PREFS },
 181     { "SPDynaDrawContext", "dyna_draw_tool", SP_VERB_CONTEXT_CALLIGRAPHIC, SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS },
 182     { "SPLPEToolContext",  "lpetool_tool",   SP_VERB_CONTEXT_LPETOOL, SP_VERB_CONTEXT_LPETOOL_PREFS },
 183     { "SPEraserContext",   "eraser_tool",    SP_VERB_CONTEXT_ERASER, SP_VERB_CONTEXT_ERASER_PREFS },
 184     { "SPFloodContext",    "paintbucket_tool",     SP_VERB_CONTEXT_PAINTBUCKET, SP_VERB_CONTEXT_PAINTBUCKET_PREFS },
 185     { "SPTextContext",     "text_tool",      SP_VERB_CONTEXT_TEXT, SP_VERB_CONTEXT_TEXT_PREFS },
 186     { "SPConnectorContext","connector_tool", SP_VERB_CONTEXT_CONNECTOR, SP_VERB_CONTEXT_CONNECTOR_PREFS },
 187     { "SPGradientContext", "gradient_tool",  SP_VERB_CONTEXT_GRADIENT, SP_VERB_CONTEXT_GRADIENT_PREFS },
 188     { "SPDropperContext",  "dropper_tool",   SP_VERB_CONTEXT_DROPPER, SP_VERB_CONTEXT_DROPPER_PREFS },
 189     { NULL, NULL, 0, 0 }
 190 };
 191
 192 static struct {
 193     gchar const *type_name;
 194     gchar const *data_name;
 195     GtkWidget *(*create_func)(SPDesktop *desktop);
 196     void (*prep_func)(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder);
 197     gchar const *ui_name;
 198     gint swatch_verb_id;
 199     gchar const *swatch_tool;
 200     gchar const *swatch_tip;
 201 } const aux_toolboxes[] = {
 202     { "SPSelectContext", "select_toolbox", 0, sp_select_toolbox_prep,            "SelectToolbar",
 203       SP_VERB_INVALID, 0, 0},
 204     { "InkNodeTool",   "node_toolbox",   0, sp_node_toolbox_prep,              "NodeToolbar",
 205       SP_VERB_INVALID, 0, 0},
 206     { "SPTweakContext",   "tweak_toolbox",   0, sp_tweak_toolbox_prep,              "TweakToolbar",
 207       SP_VERB_CONTEXT_TWEAK_PREFS, "/tools/tweak", N_("Color/opacity used for color tweaking")},
 208     { "SPSprayContext",   "spray_toolbox",   0, sp_spray_toolbox_prep,              "SprayToolbar",
 209       SP_VERB_INVALID, 0, 0},
 210     { "SPZoomContext",   "zoom_toolbox",   0, sp_zoom_toolbox_prep,              "ZoomToolbar",
 211       SP_VERB_INVALID, 0, 0},
 212     { "SPStarContext",   "star_toolbox",   0, sp_star_toolbox_prep,              "StarToolbar",
 213       SP_VERB_CONTEXT_STAR_PREFS,   "/tools/shapes/star",     N_("Style of new stars")},
 214     { "SPRectContext",   "rect_toolbox",   0, sp_rect_toolbox_prep,              "RectToolbar",
 215       SP_VERB_CONTEXT_RECT_PREFS,   "/tools/shapes/rect",     N_("Style of new rectangles")},
 216     { "Box3DContext",  "3dbox_toolbox",  0, box3d_toolbox_prep,             "3DBoxToolbar",
 217       SP_VERB_CONTEXT_3DBOX_PREFS,  "/tools/shapes/3dbox",    N_("Style of new 3D boxes")},
 218     { "SPArcContext",    "arc_toolbox",    0, sp_arc_toolbox_prep,               "ArcToolbar",
 219       SP_VERB_CONTEXT_ARC_PREFS,    "/tools/shapes/arc",      N_("Style of new ellipses")},
 220     { "SPSpiralContext", "spiral_toolbox", 0, sp_spiral_toolbox_prep,            "SpiralToolbar",
 221       SP_VERB_CONTEXT_SPIRAL_PREFS, "/tools/shapes/spiral",   N_("Style of new spirals")},
 222     { "SPPencilContext", "pencil_toolbox", 0, sp_pencil_toolbox_prep,            "PencilToolbar",
 223       SP_VERB_CONTEXT_PENCIL_PREFS, "/tools/freehand/pencil", N_("Style of new paths created by Pencil")},
 224     { "SPPenContext", "pen_toolbox", 0, sp_pen_toolbox_prep,                     "PenToolbar",
 225       SP_VERB_CONTEXT_PEN_PREFS,    "/tools/freehand/pen",    N_("Style of new paths created by Pen")},
 226     { "SPDynaDrawContext", "calligraphy_toolbox", 0, sp_calligraphy_toolbox_prep,"CalligraphyToolbar",
 227       SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS, "/tools/calligraphic", N_("Style of new calligraphic strokes")},
 228     { "SPEraserContext", "eraser_toolbox", 0, sp_eraser_toolbox_prep,"EraserToolbar",
 229       SP_VERB_CONTEXT_ERASER_PREFS, "/tools/eraser", _("TBD")},
 230     { "SPLPEToolContext", "lpetool_toolbox", 0, sp_lpetool_toolbox_prep, "LPEToolToolbar",
 231       SP_VERB_CONTEXT_LPETOOL_PREFS, "/tools/lpetool", _("TBD")},
 232     { "SPTextContext",   "text_toolbox",   0, sp_text_toolbox_prep, "TextToolbar",
 233       SP_VERB_INVALID, 0, 0},
 234     { "SPDropperContext", "dropper_toolbox", 0, sp_dropper_toolbox_prep,         "DropperToolbar",
 235       SP_VERB_INVALID, 0, 0},
 236     { "SPGradientContext", "gradient_toolbox", sp_gradient_toolbox_new, 0,       0,
 237       SP_VERB_INVALID, 0, 0},
 238     { "SPConnectorContext", "connector_toolbox", 0, sp_connector_toolbox_prep,   "ConnectorToolbar",
 239       SP_VERB_INVALID, 0, 0},
 240     { "SPFloodContext",  "paintbucket_toolbox",  0, sp_paintbucket_toolbox_prep, "PaintbucketToolbar",
 241       SP_VERB_CONTEXT_PAINTBUCKET_PREFS, "/tools/paintbucket", N_("Style of Paint Bucket fill objects")},
 242     { NULL, NULL, NULL, NULL, NULL, SP_VERB_INVALID, NULL, NULL }
 243 };
 244
 245 #define TOOLBAR_SLIDER_HINT "full"
 246
 247 static gchar const * ui_descr =
 248         "<ui>"
 249         "  <toolbar name='SelectToolbar'>"
 250         "    <toolitem action='EditSelectAll' />"
 251         "    <toolitem action='EditSelectAllInAllLayers' />"
 252         "    <toolitem action='EditDeselect' />"
 253         "    <separator />"
 254         "    <toolitem action='ObjectRotate90CCW' />"
 255         "    <toolitem action='ObjectRotate90' />"
 256         "    <toolitem action='ObjectFlipHorizontally' />"
 257         "    <toolitem action='ObjectFlipVertically' />"
 258         "    <separator />"
 259         "    <toolitem action='SelectionToBack' />"
 260         "    <toolitem action='SelectionLower' />"
 261         "    <toolitem action='SelectionRaise' />"
 262         "    <toolitem action='SelectionToFront' />"
 263         "    <separator />"
 264         "    <toolitem action='XAction' />"
 265         "    <toolitem action='YAction' />"
 266         "    <toolitem action='WidthAction' />"
 267         "    <toolitem action='LockAction' />"
 268         "    <toolitem action='HeightAction' />"
 269         "    <toolitem action='UnitsAction' />"
 270         "    <separator />"
 271         "    <toolitem action='transform_affect_label' />"
 272         "    <toolitem action='transform_stroke' />"
 273         "    <toolitem action='transform_corners' />"
 274         "    <toolitem action='transform_gradient' />"
 275         "    <toolitem action='transform_pattern' />"
 276         "  </toolbar>"
 277
 278         "  <toolbar name='NodeToolbar'>"
 279         "    <separator />"
 280         "    <toolitem action='NodeInsertAction' />"
 281         "    <toolitem action='NodeDeleteAction' />"
 282         "    <separator />"
 283         "    <toolitem action='NodeJoinAction' />"
 284         "    <toolitem action='NodeBreakAction' />"
 285         "    <separator />"
 286         "    <toolitem action='NodeJoinSegmentAction' />"
 287         "    <toolitem action='NodeDeleteSegmentAction' />"
 288         "    <separator />"
 289         "    <toolitem action='NodeCuspAction' />"
 290         "    <toolitem action='NodeSmoothAction' />"
 291         "    <toolitem action='NodeSymmetricAction' />"
 292         "    <toolitem action='NodeAutoAction' />"
 293         "    <separator />"
 294         "    <toolitem action='NodeLineAction' />"
 295         "    <toolitem action='NodeCurveAction' />"
 296         "    <separator />"
 297         "    <toolitem action='ObjectToPath' />"
 298         "    <toolitem action='StrokeToPath' />"
 299         "    <separator />"
 300         "    <toolitem action='NodeXAction' />"
 301         "    <toolitem action='NodeYAction' />"
 302         "    <toolitem action='NodeUnitsAction' />"
 303         "    <separator />"
 304         "    <toolitem action='ObjectEditClipPathAction' />"
 305         "    <toolitem action='ObjectEditMaskPathAction' />"
 306         "    <toolitem action='EditNextLPEParameterAction' />"
 307         "    <separator />"
 308         "    <toolitem action='NodesShowTransformHandlesAction' />"
 309         "    <toolitem action='NodesShowHandlesAction' />"
 310         "    <toolitem action='NodesShowHelperpath' />"
 311         "  </toolbar>"
 312
 313         "  <toolbar name='TweakToolbar'>"
 314         "    <toolitem action='TweakWidthAction' />"
 315         "    <separator />"
 316         "    <toolitem action='TweakForceAction' />"
 317         "    <toolitem action='TweakPressureAction' />"
 318         "    <separator />"
 319         "    <toolitem action='TweakModeAction' />"
 320         "    <separator />"
 321         "    <toolitem action='TweakFidelityAction' />"
 322         "    <separator />"
 323         "    <toolitem action='TweakChannelsLabel' />"
 324         "    <toolitem action='TweakDoH' />"
 325         "    <toolitem action='TweakDoS' />"
 326         "    <toolitem action='TweakDoL' />"
 327         "    <toolitem action='TweakDoO' />"
 328         "  </toolbar>"
 329
 330         "  <toolbar name='SprayToolbar'>"
 331         "    <toolitem action='SprayModeAction' />"
 332         "    <separator />"
 333         "    <separator />"
 334         "    <toolitem action='SprayWidthAction' />"
 335         "    <toolitem action='SprayPressureAction' />"
 336         "    <toolitem action='SprayPopulationAction' />"
 337         "    <separator />"
 338         "    <toolitem action='SprayRotationAction' />"
 339         "    <toolitem action='SprayScaleAction' />"
 340         "    <separator />"
 341         "    <toolitem action='SprayStandard_deviationAction' />"
 342         "    <toolitem action='SprayMeanAction' />"
 343         "  </toolbar>"
 344
 345         "  <toolbar name='ZoomToolbar'>"
 346         "    <toolitem action='ZoomIn' />"
 347         "    <toolitem action='ZoomOut' />"
 348         "    <separator />"
 349         "    <toolitem action='Zoom1:0' />"
 350         "    <toolitem action='Zoom1:2' />"
 351         "    <toolitem action='Zoom2:1' />"
 352         "    <separator />"
 353         "    <toolitem action='ZoomSelection' />"
 354         "    <toolitem action='ZoomDrawing' />"
 355         "    <toolitem action='ZoomPage' />"
 356         "    <toolitem action='ZoomPageWidth' />"
 357         "    <separator />"
 358         "    <toolitem action='ZoomPrev' />"
 359         "    <toolitem action='ZoomNext' />"
 360         "  </toolbar>"
 361
 362         "  <toolbar name='StarToolbar'>"
 363         "    <separator />"
 364         "    <toolitem action='StarStateAction' />"
 365         "    <separator />"
 366         "    <toolitem action='FlatAction' />"
 367         "    <separator />"
 368         "    <toolitem action='MagnitudeAction' />"
 369         "    <toolitem action='SpokeAction' />"
 370         "    <toolitem action='RoundednessAction' />"
 371         "    <toolitem action='RandomizationAction' />"
 372         "    <separator />"
 373         "    <toolitem action='StarResetAction' />"
 374         "  </toolbar>"
 375
 376         "  <toolbar name='RectToolbar'>"
 377         "    <toolitem action='RectStateAction' />"
 378         "    <toolitem action='RectWidthAction' />"
 379         "    <toolitem action='RectHeightAction' />"
 380         "    <toolitem action='RadiusXAction' />"
 381         "    <toolitem action='RadiusYAction' />"
 382         "    <toolitem action='RectUnitsAction' />"
 383         "    <separator />"
 384         "    <toolitem action='RectResetAction' />"
 385         "  </toolbar>"
 386
 387         "  <toolbar name='3DBoxToolbar'>"
 388         "    <toolitem action='3DBoxAngleXAction' />"
 389         "    <toolitem action='3DBoxVPXStateAction' />"
 390         "    <separator />"
 391         "    <toolitem action='3DBoxAngleYAction' />"
 392         "    <toolitem action='3DBoxVPYStateAction' />"
 393         "    <separator />"
 394         "    <toolitem action='3DBoxAngleZAction' />"
 395         "    <toolitem action='3DBoxVPZStateAction' />"
 396         "  </toolbar>"
 397
 398         "  <toolbar name='SpiralToolbar'>"
 399         "    <toolitem action='SpiralStateAction' />"
 400         "    <toolitem action='SpiralRevolutionAction' />"
 401         "    <toolitem action='SpiralExpansionAction' />"
 402         "    <toolitem action='SpiralT0Action' />"
 403         "    <separator />"
 404         "    <toolitem action='SpiralResetAction' />"
 405         "  </toolbar>"
 406
 407         "  <toolbar name='PenToolbar'>"
 408         "    <toolitem action='FreehandModeActionPen' />"
 409         "    <separator />"
 410         "    <toolitem action='SetPenShapeAction'/>"
 411         "  </toolbar>"
 412
 413         "  <toolbar name='PencilToolbar'>"
 414         "    <toolitem action='FreehandModeActionPencil' />"
 415         "    <separator />"
 416         "    <toolitem action='PencilToleranceAction' />"
 417         "    <separator />"
 418         "    <toolitem action='PencilResetAction' />"
 419         "    <separator />"
 420         "    <toolitem action='SetPencilShapeAction'/>"
 421         "  </toolbar>"
 422
 423         "  <toolbar name='CalligraphyToolbar'>"
 424         "    <separator />"
 425         "    <toolitem action='SetProfileAction'/>"
 426         "    <separator />"
 427         "    <toolitem action='CalligraphyWidthAction' />"
 428         "    <toolitem action='PressureAction' />"
 429         "    <toolitem action='TraceAction' />"
 430         "    <toolitem action='ThinningAction' />"
 431         "    <separator />"
 432         "    <toolitem action='AngleAction' />"
 433         "    <toolitem action='TiltAction' />"
 434         "    <toolitem action='FixationAction' />"
 435         "    <separator />"
 436         "    <toolitem action='CapRoundingAction' />"
 437         "    <separator />"
 438         "    <toolitem action='TremorAction' />"
 439         "    <toolitem action='WiggleAction' />"
 440         "    <toolitem action='MassAction' />"
 441         "    <separator />"
 442         "  </toolbar>"
 443
 444         "  <toolbar name='ArcToolbar'>"
 445         "    <toolitem action='ArcStateAction' />"
 446         "    <separator />"
 447         "    <toolitem action='ArcStartAction' />"
 448         "    <toolitem action='ArcEndAction' />"
 449         "    <separator />"
 450         "    <toolitem action='ArcOpenAction' />"
 451         "    <separator />"
 452         "    <toolitem action='ArcResetAction' />"
 453         "    <separator />"
 454         "  </toolbar>"
 455
 456         "  <toolbar name='PaintbucketToolbar'>"
 457         "    <toolitem action='ChannelsAction' />"
 458         "    <separator />"
 459         "    <toolitem action='ThresholdAction' />"
 460         "    <separator />"
 461         "    <toolitem action='OffsetAction' />"
 462         "    <toolitem action='PaintbucketUnitsAction' />"
 463         "    <separator />"
 464         "    <toolitem action='AutoGapAction' />"
 465         "    <separator />"
 466         "    <toolitem action='PaintbucketResetAction' />"
 467         "  </toolbar>"
 468
 469         "  <toolbar name='EraserToolbar'>"
 470         "    <toolitem action='EraserWidthAction' />"
 471         "    <separator />"
 472         "    <toolitem action='EraserModeAction' />"
 473         "  </toolbar>"
 474
 475         "  <toolbar name='TextToolbar'>"
 476         "    <toolitem action='TextFontFamilyAction' />"
 477         "    <toolitem action='TextFontSizeAction' />"
 478         "    <toolitem action='TextBoldAction' />"
 479         "    <toolitem action='TextItalicAction' />"
 480         "    <separator />"
 481         "    <toolitem action='TextAlignAction' />"
 482         "    <separator />"
 483         "    <toolitem action='TextSuperscriptAction' />"
 484         "    <toolitem action='TextSubscriptAction' />"
 485         "    <separator />"
 486         "    <toolitem action='TextLineHeightAction' />"
 487         "    <toolitem action='TextLetterSpacingAction' />"
 488         "    <toolitem action='TextWordSpacingAction' />"
 489         "    <toolitem action='TextDxAction' />"
 490         "    <toolitem action='TextDyAction' />"
 491         "    <toolitem action='TextRotationAction' />"
 492         "    <separator />"
 493         "    <toolitem action='TextOrientationAction' />"
 494         "  </toolbar>"
 495
 496         "  <toolbar name='LPEToolToolbar'>"
 497         "    <toolitem action='LPEToolModeAction' />"
 498         "    <separator />"
 499         "    <toolitem action='LPEShowBBoxAction' />"
 500         "    <toolitem action='LPEBBoxFromSelectionAction' />"
 501         "    <separator />"
 502         "    <toolitem action='LPELineSegmentAction' />"
 503         "    <separator />"
 504         "    <toolitem action='LPEMeasuringAction' />"
 505         "    <toolitem action='LPEToolUnitsAction' />"
 506         "    <separator />"
 507         "    <toolitem action='LPEOpenLPEDialogAction' />"
 508         "  </toolbar>"
 509
 510         "  <toolbar name='DropperToolbar'>"
 511         "    <toolitem action='DropperOpacityAction' />"
 512         "    <toolitem action='DropperPickAlphaAction' />"
 513         "    <toolitem action='DropperSetAlphaAction' />"
 514         "  </toolbar>"
 515
 516         "  <toolbar name='ConnectorToolbar'>"
 517 //        "    <toolitem action='ConnectorEditModeAction' />"
 518         "    <toolitem action='ConnectorAvoidAction' />"
 519         "    <toolitem action='ConnectorIgnoreAction' />"
 520         "    <toolitem action='ConnectorOrthogonalAction' />"
 521         "    <toolitem action='ConnectorCurvatureAction' />"
 522         "    <toolitem action='ConnectorSpacingAction' />"
 523         "    <toolitem action='ConnectorGraphAction' />"
 524         "    <toolitem action='ConnectorLengthAction' />"
 525         "    <toolitem action='ConnectorDirectedAction' />"
 526         "    <toolitem action='ConnectorOverlapAction' />"
 527 //        "    <toolitem action='ConnectorNewConnPointAction' />"
 528 //        "    <toolitem action='ConnectorRemoveConnPointAction' />"
 529         "  </toolbar>"
 530
 531         "</ui>"
 532 ;
 533
 534 static Glib::RefPtr<Gtk::ActionGroup> create_or_fetch_actions( SPDesktop* desktop );
 535
 536 static void setup_snap_toolbox(GtkWidget *toolbox, SPDesktop *desktop);
 537
 538 static void setup_tool_toolbox(GtkWidget *toolbox, SPDesktop *desktop);
 539 static void update_tool_toolbox(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox);
 540
 541 static void setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop);
 542 static void update_aux_toolbox(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox);
 543
 544 static void setup_commands_toolbox(GtkWidget *toolbox, SPDesktop *desktop);
 545 static void update_commands_toolbox(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox);
 546
 547 static GtkWidget * sp_toolbox_button_new_from_verb_with_doubleclick( GtkWidget *t, Inkscape::IconSize size, SPButtonType type,
 548                                                                      Inkscape::Verb *verb, Inkscape::Verb *doubleclick_verb,
 549                                                                      Inkscape::UI::View::View *view, GtkTooltips *tt);
 550
 551 class VerbAction : public Gtk::Action {
 552 public:
 553     static Glib::RefPtr<VerbAction> create(Inkscape::Verb* verb, Inkscape::Verb* verb2, Inkscape::UI::View::View *view, GtkTooltips *tooltips);
 554
 555     virtual ~VerbAction();
 556     virtual void set_active(bool active = true);
 557
 558 protected:
 559     virtual Gtk::Widget* create_menu_item_vfunc();
 560     virtual Gtk::Widget* create_tool_item_vfunc();
 561
 562     virtual void connect_proxy_vfunc(Gtk::Widget* proxy);
 563     virtual void disconnect_proxy_vfunc(Gtk::Widget* proxy);
 564
 565     virtual void on_activate();
 566
 567 private:
 568     Inkscape::Verb* verb;
 569     Inkscape::Verb* verb2;
 570     Inkscape::UI::View::View *view;
 571     GtkTooltips *tooltips;
 572     bool active;
 573
 574     VerbAction(Inkscape::Verb* verb, Inkscape::Verb* verb2, Inkscape::UI::View::View *view, GtkTooltips *tooltips);
 575 };
 576
 577
 578 Glib::RefPtr<VerbAction> VerbAction::create(Inkscape::Verb* verb, Inkscape::Verb* verb2, Inkscape::UI::View::View *view, GtkTooltips *tooltips)
 579 {
 580     Glib::RefPtr<VerbAction> result;
 581     SPAction *action = verb->get_action(view);
 582     if ( action ) {
 583         //SPAction* action2 = verb2 ? verb2->get_action(view) : 0;
 584         result = Glib::RefPtr<VerbAction>(new VerbAction(verb, verb2, view, tooltips));
 585     }
 586
 587     return result;
 588 }
 589
 590 VerbAction::VerbAction(Inkscape::Verb* verb, Inkscape::Verb* verb2, Inkscape::UI::View::View *view, GtkTooltips *tooltips) :
 591     Gtk::Action(Glib::ustring(verb->get_id()), Gtk::StockID(verb->get_image()), Glib::ustring(_(verb->get_name())), Glib::ustring(_(verb->get_tip()))),
 592     verb(verb),
 593     verb2(verb2),
 594     view(view),
 595     tooltips(tooltips),
 596     active(false)
 597 {
 598 }
 599
 600 VerbAction::~VerbAction()
 601 {
 602 }
 603
 604 Gtk::Widget* VerbAction::create_menu_item_vfunc()
 605 {
 606 // First call in to get the icon rendered if present in SVG
 607     Gtk::Widget *widget = sp_icon_get_icon( property_stock_id().get_value().get_string(), Inkscape::ICON_SIZE_MENU );
 608     delete widget;
 609     widget = 0;
 610
 611     Gtk::Widget* widg = Gtk::Action::create_menu_item_vfunc();
 612 //     g_message("create_menu_item_vfunc() = %p  for '%s'", widg, verb->get_id());
 613     return widg;
 614 }
 615
 616 Gtk::Widget* VerbAction::create_tool_item_vfunc()
 617 {
 618 //     Gtk::Widget* widg = Gtk::Action::create_tool_item_vfunc();
 619     Inkscape::IconSize toolboxSize = ToolboxFactory::prefToSize("/toolbox/tools/small");
 620     GtkWidget* toolbox = 0;
 621     GtkWidget *button = sp_toolbox_button_new_from_verb_with_doubleclick( toolbox, toolboxSize,
 622                                                                           SP_BUTTON_TYPE_TOGGLE,
 623                                                                           verb,
 624                                                                           verb2,
 625                                                                           view,
 626                                                                           tooltips );
 627     if ( active ) {
 628         sp_button_toggle_set_down( SP_BUTTON(button), active);
 629     }
 630     gtk_widget_show_all( button );
 631     Gtk::Widget* wrapped = Glib::wrap(button);
 632     Gtk::ToolItem* holder = Gtk::manage(new Gtk::ToolItem());
 633     holder->add(*wrapped);
 634
 635 //     g_message("create_tool_item_vfunc() = %p  for '%s'", holder, verb->get_id());
 636     return holder;
 637 }
 638
 639 void VerbAction::connect_proxy_vfunc(Gtk::Widget* proxy)
 640 {
 641 //     g_message("connect_proxy_vfunc(%p)  for '%s'", proxy, verb->get_id());
 642     Gtk::Action::connect_proxy_vfunc(proxy);
 643 }
 644
 645 void VerbAction::disconnect_proxy_vfunc(Gtk::Widget* proxy)
 646 {
 647 //     g_message("disconnect_proxy_vfunc(%p)  for '%s'", proxy, verb->get_id());
 648     Gtk::Action::disconnect_proxy_vfunc(proxy);
 649 }
 650
 651 void VerbAction::set_active(bool active)
 652 {
 653     this->active = active;
 654     Glib::SListHandle<Gtk::Widget*> proxies = get_proxies();
 655     for ( Glib::SListHandle<Gtk::Widget*>::iterator it = proxies.begin(); it != proxies.end(); ++it ) {
 656         Gtk::ToolItem* ti = dynamic_cast<Gtk::ToolItem*>(*it);
 657         if (ti) {
 658             // *should* have one child that is the SPButton
 659             Gtk::Widget* child = ti->get_child();
 660             if ( child && SP_IS_BUTTON(child->gobj()) ) {
 661                 SPButton* button = SP_BUTTON(child->gobj());
 662                 sp_button_toggle_set_down( button, active );
 663             }
 664         }
 665     }
 666 }
 667
 668 void VerbAction::on_activate()
 669 {
 670     if ( verb ) {
 671         SPAction *action = verb->get_action(view);
 672         if ( action ) {
 673             sp_action_perform(action, 0);
 674         }
 675     }
 676 }
 677
 678 /* Global text entry widgets necessary for update */
 679 /* GtkWidget *dropper_rgb_entry,
 680           *dropper_opacity_entry ; */
 681 // should be made a private member once this is converted to class
 682
 683 static void delete_connection(GObject * /*obj*/, sigc::connection *connection)
 684 {
 685     connection->disconnect();
 686     delete connection;
 687 }
 688
 689 static void purge_repr_listener( GObject* /*obj*/, GObject* tbl )
 690 {
 691     Inkscape::XML::Node* oldrepr = reinterpret_cast<Inkscape::XML::Node *>( g_object_get_data( tbl, "repr" ) );
 692     if (oldrepr) { // remove old listener
 693         sp_repr_remove_listener_by_data(oldrepr, tbl);
 694         Inkscape::GC::release(oldrepr);
 695         oldrepr = 0;
 696         g_object_set_data( tbl, "repr", NULL );
 697     }
 698 }
 699
 700 // ------------------------------------------------------
 701
 702 /**
 703  * A simple mediator class that keeps UI controls matched to the preference values they set.
 704  */
 705 class PrefPusher : public Inkscape::Preferences::Observer
 706 {
 707 public:
 708     /**
 709      * Constructor for a boolean value that syncs to the supplied path.
 710      * Initializes the widget to the current preference stored state and registers callbacks
 711      * for widget changes and preference changes.
 712      *
 713      * @param act the widget to synchronize preference with.
 714      * @param path the path to the preference the widget is synchronized with.
 715      * @param callback function to invoke when changes are pushed.
 716      * @param cbData data to be passed on to the callback function.
 717      */
 718     PrefPusher( GtkToggleAction *act, Glib::ustring const &path, void (*callback)(GObject*) = 0, GObject *cbData = 0 );
 719
 720     /**
 721      * Destructor that unregisters the preference callback.
 722      */
 723     virtual ~PrefPusher();
 724
 725     /**
 726      * Callback method invoked when the preference setting changes.
 727      */
 728     virtual void notify(Inkscape::Preferences::Entry const &new_val);
 729
 730 private:
 731     /**
 732      * Callback hook invoked when the widget changes.
 733      *
 734      * @param act the toggle action widget that was changed.
 735      * @param self the PrefPusher instance the callback was registered to.
 736      */
 737     static void toggleCB( GtkToggleAction *act, PrefPusher *self );
 738
 739     /**
 740      * Method to handle the widget change.
 741      */
 742     void handleToggled();
 743
 744     GtkToggleAction *act;
 745     void (*callback)(GObject*);
 746     GObject *cbData;
 747     bool freeze;
 748 };
 749
 750 PrefPusher::PrefPusher( GtkToggleAction *act, Glib::ustring const &path, void (*callback)(GObject*), GObject *cbData ) :
 751     Observer(path),
 752     act(act),
 753     callback(callback),
 754     cbData(cbData),
 755     freeze(false)
 756 {
 757     g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggleCB), this);
 758     freeze = true;
 759     gtk_toggle_action_set_active( act, Inkscape::Preferences::get()->getBool(observed_path) );
 760     freeze = false;
 761
 762     Inkscape::Preferences::get()->addObserver(*this);
 763 }
 764
 765 PrefPusher::~PrefPusher()
 766 {
 767     Inkscape::Preferences::get()->removeObserver(*this);
 768 }
 769
 770 void PrefPusher::toggleCB( GtkToggleAction * /*act*/, PrefPusher *self )
 771 {
 772     if (self) {
 773         self->handleToggled();
 774     }
 775 }
 776
 777 void PrefPusher::handleToggled()
 778 {
 779     if (!freeze) {
 780         freeze = true;
 781         Inkscape::Preferences::get()->setBool(observed_path, gtk_toggle_action_get_active( act ));
 782         if (callback) {
 783             (*callback)(cbData);
 784         }
 785         freeze = false;
 786     }
 787 }
 788
 789 void PrefPusher::notify(Inkscape::Preferences::Entry const &newVal)
 790 {
 791     bool newBool = newVal.getBool();
 792     bool oldBool = gtk_toggle_action_get_active(act);
 793
 794     if (!freeze && (newBool != oldBool)) {
 795         gtk_toggle_action_set_active( act, newBool );
 796     }
 797 }
 798
 799 static void delete_prefspusher(GtkObject * /*obj*/, PrefPusher *watcher )
 800 {
 801     delete watcher;
 802 }
 803
 804 // ------------------------------------------------------
 805
 806
 807 GtkWidget * sp_toolbox_button_new_from_verb_with_doubleclick(GtkWidget *t, Inkscape::IconSize size, SPButtonType type,
 808                                                              Inkscape::Verb *verb, Inkscape::Verb *doubleclick_verb,
 809                                                              Inkscape::UI::View::View *view, GtkTooltips *tt)
 810 {
 811     SPAction *action = verb->get_action(view);
 812     if (!action) {
 813         return NULL;
 814     }
 815
 816     SPAction *doubleclick_action;
 817     if (doubleclick_verb) {
 818         doubleclick_action = doubleclick_verb->get_action(view);
 819     } else {
 820         doubleclick_action = NULL;
 821     }
 822
 823     /* fixme: Handle sensitive/unsensitive */
 824     /* fixme: Implement sp_button_new_from_action */
 825     GtkWidget *b = sp_button_new(size, type, action, doubleclick_action, tt);
 826     gtk_widget_show(b);
 827
 828
 829     unsigned int shortcut = sp_shortcut_get_primary(verb);
 830     if (shortcut) {
 831         gchar key[256];
 832         sp_ui_shortcut_string(shortcut, key);
 833         gchar *tip = g_strdup_printf ("%s (%s)", action->tip, key);
 834         if ( t ) {
 835             gtk_toolbar_append_widget( GTK_TOOLBAR(t), b, tip, 0 );
 836         }
 837         g_free(tip);
 838     } else {
 839         if ( t ) {
 840             gtk_toolbar_append_widget( GTK_TOOLBAR(t), b, action->tip, 0 );
 841         }
 842     }
 843
 844     return b;
 845 }
 846
 847
 848 static void trigger_sp_action( GtkAction* /*act*/, gpointer user_data )
 849 {
 850     SPAction* targetAction = SP_ACTION(user_data);
 851     if ( targetAction ) {
 852         sp_action_perform( targetAction, NULL );
 853     }
 854 }
 855
 856 static void sp_action_action_set_sensitive(SPAction * /*action*/, unsigned int sensitive, void *data)
 857 {
 858     if ( data ) {
 859         GtkAction* act = GTK_ACTION(data);
 860         gtk_action_set_sensitive( act, sensitive );
 861     }
 862 }
 863
 864 static SPActionEventVector action_event_vector = {
 865     {NULL},
 866     NULL,
 867     NULL,
 868     sp_action_action_set_sensitive,
 869     NULL,
 870     NULL
 871 };
 872
 873 static GtkAction* create_action_for_verb( Inkscape::Verb* verb, Inkscape::UI::View::View* view, Inkscape::IconSize size )
 874 {
 875     GtkAction* act = 0;
 876
 877     SPAction* targetAction = verb->get_action(view);
 878     InkAction* inky = ink_action_new( verb->get_id(), _(verb->get_name()), verb->get_tip(), verb->get_image(), size  );
 879     act = GTK_ACTION(inky);
 880     gtk_action_set_sensitive( act, targetAction->sensitive );
 881
 882     g_signal_connect( G_OBJECT(inky), "activate", GTK_SIGNAL_FUNC(trigger_sp_action), targetAction );
 883
 884     SPAction*rebound = dynamic_cast<SPAction *>( nr_object_ref( dynamic_cast<NRObject *>(targetAction) ) );
 885     nr_active_object_add_listener( (NRActiveObject *)rebound, (NRObjectEventVector *)&action_event_vector, sizeof(SPActionEventVector), inky );
 886
 887     return act;
 888 }
 889
 890 static Glib::RefPtr<Gtk::ActionGroup> create_or_fetch_actions( SPDesktop* desktop )
 891 {
 892     Inkscape::UI::View::View *view = desktop;
 893     gint verbsToUse[] = {
 894         // disabled until we have icons for them:
 895         //find
 896         //SP_VERB_EDIT_TILE,
 897         //SP_VERB_EDIT_UNTILE,
 898         SP_VERB_DIALOG_ALIGN_DISTRIBUTE,
 899         SP_VERB_DIALOG_DISPLAY,
 900         SP_VERB_DIALOG_FILL_STROKE,
 901         SP_VERB_DIALOG_NAMEDVIEW,
 902         SP_VERB_DIALOG_TEXT,
 903         SP_VERB_DIALOG_XML_EDITOR,
 904         SP_VERB_DIALOG_LAYERS,
 905         SP_VERB_EDIT_CLONE,
 906         SP_VERB_EDIT_COPY,
 907         SP_VERB_EDIT_CUT,
 908         SP_VERB_EDIT_DUPLICATE,
 909         SP_VERB_EDIT_PASTE,
 910         SP_VERB_EDIT_REDO,
 911         SP_VERB_EDIT_UNDO,
 912         SP_VERB_EDIT_UNLINK_CLONE,
 913         SP_VERB_FILE_EXPORT,
 914         SP_VERB_FILE_IMPORT,
 915         SP_VERB_FILE_NEW,
 916         SP_VERB_FILE_OPEN,
 917         SP_VERB_FILE_PRINT,
 918         SP_VERB_FILE_SAVE,
 919         SP_VERB_OBJECT_TO_CURVE,
 920         SP_VERB_SELECTION_GROUP,
 921         SP_VERB_SELECTION_OUTLINE,
 922         SP_VERB_SELECTION_UNGROUP,
 923         SP_VERB_ZOOM_1_1,
 924         SP_VERB_ZOOM_1_2,
 925         SP_VERB_ZOOM_2_1,
 926         SP_VERB_ZOOM_DRAWING,
 927         SP_VERB_ZOOM_IN,
 928         SP_VERB_ZOOM_NEXT,
 929         SP_VERB_ZOOM_OUT,
 930         SP_VERB_ZOOM_PAGE,
 931         SP_VERB_ZOOM_PAGE_WIDTH,
 932         SP_VERB_ZOOM_PREV,
 933         SP_VERB_ZOOM_SELECTION,
 934     };
 935
 936     Inkscape::IconSize toolboxSize = ToolboxFactory::prefToSize("/toolbox/small");
 937
 938     static std::map<SPDesktop*, Glib::RefPtr<Gtk::ActionGroup> > groups;
 939     Glib::RefPtr<Gtk::ActionGroup> mainActions;
 940     if ( groups.find(desktop) != groups.end() ) {
 941         mainActions = groups[desktop];
 942     }
 943
 944     if ( !mainActions ) {
 945         mainActions = Gtk::ActionGroup::create("main");
 946         groups[desktop] = mainActions;
 947     }
 948
 949     for ( guint i = 0; i < G_N_ELEMENTS(verbsToUse); i++ ) {
 950         Inkscape::Verb* verb = Inkscape::Verb::get(verbsToUse[i]);
 951         if ( verb ) {
 952             if (!mainActions->get_action(verb->get_id())) {
 953                 GtkAction* act = create_action_for_verb( verb, view, toolboxSize );
 954                 mainActions->add(Glib::wrap(act));
 955             }
 956         }
 957     }
 958
 959     if ( !mainActions->get_action("ToolZoom") ) {
 960         GtkTooltips *tt = gtk_tooltips_new();
 961         for ( guint i = 0; i < G_N_ELEMENTS(tools) && tools[i].type_name; i++ ) {
 962             Glib::RefPtr<VerbAction> va = VerbAction::create(Inkscape::Verb::get(tools[i].verb), Inkscape::Verb::get(tools[i].doubleclick_verb), view, tt);
 963             if ( va ) {
 964                 mainActions->add(va);
 965                 if ( i == 0 ) {
 966                     va->set_active(true);
 967                 }
 968             }
 969         }
 970     }
 971
 972     return mainActions;
 973 }
 974
 975
 976 static void handlebox_detached(GtkHandleBox* /*handlebox*/, GtkWidget* widget, gpointer /*userData*/)
 977 {
 978     gtk_widget_set_size_request( widget,
 979                                  widget->allocation.width,
 980                                  widget->allocation.height );
 981 }
 982
 983 static void handlebox_attached(GtkHandleBox* /*handlebox*/, GtkWidget* widget, gpointer /*userData*/)
 984 {
 985     gtk_widget_set_size_request( widget, -1, -1 );
 986 }
 987
 988 static GtkWidget* toolboxNewCommon( GtkWidget* tb, BarId id, GtkPositionType handlePos )
 989 {
 990     g_object_set_data(G_OBJECT(tb), "desktop", NULL);
 991
 992     gtk_widget_set_sensitive(tb, FALSE);
 993
 994     GtkWidget *hb = 0;
 995     gboolean forceFloatAllowed = Inkscape::Preferences::get()->getBool("/options/workarounds/floatallowed", false);
 996     if ( UXManager::getInstance()->isFloatWindowProblem() && !forceFloatAllowed ) {
 997         hb = gtk_event_box_new(); // A simple, neutral container.
 998     } else {
 999         hb = gtk_handle_box_new();
1000         gtk_handle_box_set_handle_position(GTK_HANDLE_BOX(hb), handlePos);
1001         gtk_handle_box_set_shadow_type(GTK_HANDLE_BOX(hb), GTK_SHADOW_OUT);
1002         gtk_handle_box_set_snap_edge(GTK_HANDLE_BOX(hb), GTK_POS_LEFT);
1003     }
1004
1005     gtk_container_add(GTK_CONTAINER(hb), tb);
1006     gtk_widget_show(GTK_WIDGET(tb));
1007
1008     sigc::connection* conn = new sigc::connection;
1009     g_object_set_data(G_OBJECT(hb), "event_context_connection", conn);
1010
1011     if ( GTK_IS_HANDLE_BOX(hb) ) {
1012         g_signal_connect(G_OBJECT(hb), "child_detached", G_CALLBACK(handlebox_detached), static_cast<gpointer>(0));
1013         g_signal_connect(G_OBJECT(hb), "child_attached", G_CALLBACK(handlebox_attached), static_cast<gpointer>(0));
1014     }
1015
1016     gpointer val = GINT_TO_POINTER(id);
1017     g_object_set_data(G_OBJECT(hb), BAR_ID_KEY, val);
1018
1019     return hb;
1020 }
1021
1022 GtkWidget *ToolboxFactory::createToolToolbox()
1023 {
1024     GtkWidget *tb = gtk_vbox_new(FALSE, 0);
1025
1026     return toolboxNewCommon( tb, BAR_TOOL, GTK_POS_TOP );
1027 }
1028
1029 GtkWidget *ToolboxFactory::createAuxToolbox()
1030 {
1031     GtkWidget *tb = gtk_vbox_new(FALSE, 0);
1032
1033     return toolboxNewCommon( tb, BAR_AUX, GTK_POS_LEFT );
1034 }
1035
1036 //####################################
1037 //# Commands Bar
1038 //####################################
1039
1040 GtkWidget *ToolboxFactory::createCommandsToolbox()
1041 {
1042     GtkWidget *tb = gtk_vbox_new(FALSE, 0);
1043
1044     return toolboxNewCommon( tb, BAR_COMMANDS, GTK_POS_LEFT );
1045 }
1046
1047 GtkWidget *ToolboxFactory::createSnapToolbox()
1048 {
1049     GtkWidget *tb = gtk_vbox_new(FALSE, 0);
1050
1051     return toolboxNewCommon( tb, BAR_SNAP, GTK_POS_LEFT );
1052 }
1053
1054 static EgeAdjustmentAction * create_adjustment_action( gchar const *name,
1055                                                        gchar const *label, gchar const *shortLabel, gchar const *tooltip,
1056                                                        Glib::ustring const &path, gdouble def,
1057                                                        GtkWidget *focusTarget,
1058                                                        GtkWidget *us,
1059                                                        GObject *dataKludge,
1060                                                        gboolean altx, gchar const *altx_mark,
1061                                                        gdouble lower, gdouble upper, gdouble step, gdouble page,
1062                                                        gchar const** descrLabels, gdouble const* descrValues, guint descrCount,
1063                                                        void (*callback)(GtkAdjustment *, GObject *),
1064                                                        gdouble climb = 0.1, guint digits = 3, double factor = 1.0 )
1065 {
1066     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1067     GtkAdjustment* adj = GTK_ADJUSTMENT( gtk_adjustment_new( prefs->getDouble(path, def) * factor,
1068                                                              lower, upper, step, page, 0 ) );
1069     if (us) {
1070         sp_unit_selector_add_adjustment( SP_UNIT_SELECTOR(us), adj );
1071     }
1072
1073     gtk_signal_connect( GTK_OBJECT(adj), "value-changed", GTK_SIGNAL_FUNC(callback), dataKludge );
1074
1075     EgeAdjustmentAction* act = ege_adjustment_action_new( adj, name, label, tooltip, 0, climb, digits );
1076     if ( shortLabel ) {
1077         g_object_set( act, "short_label", shortLabel, NULL );
1078     }
1079
1080     if ( (descrCount > 0) && descrLabels && descrValues ) {
1081         ege_adjustment_action_set_descriptions( act, descrLabels, descrValues, descrCount );
1082     }
1083
1084     if ( focusTarget ) {
1085         ege_adjustment_action_set_focuswidget( act, focusTarget );
1086     }
1087
1088     if ( altx && altx_mark ) {
1089         g_object_set( G_OBJECT(act), "self-id", altx_mark, NULL );
1090     }
1091
1092     if ( dataKludge ) {
1093         // Rather lame, but it's the only place where we need to get the entry name
1094         // but we don't have an Entry
1095         g_object_set_data( dataKludge, prefs->getEntry(path).getEntryName().data(), adj );
1096     }
1097
1098     // Using a cast just to make sure we pass in the right kind of function pointer
1099     g_object_set( G_OBJECT(act), "tool-post", static_cast<EgeWidgetFixup>(sp_set_font_size_smaller), NULL );
1100
1101     return act;
1102 }
1103
1104
1105 //####################################
1106 //# node editing callbacks
1107 //####################################
1108
1109 /** Temporary hack: Returns the node tool in the active desktop.
1110  * Will go away during tool refactoring. */
1111 static InkNodeTool *get_node_tool()
1112 {
1113     InkNodeTool *tool = 0;
1114     if (SP_ACTIVE_DESKTOP ) {
1115         SPEventContext *ec = SP_ACTIVE_DESKTOP->event_context;
1116         if (INK_IS_NODE_TOOL(ec)) {
1117             tool = static_cast<InkNodeTool*>(ec);
1118         }
1119     }
1120     return tool;
1121 }
1122
1123 static void sp_node_path_edit_add(void)
1124 {
1125     InkNodeTool *nt = get_node_tool();
1126     if (nt) {
1127         nt->_multipath->insertNodes();
1128     }
1129 }
1130
1131 static void sp_node_path_edit_delete(void)
1132 {
1133     InkNodeTool *nt = get_node_tool();
1134     if (nt) {
1135         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1136         nt->_multipath->deleteNodes(prefs->getBool("/tools/nodes/delete_preserves_shape", true));
1137     }
1138 }
1139
1140 static void sp_node_path_edit_delete_segment(void)
1141 {
1142     InkNodeTool *nt = get_node_tool();
1143     if (nt) {
1144         nt->_multipath->deleteSegments();
1145     }
1146 }
1147
1148 static void sp_node_path_edit_break(void)
1149 {
1150     InkNodeTool *nt = get_node_tool();
1151     if (nt) {
1152         nt->_multipath->breakNodes();
1153     }
1154 }
1155
1156 static void sp_node_path_edit_join(void)
1157 {
1158     InkNodeTool *nt = get_node_tool();
1159     if (nt) {
1160         nt->_multipath->joinNodes();
1161     }
1162 }
1163
1164 static void sp_node_path_edit_join_segment(void)
1165 {
1166     InkNodeTool *nt = get_node_tool();
1167     if (nt) {
1168         nt->_multipath->joinSegments();
1169     }
1170 }
1171
1172 static void sp_node_path_edit_toline(void)
1173 {
1174     InkNodeTool *nt = get_node_tool();
1175     if (nt) {
1176         nt->_multipath->setSegmentType(Inkscape::UI::SEGMENT_STRAIGHT);
1177     }
1178 }
1179
1180 static void sp_node_path_edit_tocurve(void)
1181 {
1182     InkNodeTool *nt = get_node_tool();
1183     if (nt) {
1184         nt->_multipath->setSegmentType(Inkscape::UI::SEGMENT_CUBIC_BEZIER);
1185     }
1186 }
1187
1188 static void sp_node_path_edit_cusp(void)
1189 {
1190     InkNodeTool *nt = get_node_tool();
1191     if (nt) {
1192         nt->_multipath->setNodeType(Inkscape::UI::NODE_CUSP);
1193     }
1194 }
1195
1196 static void sp_node_path_edit_smooth(void)
1197 {
1198     InkNodeTool *nt = get_node_tool();
1199     if (nt) {
1200         nt->_multipath->setNodeType(Inkscape::UI::NODE_SMOOTH);
1201     }
1202 }
1203
1204 static void sp_node_path_edit_symmetrical(void)
1205 {
1206     InkNodeTool *nt = get_node_tool();
1207     if (nt) {
1208         nt->_multipath->setNodeType(Inkscape::UI::NODE_SYMMETRIC);
1209     }
1210 }
1211
1212 static void sp_node_path_edit_auto(void)
1213 {
1214     InkNodeTool *nt = get_node_tool();
1215     if (nt) {
1216         nt->_multipath->setNodeType(Inkscape::UI::NODE_AUTO);
1217     }
1218 }
1219
1220 static void sp_node_path_edit_nextLPEparam(GtkAction * /*act*/, gpointer data) {
1221     sp_selection_next_patheffect_param( reinterpret_cast<SPDesktop*>(data) );
1222 }
1223
1224 /* is called when the node selection is modified */
1225 static void sp_node_toolbox_coord_changed(gpointer /*shape_editor*/, GObject *tbl)
1226 {
1227     GtkAction* xact = GTK_ACTION( g_object_get_data( tbl, "nodes_x_action" ) );
1228     GtkAction* yact = GTK_ACTION( g_object_get_data( tbl, "nodes_y_action" ) );
1229     GtkAdjustment *xadj = ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION(xact));
1230     GtkAdjustment *yadj = ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION(yact));
1231
1232     // quit if run by the attr_changed listener
1233     if (g_object_get_data( tbl, "freeze" )) {
1234         return;
1235     }
1236
1237     // in turn, prevent listener from responding
1238     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE));
1239
1240     UnitTracker* tracker = reinterpret_cast<UnitTracker*>( g_object_get_data( tbl, "tracker" ) );
1241     SPUnit const *unit = tracker->getActiveUnit();
1242
1243     InkNodeTool *nt = get_node_tool();
1244     if (!nt || nt->_selected_nodes->empty()) {
1245         // no path selected
1246         gtk_action_set_sensitive(xact, FALSE);
1247         gtk_action_set_sensitive(yact, FALSE);
1248     } else {
1249         gtk_action_set_sensitive(xact, TRUE);
1250         gtk_action_set_sensitive(yact, TRUE);
1251         Geom::Coord oldx = sp_units_get_pixels(gtk_adjustment_get_value(xadj), *unit);
1252         Geom::Coord oldy = sp_units_get_pixels(gtk_adjustment_get_value(xadj), *unit);
1253         Geom::Point mid = nt->_selected_nodes->pointwiseBounds()->midpoint();
1254
1255         if (oldx != mid[Geom::X]) {
1256             gtk_adjustment_set_value(xadj, sp_pixels_get_units(mid[Geom::X], *unit));
1257         }
1258         if (oldy != mid[Geom::Y]) {
1259             gtk_adjustment_set_value(yadj, sp_pixels_get_units(mid[Geom::Y], *unit));
1260         }
1261     }
1262
1263     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
1264 }
1265
1266 static void sp_node_path_value_changed(GtkAdjustment *adj, GObject *tbl, Geom::Dim2 d)
1267 {
1268     SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
1269     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1270
1271     UnitTracker* tracker = reinterpret_cast<UnitTracker*>(g_object_get_data( tbl, "tracker" ));
1272     SPUnit const *unit = tracker->getActiveUnit();
1273
1274     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
1275         prefs->setDouble(Glib::ustring("/tools/nodes/") + (d == Geom::X ? "x" : "y"),
1276             sp_units_get_pixels(adj->value, *unit));
1277     }
1278
1279     // quit if run by the attr_changed listener
1280     if (g_object_get_data( tbl, "freeze" )) {
1281         return;
1282     }
1283
1284     // in turn, prevent listener from responding
1285     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE));
1286
1287     InkNodeTool *nt = get_node_tool();
1288     if (nt && !nt->_selected_nodes->empty()) {
1289         double val = sp_units_get_pixels(gtk_adjustment_get_value(adj), *unit);
1290         double oldval = nt->_selected_nodes->pointwiseBounds()->midpoint()[d];
1291         Geom::Point delta(0,0);
1292         delta[d] = val - oldval;
1293         nt->_multipath->move(delta);
1294     }
1295
1296     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
1297 }
1298
1299 static void sp_node_path_x_value_changed(GtkAdjustment *adj, GObject *tbl)
1300 {
1301     sp_node_path_value_changed(adj, tbl, Geom::X);
1302 }
1303
1304 static void sp_node_path_y_value_changed(GtkAdjustment *adj, GObject *tbl)
1305 {
1306     sp_node_path_value_changed(adj, tbl, Geom::Y);
1307 }
1308
1309 static void sp_node_toolbox_sel_changed(Inkscape::Selection *selection, GObject *tbl)
1310 {
1311     {
1312     GtkAction* w = GTK_ACTION( g_object_get_data( tbl, "nodes_lpeedit" ) );
1313     SPItem *item = selection->singleItem();
1314     if (item && SP_IS_LPE_ITEM(item)) {
1315        if (sp_lpe_item_has_path_effect(SP_LPE_ITEM(item))) {
1316            gtk_action_set_sensitive(w, TRUE);
1317        } else {
1318            gtk_action_set_sensitive(w, FALSE);
1319        }
1320     } else {
1321        gtk_action_set_sensitive(w, FALSE);
1322     }
1323     }
1324 }
1325
1326 static void sp_node_toolbox_sel_modified(Inkscape::Selection *selection, guint /*flags*/, GObject *tbl)
1327 {
1328     sp_node_toolbox_sel_changed (selection, tbl);
1329 }
1330
1331
1332
1333 //################################
1334 //##    Node Editing Toolbox    ##
1335 //################################
1336
1337 static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
1338 {
1339     UnitTracker* tracker = new UnitTracker( SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE );
1340     tracker->setActiveUnit( sp_desktop_namedview(desktop)->doc_units );
1341     g_object_set_data( holder, "tracker", tracker );
1342
1343     Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
1344
1345     {
1346         InkAction* inky = ink_action_new( "NodeInsertAction",
1347                                           _("Insert node"),
1348                                           _("Insert new nodes into selected segments"),
1349                                           INKSCAPE_ICON_NODE_ADD,
1350                                           secondarySize );
1351         g_object_set( inky, "short_label", _("Insert"), NULL );
1352         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_add), 0 );
1353         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1354     }
1355
1356     {
1357         InkAction* inky = ink_action_new( "NodeDeleteAction",
1358                                           _("Delete node"),
1359                                           _("Delete selected nodes"),
1360                                           INKSCAPE_ICON_NODE_DELETE,
1361                                           secondarySize );
1362         g_object_set( inky, "short_label", _("Delete"), NULL );
1363         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_delete), 0 );
1364         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1365     }
1366
1367     {
1368         InkAction* inky = ink_action_new( "NodeJoinAction",
1369                                           _("Join nodes"),
1370                                           _("Join selected nodes"),
1371                                           INKSCAPE_ICON_NODE_JOIN,
1372                                           secondarySize );
1373         g_object_set( inky, "short_label", _("Join"), NULL );
1374         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_join), 0 );
1375         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1376     }
1377
1378     {
1379         InkAction* inky = ink_action_new( "NodeBreakAction",
1380                                           _("Break nodes"),
1381                                           _("Break path at selected nodes"),
1382                                           INKSCAPE_ICON_NODE_BREAK,
1383                                           secondarySize );
1384         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_break), 0 );
1385         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1386     }
1387
1388
1389     {
1390         InkAction* inky = ink_action_new( "NodeJoinSegmentAction",
1391                                           _("Join with segment"),
1392                                           _("Join selected endnodes with a new segment"),
1393                                           INKSCAPE_ICON_NODE_JOIN_SEGMENT,
1394                                           secondarySize );
1395         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_join_segment), 0 );
1396         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1397     }
1398
1399     {
1400         InkAction* inky = ink_action_new( "NodeDeleteSegmentAction",
1401                                           _("Delete segment"),
1402                                           _("Delete segment between two non-endpoint nodes"),
1403                                           INKSCAPE_ICON_NODE_DELETE_SEGMENT,
1404                                           secondarySize );
1405         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_delete_segment), 0 );
1406         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1407     }
1408
1409     {
1410         InkAction* inky = ink_action_new( "NodeCuspAction",
1411                                           _("Node Cusp"),
1412                                           _("Make selected nodes corner"),
1413                                           INKSCAPE_ICON_NODE_TYPE_CUSP,
1414                                           secondarySize );
1415         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_cusp), 0 );
1416         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1417     }
1418
1419     {
1420         InkAction* inky = ink_action_new( "NodeSmoothAction",
1421                                           _("Node Smooth"),
1422                                           _("Make selected nodes smooth"),
1423                                           INKSCAPE_ICON_NODE_TYPE_SMOOTH,
1424                                           secondarySize );
1425         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_smooth), 0 );
1426         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1427     }
1428
1429     {
1430         InkAction* inky = ink_action_new( "NodeSymmetricAction",
1431                                           _("Node Symmetric"),
1432                                           _("Make selected nodes symmetric"),
1433                                           INKSCAPE_ICON_NODE_TYPE_SYMMETRIC,
1434                                           secondarySize );
1435         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_symmetrical), 0 );
1436         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1437     }
1438
1439     {
1440         InkAction* inky = ink_action_new( "NodeAutoAction",
1441                                           _("Node Auto"),
1442                                           _("Make selected nodes auto-smooth"),
1443                                           INKSCAPE_ICON_NODE_TYPE_AUTO_SMOOTH,
1444                                           secondarySize );
1445         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_auto), 0 );
1446         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1447     }
1448
1449     {
1450         InkAction* inky = ink_action_new( "NodeLineAction",
1451                                           _("Node Line"),
1452                                           _("Make selected segments lines"),
1453                                           INKSCAPE_ICON_NODE_SEGMENT_LINE,
1454                                           secondarySize );
1455         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_toline), 0 );
1456         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1457     }
1458
1459     {
1460         InkAction* inky = ink_action_new( "NodeCurveAction",
1461                                           _("Node Curve"),
1462                                           _("Make selected segments curves"),
1463                                           INKSCAPE_ICON_NODE_SEGMENT_CURVE,
1464                                           secondarySize );
1465         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_tocurve), 0 );
1466         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1467     }
1468
1469     {
1470         InkToggleAction* act = ink_toggle_action_new( "NodesShowTransformHandlesAction",
1471                                                       _("Show Transform Handles"),
1472                                                       _("Show transformation handles for selected nodes"),
1473                                                       "node-transform",
1474                                                       secondarySize );
1475         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
1476         PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/nodes/show_transform_handles");
1477         g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
1478     }
1479
1480     {
1481         InkToggleAction* act = ink_toggle_action_new( "NodesShowHandlesAction",
1482                                                       _("Show Handles"),
1483                                                       _("Show Bezier handles of selected nodes"),
1484                                                       INKSCAPE_ICON_SHOW_NODE_HANDLES,
1485                                                       secondarySize );
1486         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
1487         PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/nodes/show_handles");
1488         g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
1489     }
1490
1491     {
1492         InkToggleAction* act = ink_toggle_action_new( "NodesShowHelperpath",
1493                                                       _("Show Outline"),
1494                                                       _("Show path outline (without path effects)"),
1495                                                       INKSCAPE_ICON_SHOW_PATH_OUTLINE,
1496                                                       secondarySize );
1497         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
1498         PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/nodes/show_outline");
1499         g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
1500     }
1501
1502     {
1503         InkAction* inky = ink_action_new( "EditNextLPEParameterAction",
1504                                           _("Next path effect parameter"),
1505                                           _("Show next editable path effect parameter"),
1506                                           INKSCAPE_ICON_PATH_EFFECT_PARAMETER_NEXT,
1507                                           secondarySize );
1508         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_nextLPEparam), desktop );
1509         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1510         g_object_set_data( holder, "nodes_lpeedit", inky);
1511     }
1512
1513     {
1514         InkToggleAction* inky = ink_toggle_action_new( "ObjectEditClipPathAction",
1515                                           _("Edit clipping paths"),
1516                                           _("Show clipping path(s) of selected object(s)"),
1517                                           INKSCAPE_ICON_PATH_CLIP_EDIT,
1518                                           secondarySize );
1519         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1520         PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(inky), "/tools/nodes/edit_clipping_paths");
1521         g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
1522     }
1523
1524     {
1525         InkToggleAction* inky = ink_toggle_action_new( "ObjectEditMaskPathAction",
1526                                           _("Edit masks"),
1527                                           _("Show mask(s) of selected object(s)"),
1528                                           INKSCAPE_ICON_PATH_MASK_EDIT,
1529                                           secondarySize );
1530         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1531         PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(inky), "/tools/nodes/edit_masks");
1532         g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
1533     }
1534
1535     /* X coord of selected node(s) */
1536     {
1537         EgeAdjustmentAction* eact = 0;
1538         gchar const* labels[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1539         gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
1540         eact = create_adjustment_action( "NodeXAction",
1541                                          _("X coordinate:"), _("X:"), _("X coordinate of selected node(s)"),
1542                                          "/tools/nodes/Xcoord", 0,
1543                                          GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, TRUE, "altx-nodes",
1544                                          -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
1545                                          labels, values, G_N_ELEMENTS(labels),
1546                                          sp_node_path_x_value_changed );
1547         tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );
1548         g_object_set_data( holder, "nodes_x_action", eact );
1549         gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
1550         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
1551     }
1552
1553     /* Y coord of selected node(s) */
1554     {
1555         EgeAdjustmentAction* eact = 0;
1556         gchar const* labels[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1557         gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
1558         eact = create_adjustment_action( "NodeYAction",
1559                                          _("Y coordinate:"), _("Y:"), _("Y coordinate of selected node(s)"),
1560                                          "/tools/nodes/Ycoord", 0,
1561                                          GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL,
1562                                          -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
1563                                          labels, values, G_N_ELEMENTS(labels),
1564                                          sp_node_path_y_value_changed );
1565         tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );
1566         g_object_set_data( holder, "nodes_y_action", eact );
1567         gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
1568         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
1569     }
1570
1571     // add the units menu
1572     {
1573         GtkAction* act = tracker->createAction( "NodeUnitsAction", _("Units"), ("") );
1574         gtk_action_group_add_action( mainActions, act );
1575     }
1576
1577
1578     sp_node_toolbox_sel_changed(sp_desktop_selection(desktop), holder);
1579
1580     //watch selection
1581     Inkscape::ConnectionPool* pool = Inkscape::ConnectionPool::new_connection_pool ("ISNodeToolbox");
1582
1583     sigc::connection *c_selection_changed =
1584         new sigc::connection (sp_desktop_selection (desktop)->connectChanged
1585                               (sigc::bind (sigc::ptr_fun (sp_node_toolbox_sel_changed), (GObject*)holder)));
1586     pool->add_connection ("selection-changed", c_selection_changed);
1587
1588     sigc::connection *c_selection_modified =
1589         new sigc::connection (sp_desktop_selection (desktop)->connectModified
1590                               (sigc::bind (sigc::ptr_fun (sp_node_toolbox_sel_modified), (GObject*)holder)));
1591     pool->add_connection ("selection-modified", c_selection_modified);
1592
1593     sigc::connection *c_subselection_changed =
1594         new sigc::connection (desktop->connectToolSubselectionChanged
1595                               (sigc::bind (sigc::ptr_fun (sp_node_toolbox_coord_changed), (GObject*)holder)));
1596     pool->add_connection ("tool-subselection-changed", c_subselection_changed);
1597
1598     Inkscape::ConnectionPool::connect_destroy (G_OBJECT (holder), pool);
1599
1600     g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );
1601 } // end of sp_node_toolbox_prep()
1602
1603
1604 //########################
1605 //##    Zoom Toolbox    ##
1606 //########################
1607
1608 static void sp_zoom_toolbox_prep(SPDesktop * /*desktop*/, GtkActionGroup* /*mainActions*/, GObject* /*holder*/)
1609 {
1610     // no custom GtkAction setup needed
1611 } // end of sp_zoom_toolbox_prep()
1612
1613 void ToolboxFactory::setToolboxDesktop(GtkWidget *toolbox, SPDesktop *desktop)
1614 {
1615     sigc::connection *conn = static_cast<sigc::connection*>(g_object_get_data(G_OBJECT(toolbox),
1616                                                                               "event_context_connection"));
1617
1618     BarId id = static_cast<BarId>( GPOINTER_TO_INT(g_object_get_data(G_OBJECT(toolbox), BAR_ID_KEY)) );
1619
1620     SetupFunction setup_func = 0;
1621     UpdateFunction update_func = 0;
1622
1623     switch (id) {
1624         case BAR_TOOL:
1625             setup_func = setup_tool_toolbox;
1626             update_func = update_tool_toolbox;
1627             break;
1628
1629         case BAR_AUX:
1630             toolbox = gtk_bin_get_child(GTK_BIN(toolbox));
1631             setup_func = setup_aux_toolbox;
1632             update_func = update_aux_toolbox;
1633             break;
1634
1635         case BAR_COMMANDS:
1636             setup_func = setup_commands_toolbox;
1637             update_func = update_commands_toolbox;
1638             break;
1639
1640         case BAR_SNAP:
1641             setup_func = setup_snap_toolbox;
1642             update_func = updateSnapToolbox;
1643             break;
1644         default:
1645             g_warning("Unexpected toolbox id encountered.");
1646     }
1647
1648     gpointer ptr = g_object_get_data(G_OBJECT(toolbox), "desktop");
1649     SPDesktop *old_desktop = static_cast<SPDesktop*>(ptr);
1650
1651     if (old_desktop) {
1652         GList *children, *iter;
1653
1654         children = gtk_container_get_children(GTK_CONTAINER(toolbox));
1655         for ( iter = children ; iter ; iter = iter->next ) {
1656             gtk_container_remove( GTK_CONTAINER(toolbox), GTK_WIDGET(iter->data) );
1657         }
1658         g_list_free(children);
1659     }
1660
1661     g_object_set_data(G_OBJECT(toolbox), "desktop", (gpointer)desktop);
1662
1663     if (desktop && setup_func && update_func) {
1664         gtk_widget_set_sensitive(toolbox, TRUE);
1665         setup_func(toolbox, desktop);
1666         update_func(desktop, desktop->event_context, toolbox);
1667         *conn = desktop->connectEventContextChanged(sigc::bind (sigc::ptr_fun(update_func), toolbox));
1668     } else {
1669         gtk_widget_set_sensitive(toolbox, FALSE);
1670     }
1671
1672 } // end of sp_toolbox_set_desktop()
1673
1674
1675 static void setupToolboxCommon( GtkWidget *toolbox,
1676                                 SPDesktop *desktop,
1677                                 gchar const *descr,
1678                                 gchar const* toolbarName,
1679                                 gchar const* sizePref )
1680 {
1681     Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions( desktop );
1682     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1683
1684     GtkUIManager* mgr = gtk_ui_manager_new();
1685     GError* errVal = 0;
1686
1687     GtkOrientation orientation = GTK_ORIENTATION_HORIZONTAL;
1688
1689     gtk_ui_manager_insert_action_group( mgr, mainActions->gobj(), 0 );
1690     gtk_ui_manager_add_ui_from_string( mgr, descr, -1, &errVal );
1691
1692     GtkWidget* toolBar = gtk_ui_manager_get_widget( mgr, toolbarName );
1693     if ( prefs->getBool("/toolbox/icononly", true) ) {
1694         gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS );
1695     }
1696
1697     Inkscape::IconSize toolboxSize = ToolboxFactory::prefToSize(sizePref);
1698     gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), static_cast<GtkIconSize>(toolboxSize) );
1699
1700     if (GTK_IS_HANDLE_BOX(toolbox)) {
1701         // g_message("GRABBING ORIENTATION   [%s]", toolbarName);
1702         GtkPositionType pos = gtk_handle_box_get_handle_position(GTK_HANDLE_BOX(toolbox));
1703         orientation = ((pos == GTK_POS_LEFT) || (pos == GTK_POS_RIGHT)) ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL;
1704     } else {
1705         GtkPositionType pos = static_cast<GtkPositionType>(GPOINTER_TO_INT(g_object_get_data( G_OBJECT(toolbox), HANDLE_POS_MARK )));
1706         orientation = ((pos == GTK_POS_LEFT) || (pos == GTK_POS_RIGHT)) ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL;
1707     }
1708     gtk_toolbar_set_orientation(GTK_TOOLBAR(toolBar), orientation);
1709     gtk_toolbar_set_show_arrow(GTK_TOOLBAR(toolBar), TRUE);
1710
1711     g_object_set_data(G_OBJECT(toolBar), "desktop", NULL);
1712
1713     GtkWidget* child = gtk_bin_get_child(GTK_BIN(toolbox));
1714     if ( child ) {
1715         gtk_container_remove( GTK_CONTAINER(toolbox), child );
1716     }
1717
1718     gtk_container_add( GTK_CONTAINER(toolbox), toolBar );
1719 }
1720
1721 #define noDUMP_DETAILS 1
1722
1723 void ToolboxFactory::setOrientation(GtkWidget* toolbox, GtkOrientation orientation)
1724 {
1725 #if DUMP_DETAILS
1726     g_message("Set orientation for %p to be %d", toolbox, orientation);
1727     GType type = GTK_WIDGET_TYPE(toolbox);
1728     g_message("        [%s]", g_type_name(type));
1729     g_message("             %p", g_object_get_data(G_OBJECT(toolbox), BAR_ID_KEY));
1730 #endif
1731
1732     GtkPositionType pos = (orientation == GTK_ORIENTATION_HORIZONTAL) ? GTK_POS_LEFT : GTK_POS_TOP;
1733     GtkHandleBox* handleBox = 0;
1734
1735     if (GTK_IS_BIN(toolbox)) {
1736 #if DUMP_DETAILS
1737         g_message("            is a BIN");
1738 #endif // DUMP_DETAILS
1739         GtkWidget* child = gtk_bin_get_child(GTK_BIN(toolbox));
1740         if (child) {
1741 #if DUMP_DETAILS
1742             GType type2 = GTK_WIDGET_TYPE(child);
1743             g_message("            child    [%s]", g_type_name(type2));
1744 #endif // DUMP_DETAILS
1745
1746             if (GTK_IS_BOX(child)) {
1747 #if DUMP_DETAILS
1748                 g_message("                is a BOX");
1749 #endif // DUMP_DETAILS
1750
1751                 GList* children = gtk_container_get_children(GTK_CONTAINER(child));
1752                 if (children) {
1753                     for (GList* curr = children; curr; curr = g_list_next(curr)) {
1754                         GtkWidget* child2 = GTK_WIDGET(curr->data);
1755 #if DUMP_DETAILS
1756                         GType type3 = GTK_WIDGET_TYPE(child2);
1757                         g_message("                child2   [%s]", g_type_name(type3));
1758 #endif // DUMP_DETAILS
1759
1760                         if (GTK_IS_CONTAINER(child2)) {
1761                             GList* children2 = gtk_container_get_children(GTK_CONTAINER(child2));
1762                             if (children2) {
1763                                 for (GList* curr2 = children2; curr2; curr2 = g_list_next(curr2)) {
1764                                     GtkWidget* child3 = GTK_WIDGET(curr2->data);
1765 #if DUMP_DETAILS
1766                                     GType type4 = GTK_WIDGET_TYPE(child3);
1767                                     g_message("                    child3   [%s]", g_type_name(type4));
1768 #endif // DUMP_DETAILS
1769                                     if (GTK_IS_TOOLBAR(child3)) {
1770                                         GtkToolbar* childBar = GTK_TOOLBAR(child3);
1771                                         gtk_toolbar_set_orientation(childBar, orientation);
1772                                     }
1773                                 }
1774                                 g_list_free(children2);
1775                             }
1776                         }
1777
1778
1779                         if (GTK_IS_TOOLBAR(child2)) {
1780                             GtkToolbar* childBar = GTK_TOOLBAR(child2);
1781                             gtk_toolbar_set_orientation(childBar, orientation);
1782                             if (GTK_IS_HANDLE_BOX(toolbox)) {
1783                                 handleBox = GTK_HANDLE_BOX(toolbox);
1784                             }
1785                         } else {
1786                             g_message("need to add dynamic switch");
1787                         }
1788                     }
1789                     g_list_free(children);
1790                 } else {
1791                     // The call is being made before the toolbox proper has been setup.
1792                     if (GTK_IS_HANDLE_BOX(toolbox)) {
1793                         handleBox = GTK_HANDLE_BOX(toolbox);
1794                     } else {
1795                         g_object_set_data(G_OBJECT(toolbox), HANDLE_POS_MARK, GINT_TO_POINTER(pos));
1796                     }
1797                 }
1798             } else if (GTK_IS_TOOLBAR(child)) {
1799                 GtkToolbar* toolbar = GTK_TOOLBAR(child);
1800                 gtk_toolbar_set_orientation( toolbar, orientation );
1801                 if (GTK_IS_HANDLE_BOX(toolbox)) {
1802                     handleBox = GTK_HANDLE_BOX(toolbox);
1803                 }
1804             }
1805         }
1806     }
1807
1808     if (handleBox) {
1809         gtk_handle_box_set_handle_position(handleBox, pos);
1810     }
1811 }
1812
1813 void setup_tool_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
1814 {
1815     gchar const * descr =
1816         "<ui>"
1817         "  <toolbar name='ToolToolbar'>"
1818
1819         "   <!-- Basics -->"
1820         "    <toolitem action='ToolSelector' />"
1821         "    <toolitem action='ToolNode' />"
1822         "    <toolitem action='ToolTweak' />"
1823         "    <toolitem action='ToolZoom' />"
1824
1825         "   <!-- Shapes -->"
1826         "    <toolitem action='ToolRect' />"
1827         "    <toolitem action='Tool3DBox' />"
1828         "    <toolitem action='ToolArc' />"
1829         "    <toolitem action='ToolStar' />"
1830         "    <toolitem action='ToolSpiral' />"
1831
1832         "   <!-- Paths -->"
1833         "    <toolitem action='ToolPencil' />"
1834         "    <toolitem action='ToolPen' />"
1835         "    <toolitem action='ToolCalligraphic' />"
1836
1837         "   <!-- Text -->"
1838         "    <toolitem action='ToolText' />"
1839
1840         "   <!-- Paint large areas -->"
1841         "    <toolitem action='ToolSpray' />"
1842         "    <toolitem action='ToolEraser' />"
1843
1844         "   <!-- Fill -->"
1845         "    <toolitem action='ToolPaintBucket' />"
1846         "    <toolitem action='ToolGradient' />"
1847         "    <toolitem action='ToolDropper' />"
1848
1849         "    <toolitem action='ToolConnector' />"
1850
1851 //        "    <toolitem action='ToolLPETool' />"
1852         "  </toolbar>"
1853         "</ui>";
1854
1855     setupToolboxCommon( toolbox, desktop, descr,
1856                         "/ui/ToolToolbar",
1857                         "/toolbox/tools/small");
1858 }
1859
1860 void update_tool_toolbox( SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget * /*toolbox*/ )
1861 {
1862     gchar const *const tname = ( eventcontext
1863                                  ? gtk_type_name(GTK_OBJECT_TYPE(eventcontext))
1864                                  : NULL );
1865     Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions( desktop );
1866
1867     for (int i = 0 ; tools[i].type_name ; i++ ) {
1868         Glib::RefPtr<Gtk::Action> act = mainActions->get_action( Inkscape::Verb::get(tools[i].verb)->get_id() );
1869         if ( act ) {
1870             bool setActive = tname && !strcmp(tname, tools[i].type_name);
1871             Glib::RefPtr<VerbAction> verbAct = Glib::RefPtr<VerbAction>::cast_dynamic(act);
1872             if ( verbAct ) {
1873                 verbAct->set_active(setActive);
1874             }
1875         }
1876     }
1877 }
1878
1879 void setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
1880 {
1881     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1882     GtkSizeGroup* grouper = gtk_size_group_new( GTK_SIZE_GROUP_BOTH );
1883     Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions( desktop );
1884     GtkUIManager* mgr = gtk_ui_manager_new();
1885     GError* errVal = 0;
1886     gtk_ui_manager_insert_action_group( mgr, mainActions->gobj(), 0 );
1887     gtk_ui_manager_add_ui_from_string( mgr, ui_descr, -1, &errVal );
1888
1889     std::map<std::string, GtkWidget*> dataHolders;
1890
1891     for (int i = 0 ; aux_toolboxes[i].type_name ; i++ ) {
1892         if ( aux_toolboxes[i].prep_func ) {
1893             // converted to GtkActions and UIManager
1894
1895             GtkWidget* kludge = gtk_toolbar_new();
1896             g_object_set_data( G_OBJECT(kludge), "dtw", desktop->canvas);
1897             g_object_set_data( G_OBJECT(kludge), "desktop", desktop);
1898             dataHolders[aux_toolboxes[i].type_name] = kludge;
1899             aux_toolboxes[i].prep_func( desktop, mainActions->gobj(), G_OBJECT(kludge) );
1900         } else {
1901
1902             GtkWidget *sub_toolbox = 0;
1903             if (aux_toolboxes[i].create_func == NULL) {
1904                 sub_toolbox = sp_empty_toolbox_new(desktop);
1905             } else {
1906                 sub_toolbox = aux_toolboxes[i].create_func(desktop);
1907             }
1908
1909             gtk_size_group_add_widget( grouper, sub_toolbox );
1910
1911             gtk_container_add(GTK_CONTAINER(toolbox), sub_toolbox);
1912             g_object_set_data(G_OBJECT(toolbox), aux_toolboxes[i].data_name, sub_toolbox);
1913
1914         }
1915     }
1916
1917     // Second pass to create toolbars *after* all GtkActions are created
1918     for (int i = 0 ; aux_toolboxes[i].type_name ; i++ ) {
1919         if ( aux_toolboxes[i].prep_func ) {
1920             // converted to GtkActions and UIManager
1921
1922             GtkWidget* kludge = dataHolders[aux_toolboxes[i].type_name];
1923
1924             GtkWidget* holder = gtk_table_new( 1, 3, FALSE );
1925             gtk_table_attach( GTK_TABLE(holder), kludge, 2, 3, 0, 1, GTK_SHRINK, GTK_SHRINK, 0, 0 );
1926
1927             gchar* tmp = g_strdup_printf( "/ui/%s", aux_toolboxes[i].ui_name );
1928             GtkWidget* toolBar = gtk_ui_manager_get_widget( mgr, tmp );
1929             g_free( tmp );
1930             tmp = 0;
1931
1932             if ( prefs->getBool( "/toolbox/icononly", true) ) {
1933                 gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS );
1934             }
1935
1936             Inkscape::IconSize toolboxSize = ToolboxFactory::prefToSize("/toolbox/small");
1937             gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), static_cast<GtkIconSize>(toolboxSize) );
1938
1939             gtk_table_attach( GTK_TABLE(holder), toolBar, 0, 1, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0 );
1940
1941             if ( aux_toolboxes[i].swatch_verb_id != SP_VERB_INVALID ) {
1942                 Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch( NULL, _(aux_toolboxes[i].swatch_tip) );
1943                 swatch->setDesktop( desktop );
1944                 swatch->setClickVerb( aux_toolboxes[i].swatch_verb_id );
1945                 swatch->setWatchedTool( aux_toolboxes[i].swatch_tool, true );
1946                 GtkWidget *swatch_ = GTK_WIDGET( swatch->gobj() );
1947                 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 );
1948             }
1949
1950             gtk_widget_show_all( holder );
1951             sp_set_font_size_smaller( holder );
1952
1953             gtk_size_group_add_widget( grouper, holder );
1954
1955             gtk_container_add( GTK_CONTAINER(toolbox), holder );
1956             g_object_set_data( G_OBJECT(toolbox), aux_toolboxes[i].data_name, holder );
1957         }
1958     }
1959
1960     g_object_unref( G_OBJECT(grouper) );
1961 }
1962
1963 void update_aux_toolbox(SPDesktop * /*desktop*/, SPEventContext *eventcontext, GtkWidget *toolbox)
1964 {
1965     gchar const *tname = ( eventcontext
1966                            ? gtk_type_name(GTK_OBJECT_TYPE(eventcontext))
1967                            : NULL );
1968     for (int i = 0 ; aux_toolboxes[i].type_name ; i++ ) {
1969         GtkWidget *sub_toolbox = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbox), aux_toolboxes[i].data_name));
1970         if (tname && !strcmp(tname, aux_toolboxes[i].type_name)) {
1971             gtk_widget_show_all(sub_toolbox);
1972             g_object_set_data(G_OBJECT(toolbox), "shows", sub_toolbox);
1973         } else {
1974             gtk_widget_hide(sub_toolbox);
1975         }
1976     }
1977 }
1978
1979 void setup_commands_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
1980 {
1981     gchar const * descr =
1982         "<ui>"
1983         "  <toolbar name='CommandsToolbar'>"
1984         "    <toolitem action='FileNew' />"
1985         "    <toolitem action='FileOpen' />"
1986         "    <toolitem action='FileSave' />"
1987         "    <toolitem action='FilePrint' />"
1988         "    <separator />"
1989         "    <toolitem action='FileImport' />"
1990         "    <toolitem action='FileExport' />"
1991         "    <separator />"
1992         "    <toolitem action='EditUndo' />"
1993         "    <toolitem action='EditRedo' />"
1994         "    <separator />"
1995         "    <toolitem action='EditCopy' />"
1996         "    <toolitem action='EditCut' />"
1997         "    <toolitem action='EditPaste' />"
1998         "    <separator />"
1999         "    <toolitem action='ZoomSelection' />"
2000         "    <toolitem action='ZoomDrawing' />"
2001         "    <toolitem action='ZoomPage' />"
2002         "    <separator />"
2003         "    <toolitem action='EditDuplicate' />"
2004         "    <toolitem action='EditClone' />"
2005         "    <toolitem action='EditUnlinkClone' />"
2006         "    <separator />"
2007         "    <toolitem action='SelectionGroup' />"
2008         "    <toolitem action='SelectionUnGroup' />"
2009         "    <separator />"
2010         "    <toolitem action='DialogFillStroke' />"
2011         "    <toolitem action='DialogText' />"
2012         "    <toolitem action='DialogLayers' />"
2013         "    <toolitem action='DialogXMLEditor' />"
2014         "    <toolitem action='DialogAlignDistribute' />"
2015         "    <separator />"
2016         "    <toolitem action='DialogPreferences' />"
2017         "    <toolitem action='DialogDocumentProperties' />"
2018         "  </toolbar>"
2019         "</ui>";
2020
2021     setupToolboxCommon( toolbox, desktop, descr,
2022                         "/ui/CommandsToolbar",
2023                         "/toolbox/small" );
2024 }
2025
2026 void update_commands_toolbox(SPDesktop * /*desktop*/, SPEventContext * /*eventcontext*/, GtkWidget * /*toolbox*/)
2027 {
2028 }
2029
2030 static void toggle_snap_callback(GtkToggleAction *act, gpointer data) //data points to the toolbox
2031 {
2032     if (g_object_get_data(G_OBJECT(data), "freeze" )) {
2033         return;
2034     }
2035
2036     gpointer ptr = g_object_get_data(G_OBJECT(data), "desktop");
2037     g_assert(ptr != NULL);
2038
2039     SPDesktop *dt = reinterpret_cast<SPDesktop*>(ptr);
2040     SPNamedView *nv = sp_desktop_namedview(dt);
2041     SPDocument *doc = SP_OBJECT_DOCUMENT(nv);
2042
2043     if (dt == NULL || nv == NULL) {
2044         g_warning("No desktop or namedview specified (in toggle_snap_callback)!");
2045         return;
2046     }
2047
2048     Inkscape::XML::Node *repr = SP_OBJECT_REPR(nv);
2049
2050     if (repr == NULL) {
2051         g_warning("This namedview doesn't have a xml representation attached!");
2052         return;
2053     }
2054
2055     bool saved = sp_document_get_undo_sensitive(doc);
2056     sp_document_set_undo_sensitive(doc, false);
2057
2058     bool v = false;
2059     SPAttributeEnum attr = (SPAttributeEnum) GPOINTER_TO_INT(g_object_get_data(G_OBJECT(act), "SP_ATTR_INKSCAPE"));
2060
2061     switch (attr) {
2062         case SP_ATTR_INKSCAPE_SNAP_GLOBAL:
2063             dt->toggleSnapGlobal();
2064             break;
2065         case SP_ATTR_INKSCAPE_SNAP_BBOX:
2066             v = nv->snap_manager.snapprefs.getSnapModeBBox();
2067             sp_repr_set_boolean(repr, "inkscape:snap-bbox", !v);
2068             break;
2069         case SP_ATTR_INKSCAPE_BBOX_PATHS:
2070             v = nv->snap_manager.snapprefs.getSnapToBBoxPath();
2071             sp_repr_set_boolean(repr, "inkscape:bbox-paths", !v);
2072             break;
2073         case SP_ATTR_INKSCAPE_BBOX_NODES:
2074             v = nv->snap_manager.snapprefs.getSnapToBBoxNode();
2075             sp_repr_set_boolean(repr, "inkscape:bbox-nodes", !v);
2076             break;
2077         case SP_ATTR_INKSCAPE_SNAP_NODES:
2078             v = nv->snap_manager.snapprefs.getSnapModeNode();
2079             sp_repr_set_boolean(repr, "inkscape:snap-nodes", !v);
2080             break;
2081         case SP_ATTR_INKSCAPE_OBJECT_PATHS:
2082             v = nv->snap_manager.snapprefs.getSnapToItemPath();
2083             sp_repr_set_boolean(repr, "inkscape:object-paths", !v);
2084             break;
2085         case SP_ATTR_INKSCAPE_OBJECT_NODES:
2086             v = nv->snap_manager.snapprefs.getSnapToItemNode();
2087             sp_repr_set_boolean(repr, "inkscape:object-nodes", !v);
2088             break;
2089         case SP_ATTR_INKSCAPE_SNAP_SMOOTH_NODES:
2090             v = nv->snap_manager.snapprefs.getSnapSmoothNodes();
2091             sp_repr_set_boolean(repr, "inkscape:snap-smooth-nodes", !v);
2092             break;
2093         case SP_ATTR_INKSCAPE_SNAP_INTERS_PATHS:
2094             v = nv->snap_manager.snapprefs.getSnapIntersectionCS();
2095             sp_repr_set_boolean(repr, "inkscape:snap-intersection-paths", !v);
2096             break;
2097         case SP_ATTR_INKSCAPE_SNAP_CENTER:
2098             v = nv->snap_manager.snapprefs.getIncludeItemCenter();
2099             sp_repr_set_boolean(repr, "inkscape:snap-center", !v);
2100             break;
2101         case SP_ATTR_INKSCAPE_SNAP_GRIDS:
2102             v = nv->snap_manager.snapprefs.getSnapToGrids();
2103             sp_repr_set_boolean(repr, "inkscape:snap-grids", !v);
2104             break;
2105         case SP_ATTR_INKSCAPE_SNAP_TO_GUIDES:
2106             v = nv->snap_manager.snapprefs.getSnapToGuides();
2107             sp_repr_set_boolean(repr, "inkscape:snap-to-guides", !v);
2108             break;
2109         case SP_ATTR_INKSCAPE_SNAP_PAGE:
2110             v = nv->snap_manager.snapprefs.getSnapToPageBorder();
2111             sp_repr_set_boolean(repr, "inkscape:snap-page", !v);
2112             break;
2113             /*case SP_ATTR_INKSCAPE_SNAP_INTERS_GRIDGUIDE:
2114               v = nv->snap_manager.snapprefs.getSnapIntersectionGG();
2115               sp_repr_set_boolean(repr, "inkscape:snap-intersection-grid-guide", !v);
2116               break;*/
2117         case SP_ATTR_INKSCAPE_SNAP_LINE_MIDPOINTS:
2118             v = nv->snap_manager.snapprefs.getSnapLineMidpoints();
2119             sp_repr_set_boolean(repr, "inkscape:snap-midpoints", !v);
2120             break;
2121         case SP_ATTR_INKSCAPE_SNAP_OBJECT_MIDPOINTS:
2122             v = nv->snap_manager.snapprefs.getSnapObjectMidpoints();
2123             sp_repr_set_boolean(repr, "inkscape:snap-object-midpoints", !v);
2124             break;
2125         case SP_ATTR_INKSCAPE_SNAP_BBOX_EDGE_MIDPOINTS:
2126             v = nv->snap_manager.snapprefs.getSnapBBoxEdgeMidpoints();
2127             sp_repr_set_boolean(repr, "inkscape:snap-bbox-edge-midpoints", !v);
2128             break;
2129         case SP_ATTR_INKSCAPE_SNAP_BBOX_MIDPOINTS:
2130             v = nv->snap_manager.snapprefs.getSnapBBoxMidpoints();
2131             sp_repr_set_boolean(repr, "inkscape:snap-bbox-midpoints", !v);
2132             break;
2133         default:
2134             g_warning("toggle_snap_callback has been called with an ID for which no action has been defined");
2135             break;
2136     }
2137
2138     // The snapping preferences are stored in the document, and therefore toggling makes the document dirty
2139     doc->setModifiedSinceSave();
2140
2141     sp_document_set_undo_sensitive(doc, saved);
2142 }
2143
2144 void setup_snap_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
2145 {
2146     Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions(desktop);
2147
2148     gchar const * descr =
2149         "<ui>"
2150         "  <toolbar name='SnapToolbar'>"
2151         "    <toolitem action='ToggleSnapGlobal' />"
2152         "    <separator />"
2153         "    <toolitem action='ToggleSnapFromBBoxCorner' />"
2154         "    <toolitem action='ToggleSnapToBBoxPath' />"
2155         "    <toolitem action='ToggleSnapToBBoxNode' />"
2156         "    <toolitem action='ToggleSnapToFromBBoxEdgeMidpoints' />"
2157         "    <toolitem action='ToggleSnapToFromBBoxCenters' />"
2158         "    <separator />"
2159         "    <toolitem action='ToggleSnapFromNode' />"
2160         "    <toolitem action='ToggleSnapToItemPath' />"
2161         "    <toolitem action='ToggleSnapToPathIntersections' />"
2162         "    <toolitem action='ToggleSnapToItemNode' />"
2163         "    <toolitem action='ToggleSnapToSmoothNodes' />"
2164         "    <toolitem action='ToggleSnapToFromLineMidpoints' />"
2165         "    <toolitem action='ToggleSnapToFromObjectCenters' />"
2166         "    <toolitem action='ToggleSnapToFromRotationCenter' />"
2167         "    <separator />"
2168         "    <toolitem action='ToggleSnapToPageBorder' />"
2169         "    <toolitem action='ToggleSnapToGrids' />"
2170         "    <toolitem action='ToggleSnapToGuides' />"
2171         //"    <toolitem action='ToggleSnapToGridGuideIntersections' />"
2172         "  </toolbar>"
2173         "</ui>";
2174
2175     Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
2176
2177     {
2178         InkToggleAction* act = ink_toggle_action_new("ToggleSnapGlobal",
2179                                                      _("Snap"), _("Enable snapping"), INKSCAPE_ICON_SNAP, secondarySize,
2180                                                      SP_ATTR_INKSCAPE_SNAP_GLOBAL);
2181
2182         gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2183         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2184     }
2185
2186     {
2187         InkToggleAction* act = ink_toggle_action_new("ToggleSnapFromBBoxCorner",
2188                                                      _("Bounding box"), _("Snap bounding box corners"), INKSCAPE_ICON_SNAP_BOUNDING_BOX,
2189                                                      secondarySize, SP_ATTR_INKSCAPE_SNAP_BBOX);
2190
2191         gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2192         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2193     }
2194
2195     {
2196         InkToggleAction* act = ink_toggle_action_new("ToggleSnapToBBoxPath",
2197                                                      _("Bounding box edges"), _("Snap to edges of a bounding box"),
2198                                                      INKSCAPE_ICON_SNAP_BOUNDING_BOX_EDGES, secondarySize, SP_ATTR_INKSCAPE_BBOX_PATHS);
2199
2200         gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2201         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2202     }
2203
2204     {
2205         InkToggleAction* act = ink_toggle_action_new("ToggleSnapToBBoxNode",
2206                                                      _("Bounding box corners"), _("Snap to bounding box corners"),
2207                                                      INKSCAPE_ICON_SNAP_BOUNDING_BOX_CORNERS, secondarySize, SP_ATTR_INKSCAPE_BBOX_NODES);
2208
2209         gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2210         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2211     }
2212
2213     {
2214         InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromBBoxEdgeMidpoints",
2215                                                      _("BBox Edge Midpoints"), _("Snap from and to midpoints of bounding box edges"),
2216                                                      INKSCAPE_ICON_SNAP_BOUNDING_BOX_MIDPOINTS, secondarySize,
2217                                                      SP_ATTR_INKSCAPE_SNAP_BBOX_EDGE_MIDPOINTS);
2218
2219         gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2220         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2221     }
2222
2223     {
2224         InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromBBoxCenters",
2225                                                      _("BBox Centers"), _("Snapping from and to centers of bounding boxes"),
2226                                                      INKSCAPE_ICON_SNAP_BOUNDING_BOX_CENTER, secondarySize, SP_ATTR_INKSCAPE_SNAP_BBOX_MIDPOINTS);
2227
2228         gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2229         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2230     }
2231
2232     {
2233         InkToggleAction* act = ink_toggle_action_new("ToggleSnapFromNode",
2234                                                      _("Nodes"), _("Snap nodes or handles"), INKSCAPE_ICON_SNAP_NODES, secondarySize, SP_ATTR_INKSCAPE_SNAP_NODES);
2235
2236         gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2237         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2238     }
2239
2240     {
2241         InkToggleAction* act = ink_toggle_action_new("ToggleSnapToItemPath",
2242                                                      _("Paths"), _("Snap to paths"), INKSCAPE_ICON_SNAP_NODES_PATH, secondarySize,
2243                                                      SP_ATTR_INKSCAPE_OBJECT_PATHS);
2244
2245         gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2246         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2247     }
2248
2249     {
2250         InkToggleAction* act = ink_toggle_action_new("ToggleSnapToPathIntersections",
2251                                                      _("Path intersections"), _("Snap to path intersections"),
2252                                                      INKSCAPE_ICON_SNAP_NODES_INTERSECTION, secondarySize, SP_ATTR_INKSCAPE_SNAP_INTERS_PATHS);
2253
2254         gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2255         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2256     }
2257
2258     {
2259         InkToggleAction* act = ink_toggle_action_new("ToggleSnapToItemNode",
2260                                                      _("To nodes"), _("Snap to cusp nodes"), INKSCAPE_ICON_SNAP_NODES_CUSP, secondarySize,
2261                                                      SP_ATTR_INKSCAPE_OBJECT_NODES);
2262
2263         gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2264         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2265     }
2266
2267     {
2268         InkToggleAction* act = ink_toggle_action_new("ToggleSnapToSmoothNodes",
2269                                                      _("Smooth nodes"), _("Snap to smooth nodes"), INKSCAPE_ICON_SNAP_NODES_SMOOTH,
2270                                                      secondarySize, SP_ATTR_INKSCAPE_SNAP_SMOOTH_NODES);
2271
2272         gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2273         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2274     }
2275
2276     {
2277         InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromLineMidpoints",
2278                                                      _("Line Midpoints"), _("Snap from and to midpoints of line segments"),
2279                                                      INKSCAPE_ICON_SNAP_NODES_MIDPOINT, secondarySize, SP_ATTR_INKSCAPE_SNAP_LINE_MIDPOINTS);
2280
2281         gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2282         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2283     }
2284
2285     {
2286         InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromObjectCenters",
2287                                                      _("Object Centers"), _("Snap from and to centers of objects"),
2288                                                      INKSCAPE_ICON_SNAP_NODES_CENTER, secondarySize, SP_ATTR_INKSCAPE_SNAP_OBJECT_MIDPOINTS);
2289
2290         gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2291         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2292     }
2293
2294     {
2295         InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromRotationCenter",
2296                                                      _("Rotation Centers"), _("Snap from and to an item's rotation center"),
2297                                                      INKSCAPE_ICON_SNAP_NODES_ROTATION_CENTER, secondarySize, SP_ATTR_INKSCAPE_SNAP_CENTER);
2298
2299         gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2300         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2301     }
2302
2303     {
2304         InkToggleAction* act = ink_toggle_action_new("ToggleSnapToPageBorder",
2305                                                      _("Page border"), _("Snap to the page border"), INKSCAPE_ICON_SNAP_PAGE,
2306                                                      secondarySize, SP_ATTR_INKSCAPE_SNAP_PAGE);
2307
2308         gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2309         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2310     }
2311
2312     {
2313         InkToggleAction* act = ink_toggle_action_new("ToggleSnapToGrids",
2314                                                      _("Grids"), _("Snap to grids"), INKSCAPE_ICON_GRID_RECTANGULAR, secondarySize,
2315                                                      SP_ATTR_INKSCAPE_SNAP_GRIDS);
2316
2317         gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2318         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2319     }
2320
2321     {
2322         InkToggleAction* act = ink_toggle_action_new("ToggleSnapToGuides",
2323                                                      _("Guides"), _("Snap to guides"), INKSCAPE_ICON_GUIDES, secondarySize,
2324                                                      SP_ATTR_INKSCAPE_SNAP_TO_GUIDES);
2325
2326         gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2327         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2328     }
2329
2330     /*{
2331       InkToggleAction* act = ink_toggle_action_new("ToggleSnapToGridGuideIntersections",
2332       _("Grid/guide intersections"), _("Snap to intersections of a grid with a guide"),
2333       INKSCAPE_ICON_SNAP_GRID_GUIDE_INTERSECTIONS, secondarySize,
2334       SP_ATTR_INKSCAPE_SNAP_INTERS_GRIDGUIDE);
2335
2336       gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2337       g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2338       }*/
2339
2340     setupToolboxCommon( toolbox, desktop, descr,
2341                         "/ui/SnapToolbar",
2342                         "/toolbox/secondary" );
2343 }
2344
2345 Glib::ustring ToolboxFactory::getToolboxName(GtkWidget* toolbox)
2346 {
2347     Glib::ustring name;
2348     BarId id = static_cast<BarId>( GPOINTER_TO_INT(g_object_get_data(G_OBJECT(toolbox), BAR_ID_KEY)) );
2349     switch(id) {
2350         case BAR_TOOL:
2351             name = "ToolToolbar";
2352             break;
2353         case BAR_AUX:
2354             name = "AuxToolbar";
2355             break;
2356         case BAR_COMMANDS:
2357             name = "CommandsToolbar";
2358             break;
2359         case BAR_SNAP:
2360             name = "SnapToolbar";
2361             break;
2362     }
2363
2364     return name;
2365 }
2366
2367 void ToolboxFactory::updateSnapToolbox(SPDesktop *desktop, SPEventContext * /*eventcontext*/, GtkWidget *toolbox)
2368 {
2369     g_assert(desktop != NULL);
2370     g_assert(toolbox != NULL);
2371
2372     SPNamedView *nv = sp_desktop_namedview(desktop);
2373     if (nv == NULL) {
2374         g_warning("Namedview cannot be retrieved (in updateSnapToolbox)!");
2375         return;
2376     }
2377
2378     Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions(desktop);
2379
2380     Glib::RefPtr<Gtk::Action> act1 = mainActions->get_action("ToggleSnapGlobal");
2381     Glib::RefPtr<Gtk::Action> act2 = mainActions->get_action("ToggleSnapFromBBoxCorner");
2382     Glib::RefPtr<Gtk::Action> act3 = mainActions->get_action("ToggleSnapToBBoxPath");
2383     Glib::RefPtr<Gtk::Action> act4 = mainActions->get_action("ToggleSnapToBBoxNode");
2384     Glib::RefPtr<Gtk::Action> act4b = mainActions->get_action("ToggleSnapToFromBBoxEdgeMidpoints");
2385     Glib::RefPtr<Gtk::Action> act4c = mainActions->get_action("ToggleSnapToFromBBoxCenters");
2386     Glib::RefPtr<Gtk::Action> act5 = mainActions->get_action("ToggleSnapFromNode");
2387     Glib::RefPtr<Gtk::Action> act6 = mainActions->get_action("ToggleSnapToItemPath");
2388     Glib::RefPtr<Gtk::Action> act6b = mainActions->get_action("ToggleSnapToPathIntersections");
2389     Glib::RefPtr<Gtk::Action> act7 = mainActions->get_action("ToggleSnapToItemNode");
2390     Glib::RefPtr<Gtk::Action> act8 = mainActions->get_action("ToggleSnapToSmoothNodes");
2391     Glib::RefPtr<Gtk::Action> act9 = mainActions->get_action("ToggleSnapToFromLineMidpoints");
2392     Glib::RefPtr<Gtk::Action> act10 = mainActions->get_action("ToggleSnapToFromObjectCenters");
2393     Glib::RefPtr<Gtk::Action> act11 = mainActions->get_action("ToggleSnapToFromRotationCenter");
2394     Glib::RefPtr<Gtk::Action> act12 = mainActions->get_action("ToggleSnapToPageBorder");
2395     //Glib::RefPtr<Gtk::Action> act13 = mainActions->get_action("ToggleSnapToGridGuideIntersections");
2396     Glib::RefPtr<Gtk::Action> act14 = mainActions->get_action("ToggleSnapToGrids");
2397     Glib::RefPtr<Gtk::Action> act15 = mainActions->get_action("ToggleSnapToGuides");
2398
2399
2400     if (!act1) {
2401         return; // The snap actions haven't been defined yet (might be the case during startup)
2402     }
2403
2404     // The ..._set_active calls below will toggle the buttons, but this shouldn't lead to
2405     // changes in our document because we're only updating the UI;
2406     // Setting the "freeze" parameter to true will block the code in toggle_snap_callback()
2407     g_object_set_data(G_OBJECT(toolbox), "freeze", GINT_TO_POINTER(TRUE));
2408
2409     bool const c1 = nv->snap_manager.snapprefs.getSnapEnabledGlobally();
2410     gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act1->gobj()), c1);
2411
2412     bool const c2 = nv->snap_manager.snapprefs.getSnapModeBBox();
2413     gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act2->gobj()), c2);
2414     gtk_action_set_sensitive(GTK_ACTION(act2->gobj()), c1);
2415
2416     gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act3->gobj()), nv->snap_manager.snapprefs.getSnapToBBoxPath());
2417     gtk_action_set_sensitive(GTK_ACTION(act3->gobj()), c1 && c2);
2418     gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act4->gobj()), nv->snap_manager.snapprefs.getSnapToBBoxNode());
2419     gtk_action_set_sensitive(GTK_ACTION(act4->gobj()), c1 && c2);
2420     gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act4b->gobj()), nv->snap_manager.snapprefs.getSnapBBoxEdgeMidpoints());
2421     gtk_action_set_sensitive(GTK_ACTION(act4b->gobj()), c1 && c2);
2422     gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act4c->gobj()), nv->snap_manager.snapprefs.getSnapBBoxMidpoints());
2423     gtk_action_set_sensitive(GTK_ACTION(act4c->gobj()), c1 && c2);
2424
2425     bool const c3 = nv->snap_manager.snapprefs.getSnapModeNode();
2426     gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act5->gobj()), c3);
2427     gtk_action_set_sensitive(GTK_ACTION(act5->gobj()), c1);
2428
2429     bool const c4 = nv->snap_manager.snapprefs.getSnapToItemPath();
2430     gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act6->gobj()), c4);
2431     gtk_action_set_sensitive(GTK_ACTION(act6->gobj()), c1 && c3);
2432     gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act6b->gobj()), nv->snap_manager.snapprefs.getSnapIntersectionCS());
2433     gtk_action_set_sensitive(GTK_ACTION(act6b->gobj()), c1 && c3 && c4);
2434     gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act7->gobj()), nv->snap_manager.snapprefs.getSnapToItemNode());
2435     gtk_action_set_sensitive(GTK_ACTION(act7->gobj()), c1 && c3);
2436     gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act8->gobj()), nv->snap_manager.snapprefs.getSnapSmoothNodes());
2437     gtk_action_set_sensitive(GTK_ACTION(act8->gobj()), c1 && c3);
2438     gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act9->gobj()), nv->snap_manager.snapprefs.getSnapLineMidpoints());
2439     gtk_action_set_sensitive(GTK_ACTION(act9->gobj()), c1 && c3);
2440     gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act10->gobj()), nv->snap_manager.snapprefs.getSnapObjectMidpoints());
2441     gtk_action_set_sensitive(GTK_ACTION(act10->gobj()), c1 && c3);
2442     gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act11->gobj()), nv->snap_manager.snapprefs.getIncludeItemCenter());
2443     gtk_action_set_sensitive(GTK_ACTION(act11->gobj()), c1 && c3);
2444
2445     gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act12->gobj()), nv->snap_manager.snapprefs.getSnapToPageBorder());
2446     gtk_action_set_sensitive(GTK_ACTION(act12->gobj()), c1);
2447     //gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act13->gobj()), nv->snap_manager.snapprefs.getSnapIntersectionGG());
2448     //gtk_action_set_sensitive(GTK_ACTION(act13->gobj()), c1);
2449
2450     gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act14->gobj()), nv->snap_manager.snapprefs.getSnapToGrids());
2451     gtk_action_set_sensitive(GTK_ACTION(act14->gobj()), c1);
2452     gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act15->gobj()), nv->snap_manager.snapprefs.getSnapToGuides());
2453     gtk_action_set_sensitive(GTK_ACTION(act15->gobj()), c1);
2454
2455
2456     g_object_set_data(G_OBJECT(toolbox), "freeze", GINT_TO_POINTER(FALSE)); // unfreeze (see above)
2457 }
2458
2459 void ToolboxFactory::showAuxToolbox(GtkWidget *toolbox_toplevel)
2460 {
2461     gtk_widget_show(toolbox_toplevel);
2462     GtkWidget *toolbox = gtk_bin_get_child(GTK_BIN(toolbox_toplevel));
2463
2464     GtkWidget *shown_toolbox = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbox), "shows"));
2465     if (!shown_toolbox) {
2466         return;
2467     }
2468     gtk_widget_show(toolbox);
2469
2470     gtk_widget_show_all(shown_toolbox);
2471 }
2472
2473 static GtkWidget *sp_empty_toolbox_new(SPDesktop *desktop)
2474 {
2475     GtkWidget *tbl = gtk_toolbar_new();
2476     gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
2477     gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop);
2478
2479     gtk_widget_show_all(tbl);
2480     sp_set_font_size_smaller (tbl);
2481
2482     return tbl;
2483 }
2484
2485 #define MODE_LABEL_WIDTH 70
2486
2487 //########################
2488 //##       Star         ##
2489 //########################
2490
2491 static void sp_stb_magnitude_value_changed( GtkAdjustment *adj, GObject *dataKludge )
2492 {
2493     SPDesktop *desktop = (SPDesktop *) g_object_get_data( dataKludge, "desktop" );
2494
2495     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
2496         // do not remember prefs if this call is initiated by an undo change, because undoing object
2497         // creation sets bogus values to its attributes before it is deleted
2498         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
2499         prefs->setInt("/tools/shapes/star/magnitude", (gint)adj->value);
2500     }
2501
2502     // quit if run by the attr_changed listener
2503     if (g_object_get_data( dataKludge, "freeze" )) {
2504         return;
2505     }
2506
2507     // in turn, prevent listener from responding
2508     g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(TRUE) );
2509
2510     bool modmade = false;
2511
2512     Inkscape::Selection *selection = sp_desktop_selection(desktop);
2513     GSList const *items = selection->itemList();
2514     for (; items != NULL; items = items->next) {
2515         if (SP_IS_STAR((SPItem *) items->data)) {
2516             Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
2517             sp_repr_set_int(repr,"sodipodi:sides",(gint)adj->value);
2518             sp_repr_set_svg_double(repr, "sodipodi:arg2",
2519                                    (sp_repr_get_double_attribute(repr, "sodipodi:arg1", 0.5)
2520                                     + M_PI / (gint)adj->value));
2521             SP_OBJECT((SPItem *) items->data)->updateRepr();
2522             modmade = true;
2523         }
2524     }
2525     if (modmade) {
2526         sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
2527                          _("Star: Change number of corners"));
2528     }
2529
2530     g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) );
2531 }
2532
2533 static void sp_stb_proportion_value_changed( GtkAdjustment *adj, GObject *dataKludge )
2534 {
2535     SPDesktop *desktop = (SPDesktop *) g_object_get_data( dataKludge, "desktop" );
2536
2537     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
2538         if (!IS_NAN(adj->value)) {
2539             Inkscape::Preferences *prefs = Inkscape::Preferences::get();
2540             prefs->setDouble("/tools/shapes/star/proportion", adj->value);
2541         }
2542     }
2543
2544     // quit if run by the attr_changed listener
2545     if (g_object_get_data( dataKludge, "freeze" )) {
2546         return;
2547     }
2548
2549     // in turn, prevent listener from responding
2550     g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(TRUE) );
2551
2552     bool modmade = false;
2553     Inkscape::Selection *selection = sp_desktop_selection(desktop);
2554     GSList const *items = selection->itemList();
2555     for (; items != NULL; items = items->next) {
2556         if (SP_IS_STAR((SPItem *) items->data)) {
2557             Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
2558
2559             gdouble r1 = sp_repr_get_double_attribute(repr, "sodipodi:r1", 1.0);
2560             gdouble r2 = sp_repr_get_double_attribute(repr, "sodipodi:r2", 1.0);
2561             if (r2 < r1) {
2562                 sp_repr_set_svg_double(repr, "sodipodi:r2", r1*adj->value);
2563             } else {
2564                 sp_repr_set_svg_double(repr, "sodipodi:r1", r2*adj->value);
2565             }
2566
2567             SP_OBJECT((SPItem *) items->data)->updateRepr();
2568             modmade = true;
2569         }
2570     }
2571
2572     if (modmade) {
2573         sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
2574                          _("Star: Change spoke ratio"));
2575     }
2576
2577     g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) );
2578 }
2579
2580 static void sp_stb_sides_flat_state_changed( EgeSelectOneAction *act, GObject *dataKludge )
2581 {
2582     SPDesktop *desktop = (SPDesktop *) g_object_get_data( dataKludge, "desktop" );
2583     bool flat = ege_select_one_action_get_active( act ) == 0;
2584
2585     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
2586         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
2587         prefs->setBool( "/tools/shapes/star/isflatsided", flat);
2588     }
2589
2590     // quit if run by the attr_changed listener
2591     if (g_object_get_data( dataKludge, "freeze" )) {
2592         return;
2593     }
2594
2595     // in turn, prevent listener from responding
2596     g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(TRUE) );
2597
2598     Inkscape::Selection *selection = sp_desktop_selection(desktop);
2599     GSList const *items = selection->itemList();
2600     GtkAction* prop_action = GTK_ACTION( g_object_get_data( dataKludge, "prop_action" ) );
2601     bool modmade = false;
2602
2603     if ( prop_action ) {
2604         gtk_action_set_sensitive( prop_action, !flat );
2605     }
2606
2607     for (; items != NULL; items = items->next) {
2608         if (SP_IS_STAR((SPItem *) items->data)) {
2609             Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
2610             repr->setAttribute("inkscape:flatsided", flat ? "true" : "false" );
2611             SP_OBJECT((SPItem *) items->data)->updateRepr();
2612             modmade = true;
2613         }
2614     }
2615
2616     if (modmade) {
2617         sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
2618                          flat ? _("Make polygon") : _("Make star"));
2619     }
2620
2621     g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) );
2622 }
2623
2624 static void sp_stb_rounded_value_changed( GtkAdjustment *adj, GObject *dataKludge )
2625 {
2626     SPDesktop *desktop = (SPDesktop *) g_object_get_data( dataKludge, "desktop" );
2627
2628     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
2629         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
2630         prefs->setDouble("/tools/shapes/star/rounded", (gdouble) adj->value);
2631     }
2632
2633     // quit if run by the attr_changed listener
2634     if (g_object_get_data( dataKludge, "freeze" )) {
2635         return;
2636     }
2637
2638     // in turn, prevent listener from responding
2639     g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(TRUE) );
2640
2641     bool modmade = false;
2642
2643     Inkscape::Selection *selection = sp_desktop_selection(desktop);
2644     GSList const *items = selection->itemList();
2645     for (; items != NULL; items = items->next) {
2646         if (SP_IS_STAR((SPItem *) items->data)) {
2647             Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
2648             sp_repr_set_svg_double(repr, "inkscape:rounded", (gdouble) adj->value);
2649             SP_OBJECT(items->data)->updateRepr();
2650             modmade = true;
2651         }
2652     }
2653     if (modmade) {
2654         sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
2655                          _("Star: Change rounding"));
2656     }
2657
2658     g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) );
2659 }
2660
2661 static void sp_stb_randomized_value_changed( GtkAdjustment *adj, GObject *dataKludge )
2662 {
2663     SPDesktop *desktop = (SPDesktop *) g_object_get_data( dataKludge, "desktop" );
2664
2665     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
2666         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
2667         prefs->setDouble("/tools/shapes/star/randomized", (gdouble) adj->value);
2668     }
2669
2670     // quit if run by the attr_changed listener
2671     if (g_object_get_data( dataKludge, "freeze" )) {
2672         return;
2673     }
2674
2675     // in turn, prevent listener from responding
2676     g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(TRUE) );
2677
2678     bool modmade = false;
2679
2680     Inkscape::Selection *selection = sp_desktop_selection(desktop);
2681     GSList const *items = selection->itemList();
2682     for (; items != NULL; items = items->next) {
2683         if (SP_IS_STAR((SPItem *) items->data)) {
2684             Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
2685             sp_repr_set_svg_double(repr, "inkscape:randomized", (gdouble) adj->value);
2686             SP_OBJECT(items->data)->updateRepr();
2687             modmade = true;
2688         }
2689     }
2690     if (modmade) {
2691         sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
2692                          _("Star: Change randomization"));
2693     }
2694
2695     g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) );
2696 }
2697
2698
2699 static void star_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const *name,
2700                                        gchar const * /*old_value*/, gchar const * /*new_value*/,
2701                                        bool /*is_interactive*/, gpointer data)
2702 {
2703     GtkWidget *tbl = GTK_WIDGET(data);
2704
2705     // quit if run by the _changed callbacks
2706     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
2707         return;
2708     }
2709
2710     // in turn, prevent callbacks from responding
2711     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE));
2712
2713     GtkAdjustment *adj = 0;
2714
2715     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
2716     bool isFlatSided = prefs->getBool("/tools/shapes/star/isflatsided", true);
2717
2718     if (!strcmp(name, "inkscape:randomized")) {
2719         adj = GTK_ADJUSTMENT( gtk_object_get_data(GTK_OBJECT(tbl), "randomized") );
2720         gtk_adjustment_set_value(adj, sp_repr_get_double_attribute(repr, "inkscape:randomized", 0.0));
2721     } else if (!strcmp(name, "inkscape:rounded")) {
2722         adj = GTK_ADJUSTMENT( gtk_object_get_data(GTK_OBJECT(tbl), "rounded") );
2723         gtk_adjustment_set_value(adj, sp_repr_get_double_attribute(repr, "inkscape:rounded", 0.0));
2724     } else if (!strcmp(name, "inkscape:flatsided")) {
2725         GtkAction* prop_action = GTK_ACTION( g_object_get_data(G_OBJECT(tbl), "prop_action") );
2726         char const *flatsides = repr->attribute("inkscape:flatsided");
2727         EgeSelectOneAction* flat_action = EGE_SELECT_ONE_ACTION( g_object_get_data( G_OBJECT(tbl), "flat_action" ) );
2728         if ( flatsides && !strcmp(flatsides,"false") ) {
2729             ege_select_one_action_set_active( flat_action, 1 );
2730             gtk_action_set_sensitive( prop_action, TRUE );
2731         } else {
2732             ege_select_one_action_set_active( flat_action, 0 );
2733             gtk_action_set_sensitive( prop_action, FALSE );
2734         }
2735     } else if ((!strcmp(name, "sodipodi:r1") || !strcmp(name, "sodipodi:r2")) && (!isFlatSided) ) {
2736         adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "proportion");
2737         gdouble r1 = sp_repr_get_double_attribute(repr, "sodipodi:r1", 1.0);
2738         gdouble r2 = sp_repr_get_double_attribute(repr, "sodipodi:r2", 1.0);
2739         if (r2 < r1) {
2740             gtk_adjustment_set_value(adj, r2/r1);
2741         } else {
2742             gtk_adjustment_set_value(adj, r1/r2);
2743         }
2744     } else if (!strcmp(name, "sodipodi:sides")) {
2745         adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "magnitude");
2746         gtk_adjustment_set_value(adj, sp_repr_get_int_attribute(repr, "sodipodi:sides", 0));
2747     }
2748
2749     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
2750 }
2751
2752
2753 static Inkscape::XML::NodeEventVector star_tb_repr_events =
2754 {
2755     NULL, /* child_added */
2756     NULL, /* child_removed */
2757     star_tb_event_attr_changed,
2758     NULL, /* content_changed */
2759     NULL  /* order_changed */
2760 };
2761
2762
2763 /**
2764  *  \param selection Should not be NULL.
2765  */
2766 static void
2767 sp_star_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
2768 {
2769     int n_selected = 0;
2770     Inkscape::XML::Node *repr = NULL;
2771
2772     purge_repr_listener( tbl, tbl );
2773
2774     for (GSList const *items = selection->itemList();
2775          items != NULL;
2776          items = items->next)
2777     {
2778         if (SP_IS_STAR((SPItem *) items->data)) {
2779             n_selected++;
2780             repr = SP_OBJECT_REPR((SPItem *) items->data);
2781         }
2782     }
2783
2784     EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) );
2785
2786     if (n_selected == 0) {
2787         g_object_set( G_OBJECT(act), "label", _("<b>New:</b>"), NULL );
2788     } else if (n_selected == 1) {
2789         g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
2790
2791         if (repr) {
2792             g_object_set_data( tbl, "repr", repr );
2793             Inkscape::GC::anchor(repr);
2794             sp_repr_add_listener(repr, &star_tb_repr_events, tbl);
2795             sp_repr_synthesize_events(repr, &star_tb_repr_events, tbl);
2796         }
2797     } else {
2798         // FIXME: implement averaging of all parameters for multiple selected stars
2799         //gtk_label_set_markup(GTK_LABEL(l), _("<b>Average:</b>"));
2800         //gtk_label_set_markup(GTK_LABEL(l), _("<b>Change:</b>"));
2801     }
2802 }
2803
2804
2805 static void sp_stb_defaults( GtkWidget * /*widget*/, GObject *dataKludge )
2806 {
2807     // FIXME: in this and all other _default functions, set some flag telling the value_changed
2808     // callbacks to lump all the changes for all selected objects in one undo step
2809
2810     GtkAdjustment *adj = 0;
2811
2812     // fixme: make settable in prefs!
2813     gint mag = 5;
2814     gdouble prop = 0.5;
2815     gboolean flat = FALSE;
2816     gdouble randomized = 0;
2817     gdouble rounded = 0;
2818
2819     EgeSelectOneAction* flat_action = EGE_SELECT_ONE_ACTION( g_object_get_data( dataKludge, "flat_action" ) );
2820     ege_select_one_action_set_active( flat_action, flat ? 0 : 1 );
2821
2822     GtkAction* sb2 = GTK_ACTION( g_object_get_data( dataKludge, "prop_action" ) );
2823     gtk_action_set_sensitive( sb2, !flat );
2824
2825     adj = GTK_ADJUSTMENT( g_object_get_data( dataKludge, "magnitude" ) );
2826     gtk_adjustment_set_value(adj, mag);
2827     gtk_adjustment_value_changed(adj);
2828
2829     adj = GTK_ADJUSTMENT( g_object_get_data( dataKludge, "proportion" ) );
2830     gtk_adjustment_set_value(adj, prop);
2831     gtk_adjustment_value_changed(adj);
2832
2833     adj = GTK_ADJUSTMENT( g_object_get_data( dataKludge, "rounded" ) );
2834     gtk_adjustment_set_value(adj, rounded);
2835     gtk_adjustment_value_changed(adj);
2836
2837     adj = GTK_ADJUSTMENT( g_object_get_data( dataKludge, "randomized" ) );
2838     gtk_adjustment_set_value(adj, randomized);
2839     gtk_adjustment_value_changed(adj);
2840 }
2841
2842
2843 // public:
2844 void sp_toolbox_add_label(GtkWidget *tbl, gchar const *title, bool wide)
2845 {
2846     GtkWidget *boxl = gtk_hbox_new(FALSE, 0);
2847     if (wide) {
2848         gtk_widget_set_size_request(boxl, MODE_LABEL_WIDTH, -1);
2849     }
2850     GtkWidget *l = gtk_label_new(NULL);
2851     gtk_label_set_markup(GTK_LABEL(l), title);
2852     gtk_box_pack_end(GTK_BOX(boxl), l, FALSE, FALSE, 0);
2853     if ( GTK_IS_TOOLBAR(tbl) ) {
2854         gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), boxl, "", "" );
2855     } else {
2856         gtk_box_pack_start(GTK_BOX(tbl), boxl, FALSE, FALSE, 0);
2857     }
2858     gtk_object_set_data(GTK_OBJECT(tbl), "mode_label", l);
2859 }
2860
2861
2862 static void sp_star_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
2863 {
2864     Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
2865
2866     {
2867         EgeOutputAction* act = ege_output_action_new( "StarStateAction", _("<b>New:</b>"), "", 0 );
2868         ege_output_action_set_use_markup( act, TRUE );
2869         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
2870         g_object_set_data( holder, "mode_action", act );
2871     }
2872
2873     {
2874         EgeAdjustmentAction* eact = 0;
2875         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
2876         bool isFlatSided = prefs->getBool("/tools/shapes/star/isflatsided", true);
2877
2878         /* Flatsided checkbox */
2879         {
2880             GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
2881
2882             GtkTreeIter iter;
2883             gtk_list_store_append( model, &iter );
2884             gtk_list_store_set( model, &iter,
2885                                 0, _("Polygon"),
2886                                 1, _("Regular polygon (with one handle) instead of a star"),
2887                                 2, INKSCAPE_ICON_DRAW_POLYGON,
2888                                 -1 );
2889
2890             gtk_list_store_append( model, &iter );
2891             gtk_list_store_set( model, &iter,
2892                                 0, _("Star"),
2893                                 1, _("Star instead of a regular polygon (with one handle)"),
2894                                 2, INKSCAPE_ICON_DRAW_STAR,
2895                                 -1 );
2896
2897             EgeSelectOneAction* act = ege_select_one_action_new( "FlatAction", (""), (""), NULL, GTK_TREE_MODEL(model) );
2898             gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
2899             g_object_set_data( holder, "flat_action", act );
2900
2901             ege_select_one_action_set_appearance( act, "full" );
2902             ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
2903             g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
2904             ege_select_one_action_set_icon_column( act, 2 );
2905             ege_select_one_action_set_icon_size( act, secondarySize );
2906             ege_select_one_action_set_tooltip_column( act, 1  );
2907
2908             ege_select_one_action_set_active( act, isFlatSided ? 0 : 1 );
2909             g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_stb_sides_flat_state_changed), holder);
2910         }
2911
2912         /* Magnitude */
2913         {
2914         gchar const* labels[] = {_("triangle/tri-star"), _("square/quad-star"), _("pentagon/five-pointed star"), _("hexagon/six-pointed star"), 0, 0, 0, 0, 0};
2915         gdouble values[] = {3, 4, 5, 6, 7, 8, 10, 12, 20};
2916         eact = create_adjustment_action( "MagnitudeAction",
2917                                          _("Corners"), _("Corners:"), _("Number of corners of a polygon or star"),
2918                                          "/tools/shapes/star/magnitude", 3,
2919                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
2920                                          3, 1024, 1, 5,
2921                                          labels, values, G_N_ELEMENTS(labels),
2922                                          sp_stb_magnitude_value_changed,
2923                                          1.0, 0 );
2924         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
2925         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
2926         }
2927
2928         /* Spoke ratio */
2929         {
2930         gchar const* labels[] = {_("thin-ray star"), 0, _("pentagram"), _("hexagram"), _("heptagram"), _("octagram"), _("regular polygon")};
2931         gdouble values[] = {0.01, 0.2, 0.382, 0.577, 0.692, 0.765, 1};
2932         eact = create_adjustment_action( "SpokeAction",
2933                                          _("Spoke ratio"), _("Spoke ratio:"),
2934                                          // TRANSLATORS: Tip radius of a star is the distance from the center to the farthest handle.
2935                                          // Base radius is the same for the closest handle.
2936                                          _("Base radius to tip radius ratio"),
2937                                          "/tools/shapes/star/proportion", 0.5,
2938                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
2939                                          0.01, 1.0, 0.01, 0.1,
2940                                          labels, values, G_N_ELEMENTS(labels),
2941                                          sp_stb_proportion_value_changed );
2942         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
2943         g_object_set_data( holder, "prop_action", eact );
2944         }
2945
2946         if ( !isFlatSided ) {
2947             gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
2948         } else {
2949             gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
2950         }
2951
2952         /* Roundedness */
2953         {
2954         gchar const* labels[] = {_("stretched"), _("twisted"), _("slightly pinched"), _("NOT rounded"), _("slightly rounded"), _("visibly rounded"), _("well rounded"), _("amply rounded"), 0, _("stretched"), _("blown up")};
2955         gdouble values[] = {-1, -0.2, -0.03, 0, 0.05, 0.1, 0.2, 0.3, 0.5, 1, 10};
2956         eact = create_adjustment_action( "RoundednessAction",
2957                                          _("Rounded"), _("Rounded:"), _("How much rounded are the corners (0 for sharp)"),
2958                                          "/tools/shapes/star/rounded", 0.0,
2959                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
2960                                          -10.0, 10.0, 0.01, 0.1,
2961                                          labels, values, G_N_ELEMENTS(labels),
2962                                          sp_stb_rounded_value_changed );
2963         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
2964         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
2965         }
2966
2967         /* Randomization */
2968         {
2969         gchar const* labels[] = {_("NOT randomized"), _("slightly irregular"), _("visibly randomized"), _("strongly randomized"), _("blown up")};
2970         gdouble values[] = {0, 0.01, 0.1, 0.5, 10};
2971         eact = create_adjustment_action( "RandomizationAction",
2972                                          _("Randomized"), _("Randomized:"), _("Scatter randomly the corners and angles"),
2973                                          "/tools/shapes/star/randomized", 0.0,
2974                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
2975                                          -10.0, 10.0, 0.001, 0.01,
2976                                          labels, values, G_N_ELEMENTS(labels),
2977                                          sp_stb_randomized_value_changed, 0.1, 3 );
2978         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
2979         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
2980         }
2981     }
2982
2983     {
2984         /* Reset */
2985         {
2986             GtkAction* act = gtk_action_new( "StarResetAction",
2987                                              _("Defaults"),
2988                                              _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
2989                                              GTK_STOCK_CLEAR );
2990             g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(sp_stb_defaults), holder );
2991             gtk_action_group_add_action( mainActions, act );
2992             gtk_action_set_sensitive( act, TRUE );
2993         }
2994     }
2995
2996     sigc::connection *connection = new sigc::connection(
2997         sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_star_toolbox_selection_changed), (GObject *)holder))
2998         );
2999     g_signal_connect( holder, "destroy", G_CALLBACK(delete_connection), connection );
3000     g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );
3001 }
3002
3003
3004 //########################
3005 //##       Rect         ##
3006 //########################
3007
3008 static void sp_rtb_sensitivize( GObject *tbl )
3009 {
3010     GtkAdjustment *adj1 = GTK_ADJUSTMENT( g_object_get_data(tbl, "rx") );
3011     GtkAdjustment *adj2 = GTK_ADJUSTMENT( g_object_get_data(tbl, "ry") );
3012     GtkAction* not_rounded = GTK_ACTION( g_object_get_data(tbl, "not_rounded") );
3013
3014     if (adj1->value == 0 && adj2->value == 0 && g_object_get_data(tbl, "single")) { // only for a single selected rect (for now)
3015         gtk_action_set_sensitive( not_rounded, FALSE );
3016     } else {
3017         gtk_action_set_sensitive( not_rounded, TRUE );
3018     }
3019 }
3020
3021
3022 static void sp_rtb_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_name,
3023                                  void (*setter)(SPRect *, gdouble))
3024 {
3025     SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
3026
3027     UnitTracker* tracker = reinterpret_cast<UnitTracker*>(g_object_get_data( tbl, "tracker" ));
3028     SPUnit const *unit = tracker->getActiveUnit();
3029
3030     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
3031         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
3032         prefs->setDouble(Glib::ustring("/tools/shapes/rect/") + value_name, sp_units_get_pixels(adj->value, *unit));
3033     }
3034
3035     // quit if run by the attr_changed listener
3036     if (g_object_get_data( tbl, "freeze" )) {
3037         return;
3038     }
3039
3040     // in turn, prevent listener from responding
3041     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE));
3042
3043     bool modmade = false;
3044     Inkscape::Selection *selection = sp_desktop_selection(desktop);
3045     for (GSList const *items = selection->itemList(); items != NULL; items = items->next) {
3046         if (SP_IS_RECT(items->data)) {
3047             if (adj->value != 0) {
3048                 setter(SP_RECT(items->data), sp_units_get_pixels(adj->value, *unit));
3049             } else {
3050                 SP_OBJECT_REPR(items->data)->setAttribute(value_name, NULL);
3051             }
3052             modmade = true;
3053         }
3054     }
3055
3056     sp_rtb_sensitivize( tbl );
3057
3058     if (modmade) {
3059         sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_RECT,
3060                                    _("Change rectangle"));
3061     }
3062
3063     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
3064 }
3065
3066 static void sp_rtb_rx_value_changed(GtkAdjustment *adj, GObject *tbl)
3067 {
3068     sp_rtb_value_changed(adj, tbl, "rx", sp_rect_set_visible_rx);
3069 }
3070
3071 static void sp_rtb_ry_value_changed(GtkAdjustment *adj, GObject *tbl)
3072 {
3073     sp_rtb_value_changed(adj, tbl, "ry", sp_rect_set_visible_ry);
3074 }
3075
3076 static void sp_rtb_width_value_changed(GtkAdjustment *adj, GObject *tbl)
3077 {
3078     sp_rtb_value_changed(adj, tbl, "width", sp_rect_set_visible_width);
3079 }
3080
3081 static void sp_rtb_height_value_changed(GtkAdjustment *adj, GObject *tbl)
3082 {
3083     sp_rtb_value_changed(adj, tbl, "height", sp_rect_set_visible_height);
3084 }
3085
3086
3087
3088 static void sp_rtb_defaults( GtkWidget * /*widget*/, GObject *obj)
3089 {
3090     GtkAdjustment *adj = 0;
3091
3092     adj = GTK_ADJUSTMENT( g_object_get_data(obj, "rx") );
3093     gtk_adjustment_set_value(adj, 0.0);
3094     // this is necessary if the previous value was 0, but we still need to run the callback to change all selected objects
3095     gtk_adjustment_value_changed(adj);
3096
3097     adj = GTK_ADJUSTMENT( g_object_get_data(obj, "ry") );
3098     gtk_adjustment_set_value(adj, 0.0);
3099     gtk_adjustment_value_changed(adj);
3100
3101     sp_rtb_sensitivize( obj );
3102 }
3103
3104 static void rect_tb_event_attr_changed(Inkscape::XML::Node * /*repr*/, gchar const * /*name*/,
3105                                        gchar const * /*old_value*/, gchar const * /*new_value*/,
3106                                        bool /*is_interactive*/, gpointer data)
3107 {
3108     GObject *tbl = G_OBJECT(data);
3109
3110     // quit if run by the _changed callbacks
3111     if (g_object_get_data( tbl, "freeze" )) {
3112         return;
3113     }
3114
3115     // in turn, prevent callbacks from responding
3116     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
3117
3118     UnitTracker* tracker = reinterpret_cast<UnitTracker*>( g_object_get_data( tbl, "tracker" ) );
3119     SPUnit const *unit = tracker->getActiveUnit();
3120
3121     gpointer item = g_object_get_data( tbl, "item" );
3122     if (item && SP_IS_RECT(item)) {
3123         {
3124             GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "rx" ) );
3125             gdouble rx = sp_rect_get_visible_rx(SP_RECT(item));
3126             gtk_adjustment_set_value(adj, sp_pixels_get_units(rx, *unit));
3127         }
3128
3129         {
3130             GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "ry" ) );
3131             gdouble ry = sp_rect_get_visible_ry(SP_RECT(item));
3132             gtk_adjustment_set_value(adj, sp_pixels_get_units(ry, *unit));
3133         }
3134
3135         {
3136             GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "width" ) );
3137             gdouble width = sp_rect_get_visible_width (SP_RECT(item));
3138             gtk_adjustment_set_value(adj, sp_pixels_get_units(width, *unit));
3139         }
3140
3141         {
3142             GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "height" ) );
3143             gdouble height = sp_rect_get_visible_height (SP_RECT(item));
3144             gtk_adjustment_set_value(adj, sp_pixels_get_units(height, *unit));
3145         }
3146     }
3147
3148     sp_rtb_sensitivize( tbl );
3149
3150     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
3151 }
3152
3153
3154 static Inkscape::XML::NodeEventVector rect_tb_repr_events = {
3155     NULL, /* child_added */
3156     NULL, /* child_removed */
3157     rect_tb_event_attr_changed,
3158     NULL, /* content_changed */
3159     NULL  /* order_changed */
3160 };
3161
3162 /**
3163  *  \param selection should not be NULL.
3164  */
3165 static void sp_rect_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
3166 {
3167     int n_selected = 0;
3168     Inkscape::XML::Node *repr = NULL;
3169     SPItem *item = NULL;
3170
3171     if ( g_object_get_data( tbl, "repr" ) ) {
3172         g_object_set_data( tbl, "item", NULL );
3173     }
3174     purge_repr_listener( tbl, tbl );
3175
3176     for (GSList const *items = selection->itemList();
3177          items != NULL;
3178          items = items->next) {
3179         if (SP_IS_RECT((SPItem *) items->data)) {
3180             n_selected++;
3181             item = (SPItem *) items->data;
3182             repr = SP_OBJECT_REPR(item);
3183         }
3184     }
3185
3186     EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) );
3187
3188     g_object_set_data( tbl, "single", GINT_TO_POINTER(FALSE) );
3189
3190     if (n_selected == 0) {
3191         g_object_set( G_OBJECT(act), "label", _("<b>New:</b>"), NULL );
3192
3193         GtkAction* w = GTK_ACTION( g_object_get_data( tbl, "width_action" ) );
3194         gtk_action_set_sensitive(w, FALSE);
3195         GtkAction* h = GTK_ACTION( g_object_get_data( tbl, "height_action" ) );
3196         gtk_action_set_sensitive(h, FALSE);
3197
3198     } else if (n_selected == 1) {
3199         g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
3200         g_object_set_data( tbl, "single", GINT_TO_POINTER(TRUE) );
3201
3202         GtkAction* w = GTK_ACTION( g_object_get_data( tbl, "width_action" ) );
3203         gtk_action_set_sensitive(w, TRUE);
3204         GtkAction* h = GTK_ACTION( g_object_get_data( tbl, "height_action" ) );
3205         gtk_action_set_sensitive(h, TRUE);
3206
3207         if (repr) {
3208             g_object_set_data( tbl, "repr", repr );
3209             g_object_set_data( tbl, "item", item );
3210             Inkscape::GC::anchor(repr);
3211             sp_repr_add_listener(repr, &rect_tb_repr_events, tbl);
3212             sp_repr_synthesize_events(repr, &rect_tb_repr_events, tbl);
3213         }
3214     } else {
3215         // FIXME: implement averaging of all parameters for multiple selected
3216         //gtk_label_set_markup(GTK_LABEL(l), _("<b>Average:</b>"));
3217         g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
3218         sp_rtb_sensitivize( tbl );
3219     }
3220 }
3221
3222
3223 static void sp_rect_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
3224 {
3225     EgeAdjustmentAction* eact = 0;
3226     Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
3227
3228     {
3229         EgeOutputAction* act = ege_output_action_new( "RectStateAction", _("<b>New:</b>"), "", 0 );
3230         ege_output_action_set_use_markup( act, TRUE );
3231         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
3232         g_object_set_data( holder, "mode_action", act );
3233     }
3234
3235     // rx/ry units menu: create
3236     UnitTracker* tracker = new UnitTracker( SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE );
3237     //tracker->addUnit( SP_UNIT_PERCENT, 0 );
3238     // fixme: add % meaning per cent of the width/height
3239     tracker->setActiveUnit( sp_desktop_namedview(desktop)->doc_units );
3240     g_object_set_data( holder, "tracker", tracker );
3241
3242     /* W */
3243     {
3244         gchar const* labels[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
3245         gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
3246         eact = create_adjustment_action( "RectWidthAction",
3247                                          _("Width"), _("W:"), _("Width of rectangle"),
3248                                          "/tools/shapes/rect/width", 0,
3249                                          GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, TRUE, "altx-rect",
3250                                          0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
3251                                          labels, values, G_N_ELEMENTS(labels),
3252                                          sp_rtb_width_value_changed );
3253         tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );
3254         g_object_set_data( holder, "width_action", eact );
3255         gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
3256         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3257     }
3258
3259     /* H */
3260     {
3261         gchar const* labels[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
3262         gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
3263         eact = create_adjustment_action( "RectHeightAction",
3264                                          _("Height"), _("H:"), _("Height of rectangle"),
3265                                          "/tools/shapes/rect/height", 0,
3266                                          GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL,
3267                                          0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
3268                                          labels, values, G_N_ELEMENTS(labels),
3269                                          sp_rtb_height_value_changed );
3270         tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );
3271         g_object_set_data( holder, "height_action", eact );
3272         gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
3273         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3274     }
3275
3276     /* rx */
3277     {
3278         gchar const* labels[] = {_("not rounded"), 0, 0, 0, 0, 0, 0, 0, 0};
3279         gdouble values[] = {0.5, 1, 2, 3, 5, 10, 20, 50, 100};
3280         eact = create_adjustment_action( "RadiusXAction",
3281                                          _("Horizontal radius"), _("Rx:"), _("Horizontal radius of rounded corners"),
3282                                          "/tools/shapes/rect/rx", 0,
3283                                          GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL,
3284                                          0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
3285                                          labels, values, G_N_ELEMENTS(labels),
3286                                          sp_rtb_rx_value_changed);
3287         tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );
3288         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3289     }
3290
3291     /* ry */
3292     {
3293         gchar const* labels[] = {_("not rounded"), 0, 0, 0, 0, 0, 0, 0, 0};
3294         gdouble values[] = {0.5, 1, 2, 3, 5, 10, 20, 50, 100};
3295         eact = create_adjustment_action( "RadiusYAction",
3296                                          _("Vertical radius"), _("Ry:"), _("Vertical radius of rounded corners"),
3297                                          "/tools/shapes/rect/ry", 0,
3298                                          GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL,
3299                                          0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
3300                                          labels, values, G_N_ELEMENTS(labels),
3301                                          sp_rtb_ry_value_changed);
3302         tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );
3303         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3304     }
3305
3306     // add the units menu
3307     {
3308         GtkAction* act = tracker->createAction( "RectUnitsAction", _("Units"), ("") );
3309         gtk_action_group_add_action( mainActions, act );
3310     }
3311
3312     /* Reset */
3313     {
3314         InkAction* inky = ink_action_new( "RectResetAction",
3315                                           _("Not rounded"),
3316                                           _("Make corners sharp"),
3317                                           INKSCAPE_ICON_RECTANGLE_MAKE_CORNERS_SHARP,
3318                                           secondarySize );
3319         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_rtb_defaults), holder );
3320         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
3321         gtk_action_set_sensitive( GTK_ACTION(inky), TRUE );
3322         g_object_set_data( holder, "not_rounded", inky );
3323     }
3324
3325     g_object_set_data( holder, "single", GINT_TO_POINTER(TRUE) );
3326     sp_rtb_sensitivize( holder );
3327
3328     sigc::connection *connection = new sigc::connection(
3329         sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_rect_toolbox_selection_changed), (GObject *)holder))
3330         );
3331     g_signal_connect( holder, "destroy", G_CALLBACK(delete_connection), connection );
3332     g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );
3333 }
3334
3335 //########################
3336 //##       3D Box       ##
3337 //########################
3338
3339 // normalize angle so that it lies in the interval [0,360]
3340 static double box3d_normalize_angle (double a) {
3341     double angle = a + ((int) (a/360.0))*360;
3342     if (angle < 0) {
3343         angle += 360.0;
3344     }
3345     return angle;
3346 }
3347
3348 static void box3d_set_button_and_adjustment(Persp3D *persp,
3349                                             Proj::Axis axis,
3350                                             GtkAdjustment *adj,
3351                                             GtkAction *act,
3352                                             GtkToggleAction *tact)
3353 {
3354     // TODO: Take all selected perspectives into account but don't touch the state button if not all of them
3355     //       have the same state (otherwise a call to box3d_vp_z_state_changed() is triggered and the states
3356     //       are reset).
3357     bool is_infinite = !persp3d_VP_is_finite(persp->perspective_impl, axis);
3358
3359     if (is_infinite) {
3360         gtk_toggle_action_set_active(tact, TRUE);
3361         gtk_action_set_sensitive(act, TRUE);
3362
3363         double angle = persp3d_get_infinite_angle(persp, axis);
3364         if (angle != NR_HUGE) { // FIXME: We should catch this error earlier (don't show the spinbutton at all)
3365             gtk_adjustment_set_value(adj, box3d_normalize_angle(angle));
3366         }
3367     } else {
3368         gtk_toggle_action_set_active(tact, FALSE);
3369         gtk_action_set_sensitive(act, FALSE);
3370     }
3371 }
3372
3373 static void box3d_resync_toolbar(Inkscape::XML::Node *persp_repr, GObject *data)
3374 {
3375     if (!persp_repr) {
3376         g_print ("No perspective given to box3d_resync_toolbar().\n");
3377         return;
3378     }
3379
3380     GtkWidget *tbl = GTK_WIDGET(data);
3381     GtkAdjustment *adj = 0;
3382     GtkAction *act = 0;
3383     GtkToggleAction *tact = 0;
3384     Persp3D *persp = persp3d_get_from_repr(persp_repr);
3385     if (!persp) {
3386         // Hmm, is it an error if this happens?
3387         return;
3388     }
3389     {
3390         adj = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(tbl), "box3d_angle_x"));
3391         act = GTK_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_angle_x_action"));
3392         tact = &INK_TOGGLE_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_vp_x_state_action"))->action;
3393
3394         box3d_set_button_and_adjustment(persp, Proj::X, adj, act, tact);
3395     }
3396     {
3397         adj = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(tbl), "box3d_angle_y"));
3398         act = GTK_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_angle_y_action"));
3399         tact = &INK_TOGGLE_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_vp_y_state_action"))->action;
3400
3401         box3d_set_button_and_adjustment(persp, Proj::Y, adj, act, tact);
3402     }
3403     {
3404         adj = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(tbl), "box3d_angle_z"));
3405         act = GTK_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_angle_z_action"));
3406         tact = &INK_TOGGLE_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_vp_z_state_action"))->action;
3407
3408         box3d_set_button_and_adjustment(persp, Proj::Z, adj, act, tact);
3409     }
3410 }
3411
3412 static void box3d_persp_tb_event_attr_changed(Inkscape::XML::Node *repr,
3413                                               gchar const * /*name*/,
3414                                               gchar const * /*old_value*/,
3415                                               gchar const * /*new_value*/,
3416                                               bool /*is_interactive*/,
3417                                               gpointer data)
3418 {
3419     GtkWidget *tbl = GTK_WIDGET(data);
3420
3421     // quit if run by the attr_changed or selection changed listener
3422     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
3423         return;
3424     }
3425
3426     // set freeze so that it can be caught in box3d_angle_z_value_changed() (to avoid calling
3427     // sp_document_maybe_done() when the document is undo insensitive)
3428     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE));
3429
3430     // TODO: Only update the appropriate part of the toolbar
3431 //    if (!strcmp(name, "inkscape:vp_z")) {
3432         box3d_resync_toolbar(repr, G_OBJECT(tbl));
3433 //    }
3434
3435     Persp3D *persp = persp3d_get_from_repr(repr);
3436     persp3d_update_box_reprs(persp);
3437
3438     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
3439 }
3440
3441 static Inkscape::XML::NodeEventVector box3d_persp_tb_repr_events =
3442 {
3443     NULL, /* child_added */
3444     NULL, /* child_removed */
3445     box3d_persp_tb_event_attr_changed,
3446     NULL, /* content_changed */
3447     NULL  /* order_changed */
3448 };
3449
3450 /**
3451  *  \param selection Should not be NULL.
3452  */
3453 // FIXME: This should rather be put into persp3d-reference.cpp or something similar so that it reacts upon each
3454 //        Change of the perspective, and not of the current selection (but how to refer to the toolbar then?)
3455 static void box3d_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
3456 {
3457     // Here the following should be done: If all selected boxes have finite VPs in a certain direction,
3458     // disable the angle entry fields for this direction (otherwise entering a value in them should only
3459     // update the perspectives with infinite VPs and leave the other ones untouched).
3460
3461     Inkscape::XML::Node *persp_repr = NULL;
3462     purge_repr_listener(tbl, tbl);
3463
3464     SPItem *item = selection->singleItem();
3465     if (item && SP_IS_BOX3D(item)) {
3466         // FIXME: Also deal with multiple selected boxes
3467         SPBox3D *box = SP_BOX3D(item);
3468         Persp3D *persp = box3d_get_perspective(box);
3469         persp_repr = SP_OBJECT_REPR(persp);
3470         if (persp_repr) {
3471             g_object_set_data(tbl, "repr", persp_repr);
3472             Inkscape::GC::anchor(persp_repr);
3473             sp_repr_add_listener(persp_repr, &box3d_persp_tb_repr_events, tbl);
3474             sp_repr_synthesize_events(persp_repr, &box3d_persp_tb_repr_events, tbl);
3475         }
3476
3477         inkscape_active_document()->setCurrentPersp3D(persp3d_get_from_repr(persp_repr));
3478         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
3479         prefs->setString("/tools/shapes/3dbox/persp", persp_repr->attribute("id"));
3480
3481         g_object_set_data(tbl, "freeze", GINT_TO_POINTER(TRUE));
3482         box3d_resync_toolbar(persp_repr, tbl);
3483         g_object_set_data(tbl, "freeze", GINT_TO_POINTER(FALSE));
3484     }
3485 }
3486
3487 static void box3d_angle_value_changed(GtkAdjustment *adj, GObject *dataKludge, Proj::Axis axis)
3488 {
3489     SPDesktop *desktop = (SPDesktop *) g_object_get_data( dataKludge, "desktop" );
3490     SPDocument *document = sp_desktop_document(desktop);
3491
3492     // quit if run by the attr_changed or selection changed listener
3493     if (g_object_get_data( dataKludge, "freeze" )) {
3494         return;
3495     }
3496
3497     // in turn, prevent listener from responding
3498     g_object_set_data(dataKludge, "freeze", GINT_TO_POINTER(TRUE));
3499
3500     std::list<Persp3D *> sel_persps = sp_desktop_selection(desktop)->perspList();
3501     if (sel_persps.empty()) {
3502         // this can happen when the document is created; we silently ignore it
3503         return;
3504     }
3505     Persp3D *persp = sel_persps.front();
3506
3507     persp->perspective_impl->tmat.set_infinite_direction (axis, adj->value);
3508     SP_OBJECT(persp)->updateRepr();
3509
3510     // TODO: use the correct axis here, too
3511     sp_document_maybe_done(document, "perspangle", SP_VERB_CONTEXT_3DBOX, _("3D Box: Change perspective (angle of infinite axis)"));
3512
3513     g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) );
3514 }
3515
3516
3517 static void box3d_angle_x_value_changed(GtkAdjustment *adj, GObject *dataKludge)
3518 {
3519     box3d_angle_value_changed(adj, dataKludge, Proj::X);
3520 }
3521
3522 static void box3d_angle_y_value_changed(GtkAdjustment *adj, GObject *dataKludge)
3523 {
3524     box3d_angle_value_changed(adj, dataKludge, Proj::Y);
3525 }
3526
3527 static void box3d_angle_z_value_changed(GtkAdjustment *adj, GObject *dataKludge)
3528 {
3529     box3d_angle_value_changed(adj, dataKludge, Proj::Z);
3530 }
3531
3532
3533 static void box3d_vp_state_changed( GtkToggleAction *act, GtkAction * /*box3d_angle*/, Proj::Axis axis )
3534 {
3535     // TODO: Take all selected perspectives into account
3536     std::list<Persp3D *> sel_persps = sp_desktop_selection(inkscape_active_desktop())->perspList();
3537     if (sel_persps.empty()) {
3538         // this can happen when the document is created; we silently ignore it
3539         return;
3540     }
3541     Persp3D *persp = sel_persps.front();
3542
3543     bool set_infinite = gtk_toggle_action_get_active(act);
3544     persp3d_set_VP_state (persp, axis, set_infinite ? Proj::VP_INFINITE : Proj::VP_FINITE);
3545 }
3546
3547 static void box3d_vp_x_state_changed( GtkToggleAction *act, GtkAction *box3d_angle )
3548 {
3549     box3d_vp_state_changed(act, box3d_angle, Proj::X);
3550 }
3551
3552 static void box3d_vp_y_state_changed( GtkToggleAction *act, GtkAction *box3d_angle )
3553 {
3554     box3d_vp_state_changed(act, box3d_angle, Proj::Y);
3555 }
3556
3557 static void box3d_vp_z_state_changed( GtkToggleAction *act, GtkAction *box3d_angle )
3558 {
3559     box3d_vp_state_changed(act, box3d_angle, Proj::Z);
3560 }
3561
3562 static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
3563 {
3564     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
3565     EgeAdjustmentAction* eact = 0;
3566     SPDocument *document = sp_desktop_document (desktop);
3567     Persp3DImpl *persp_impl = document->getCurrentPersp3DImpl();
3568
3569     EgeAdjustmentAction* box3d_angle_x = 0;
3570     EgeAdjustmentAction* box3d_angle_y = 0;
3571     EgeAdjustmentAction* box3d_angle_z = 0;
3572
3573     /* Angle X */
3574     {
3575         gchar const* labels[] = { 0, 0, 0, 0, 0, 0, 0 };
3576         gdouble values[] = {-90, -60, -30, 0, 30, 60, 90};
3577         eact = create_adjustment_action( "3DBoxAngleXAction",
3578                                          _("Angle in X direction"), _("Angle X:"),
3579                                          // Translators: PL is short for 'perspective line'
3580                                          _("Angle of PLs in X direction"),
3581                                          "/tools/shapes/3dbox/box3d_angle_x", 30,
3582                                          GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-box3d",
3583                                          -360.0, 360.0, 1.0, 10.0,
3584                                          labels, values, G_N_ELEMENTS(labels),
3585                                          box3d_angle_x_value_changed );
3586         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3587         g_object_set_data( holder, "box3d_angle_x_action", eact );
3588         box3d_angle_x = eact;
3589     }
3590
3591     if (!persp_impl || !persp3d_VP_is_finite(persp_impl, Proj::X)) {
3592         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
3593     } else {
3594         gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
3595     }
3596
3597
3598     /* VP X state */
3599     {
3600         InkToggleAction* act = ink_toggle_action_new( "3DBoxVPXStateAction",
3601                                                       // Translators: VP is short for 'vanishing point'
3602                                                       _("State of VP in X direction"),
3603                                                       _("Toggle VP in X direction between 'finite' and 'infinite' (=parallel)"),
3604                                                       INKSCAPE_ICON_PERSPECTIVE_PARALLEL,
3605                                                       Inkscape::ICON_SIZE_DECORATION );
3606         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
3607         g_object_set_data( holder, "box3d_vp_x_state_action", act );
3608         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(box3d_vp_x_state_changed), box3d_angle_x );
3609         gtk_action_set_sensitive( GTK_ACTION(box3d_angle_x), !prefs->getBool("/tools/shapes/3dbox/vp_x_state", true) );
3610         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/shapes/3dbox/vp_x_state", true) );
3611     }
3612
3613     /* Angle Y */
3614     {
3615         gchar const* labels[] = { 0, 0, 0, 0, 0, 0, 0 };
3616         gdouble values[] = {-90, -60, -30, 0, 30, 60, 90};
3617         eact = create_adjustment_action( "3DBoxAngleYAction",
3618                                          _("Angle in Y direction"), _("Angle Y:"),
3619                                          // Translators: PL is short for 'perspective line'
3620                                          _("Angle of PLs in Y direction"),
3621                                          "/tools/shapes/3dbox/box3d_angle_y", 30,
3622                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
3623                                          -360.0, 360.0, 1.0, 10.0,
3624                                          labels, values, G_N_ELEMENTS(labels),
3625                                          box3d_angle_y_value_changed );
3626         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3627         g_object_set_data( holder, "box3d_angle_y_action", eact );
3628         box3d_angle_y = eact;
3629     }
3630
3631     if (!persp_impl || !persp3d_VP_is_finite(persp_impl, Proj::Y)) {
3632         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
3633     } else {
3634         gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
3635     }
3636
3637     /* VP Y state */
3638     {
3639         InkToggleAction* act = ink_toggle_action_new( "3DBoxVPYStateAction",
3640                                                       // Translators: VP is short for 'vanishing point'
3641                                                       _("State of VP in Y direction"),
3642                                                       _("Toggle VP in Y direction between 'finite' and 'infinite' (=parallel)"),
3643                                                       INKSCAPE_ICON_PERSPECTIVE_PARALLEL,
3644                                                       Inkscape::ICON_SIZE_DECORATION );
3645         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
3646         g_object_set_data( holder, "box3d_vp_y_state_action", act );
3647         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(box3d_vp_y_state_changed), box3d_angle_y );
3648         gtk_action_set_sensitive( GTK_ACTION(box3d_angle_y), !prefs->getBool("/tools/shapes/3dbox/vp_y_state", true) );
3649         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/shapes/3dbox/vp_y_state", true) );
3650     }
3651
3652     /* Angle Z */
3653     {
3654         gchar const* labels[] = { 0, 0, 0, 0, 0, 0, 0 };
3655         gdouble values[] = {-90, -60, -30, 0, 30, 60, 90};
3656         eact = create_adjustment_action( "3DBoxAngleZAction",
3657                                          _("Angle in Z direction"), _("Angle Z:"),
3658                                          // Translators: PL is short for 'perspective line'
3659                                          _("Angle of PLs in Z direction"),
3660                                          "/tools/shapes/3dbox/box3d_angle_z", 30,
3661                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
3662                                          -360.0, 360.0, 1.0, 10.0,
3663                                          labels, values, G_N_ELEMENTS(labels),
3664                                          box3d_angle_z_value_changed );
3665         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3666         g_object_set_data( holder, "box3d_angle_z_action", eact );
3667         box3d_angle_z = eact;
3668     }
3669
3670     if (!persp_impl || !persp3d_VP_is_finite(persp_impl, Proj::Z)) {
3671         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
3672     } else {
3673         gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
3674     }
3675
3676     /* VP Z state */
3677     {
3678         InkToggleAction* act = ink_toggle_action_new( "3DBoxVPZStateAction",
3679                                                       // Translators: VP is short for 'vanishing point'
3680                                                       _("State of VP in Z direction"),
3681                                                       _("Toggle VP in Z direction between 'finite' and 'infinite' (=parallel)"),
3682                                                       INKSCAPE_ICON_PERSPECTIVE_PARALLEL,
3683                                                       Inkscape::ICON_SIZE_DECORATION );
3684         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
3685         g_object_set_data( holder, "box3d_vp_z_state_action", act );
3686         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(box3d_vp_z_state_changed), box3d_angle_z );
3687         gtk_action_set_sensitive( GTK_ACTION(box3d_angle_z), !prefs->getBool("/tools/shapes/3dbox/vp_z_state", true) );
3688         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/shapes/3dbox/vp_z_state", true) );
3689     }
3690
3691     sigc::connection *connection = new sigc::connection(
3692         sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(box3d_toolbox_selection_changed), (GObject *)holder))
3693        );
3694     g_signal_connect(holder, "destroy", G_CALLBACK(delete_connection), connection);
3695     g_signal_connect(holder, "destroy", G_CALLBACK(purge_repr_listener), holder);
3696 }
3697
3698 //########################
3699 //##       Spiral       ##
3700 //########################
3701
3702 static void sp_spl_tb_value_changed(GtkAdjustment *adj, GObject *tbl, Glib::ustring const &value_name)
3703 {
3704     SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
3705
3706     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
3707         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
3708         prefs->setDouble("/tools/shapes/spiral/" + value_name, adj->value);
3709     }
3710
3711     // quit if run by the attr_changed listener
3712     if (g_object_get_data( tbl, "freeze" )) {
3713         return;
3714     }
3715
3716     // in turn, prevent listener from responding
3717     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
3718
3719     gchar* namespaced_name = g_strconcat("sodipodi:", value_name.data(), NULL);
3720
3721     bool modmade = false;
3722     for (GSList const *items = sp_desktop_selection(desktop)->itemList();
3723          items != NULL;
3724          items = items->next)
3725     {
3726         if (SP_IS_SPIRAL((SPItem *) items->data)) {
3727             Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
3728             sp_repr_set_svg_double( repr, namespaced_name, adj->value );
3729             SP_OBJECT((SPItem *) items->data)->updateRepr();
3730             modmade = true;
3731         }
3732     }
3733
3734     g_free(namespaced_name);
3735
3736     if (modmade) {
3737         sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_SPIRAL,
3738                                    _("Change spiral"));
3739     }
3740
3741     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
3742 }
3743
3744 static void sp_spl_tb_revolution_value_changed(GtkAdjustment *adj, GObject *tbl)
3745 {
3746     sp_spl_tb_value_changed(adj, tbl, "revolution");
3747 }
3748
3749 static void sp_spl_tb_expansion_value_changed(GtkAdjustment *adj, GObject *tbl)
3750 {
3751     sp_spl_tb_value_changed(adj, tbl, "expansion");
3752 }
3753
3754 static void sp_spl_tb_t0_value_changed(GtkAdjustment *adj, GObject *tbl)
3755 {
3756     sp_spl_tb_value_changed(adj, tbl, "t0");
3757 }
3758
3759 static void sp_spl_tb_defaults(GtkWidget * /*widget*/, GtkObject *obj)
3760 {
3761     GtkWidget *tbl = GTK_WIDGET(obj);
3762
3763     GtkAdjustment *adj;
3764
3765     // fixme: make settable
3766     gdouble rev = 5;
3767     gdouble exp = 1.0;
3768     gdouble t0 = 0.0;
3769
3770     adj = (GtkAdjustment*)gtk_object_get_data(obj, "revolution");
3771     gtk_adjustment_set_value(adj, rev);
3772     gtk_adjustment_value_changed(adj);
3773
3774     adj = (GtkAdjustment*)gtk_object_get_data(obj, "expansion");
3775     gtk_adjustment_set_value(adj, exp);
3776     gtk_adjustment_value_changed(adj);
3777
3778     adj = (GtkAdjustment*)gtk_object_get_data(obj, "t0");
3779     gtk_adjustment_set_value(adj, t0);
3780     gtk_adjustment_value_changed(adj);
3781
3782     spinbutton_defocus(GTK_OBJECT(tbl));
3783 }
3784
3785
3786 static void spiral_tb_event_attr_changed(Inkscape::XML::Node *repr,
3787                                          gchar const * /*name*/,
3788                                          gchar const * /*old_value*/,
3789                                          gchar const * /*new_value*/,
3790                                          bool /*is_interactive*/,
3791                                          gpointer data)
3792 {
3793     GtkWidget *tbl = GTK_WIDGET(data);
3794
3795     // quit if run by the _changed callbacks
3796     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
3797         return;
3798     }
3799
3800     // in turn, prevent callbacks from responding
3801     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE));
3802
3803     GtkAdjustment *adj;
3804     adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "revolution");
3805     gtk_adjustment_set_value(adj, (sp_repr_get_double_attribute(repr, "sodipodi:revolution", 3.0)));
3806
3807     adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "expansion");
3808     gtk_adjustment_set_value(adj, (sp_repr_get_double_attribute(repr, "sodipodi:expansion", 1.0)));
3809
3810     adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "t0");
3811     gtk_adjustment_set_value(adj, (sp_repr_get_double_attribute(repr, "sodipodi:t0", 0.0)));
3812
3813     g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
3814 }
3815
3816
3817 static Inkscape::XML::NodeEventVector spiral_tb_repr_events = {
3818     NULL, /* child_added */
3819     NULL, /* child_removed */
3820     spiral_tb_event_attr_changed,
3821     NULL, /* content_changed */
3822     NULL  /* order_changed */
3823 };
3824
3825 static void sp_spiral_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
3826 {
3827     int n_selected = 0;
3828     Inkscape::XML::Node *repr = NULL;
3829
3830     purge_repr_listener( tbl, tbl );
3831
3832     for (GSList const *items = selection->itemList();
3833          items != NULL;
3834          items = items->next)
3835     {
3836         if (SP_IS_SPIRAL((SPItem *) items->data)) {
3837             n_selected++;
3838             repr = SP_OBJECT_REPR((SPItem *) items->data);
3839         }
3840     }
3841
3842     EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) );
3843
3844     if (n_selected == 0) {
3845         g_object_set( G_OBJECT(act), "label", _("<b>New:</b>"), NULL );
3846     } else if (n_selected == 1) {
3847         g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
3848
3849         if (repr) {
3850             g_object_set_data( tbl, "repr", repr );
3851             Inkscape::GC::anchor(repr);
3852             sp_repr_add_listener(repr, &spiral_tb_repr_events, tbl);
3853             sp_repr_synthesize_events(repr, &spiral_tb_repr_events, tbl);
3854         }
3855     } else {
3856         // FIXME: implement averaging of all parameters for multiple selected
3857         //gtk_label_set_markup(GTK_LABEL(l), _("<b>Average:</b>"));
3858         g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
3859     }
3860 }
3861
3862
3863 static void sp_spiral_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
3864 {
3865     EgeAdjustmentAction* eact = 0;
3866     Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
3867
3868     {
3869         EgeOutputAction* act = ege_output_action_new( "SpiralStateAction", _("<b>New:</b>"), "", 0 );
3870         ege_output_action_set_use_markup( act, TRUE );
3871         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
3872         g_object_set_data( holder, "mode_action", act );
3873     }
3874
3875     /* Revolution */
3876     {
3877         gchar const* labels[] = {_("just a curve"), 0, _("one full revolution"), 0, 0, 0, 0, 0, 0};
3878         gdouble values[] = {0.01, 0.5, 1, 2, 3, 5, 10, 20, 50, 100};
3879         eact = create_adjustment_action( "SpiralRevolutionAction",
3880                                          _("Number of turns"), _("Turns:"), _("Number of revolutions"),
3881                                          "/tools/shapes/spiral/revolution", 3.0,
3882                                          GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-spiral",
3883                                          0.01, 1024.0, 0.1, 1.0,
3884                                          labels, values, G_N_ELEMENTS(labels),
3885                                          sp_spl_tb_revolution_value_changed, 1, 2);
3886         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3887     }
3888
3889     /* Expansion */
3890     {
3891         gchar const* labels[] = {_("circle"), _("edge is much denser"), _("edge is denser"), _("even"), _("center is denser"), _("center is much denser"), 0};
3892         gdouble values[] = {0, 0.1, 0.5, 1, 1.5, 5, 20};
3893         eact = create_adjustment_action( "SpiralExpansionAction",
3894                                          _("Divergence"), _("Divergence:"), _("How much denser/sparser are outer revolutions; 1 = uniform"),
3895                                          "/tools/shapes/spiral/expansion", 1.0,
3896                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
3897                                          0.0, 1000.0, 0.01, 1.0,
3898                                          labels, values, G_N_ELEMENTS(labels),
3899                                          sp_spl_tb_expansion_value_changed);
3900         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3901     }
3902
3903     /* T0 */
3904     {
3905         gchar const* labels[] = {_("starts from center"), _("starts mid-way"), _("starts near edge")};
3906         gdouble values[] = {0, 0.5, 0.9};
3907         eact = create_adjustment_action( "SpiralT0Action",
3908                                          _("Inner radius"), _("Inner radius:"), _("Radius of the innermost revolution (relative to the spiral size)"),
3909                                          "/tools/shapes/spiral/t0", 0.0,
3910                                          GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
3911                                          0.0, 0.999, 0.01, 1.0,
3912                                          labels, values, G_N_ELEMENTS(labels),
3913                                          sp_spl_tb_t0_value_changed);
3914         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3915     }
3916
3917     /* Reset */
3918     {
3919         InkAction* inky = ink_action_new( "SpiralResetAction",
3920                                           _("Defaults"),
3921                                           _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
3922                                           GTK_STOCK_CLEAR,
3923                                           secondarySize );
3924         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_spl_tb_defaults), holder );
3925         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
3926     }
3927
3928
3929     sigc::connection *connection = new sigc::connection(
3930         sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_spiral_toolbox_selection_changed), (GObject *)holder))
3931         );
3932     g_signal_connect( holder, "destroy", G_CALLBACK(delete_connection), connection );
3933     g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );
3934 }
3935
3936 //########################
3937 //##     Pen/Pencil     ##
3938 //########################
3939
3940 /* This is used in generic functions below to share large portions of code between pen and pencil tool */
3941 static Glib::ustring const freehand_tool_name(GObject *dataKludge)
3942 {
3943     SPDesktop *desktop = (SPDesktop *) g_object_get_data(dataKludge, "desktop");
3944     return ( tools_isactive(desktop, TOOLS_FREEHAND_PEN)
3945              ? "/tools/freehand/pen"
3946              : "/tools/freehand/pencil" );
3947 }
3948
3949 static void freehand_mode_changed(EgeSelectOneAction* act, GObject* tbl)
3950 {
3951     gint mode = ege_select_one_action_get_active(act);
3952
3953     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
3954     prefs->setInt(freehand_tool_name(tbl) + "/freehand-mode", mode);
3955
3956     SPDesktop *desktop = (SPDesktop *) g_object_get_data(tbl, "desktop");
3957
3958     // in pen tool we have more options than in pencil tool; if one of them was chosen, we do any
3959     // preparatory work here
3960     if (SP_IS_PEN_CONTEXT(desktop->event_context)) {
3961         SPPenContext *pc = SP_PEN_CONTEXT(desktop->event_context);
3962         sp_pen_context_set_polyline_mode(pc);
3963     }
3964 }
3965
3966 static void sp_add_freehand_mode_toggle(GtkActionGroup* mainActions, GObject* holder, bool tool_is_pencil)
3967 {
3968     /* Freehand mode toggle buttons */
3969     {
3970         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
3971         guint freehandMode = prefs->getInt(( tool_is_pencil ? "/tools/freehand/pencil/freehand-mode" : "/tools/freehand/pen/freehand-mode" ), 0);
3972         Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
3973
3974         {
3975             GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
3976
3977             GtkTreeIter iter;
3978             gtk_list_store_append( model, &iter );
3979             gtk_list_store_set( model, &iter,
3980                                 0, _("Bezier"),
3981                                 1, _("Create regular Bezier path"),
3982                                 2, INKSCAPE_ICON_PATH_MODE_BEZIER,
3983                                 -1 );
3984
3985             gtk_list_store_append( model, &iter );
3986             gtk_list_store_set( model, &iter,
3987                                 0, _("Spiro"),
3988                                 1, _("Create Spiro path"),
3989                                 2, INKSCAPE_ICON_PATH_MODE_SPIRO,
3990                                 -1 );
3991
3992             if (!tool_is_pencil) {
3993                 gtk_list_store_append( model, &iter );
3994                 gtk_list_store_set( model, &iter,
3995                                     0, _("Zigzag"),
3996                                     1, _("Create a sequence of straight line segments"),
3997                                     2, INKSCAPE_ICON_PATH_MODE_POLYLINE,
3998                                     -1 );
3999
4000                 gtk_list_store_append( model, &iter );
4001                 gtk_list_store_set( model, &iter,
4002                                     0, _("Paraxial"),
4003                                     1, _("Create a sequence of paraxial line segments"),
4004                                     2, INKSCAPE_ICON_PATH_MODE_POLYLINE_PARAXIAL,
4005                                     -1 );
4006             }
4007
4008             EgeSelectOneAction* act = ege_select_one_action_new(tool_is_pencil ?
4009                                                                 "FreehandModeActionPencil" :
4010                                                                 "FreehandModeActionPen",
4011                                                                 (_("Mode:")), (_("Mode of new lines drawn by this tool")), NULL, GTK_TREE_MODEL(model) );
4012             gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
4013
4014             ege_select_one_action_set_appearance( act, "full" );
4015             ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
4016             g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
4017             ege_select_one_action_set_icon_column( act, 2 );
4018             ege_select_one_action_set_icon_size( act, secondarySize );
4019             ege_select_one_action_set_tooltip_column( act, 1  );
4020
4021             ege_select_one_action_set_active( act, freehandMode);
4022             g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(freehand_mode_changed), holder);
4023         }
4024     }
4025 }
4026
4027 static void freehand_change_shape(EgeSelectOneAction* act, GObject *dataKludge) {
4028     gint shape = ege_select_one_action_get_active( act );
4029     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4030     prefs->setInt(freehand_tool_name(dataKludge) + "/shape", shape);
4031 }
4032
4033 /**
4034  * \brief Generate the list of freehand advanced shape option entries.
4035  */
4036 static GList * freehand_shape_dropdown_items_list() {
4037     GList *glist = NULL;
4038
4039     glist = g_list_append (glist, _("None"));
4040     glist = g_list_append (glist, _("Triangle in"));
4041     glist = g_list_append (glist, _("Triangle out"));
4042     glist = g_list_append (glist, _("Ellipse"));
4043     glist = g_list_append (glist, _("From clipboard"));
4044
4045     return glist;
4046 }
4047
4048 static void freehand_add_advanced_shape_options(GtkActionGroup* mainActions, GObject* holder, bool tool_is_pencil)
4049 {
4050     /*advanced shape options */
4051     {
4052         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4053         GtkListStore* model = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_INT );
4054
4055         GList* items = 0;
4056         gint count = 0;
4057         for ( items = freehand_shape_dropdown_items_list(); items ; items = g_list_next(items) )
4058         {
4059             GtkTreeIter iter;
4060             gtk_list_store_append( model, &iter );
4061             gtk_list_store_set( model, &iter, 0, reinterpret_cast<gchar*>(items->data), 1, count, -1 );
4062             count++;
4063         }
4064         g_list_free( items );
4065         items = 0;
4066         EgeSelectOneAction* act1 = ege_select_one_action_new(
4067             tool_is_pencil ? "SetPencilShapeAction" : "SetPenShapeAction",
4068             _("Shape:"), (_("Shape of new paths drawn by this tool")), NULL, GTK_TREE_MODEL(model));
4069         g_object_set( act1, "short_label", _("Shape:"), NULL );
4070         ege_select_one_action_set_appearance( act1, "compact" );
4071         ege_select_one_action_set_active( act1, prefs->getInt(( tool_is_pencil ? "/tools/freehand/pencil/shape" : "/tools/freehand/pen/shape" ), 0) );
4072         g_signal_connect( G_OBJECT(act1), "changed", G_CALLBACK(freehand_change_shape), holder );
4073         gtk_action_group_add_action( mainActions, GTK_ACTION(act1) );
4074         g_object_set_data( holder, "shape_action", act1 );
4075     }
4076 }
4077
4078 static void sp_pen_toolbox_prep(SPDesktop * /*desktop*/, GtkActionGroup* mainActions, GObject* holder)
4079 {
4080     sp_add_freehand_mode_toggle(mainActions, holder, false);
4081     freehand_add_advanced_shape_options(mainActions, holder, false);
4082 }
4083
4084
4085 static void sp_pencil_tb_defaults(GtkWidget * /*widget*/, GtkObject *obj)
4086 {
4087     GtkWidget *tbl = GTK_WIDGET(obj);
4088
4089     GtkAdjustment *adj;
4090
4091     // fixme: make settable
4092     gdouble tolerance = 4;
4093
4094     adj = (GtkAdjustment*)gtk_object_get_data(obj, "tolerance");
4095     gtk_adjustment_set_value(adj, tolerance);
4096     gtk_adjustment_value_changed(adj);
4097
4098     spinbutton_defocus(GTK_OBJECT(tbl));
4099 }
4100
4101 static void sp_pencil_tb_tolerance_value_changed(GtkAdjustment *adj, GObject *tbl)
4102 {
4103     // quit if run by the attr_changed listener
4104     if (g_object_get_data( tbl, "freeze" )) {
4105         return;
4106     }
4107     // in turn, prevent listener from responding
4108     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4109     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
4110     prefs->setDouble("/tools/freehand/pencil/tolerance", adj->value);
4111     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
4112 }
4113
4114 /*
4115 class PencilToleranceObserver : public Inkscape::Preferences::Observer {
4116 public:
4117     PencilToleranceObserver(Glib::ustring const &path, GObject *x) : Observer(path), _obj(x)
4118     {
4119         g_object_set_data(_obj, "prefobserver", this);
4120     }
4121     virtual ~PencilToleranceObserver() {
4122         if (g_object_get_data(_obj, "prefobserver") == this) {
4123             g_object_set_data(_obj, "prefobserver", NULL);
4124         }
4125     }
4126     virtual void notify(Inkscape::Preferences::Entry const &val) {
4127         GObject* tbl = _obj;
4128         if (g_object_get_data( tbl, "freeze" )) {
4129             return;
4130         }
4131         g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
4132
4133         GtkAdjustment * adj = (GtkAdjustment*)g_object_get_data(tbl, "tolerance");
4134
4135         double v = val.getDouble(adj->value);
4136         gtk_adjustment_set_value(adj, v);
4137         g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
4138     }
4139 private:
4140     GObject *_obj;
4141 };
4142 */
4143
4144 static void sp_pencil_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
4145 {
4146     sp_add_freehand_mode_toggle(mainActions, holder, true);
4147
4148     EgeAdjustmentAction* eact = 0;
4149
4150     /* Tolerance */
4151     {
4152         gchar const* labels[] = {_("(many nodes, rough)"), _("(default)"), 0, 0, 0, 0, _("(few nodes, smooth)")};
4153         gdouble values[] = {1, 10, 20, 30, 50, 75, 100};
4154         eact = create_adjustment_action( "PencilToleranceAction",
4155                                          _("Smoothing:"), _("Smoothing: "),
4156                  _("How much smoothing (simplifying) is applied to the line"),
4157                                          "/tools/freehand/pencil/tolerance",
4158                                          3.0,
4159                                          GTK_WIDGET(desktop->canvas), NULL,
4160                                          holder, TRUE, "altx-pencil",
4161                                          1, 100.0, 0.5, 1.0,
4162                                          labels, values, G_N_ELEMENTS(labels),
4163                                          sp_pencil_tb_tolerance_value_changed,
4164                                          1, 2);
4165         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
4166         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
4167     }
4168
4169     /* advanced shape options */
4170     freehand_add_advanced_shape_options(mainActions, holder, true);
4171
4172     /* Reset */
4173     {
4174         InkAction* inky = ink_action_new( "PencilResetAction",
4175                                           _("Defaults"),
4176                                           _("Reset pencil parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
4177                                           GTK_STOCK_CLEAR,
4178                                           Inkscape::ICON_SIZE_SMALL_TOOLBAR );
4179         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_pencil_tb_defaults), holder );
4180         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
4181     }
4182
4183     g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );
4184
4185 }
4186
4187
4188 //########################
4189 //##       Tweak        ##
4190 //########################
4191
4192 static void sp_tweak_width_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
4193 {
4194     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4195     prefs->setDouble( "/tools/tweak/width", adj->value * 0.01 );
4196 }
4197
4198 static void sp_tweak_force_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
4199 {
4200     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4201     prefs->setDouble( "/tools/tweak/force", adj->value * 0.01 );
4202 }
4203
4204 static void sp_tweak_pressure_state_changed( GtkToggleAction *act, gpointer /*data*/ )
4205 {
4206     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4207     prefs->setBool("/tools/tweak/usepressure", gtk_toggle_action_get_active(act));
4208 }
4209
4210 static void sp_tweak_mode_changed( EgeSelectOneAction *act, GObject *tbl )
4211 {
4212     int mode = ege_select_one_action_get_active( act );
4213     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4214     prefs->setInt("/tools/tweak/mode", mode);
4215
4216     static gchar const* names[] = {"tweak_doh", "tweak_dos", "tweak_dol", "tweak_doo", "tweak_channels_label"};
4217     bool flag = ((mode == TWEAK_MODE_COLORPAINT) || (mode == TWEAK_MODE_COLORJITTER));
4218     for (size_t i = 0; i < G_N_ELEMENTS(names); ++i) {
4219         GtkAction *act = GTK_ACTION(g_object_get_data( tbl, names[i] ));
4220         if (act) {
4221             gtk_action_set_sensitive(act, flag);
4222         }
4223     }
4224     GtkAction *fid = GTK_ACTION(g_object_get_data( tbl, "tweak_fidelity"));
4225     if (fid) {
4226         gtk_action_set_sensitive(fid, !flag);
4227     }
4228 }
4229
4230 static void sp_tweak_fidelity_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
4231 {
4232     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4233     prefs->setDouble( "/tools/tweak/fidelity", adj->value * 0.01 );
4234 }
4235
4236 static void tweak_toggle_doh(GtkToggleAction *act, gpointer /*data*/) {
4237     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4238     prefs->setBool("/tools/tweak/doh", gtk_toggle_action_get_active(act));
4239 }
4240 static void tweak_toggle_dos(GtkToggleAction *act, gpointer /*data*/) {
4241     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4242     prefs->setBool("/tools/tweak/dos", gtk_toggle_action_get_active(act));
4243 }
4244 static void tweak_toggle_dol(GtkToggleAction *act, gpointer /*data*/) {
4245     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4246     prefs->setBool("/tools/tweak/dol", gtk_toggle_action_get_active(act));
4247 }
4248 static void tweak_toggle_doo(GtkToggleAction *act, gpointer /*data*/) {
4249     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4250     prefs->setBool("/tools/tweak/doo", gtk_toggle_action_get_active(act));
4251 }
4252
4253 static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
4254 {
4255     Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
4256     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4257
4258     {
4259         /* Width */
4260         gchar const* labels[] = {_("(pinch tweak)"), 0, 0, 0, _("(default)"), 0, 0, 0, 0, _("(broad tweak)")};
4261         gdouble values[] = {1, 3, 5, 10, 15, 20, 30, 50, 75, 100};
4262         EgeAdjustmentAction *eact = create_adjustment_action( "TweakWidthAction",
4263                                                               _("Width"), _("Width:"), _("The width of the tweak area (relative to the visible canvas area)"),
4264                                                               "/tools/tweak/width", 15,
4265                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-tweak",
4266                                                               1, 100, 1.0, 10.0,
4267                                                               labels, values, G_N_ELEMENTS(labels),
4268                                                               sp_tweak_width_value_changed,  0.01, 0, 100 );
4269         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
4270         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
4271         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
4272     }
4273
4274
4275     {
4276         /* Force */
4277         gchar const* labels[] = {_("(minimum force)"), 0, 0, _("(default)"), 0, 0, 0, _("(maximum force)")};
4278         gdouble values[] = {1, 5, 10, 20, 30, 50, 70, 100};
4279         EgeAdjustmentAction *eact = create_adjustment_action( "TweakForceAction",
4280                                                               _("Force"), _("Force:"), _("The force of the tweak action"),
4281                                                               "/tools/tweak/force", 20,
4282                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "tweak-force",
4283                                                               1, 100, 1.0, 10.0,
4284                                                               labels, values, G_N_ELEMENTS(labels),
4285                                                               sp_tweak_force_value_changed,  0.01, 0, 100 );
4286         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
4287         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
4288         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
4289     }
4290
4291     /* Mode */
4292     {
4293         GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
4294
4295         GtkTreeIter iter;
4296         gtk_list_store_append( model, &iter );
4297         gtk_list_store_set( model, &iter,
4298                             0, _("Move mode"),
4299                             1, _("Move objects in any direction"),
4300                             2, INKSCAPE_ICON_OBJECT_TWEAK_PUSH,
4301                             -1 );
4302
4303         gtk_list_store_append( model, &iter );
4304         gtk_list_store_set( model, &iter,
4305                             0, _("Move in/out mode"),
4306                             1, _("Move objects towards cursor; with Shift from cursor"),
4307                             2, INKSCAPE_ICON_OBJECT_TWEAK_ATTRACT,
4308                             -1 );
4309
4310         gtk_list_store_append( model, &iter );
4311         gtk_list_store_set( model, &iter,
4312                             0, _("Move jitter mode"),
4313                             1, _("Move objects in random directions"),
4314                             2, INKSCAPE_ICON_OBJECT_TWEAK_RANDOMIZE,
4315                             -1 );
4316
4317         gtk_list_store_append( model, &iter );
4318         gtk_list_store_set( model, &iter,
4319                             0, _("Scale mode"),
4320                             1, _("Shrink objects, with Shift enlarge"),
4321                             2, INKSCAPE_ICON_OBJECT_TWEAK_SHRINK,
4322                             -1 );
4323
4324         gtk_list_store_append( model, &iter );
4325         gtk_list_store_set( model, &iter,
4326                             0, _("Rotate mode"),
4327                             1, _("Rotate objects, with Shift counterclockwise"),
4328                             2, INKSCAPE_ICON_OBJECT_TWEAK_ROTATE,
4329                             -1 );
4330
4331         gtk_list_store_append( model, &iter );
4332         gtk_list_store_set( model, &iter,
4333                             0, _("Duplicate/delete mode"),
4334                             1, _("Duplicate objects, with Shift delete"),
4335                             2, INKSCAPE_ICON_OBJECT_TWEAK_DUPLICATE,
4336                             -1 );
4337
4338         gtk_list_store_append( model, &iter );
4339         gtk_list_store_set( model, &iter,
4340                             0, _("Push mode"),
4341                             1, _("Push parts of paths in any direction"),
4342                             2, INKSCAPE_ICON_PATH_TWEAK_PUSH,
4343                             -1 );
4344
4345         gtk_list_store_append( model, &iter );
4346         gtk_list_store_set( model, &iter,
4347                             0, _("Shrink/grow mode"),
4348                             1, _("Shrink (inset) parts of paths; with Shift grow (outset)"),
4349                             2, INKSCAPE_ICON_PATH_TWEAK_SHRINK,
4350                             -1 );
4351
4352         gtk_list_store_append( model, &iter );
4353         gtk_list_store_set( model, &iter,
4354                             0, _("Attract/repel mode"),
4355                             1, _("Attract parts of paths towards cursor; with Shift from cursor"),
4356                             2, INKSCAPE_ICON_PATH_TWEAK_ATTRACT,
4357                             -1 );
4358
4359         gtk_list_store_append( model, &iter );
4360         gtk_list_store_set( model, &iter,
4361                             0, _("Roughen mode"),
4362                             1, _("Roughen parts of paths"),
4363                             2, INKSCAPE_ICON_PATH_TWEAK_ROUGHEN,
4364                             -1 );
4365
4366         gtk_list_store_append( model, &iter );
4367         gtk_list_store_set( model, &iter,
4368                             0, _("Color paint mode"),
4369                             1, _("Paint the tool's color upon selected objects"),
4370                             2, INKSCAPE_ICON_OBJECT_TWEAK_PAINT,
4371                             -1 );
4372
4373         gtk_list_store_append( model, &iter );
4374         gtk_list_store_set( model, &iter,
4375                             0, _("Color jitter mode"),
4376                             1, _("Jitter the colors of selected objects"),
4377                             2, INKSCAPE_ICON_OBJECT_TWEAK_JITTER_COLOR,
4378                             -1 );
4379
4380         gtk_list_store_append( model, &iter );
4381         gtk_list_store_set( model, &iter,
4382                             0, _("Blur mode"),
4383                             1, _("Blur selected objects more; with Shift, blur less"),
4384                             2, INKSCAPE_ICON_OBJECT_TWEAK_BLUR,
4385                             -1 );
4386
4387
4388         EgeSelectOneAction* act = ege_select_one_action_new( "TweakModeAction", _("Mode"), (""), NULL, GTK_TREE_MODEL(model) );
4389         g_object_set( act, "short_label", _("Mode:"), NULL );
4390         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
4391         g_object_set_data( holder, "mode_action", act );
4392
4393         ege_select_one_action_set_appearance( act, "full" );
4394         ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
4395         g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
4396         ege_select_one_action_set_icon_column( act, 2 );
4397         ege_select_one_action_set_icon_size( act, secondarySize );
4398         ege_select_one_action_set_tooltip_column( act, 1  );
4399
4400         gint mode = prefs->getInt("/tools/tweak/mode", 0);
4401         ege_select_one_action_set_active( act, mode );
4402         g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_tweak_mode_changed), holder );
4403
4404         g_object_set_data( G_OBJECT(holder), "tweak_tool_mode", act);
4405     }
4406
4407     guint mode = prefs->getInt("/tools/tweak/mode", 0);
4408
4409     {
4410         EgeOutputAction* act = ege_output_action_new( "TweakChannelsLabel", _("Channels:"), "", 0 );
4411         ege_output_action_set_use_markup( act, TRUE );
4412         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
4413         if (mode != TWEAK_MODE_COLORPAINT && mode != TWEAK_MODE_COLORJITTER) {
4414             gtk_action_set_sensitive (GTK_ACTION(act), FALSE);
4415         }
4416         g_object_set_data( holder, "tweak_channels_label", act);
4417     }
4418
4419     {
4420         InkToggleAction* act = ink_toggle_action_new( "TweakDoH",
4421                                                       _("Hue"),
4422                                                       _("In color mode, act on objects' hue"),
4423                                                       NULL,
4424                                                       Inkscape::ICON_SIZE_DECORATION );
4425         //TRANSLATORS:  "H" here stands for hue
4426         g_object_set( act, "short_label", _("H"), NULL );
4427         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
4428         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_doh), desktop );
4429         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/doh", true) );
4430         if (mode != TWEAK_MODE_COLORPAINT && mode != TWEAK_MODE_COLORJITTER) {
4431             gtk_action_set_sensitive (GTK_ACTION(act), FALSE);
4432         }
4433         g_object_set_data( holder, "tweak_doh", act);
4434     }
4435     {
4436         InkToggleAction* act = ink_toggle_action_new( "TweakDoS",
4437                                                       _("Saturation"),
4438                                                       _("In color mode, act on objects' saturation"),
4439                                                       NULL,
4440                                                       Inkscape::ICON_SIZE_DECORATION );
4441         //TRANSLATORS: "S" here stands for Saturation
4442         g_object_set( act, "short_label", _("S"), NULL );
4443         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
4444         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_dos), desktop );
4445         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/dos", true) );
4446         if (mode != TWEAK_MODE_COLORPAINT && mode != TWEAK_MODE_COLORJITTER) {
4447             gtk_action_set_sensitive (GTK_ACTION(act), FALSE);
4448         }
4449         g_object_set_data( holder, "tweak_dos", act );
4450     }
4451     {
4452         InkToggleAction* act = ink_toggle_action_new( "TweakDoL",
4453                                                       _("Lightness"),
4454                                                       _("In color mode, act on objects' lightness"),
4455                                                       NULL,
4456                                                       Inkscape::ICON_SIZE_DECORATION );
4457         //TRANSLATORS: "L" here stands for Lightness
4458         g_object_set( act, "short_label", _("L"), NULL );
4459         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
4460         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_dol), desktop );
4461         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/dol", true) );
4462         if (mode != TWEAK_MODE_COLORPAINT && mode != TWEAK_MODE_COLORJITTER) {
4463             gtk_action_set_sensitive (GTK_ACTION(act), FALSE);
4464         }
4465         g_object_set_data( holder, "tweak_dol", act );
4466     }
4467     {
4468         InkToggleAction* act = ink_toggle_action_new( "TweakDoO",
4469                                                       _("Opacity"),
4470                                                       _("In color mode, act on objects' opacity"),
4471                                                       NULL,
4472                                                       Inkscape::ICON_SIZE_DECORATION );
4473         //TRANSLATORS: "O" here stands for Opacity
4474         g_object_set( act, "short_label", _("O"), NULL );
4475         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
4476         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_doo), desktop );
4477         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/doo", true) );
4478         if (mode != TWEAK_MODE_COLORPAINT && mode != TWEAK_MODE_COLORJITTER) {
4479             gtk_action_set_sensitive (GTK_ACTION(act), FALSE);
4480         }
4481         g_object_set_data( holder, "tweak_doo", act );
4482     }
4483
4484     {   /* Fidelity */
4485         gchar const* labels[] = {_("(rough, simplified)"), 0, 0, _("(default)"), 0, 0, _("(fine, but many nodes)")};
4486         gdouble values[] = {10, 25, 35, 50, 60, 80, 100};
4487         EgeAdjustmentAction *eact = create_adjustment_action( "TweakFidelityAction",
4488                                                               _("Fidelity"), _("Fidelity:"),
4489                                                               _("Low fidelity simplifies paths; high fidelity preserves path features but may generate a lot of new nodes"),
4490                                                               "/tools/tweak/fidelity", 50,
4491                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "tweak-fidelity",
4492                                                               1, 100, 1.0, 10.0,
4493                                                               labels, values, G_N_ELEMENTS(labels),
4494                                                               sp_tweak_fidelity_value_changed,  0.01, 0, 100 );
4495         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
4496         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
4497         if (mode == TWEAK_MODE_COLORPAINT || mode == TWEAK_MODE_COLORJITTER) {
4498             gtk_action_set_sensitive (GTK_ACTION(eact), FALSE);
4499         }
4500         g_object_set_data( holder, "tweak_fidelity", eact );
4501     }
4502
4503
4504     /* Use Pressure button */
4505     {
4506         InkToggleAction* act = ink_toggle_action_new( "TweakPressureAction",
4507                                                       _("Pressure"),
4508                                                       _("Use the pressure of the input device to alter the force of tweak action"),
4509                                                       INKSCAPE_ICON_DRAW_USE_PRESSURE,
4510                                                       Inkscape::ICON_SIZE_DECORATION );
4511         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
4512         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_tweak_pressure_state_changed), NULL);
4513         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/usepressure", true) );
4514     }
4515
4516 }
4517
4518
4519 //########################
4520 //##       Spray        ##
4521 //########################
4522
4523 static void sp_spray_width_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
4524 {
4525     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4526     prefs->setDouble( "/tools/spray/width", adj->value );
4527 }
4528
4529 static void sp_spray_mean_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
4530 {
4531     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4532     prefs->setDouble( "/tools/spray/mean", adj->value );
4533 }
4534
4535 static void sp_spray_standard_deviation_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
4536 {
4537     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4538     prefs->setDouble( "/tools/spray/standard_deviation", adj->value );
4539 }
4540
4541 static void sp_spray_pressure_state_changed( GtkToggleAction *act, gpointer /*data*/ )
4542 {
4543     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4544     prefs->setBool("/tools/spray/usepressure", gtk_toggle_action_get_active(act));
4545 }
4546
4547 static void sp_spray_mode_changed( EgeSelectOneAction *act, GObject * /*tbl*/ )
4548 {
4549     int mode = ege_select_one_action_get_active( act );
4550     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4551     prefs->setInt("/tools/spray/mode", mode);
4552 }
4553
4554 static void sp_spray_population_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
4555 {
4556     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4557     prefs->setDouble( "/tools/spray/population", adj->value );
4558 }
4559
4560 static void sp_spray_rotation_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
4561 {
4562     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4563     prefs->setDouble( "/tools/spray/rotation_variation", adj->value );
4564 }
4565
4566 static void sp_spray_scale_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
4567 {
4568     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4569     prefs->setDouble( "/tools/spray/scale_variation", adj->value );
4570 }
4571
4572
4573 static void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
4574 {
4575     Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
4576     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4577
4578     {
4579         /* Width */
4580         gchar const* labels[] = {_("(narrow spray)"), 0, 0, 0, _("(default)"), 0, 0, 0, 0, _("(broad spray)")};
4581         gdouble values[] = {1, 3, 5, 10, 15, 20, 30, 50, 75, 100};
4582         EgeAdjustmentAction *eact = create_adjustment_action( "SprayWidthAction",
4583                                                               _("Width"), _("Width:"), _("The width of the spray area (relative to the visible canvas area)"),
4584                                                               "/tools/spray/width", 15,
4585                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-spray",
4586                                                               1, 100, 1.0, 10.0,
4587                                                               labels, values, G_N_ELEMENTS(labels),
4588                                                               sp_spray_width_value_changed,  1, 0 );
4589         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
4590         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
4591         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
4592     }
4593
4594     {
4595         /* Mean */
4596         gchar const* labels[] = {_("(minimum mean)"), 0, 0, _("(default)"), 0, 0, 0, _("(maximum mean)")};
4597         gdouble values[] = {1, 5, 10, 20, 30, 50, 70, 100};
4598         EgeAdjustmentAction *eact = create_adjustment_action( "SprayMeanAction",
4599                                                               _("Focus"), _("Focus:"), _("0 to spray a spot. Increase to enlarge the ring radius."),
4600                                                               "/tools/spray/mean", 0,
4601                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "spray-mean",
4602                                                               0, 100, 1.0, 10.0,
4603                                                               labels, values, G_N_ELEMENTS(labels),
4604                                                               sp_spray_mean_value_changed,  1, 0 );
4605         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
4606         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
4607         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
4608     }
4609
4610     {
4611         /* Standard_deviation */
4612         gchar const* labels[] = {_("(minimum scatter)"), 0, 0, _("(default)"), 0, 0, 0, _("(maximum scatter)")};
4613         gdouble values[] = {1, 5, 10, 20, 30, 50, 70, 100};
4614
4615         //TRANSLATORS: only translate "string" in "context|string".
4616         // For more details, see http://developer.gnome.org/doc/API/2.0/glib/glib-I18N.html#Q-:CAPS
4617         EgeAdjustmentAction *eact = create_adjustment_action( "SprayStandard_deviationAction",
4618                                                               Q_("Toolbox|Scatter"), Q_("Toolbox|Scatter:"), _("Increase to scatter sprayed objects."),
4619                                                               "/tools/spray/standard_deviation", 70,
4620                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "spray-standard_deviation",
4621                                                               1, 100, 1.0, 10.0,
4622                                                               labels, values, G_N_ELEMENTS(labels),
4623                                                               sp_spray_standard_deviation_value_changed,  1, 0 );
4624         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
4625         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
4626         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
4627     }
4628
4629     /* Mode */
4630     {
4631         GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
4632
4633         GtkTreeIter iter;
4634         gtk_list_store_append( model, &iter );
4635         gtk_list_store_set( model, &iter,
4636                             0, _("Spray with copies"),
4637                             1, _("Spray copies of the initial selection"),
4638                             2, INKSCAPE_ICON_SPRAY_COPY_MODE,
4639                             -1 );
4640
4641         gtk_list_store_append( model, &iter );
4642         gtk_list_store_set( model, &iter,
4643                             0, _("Spray with clones"),
4644                             1, _("Spray clones of the initial selection"),
4645                             2, INKSCAPE_ICON_SPRAY_CLONE_MODE,
4646                             -1 );
4647
4648         gtk_list_store_append( model, &iter );
4649         gtk_list_store_set( model, &iter,
4650                             0, _("Spray single path"),
4651                             1, _("Spray objects in a single path"),
4652                             2, INKSCAPE_ICON_SPRAY_UNION_MODE,
4653                             -1 );
4654
4655         EgeSelectOneAction* act = ege_select_one_action_new( "SprayModeAction", _("Mode"), (""), NULL, GTK_TREE_MODEL(model) );
4656         g_object_set( act, "short_label", _("Mode:"), NULL );
4657         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
4658         g_object_set_data( holder, "mode_action", act );
4659
4660         ege_select_one_action_set_appearance( act, "full" );
4661         ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
4662         g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
4663         ege_select_one_action_set_icon_column( act, 2 );
4664         ege_select_one_action_set_icon_size( act, secondarySize );
4665         ege_select_one_action_set_tooltip_column( act, 1  );
4666
4667         gint mode = prefs->getInt("/tools/spray/mode", 1);
4668         ege_select_one_action_set_active( act, mode );
4669         g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_spray_mode_changed), holder );
4670
4671         g_object_set_data( G_OBJECT(holder), "spray_tool_mode", act);
4672     }
4673
4674     {   /* Population */
4675         gchar const* labels[] = {_("(low population)"), 0, 0, _("(default)"), 0, 0, _("(high population)")};
4676         gdouble values[] = {10, 25, 35, 50, 60, 80, 100};
4677         EgeAdjustmentAction *eact = create_adjustment_action( "SprayPopulationAction",
4678                                                               _("Amount"), _("Amount:"),
4679                                                               _("Adjusts the number of items sprayed per clic."),
4680                                                               "/tools/spray/population", 70,
4681                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "spray-population",
4682                                                               1, 100, 1.0, 10.0,
4683                                                               labels, values, G_N_ELEMENTS(labels),
4684                                                               sp_spray_population_value_changed,  1, 0 );
4685         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
4686         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
4687         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
4688         g_object_set_data( holder, "spray_population", eact );
4689     }
4690
4691     /* Use Pressure button */
4692     {
4693         InkToggleAction* act = ink_toggle_action_new( "SprayPressureAction",
4694                                                       _("Pressure"),
4695                                                       _("Use the pressure of the input device to alter the amount of sprayed objects."),
4696                                                       "use_pressure",
4697                                                       Inkscape::ICON_SIZE_DECORATION );
4698         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
4699         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_spray_pressure_state_changed), NULL);
4700         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/usepressure", true) );
4701     }
4702
4703     {   /* Rotation */
4704         gchar const* labels[] = {_("(low rotation variation)"), 0, 0, _("(default)"), 0, 0, _("(high rotation variation)")};
4705         gdouble values[] = {10, 25, 35, 50, 60, 80, 100};
4706         EgeAdjustmentAction *eact = create_adjustment_action( "SprayRotationAction",
4707                                                               _("Rotation"), _("Rotation:"),
4708                                                               // xgettext:no-c-format
4709                                                               _("Variation of the rotation of the sprayed objects. 0% for the same rotation than the original object."),
4710                                                               "/tools/spray/rotation_variation", 0,
4711                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "spray-rotation",
4712                                                               0, 100, 1.0, 10.0,
4713                                                               labels, values, G_N_ELEMENTS(labels),
4714                                                               sp_spray_rotation_value_changed,  1, 0 );
4715         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
4716         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
4717         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
4718         g_object_set_data( holder, "spray_rotation", eact );
4719     }
4720
4721     {   /* Scale */
4722         gchar const* labels[] = {_("(low scale variation)"), 0, 0, _("(default)"), 0, 0, _("(high scale variation)")};
4723         gdouble values[] = {10, 25, 35, 50, 60, 80, 100};
4724
4725         //TRANSLATORS: only translate "string" in "context|string".
4726         // For more details, see http://developer.gnome.org/doc/API/2.0/glib/glib-I18N.html#Q-:CAPS
4727         EgeAdjustmentAction *eact = create_adjustment_action( "SprayScaleAction",
4728                                                               Q_("Toolbox|Scale"), Q_("Toolbox|Scale:"),
4729                                                               // xgettext:no-c-format
4730                                                               _("Variation in the scale of the sprayed objects. 0% for the same scale than the original object."),
4731                                                               "/tools/spray/scale_variation", 0,
4732                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "spray-scale",
4733                                                               0, 100, 1.0, 10.0,
4734                                                               labels, values, G_N_ELEMENTS(labels),
4735                                                               sp_spray_scale_value_changed,  1, 0 );
4736         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
4737         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
4738         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
4739         g_object_set_data( holder, "spray_scale", eact );
4740     }
4741
4742
4743
4744 }
4745
4746
4747 //########################
4748 //##     Calligraphy    ##
4749 //########################
4750 static void update_presets_list(GObject *tbl)
4751 {
4752     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4753     if (g_object_get_data(tbl, "presets_blocked")) {
4754         return;
4755     }
4756
4757     EgeSelectOneAction *sel = static_cast<EgeSelectOneAction *>(g_object_get_data(tbl, "profile_selector"));
4758     if (!sel) {
4759         // WTF!? This will cause a segfault if ever reached
4760         //ege_select_one_action_set_active(sel, 0);
4761         return;
4762     }
4763
4764     std::vector<Glib::ustring> presets = prefs->getAllDirs("/tools/calligraphic/preset");
4765
4766     int ege_index = 1;
4767     for (std::vector<Glib::ustring>::iterator i = presets.begin(); i != presets.end(); ++i, ++ege_index) {
4768         bool match = true;
4769
4770         std::vector<Inkscape::Preferences::Entry> preset = prefs->getAllEntries(*i);
4771         for (std::vector<Inkscape::Preferences::Entry>::iterator j = preset.begin(); j != preset.end(); ++j) {
4772             Glib::ustring entry_name = j->getEntryName();
4773             if (entry_name == "id" || entry_name == "name") {
4774                 continue;
4775             }
4776
4777             void *widget = g_object_get_data(tbl, entry_name.data());
4778             if (widget) {
4779                 if (GTK_IS_ADJUSTMENT(widget)) {
4780                     double v = j->getDouble();
4781                     GtkAdjustment* adj = static_cast<GtkAdjustment *>(widget);
4782                     //std::cout << "compared adj " << attr_name << gtk_adjustment_get_value(adj) << " to " << v << "\n";
4783                     if (fabs(gtk_adjustment_get_value(adj) - v) > 1e-6) {
4784                         match = false;
4785                         break;
4786                     }
4787                 } else if (GTK_IS_TOGGLE_ACTION(widget)) {
4788                     bool v = j->getBool();
4789                     GtkToggleAction* toggle = static_cast<GtkToggleAction *>(widget);
4790                     //std::cout << "compared toggle " << attr_name << gtk_toggle_action_get_active(toggle) << " to " << v << "\n";
4791                     if ( static_cast<bool>(gtk_toggle_action_get_active(toggle)) != v ) {
4792                         match = false;
4793                         break;
4794                     }
4795                 }
4796             }
4797         }
4798
4799         if (match) {
4800             // newly added item is at the same index as the
4801             // save command, so we need to change twice for it to take effect
4802             ege_select_one_action_set_active(sel, 0);
4803             ege_select_one_action_set_active(sel, ege_index); // one-based index
4804             return;
4805         }
4806     }
4807
4808     // no match found
4809     ege_select_one_action_set_active(sel, 0);
4810 }
4811
4812 static void sp_ddc_mass_value_changed( GtkAdjustment *adj, GObject* tbl )
4813 {
4814     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4815     prefs->setDouble( "/tools/calligraphic/mass", adj->value );
4816     update_presets_list(tbl);
4817 }
4818
4819 static void sp_ddc_wiggle_value_changed( GtkAdjustment *adj, GObject* tbl )
4820 {
4821     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4822     prefs->setDouble( "/tools/calligraphic/wiggle", adj->value );
4823     update_presets_list(tbl);
4824 }
4825
4826 static void sp_ddc_angle_value_changed( GtkAdjustment *adj, GObject* tbl )
4827 {
4828     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4829     prefs->setDouble( "/tools/calligraphic/angle", adj->value );
4830     update_presets_list(tbl);
4831 }
4832
4833 static void sp_ddc_width_value_changed( GtkAdjustment *adj, GObject *tbl )
4834 {
4835     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4836     prefs->setDouble( "/tools/calligraphic/width", adj->value );
4837     update_presets_list(tbl);
4838 }
4839
4840 static void sp_ddc_velthin_value_changed( GtkAdjustment *adj, GObject* tbl )
4841 {
4842     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4843     prefs->setDouble("/tools/calligraphic/thinning", adj->value );
4844     update_presets_list(tbl);
4845 }
4846
4847 static void sp_ddc_flatness_value_changed( GtkAdjustment *adj, GObject* tbl )
4848 {
4849     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4850     prefs->setDouble( "/tools/calligraphic/flatness", adj->value );
4851     update_presets_list(tbl);
4852 }
4853
4854 static void sp_ddc_tremor_value_changed( GtkAdjustment *adj, GObject* tbl )
4855 {
4856     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4857     prefs->setDouble( "/tools/calligraphic/tremor", adj->value );
4858     update_presets_list(tbl);
4859 }
4860
4861 static void sp_ddc_cap_rounding_value_changed( GtkAdjustment *adj, GObject* tbl )
4862 {
4863     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4864     prefs->setDouble( "/tools/calligraphic/cap_rounding", adj->value );
4865     update_presets_list(tbl);
4866 }
4867
4868 static void sp_ddc_tilt_state_changed( GtkToggleAction *act, GObject*  tbl )
4869 {
4870     // TODO merge into PrefPusher
4871     GtkAction * calligraphy_angle = static_cast<GtkAction *> (g_object_get_data(tbl,"angle_action"));
4872     if (calligraphy_angle ) {
4873         gtk_action_set_sensitive( calligraphy_angle, !gtk_toggle_action_get_active( act ) );
4874     }
4875 }
4876
4877
4878 static gchar const *const widget_names[] = {
4879     "width",
4880     "mass",
4881     "wiggle",
4882     "angle",
4883     "thinning",
4884     "tremor",
4885     "flatness",
4886     "cap_rounding",
4887     "usepressure",
4888     "tracebackground",
4889     "usetilt"
4890 };
4891
4892
4893 static void sp_dcc_build_presets_list(GObject *tbl)
4894 {
4895     g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(TRUE));
4896
4897     EgeSelectOneAction* selector = static_cast<EgeSelectOneAction *>(g_object_get_data(tbl, "profile_selector"));
4898     GtkListStore* model = GTK_LIST_STORE(ege_select_one_action_get_model(selector));
4899     gtk_list_store_clear (model);
4900
4901     {
4902         GtkTreeIter iter;
4903         gtk_list_store_append( model, &iter );
4904         gtk_list_store_set( model, &iter, 0, _("No preset"), 1, 0, -1 );
4905     }
4906
4907     // iterate over all presets to populate the list
4908     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4909     std::vector<Glib::ustring> presets = prefs->getAllDirs("/tools/calligraphic/preset");
4910     int ii=1;
4911
4912     for (std::vector<Glib::ustring>::iterator i = presets.begin(); i != presets.end(); ++i) {
4913         GtkTreeIter iter;
4914         Glib::ustring preset_name = prefs->getString(*i + "/name");
4915         gtk_list_store_append( model, &iter );
4916         gtk_list_store_set( model, &iter, 0, _(preset_name.data()), 1, ii++, -1 );
4917     }
4918
4919     {
4920         GtkTreeIter iter;
4921         gtk_list_store_append( model, &iter );
4922         gtk_list_store_set( model, &iter, 0, _("Save..."), 1, ii, -1 );
4923         g_object_set_data(tbl, "save_presets_index", GINT_TO_POINTER(ii));
4924     }
4925
4926     g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(FALSE));
4927
4928     update_presets_list (tbl);
4929 }
4930
4931 static void sp_dcc_save_profile(GtkWidget * /*widget*/, GObject *tbl)
4932 {
4933     using Inkscape::UI::Dialog::CalligraphicProfileRename;
4934     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4935     SPDesktop *desktop = (SPDesktop *) g_object_get_data(tbl, "desktop" );
4936     if (! desktop) {
4937         return;
4938     }
4939
4940     if (g_object_get_data(tbl, "presets_blocked")) {
4941         return;
4942     }
4943
4944     CalligraphicProfileRename::show(desktop);
4945     if ( !CalligraphicProfileRename::applied()) {
4946         // dialog cancelled
4947         update_presets_list (tbl);
4948         return;
4949     }
4950     Glib::ustring profile_name = CalligraphicProfileRename::getProfileName();
4951
4952     if (profile_name.empty()) {
4953         // empty name entered
4954         update_presets_list (tbl);
4955         return;
4956     }
4957
4958     g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(TRUE));
4959
4960     // If there's a preset with the given name, find it and set save_path appropriately
4961     std::vector<Glib::ustring> presets = prefs->getAllDirs("/tools/calligraphic/preset");
4962     int total_presets = presets.size();
4963     int new_index = -1;
4964     Glib::ustring save_path; // profile pref path without a trailing slash
4965
4966     int temp_index = 0;
4967     for (std::vector<Glib::ustring>::iterator i = presets.begin(); i != presets.end(); ++i, ++temp_index) {
4968         Glib::ustring name = prefs->getString(*i + "/name");
4969         if (!name.empty() && profile_name == name) {
4970             new_index = temp_index;
4971             save_path = *i;
4972             break;
4973         }
4974     }
4975
4976     if (new_index == -1) {
4977         // no preset with this name, create
4978         new_index = total_presets + 1;
4979         gchar *profile_id = g_strdup_printf("/dcc%d", new_index);
4980         save_path = Glib::ustring("/tools/calligraphic/preset") + profile_id;
4981         g_free(profile_id);
4982     }
4983
4984     for (unsigned i = 0; i < G_N_ELEMENTS(widget_names); ++i) {
4985         gchar const *const widget_name = widget_names[i];
4986         void *widget = g_object_get_data(tbl, widget_name);
4987         if (widget) {
4988             if (GTK_IS_ADJUSTMENT(widget)) {
4989                 GtkAdjustment* adj = static_cast<GtkAdjustment *>(widget);
4990                 prefs->setDouble(save_path + "/" + widget_name, gtk_adjustment_get_value(adj));
4991                 //std::cout << "wrote adj " << widget_name << ": " << v << "\n";
4992             } else if (GTK_IS_TOGGLE_ACTION(widget)) {
4993                 GtkToggleAction* toggle = static_cast<GtkToggleAction *>(widget);
4994                 prefs->setBool(save_path + "/" + widget_name, gtk_toggle_action_get_active(toggle));
4995                 //std::cout << "wrote tog " << widget_name << ": " << v << "\n";
4996             } else {
4997                 g_warning("Unknown widget type for preset: %s\n", widget_name);
4998             }
4999         } else {
5000             g_warning("Bad key when writing preset: %s\n", widget_name);
5001         }
5002     }
5003     prefs->setString(save_path + "/name", profile_name);
5004
5005     g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(FALSE));
5006     sp_dcc_build_presets_list (tbl);
5007 }
5008
5009
5010 static void sp_ddc_change_profile(EgeSelectOneAction* act, GObject* tbl)
5011 {
5012     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5013
5014     gint preset_index = ege_select_one_action_get_active( act );
5015     // This is necessary because EgeSelectOneAction spams us with GObject "changed" signal calls
5016     // even when the preset is not changed. It would be good to replace it with something more
5017     // modern. Index 0 means "No preset", so we don't do anything.
5018     if (preset_index == 0) {
5019         return;
5020     }
5021
5022     gint save_presets_index = GPOINTER_TO_INT(g_object_get_data(tbl, "save_presets_index"));
5023
5024     if (preset_index == save_presets_index) {
5025         // this is the Save command
5026         sp_dcc_save_profile(NULL, tbl);
5027         return;
5028     }
5029
5030     if (g_object_get_data(tbl, "presets_blocked")) {
5031         return;
5032     }
5033
5034     // preset_index is one-based so we subtract 1
5035     std::vector<Glib::ustring> presets = prefs->getAllDirs("/tools/calligraphic/preset");
5036     Glib::ustring preset_path = presets.at(preset_index - 1);
5037
5038     if (!preset_path.empty()) {
5039         g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(TRUE)); //temporarily block the selector so no one will updadte it while we're reading it
5040
5041         std::vector<Inkscape::Preferences::Entry> preset = prefs->getAllEntries(preset_path);
5042
5043         // Shouldn't this be std::map?
5044         for (std::vector<Inkscape::Preferences::Entry>::iterator i = preset.begin(); i != preset.end(); ++i) {
5045             Glib::ustring entry_name = i->getEntryName();
5046             if (entry_name == "id" || entry_name == "name") {
5047                 continue;
5048             }
5049             void *widget = g_object_get_data(tbl, entry_name.data());
5050             if (widget) {
5051                 if (GTK_IS_ADJUSTMENT(widget)) {
5052                     GtkAdjustment* adj = static_cast<GtkAdjustment *>(widget);
5053                     gtk_adjustment_set_value(adj, i->getDouble());
5054                     //std::cout << "set adj " << attr_name << " to " << v << "\n";
5055                 } else if (GTK_IS_TOGGLE_ACTION(widget)) {
5056                     GtkToggleAction* toggle = static_cast<GtkToggleAction *>(widget);
5057                     gtk_toggle_action_set_active(toggle, i->getBool());
5058                     //std::cout << "set toggle " << attr_name << " to " << v << "\n";
5059                 } else {
5060                     g_warning("Unknown widget type for preset: %s\n", entry_name.data());
5061                 }
5062             } else {
5063                 g_warning("Bad key found in a preset record: %s\n", entry_name.data());
5064             }
5065         }
5066         g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(FALSE));
5067     }
5068 }
5069
5070 static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
5071 {
5072     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5073     {
5074         g_object_set_data(holder, "presets_blocked", GINT_TO_POINTER(TRUE));
5075
5076         EgeAdjustmentAction* calligraphy_angle = 0;
5077
5078         {
5079         /* Width */
5080         gchar const* labels[] = {_("(hairline)"), 0, 0, 0, _("(default)"), 0, 0, 0, 0, _("(broad stroke)")};
5081         gdouble values[] = {1, 3, 5, 10, 15, 20, 30, 50, 75, 100};
5082         EgeAdjustmentAction *eact = create_adjustment_action( "CalligraphyWidthAction",
5083                                                               _("Pen Width"), _("Width:"),
5084                                                               _("The width of the calligraphic pen (relative to the visible canvas area)"),
5085                                                               "/tools/calligraphic/width", 15,
5086                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-calligraphy",
5087                                                               1, 100, 1.0, 10.0,
5088                                                               labels, values, G_N_ELEMENTS(labels),
5089                                                               sp_ddc_width_value_changed,  1, 0 );
5090         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
5091         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
5092         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
5093         }
5094
5095         {
5096         /* Thinning */
5097             gchar const* labels[] = {_("(speed blows up stroke)"), 0, 0, _("(slight widening)"), _("(constant width)"), _("(slight thinning, default)"), 0, 0, _("(speed deflates stroke)")};
5098             gdouble values[] = {-100, -40, -20, -10, 0, 10, 20, 40, 100};
5099         EgeAdjustmentAction* eact = create_adjustment_action( "ThinningAction",
5100                                                               _("Stroke Thinning"), _("Thinning:"),
5101                                                               _("How much velocity thins the stroke (> 0 makes fast strokes thinner, < 0 makes them broader, 0 makes width independent of velocity)"),
5102                                                               "/tools/calligraphic/thinning", 10,
5103                                                               GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
5104                                                               -100, 100, 1, 10.0,
5105                                                               labels, values, G_N_ELEMENTS(labels),
5106                                                               sp_ddc_velthin_value_changed, 1, 0);
5107         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
5108         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
5109         }
5110
5111         {
5112         /* Angle */
5113         gchar const* labels[] = {_("(left edge up)"), 0, 0, _("(horizontal)"), _("(default)"), 0, _("(right edge up)")};
5114         gdouble values[] = {-90, -60, -30, 0, 30, 60, 90};
5115         EgeAdjustmentAction* eact = create_adjustment_action( "AngleAction",
5116                                                               _("Pen Angle"), _("Angle:"),
5117                                                               _("The angle of the pen's nib (in degrees; 0 = horizontal; has no effect if fixation = 0)"),
5118                                                               "/tools/calligraphic/angle", 30,
5119                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "calligraphy-angle",
5120                                                               -90.0, 90.0, 1.0, 10.0,
5121                                                               labels, values, G_N_ELEMENTS(labels),
5122                                                               sp_ddc_angle_value_changed, 1, 0 );
5123         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
5124         g_object_set_data( holder, "angle_action", eact );
5125         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
5126         calligraphy_angle = eact;
5127         }
5128
5129         {
5130         /* Fixation */
5131             gchar const* labels[] = {_("(perpendicular to stroke, \"brush\")"), 0, 0, 0, _("(almost fixed, default)"), _("(fixed by Angle, \"pen\")")};
5132         gdouble values[] = {0, 20, 40, 60, 90, 100};
5133         EgeAdjustmentAction* eact = create_adjustment_action( "FixationAction",
5134                                                               _("Fixation"), _("Fixation:"),
5135                                                               _("Angle behavior (0 = nib always perpendicular to stroke direction, 100 = fixed angle)"),
5136                                                               "/tools/calligraphic/flatness", 90,
5137                                                               GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
5138                                                               0.0, 100, 1.0, 10.0,
5139                                                               labels, values, G_N_ELEMENTS(labels),
5140                                                               sp_ddc_flatness_value_changed, 1, 0);
5141         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
5142         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
5143         }
5144
5145         {
5146         /* Cap Rounding */
5147             gchar const* labels[] = {_("(blunt caps, default)"), _("(slightly bulging)"), 0, 0, _("(approximately round)"), _("(long protruding caps)")};
5148         gdouble values[] = {0, 0.3, 0.5, 1.0, 1.4, 5.0};
5149         // TRANSLATORS: "cap" means "end" (both start and finish) here
5150         EgeAdjustmentAction* eact = create_adjustment_action( "CapRoundingAction",
5151                                                               _("Cap rounding"), _("Caps:"),
5152                                                               _("Increase to make caps at the ends of strokes protrude more (0 = no caps, 1 = round caps)"),
5153                                                               "/tools/calligraphic/cap_rounding", 0.0,
5154                                                               GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
5155                                                               0.0, 5.0, 0.01, 0.1,
5156                                                               labels, values, G_N_ELEMENTS(labels),
5157                                                               sp_ddc_cap_rounding_value_changed, 0.01, 2 );
5158         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
5159         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
5160         }
5161
5162         {
5163         /* Tremor */
5164             gchar const* labels[] = {_("(smooth line)"), _("(slight tremor)"), _("(noticeable tremor)"), 0, 0, _("(maximum tremor)")};
5165         gdouble values[] = {0, 10, 20, 40, 60, 100};
5166         EgeAdjustmentAction* eact = create_adjustment_action( "TremorAction",
5167                                                               _("Stroke Tremor"), _("Tremor:"),
5168                                                               _("Increase to make strokes rugged and trembling"),
5169                                                               "/tools/calligraphic/tremor", 0.0,
5170                                                               GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
5171                                                               0.0, 100, 1, 10.0,
5172                                                               labels, values, G_N_ELEMENTS(labels),
5173                                                               sp_ddc_tremor_value_changed, 1, 0);
5174
5175         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
5176         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
5177         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
5178         }
5179
5180         {
5181         /* Wiggle */
5182         gchar const* labels[] = {_("(no wiggle)"), _("(slight deviation)"), 0, 0, _("(wild waves and curls)")};
5183         gdouble values[] = {0, 20, 40, 60, 100};
5184         EgeAdjustmentAction* eact = create_adjustment_action( "WiggleAction",
5185                                                               _("Pen Wiggle"), _("Wiggle:"),
5186                                                               _("Increase to make the pen waver and wiggle"),
5187                                                               "/tools/calligraphic/wiggle", 0.0,
5188                                                               GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
5189                                                               0.0, 100, 1, 10.0,
5190                                                               labels, values, G_N_ELEMENTS(labels),
5191                                                               sp_ddc_wiggle_value_changed, 1, 0);
5192         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
5193         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
5194         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
5195         }
5196
5197         {
5198         /* Mass */
5199             gchar const* labels[] = {_("(no inertia)"), _("(slight smoothing, default)"), _("(noticeable lagging)"), 0, 0, _("(maximum inertia)")};
5200         gdouble values[] = {0.0, 2, 10, 20, 50, 100};
5201         EgeAdjustmentAction* eact = create_adjustment_action( "MassAction",
5202                                                               _("Pen Mass"), _("Mass:"),
5203                                                               _("Increase to make the pen drag behind, as if slowed by inertia"),
5204                                                               "/tools/calligraphic/mass", 2.0,
5205                                                               GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
5206                                                               0.0, 100, 1, 10.0,
5207                                                               labels, values, G_N_ELEMENTS(labels),
5208                                                               sp_ddc_mass_value_changed, 1, 0);
5209         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
5210         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
5211         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
5212         }
5213
5214
5215         /* Trace Background button */
5216         {
5217             InkToggleAction* act = ink_toggle_action_new( "TraceAction",
5218                                                           _("Trace Background"),
5219                                                           _("Trace the lightness of the background by the width of the pen (white - minimum width, black - maximum width)"),
5220                                                           INKSCAPE_ICON_DRAW_TRACE_BACKGROUND,
5221                                                           Inkscape::ICON_SIZE_DECORATION );
5222             gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
5223             PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/calligraphic/tracebackground", update_presets_list, holder);
5224             g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
5225             g_object_set_data( holder, "tracebackground", act );
5226         }
5227
5228         /* Use Pressure button */
5229         {
5230             InkToggleAction* act = ink_toggle_action_new( "PressureAction",
5231                                                           _("Pressure"),
5232                                                           _("Use the pressure of the input device to alter the width of the pen"),
5233                                                           INKSCAPE_ICON_DRAW_USE_PRESSURE,
5234                                                           Inkscape::ICON_SIZE_DECORATION );
5235             gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
5236             PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/calligraphic/usepressure", update_presets_list, holder);
5237             g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
5238             g_object_set_data( holder, "usepressure", act );
5239         }
5240
5241         /* Use Tilt button */
5242         {
5243             InkToggleAction* act = ink_toggle_action_new( "TiltAction",
5244                                                           _("Tilt"),
5245                                                           _("Use the tilt of the input device to alter the angle of the pen's nib"),
5246                                                           INKSCAPE_ICON_DRAW_USE_TILT,
5247                                                           Inkscape::ICON_SIZE_DECORATION );
5248             gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
5249             PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/calligraphic/usetilt", update_presets_list, holder);
5250             g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
5251             g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_ddc_tilt_state_changed), holder );
5252             gtk_action_set_sensitive( GTK_ACTION(calligraphy_angle), !prefs->getBool("/tools/calligraphic/usetilt", true) );
5253             gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/calligraphic/usetilt", true) );
5254             g_object_set_data( holder, "usetilt", act );
5255         }
5256
5257         /*calligraphic profile */
5258         {
5259             GtkListStore* model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
5260             EgeSelectOneAction* act1 = ege_select_one_action_new ("SetProfileAction", "" , (_("Choose a preset")), NULL, GTK_TREE_MODEL(model));
5261             ege_select_one_action_set_appearance (act1, "compact");
5262             g_object_set_data (holder, "profile_selector", act1 );
5263
5264             g_object_set_data(holder, "presets_blocked", GINT_TO_POINTER(FALSE));
5265
5266             sp_dcc_build_presets_list (holder);
5267
5268             g_signal_connect(G_OBJECT(act1), "changed", G_CALLBACK(sp_ddc_change_profile), holder);
5269             gtk_action_group_add_action(mainActions, GTK_ACTION(act1));
5270         }
5271     }
5272 }
5273
5274
5275 //########################
5276 //##    Circle / Arc    ##
5277 //########################
5278
5279 static void sp_arctb_sensitivize( GObject *tbl, double v1, double v2 )
5280 {
5281     GtkAction *ocb = GTK_ACTION( g_object_get_data( tbl, "open_action" ) );
5282     GtkAction *make_whole = GTK_ACTION( g_object_get_data( tbl, "make_whole" ) );
5283
5284     if (v1 == 0 && v2 == 0) {
5285         if (g_object_get_data( tbl, "single" )) { // only for a single selected ellipse (for now)
5286             gtk_action_set_sensitive( ocb, FALSE );
5287             gtk_action_set_sensitive( make_whole, FALSE );
5288         }
5289     } else {
5290         gtk_action_set_sensitive( ocb, TRUE );
5291         gtk_action_set_sensitive( make_whole, TRUE );
5292     }
5293 }
5294
5295 static void
5296 sp_arctb_startend_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_name, gchar const *other_name)
5297 {
5298     SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
5299
5300     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
5301         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5302         prefs->setDouble(Glib::ustring("/tools/shapes/arc/") + value_name, adj->value);
5303     }
5304
5305     // quit if run by the attr_changed listener
5306     if (g_object_get_data( tbl, "freeze" )) {
5307         return;
5308     }
5309
5310     // in turn, prevent listener from responding
5311     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
5312
5313     gchar* namespaced_name = g_strconcat("sodipodi:", value_name, NULL);
5314
5315     bool modmade = false;
5316     for (GSList const *items = sp_desktop_selection(desktop)->itemList();
5317          items != NULL;
5318          items = items->next)
5319     {
5320         SPItem *item = SP_ITEM(items->data);
5321
5322         if (SP_IS_ARC(item) && SP_IS_GENERICELLIPSE(item)) {
5323
5324             SPGenericEllipse *ge = SP_GENERICELLIPSE(item);
5325             SPArc *arc = SP_ARC(item);
5326
5327             if (!strcmp(value_name, "start")) {
5328                 ge->start = (adj->value * M_PI)/ 180;
5329             } else {
5330                 ge->end = (adj->value * M_PI)/ 180;
5331             }
5332
5333             sp_genericellipse_normalize(ge);
5334             ((SPObject *)arc)->updateRepr();
5335             ((SPObject *)arc)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
5336
5337             modmade = true;
5338         }
5339     }
5340
5341     g_free(namespaced_name);
5342
5343     GtkAdjustment *other = GTK_ADJUSTMENT( g_object_get_data( tbl, other_name ) );
5344
5345     sp_arctb_sensitivize( tbl, adj->value, other->value );
5346
5347     if (modmade) {
5348         sp_document_maybe_done(sp_desktop_document(desktop), value_name, SP_VERB_CONTEXT_ARC,
5349                                    _("Arc: Change start/end"));
5350     }
5351
5352     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
5353 }
5354
5355
5356 static void sp_arctb_start_value_changed(GtkAdjustment *adj,  GObject *tbl)
5357 {
5358     sp_arctb_startend_value_changed(adj,  tbl, "start", "end");
5359 }
5360
5361 static void sp_arctb_end_value_changed(GtkAdjustment *adj, GObject *tbl)
5362 {
5363     sp_arctb_startend_value_changed(adj,  tbl, "end", "start");
5364 }
5365
5366
5367 static void sp_arctb_open_state_changed( EgeSelectOneAction *act, GObject *tbl )
5368 {
5369     SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
5370     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
5371         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5372         prefs->setBool("/tools/shapes/arc/open", ege_select_one_action_get_active(act) != 0);
5373     }
5374
5375     // quit if run by the attr_changed listener
5376     if (g_object_get_data( tbl, "freeze" )) {
5377         return;
5378     }
5379
5380     // in turn, prevent listener from responding
5381     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
5382
5383     bool modmade = false;
5384
5385     if ( ege_select_one_action_get_active(act) != 0 ) {
5386         for (GSList const *items = sp_desktop_selection(desktop)->itemList();
5387              items != NULL;
5388              items = items->next)
5389         {
5390             if (SP_IS_ARC((SPItem *) items->data)) {
5391                 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
5392                 repr->setAttribute("sodipodi:open", "true");
5393                 SP_OBJECT((SPItem *) items->data)->updateRepr();
5394                 modmade = true;
5395             }
5396         }
5397     } else {
5398         for (GSList const *items = sp_desktop_selection(desktop)->itemList();
5399              items != NULL;
5400              items = items->next)
5401         {
5402             if (SP_IS_ARC((SPItem *) items->data)) {
5403                 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
5404                 repr->setAttribute("sodipodi:open", NULL);
5405                 SP_OBJECT((SPItem *) items->data)->updateRepr();
5406                 modmade = true;
5407             }
5408         }
5409     }
5410
5411     if (modmade) {
5412         sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_ARC,
5413                                    _("Arc: Change open/closed"));
5414     }
5415
5416     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
5417 }
5418
5419 static void sp_arctb_defaults(GtkWidget *, GObject *obj)
5420 {
5421     GtkAdjustment *adj;
5422     adj = GTK_ADJUSTMENT( g_object_get_data(obj, "start") );
5423     gtk_adjustment_set_value(adj, 0.0);
5424     gtk_adjustment_value_changed(adj);
5425
5426     adj = GTK_ADJUSTMENT( g_object_get_data(obj, "end") );
5427     gtk_adjustment_set_value(adj, 0.0);
5428     gtk_adjustment_value_changed(adj);
5429
5430     spinbutton_defocus( GTK_OBJECT(obj) );
5431 }
5432
5433 static void arc_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const * /*name*/,
5434                                       gchar const * /*old_value*/, gchar const * /*new_value*/,
5435                                       bool /*is_interactive*/, gpointer data)
5436 {
5437     GObject *tbl = G_OBJECT(data);
5438
5439     // quit if run by the _changed callbacks
5440     if (g_object_get_data( tbl, "freeze" )) {
5441         return;
5442     }
5443
5444     // in turn, prevent callbacks from responding
5445     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
5446
5447     gdouble start = sp_repr_get_double_attribute(repr, "sodipodi:start", 0.0);
5448     gdouble end = sp_repr_get_double_attribute(repr, "sodipodi:end", 0.0);
5449
5450     GtkAdjustment *adj1,*adj2;
5451     adj1 = GTK_ADJUSTMENT( g_object_get_data( tbl, "start" ) );
5452     gtk_adjustment_set_value(adj1, mod360((start * 180)/M_PI));
5453     adj2 = GTK_ADJUSTMENT( g_object_get_data( tbl, "end" ) );
5454     gtk_adjustment_set_value(adj2, mod360((end * 180)/M_PI));
5455
5456     sp_arctb_sensitivize( tbl, adj1->value, adj2->value );
5457
5458     char const *openstr = NULL;
5459     openstr = repr->attribute("sodipodi:open");
5460     EgeSelectOneAction *ocb = EGE_SELECT_ONE_ACTION( g_object_get_data( tbl, "open_action" ) );
5461
5462     if (openstr) {
5463         ege_select_one_action_set_active( ocb, 1 );
5464     } else {
5465         ege_select_one_action_set_active( ocb, 0 );
5466     }
5467
5468     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
5469 }
5470
5471 static Inkscape::XML::NodeEventVector arc_tb_repr_events = {
5472     NULL, /* child_added */
5473     NULL, /* child_removed */
5474     arc_tb_event_attr_changed,
5475     NULL, /* content_changed */
5476     NULL  /* order_changed */
5477 };
5478
5479
5480 static void sp_arc_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
5481 {
5482     int n_selected = 0;
5483     Inkscape::XML::Node *repr = NULL;
5484
5485     purge_repr_listener( tbl, tbl );
5486
5487     for (GSList const *items = selection->itemList();
5488          items != NULL;
5489          items = items->next)
5490     {
5491         if (SP_IS_ARC((SPItem *) items->data)) {
5492             n_selected++;
5493             repr = SP_OBJECT_REPR((SPItem *) items->data);
5494         }
5495     }
5496
5497     EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) );
5498
5499     g_object_set_data( tbl, "single", GINT_TO_POINTER(FALSE) );
5500     if (n_selected == 0) {
5501         g_object_set( G_OBJECT(act), "label", _("<b>New:</b>"), NULL );
5502     } else if (n_selected == 1) {
5503         g_object_set_data( tbl, "single", GINT_TO_POINTER(TRUE) );
5504         g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
5505
5506         if (repr) {
5507             g_object_set_data( tbl, "repr", repr );
5508             Inkscape::GC::anchor(repr);
5509             sp_repr_add_listener(repr, &arc_tb_repr_events, tbl);
5510             sp_repr_synthesize_events(repr, &arc_tb_repr_events, tbl);
5511         }
5512     } else {
5513         // FIXME: implement averaging of all parameters for multiple selected
5514         //gtk_label_set_markup(GTK_LABEL(l), _("<b>Average:</b>"));
5515         g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
5516         sp_arctb_sensitivize( tbl, 1, 0 );
5517     }
5518 }
5519
5520
5521 static void sp_arc_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
5522 {
5523     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5524
5525     EgeAdjustmentAction* eact = 0;
5526     Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
5527
5528
5529     {
5530         EgeOutputAction* act = ege_output_action_new( "ArcStateAction", _("<b>New:</b>"), "", 0 );
5531         ege_output_action_set_use_markup( act, TRUE );
5532         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
5533         g_object_set_data( holder, "mode_action", act );
5534     }
5535
5536     /* Start */
5537     {
5538         eact = create_adjustment_action( "ArcStartAction",
5539                                          _("Start"), _("Start:"),
5540                                          _("The angle (in degrees) from the horizontal to the arc's start point"),
5541                                          "/tools/shapes/arc/start", 0.0,
5542                                          GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, TRUE, "altx-arc",
5543                                          -360.0, 360.0, 1.0, 10.0,
5544                                          0, 0, 0,
5545                                          sp_arctb_start_value_changed);
5546         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
5547     }
5548
5549     /* End */
5550     {
5551         eact = create_adjustment_action( "ArcEndAction",
5552                                          _("End"), _("End:"),
5553                                          _("The angle (in degrees) from the horizontal to the arc's end point"),
5554                                          "/tools/shapes/arc/end", 0.0,
5555                                          GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL,
5556                                          -360.0, 360.0, 1.0, 10.0,
5557                                          0, 0, 0,
5558                                          sp_arctb_end_value_changed);
5559         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
5560     }
5561
5562     /* Segments / Pie checkbox */
5563     {
5564         GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
5565
5566         GtkTreeIter iter;
5567         gtk_list_store_append( model, &iter );
5568         gtk_list_store_set( model, &iter,
5569                             0, _("Closed arc"),
5570                             1, _("Switch to segment (closed shape with two radii)"),
5571                             2, INKSCAPE_ICON_DRAW_ELLIPSE_SEGMENT,
5572                             -1 );
5573
5574         gtk_list_store_append( model, &iter );
5575         gtk_list_store_set( model, &iter,
5576                             0, _("Open Arc"),
5577                             1, _("Switch to arc (unclosed shape)"),
5578                             2, INKSCAPE_ICON_DRAW_ELLIPSE_ARC,
5579                             -1 );
5580
5581         EgeSelectOneAction* act = ege_select_one_action_new( "ArcOpenAction", (""), (""), NULL, GTK_TREE_MODEL(model) );
5582         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
5583         g_object_set_data( holder, "open_action", act );
5584
5585         ege_select_one_action_set_appearance( act, "full" );
5586         ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
5587         g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
5588         ege_select_one_action_set_icon_column( act, 2 );
5589         ege_select_one_action_set_icon_size( act, secondarySize );
5590         ege_select_one_action_set_tooltip_column( act, 1  );
5591
5592         bool isClosed = !prefs->getBool("/tools/shapes/arc/open", false);
5593         ege_select_one_action_set_active( act, isClosed ? 0 : 1 );
5594         g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_arctb_open_state_changed), holder );
5595     }
5596
5597     /* Make Whole */
5598     {
5599         InkAction* inky = ink_action_new( "ArcResetAction",
5600                                           _("Make whole"),
5601                                           _("Make the shape a whole ellipse, not arc or segment"),
5602                                           INKSCAPE_ICON_DRAW_ELLIPSE_WHOLE,
5603                                           secondarySize );
5604         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_arctb_defaults), holder );
5605         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
5606         gtk_action_set_sensitive( GTK_ACTION(inky), TRUE );
5607         g_object_set_data( holder, "make_whole", inky );
5608     }
5609
5610     g_object_set_data( G_OBJECT(holder), "single", GINT_TO_POINTER(TRUE) );
5611     // sensitivize make whole and open checkbox
5612     {
5613         GtkAdjustment *adj1 = GTK_ADJUSTMENT( g_object_get_data( holder, "start" ) );
5614         GtkAdjustment *adj2 = GTK_ADJUSTMENT( g_object_get_data( holder, "end" ) );
5615         sp_arctb_sensitivize( holder, adj1->value, adj2->value );
5616     }
5617
5618
5619     sigc::connection *connection = new sigc::connection(
5620         sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_arc_toolbox_selection_changed), (GObject *)holder))
5621         );
5622     g_signal_connect( holder, "destroy", G_CALLBACK(delete_connection), connection );
5623     g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );
5624 }
5625
5626
5627
5628
5629 // toggle button callbacks and updaters
5630
5631 //########################
5632 //##      Dropper       ##
5633 //########################
5634
5635 static void toggle_dropper_pick_alpha( GtkToggleAction* act, gpointer tbl )
5636 {
5637     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5638     prefs->setInt( "/tools/dropper/pick", gtk_toggle_action_get_active( act ) );
5639     GtkAction* set_action = GTK_ACTION( g_object_get_data(G_OBJECT(tbl), "set_action") );
5640     if ( set_action ) {
5641         if ( gtk_toggle_action_get_active( act ) ) {
5642             gtk_action_set_sensitive( set_action, TRUE );
5643         } else {
5644             gtk_action_set_sensitive( set_action, FALSE );
5645         }
5646     }
5647
5648     spinbutton_defocus(GTK_OBJECT(tbl));
5649 }
5650
5651 static void toggle_dropper_set_alpha( GtkToggleAction* act, gpointer tbl )
5652 {
5653     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5654     prefs->setBool( "/tools/dropper/setalpha", gtk_toggle_action_get_active( act ) );
5655     spinbutton_defocus(GTK_OBJECT(tbl));
5656 }
5657
5658
5659 /**
5660  * Dropper auxiliary toolbar construction and setup.
5661  *
5662  * TODO: Would like to add swatch of current color.
5663  * TODO: Add queue of last 5 or so colors selected with new swatches so that
5664  *       can drag and drop places. Will provide a nice mixing palette.
5665  */
5666 static void sp_dropper_toolbox_prep(SPDesktop * /*desktop*/, GtkActionGroup* mainActions, GObject* holder)
5667 {
5668     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5669     gint pickAlpha = prefs->getInt( "/tools/dropper/pick", 1 );
5670
5671     {
5672         EgeOutputAction* act = ege_output_action_new( "DropperOpacityAction", _("Opacity:"), "", 0 );
5673         ege_output_action_set_use_markup( act, TRUE );
5674         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
5675     }
5676
5677     {
5678         InkToggleAction* act = ink_toggle_action_new( "DropperPickAlphaAction",
5679                                                       _("Pick opacity"),
5680                                                       _("Pick both the color and the alpha (transparency) under cursor; otherwise, pick only the visible color premultiplied by alpha"),
5681                                                       NULL,
5682                                                       Inkscape::ICON_SIZE_DECORATION );
5683         g_object_set( act, "short_label", _("Pick"), NULL );
5684         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
5685         g_object_set_data( holder, "pick_action", act );
5686         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), pickAlpha );
5687         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_dropper_pick_alpha), holder );
5688     }
5689
5690     {
5691         InkToggleAction* act = ink_toggle_action_new( "DropperSetAlphaAction",
5692                                                       _("Assign opacity"),
5693                                                       _("If alpha was picked, assign it to selection as fill or stroke transparency"),
5694                                                       NULL,
5695                                                       Inkscape::ICON_SIZE_DECORATION );
5696         g_object_set( act, "short_label", _("Assign"), NULL );
5697         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
5698         g_object_set_data( holder, "set_action", act );
5699         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool( "/tools/dropper/setalpha", true) );
5700         // make sure it's disabled if we're not picking alpha
5701         gtk_action_set_sensitive( GTK_ACTION(act), pickAlpha );
5702         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_dropper_set_alpha), holder );
5703     }
5704 }
5705
5706
5707 //########################
5708 //##      LPETool       ##
5709 //########################
5710
5711 // the subtools from which the toolbar is built automatically are listed in lpe-tool-context.h
5712
5713 // this is called when the mode is changed via the toolbar (i.e., one of the subtool buttons is pressed)
5714 static void sp_lpetool_mode_changed(EgeSelectOneAction *act, GObject *tbl)
5715 {
5716     using namespace Inkscape::LivePathEffect;
5717
5718     SPDesktop *desktop = (SPDesktop *) g_object_get_data(tbl, "desktop");
5719     SPEventContext *ec = desktop->event_context;
5720     if (!SP_IS_LPETOOL_CONTEXT(ec)) {
5721         return;
5722     }
5723
5724     // only take action if run by the attr_changed listener
5725     if (!g_object_get_data(tbl, "freeze")) {
5726         // in turn, prevent listener from responding
5727         g_object_set_data(tbl, "freeze", GINT_TO_POINTER(TRUE));
5728
5729         gint mode = ege_select_one_action_get_active(act);
5730         EffectType type = lpesubtools[mode].type;
5731
5732         SPLPEToolContext *lc = SP_LPETOOL_CONTEXT(desktop->event_context);
5733         bool success = lpetool_try_construction(lc, type);
5734         if (success) {
5735             // since the construction was already performed, we set the state back to inactive
5736             ege_select_one_action_set_active(act, 0);
5737             mode = 0;
5738         } else {
5739             // switch to the chosen subtool
5740             SP_LPETOOL_CONTEXT(desktop->event_context)->mode = type;
5741         }
5742
5743         if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
5744             Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5745             prefs->setInt( "/tools/lpetool/mode", mode );
5746         }
5747
5748         g_object_set_data(tbl, "freeze", GINT_TO_POINTER(FALSE));
5749     }
5750 }
5751
5752 static void sp_lpetool_toolbox_sel_modified(Inkscape::Selection *selection, guint /*flags*/, GObject * /*tbl*/)
5753 {
5754     SPEventContext *ec = selection->desktop()->event_context;
5755     if (SP_IS_LPETOOL_CONTEXT(ec)) {
5756         lpetool_update_measuring_items(SP_LPETOOL_CONTEXT(ec));
5757     }
5758 }
5759
5760 static void sp_lpetool_toolbox_sel_changed(Inkscape::Selection *selection, GObject *tbl)
5761 {
5762     using namespace Inkscape::LivePathEffect;
5763     SPEventContext *ec = selection->desktop()->event_context;
5764     if (!SP_IS_LPETOOL_CONTEXT(ec)) {
5765         return;
5766     }
5767     SPLPEToolContext *lc = SP_LPETOOL_CONTEXT(ec);
5768
5769     lpetool_delete_measuring_items(lc);
5770     lpetool_create_measuring_items(lc, selection);
5771
5772     // activate line segment combo box if a single item with LPELineSegment is selected
5773     GtkAction* w = GTK_ACTION(g_object_get_data(tbl, "lpetool_line_segment_action"));
5774     SPItem *item = selection->singleItem();
5775     if (item && SP_IS_LPE_ITEM(item) && lpetool_item_has_construction(lc, item)) {
5776         SPLPEItem *lpeitem = SP_LPE_ITEM(item);
5777         Effect* lpe = sp_lpe_item_get_current_lpe(lpeitem);
5778         if (lpe && lpe->effectType() == LINE_SEGMENT) {
5779             LPELineSegment *lpels = static_cast<LPELineSegment*>(lpe);
5780             g_object_set_data(tbl, "currentlpe", lpe);
5781             g_object_set_data(tbl, "currentlpeitem", lpeitem);
5782             gtk_action_set_sensitive(w, TRUE);
5783             ege_select_one_action_set_active(EGE_SELECT_ONE_ACTION(w), lpels->end_type.get_value());
5784         } else {
5785             g_object_set_data(tbl, "currentlpe", NULL);
5786             g_object_set_data(tbl, "currentlpeitem", NULL);
5787             gtk_action_set_sensitive(w, FALSE);
5788         }
5789     } else {
5790         g_object_set_data(tbl, "currentlpe", NULL);
5791         g_object_set_data(tbl, "currentlpeitem", NULL);
5792         gtk_action_set_sensitive(w, FALSE);
5793     }
5794 }
5795
5796 static void lpetool_toggle_show_bbox(GtkToggleAction *act, gpointer data) {
5797     SPDesktop *desktop = static_cast<SPDesktop *>(data);
5798     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5799
5800     bool show = gtk_toggle_action_get_active( act );
5801     prefs->setBool("/tools/lpetool/show_bbox",  show);
5802
5803     if (tools_isactive(desktop, TOOLS_LPETOOL)) {
5804         SPLPEToolContext *lc = SP_LPETOOL_CONTEXT(desktop->event_context);
5805         lpetool_context_reset_limiting_bbox(lc);
5806     }
5807 }
5808
5809 static void lpetool_toggle_show_measuring_info(GtkToggleAction *act, GObject *tbl)
5810 {
5811     SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(tbl, "desktop"));
5812     if (!tools_isactive(desktop, TOOLS_LPETOOL)) {
5813         return;
5814     }
5815
5816     GtkAction *unitact = static_cast<GtkAction*>(g_object_get_data(tbl, "lpetool_units_action"));
5817     SPLPEToolContext *lc = SP_LPETOOL_CONTEXT(desktop->event_context);
5818     if (tools_isactive(desktop, TOOLS_LPETOOL)) {
5819         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5820         bool show = gtk_toggle_action_get_active( act );
5821         prefs->setBool("/tools/lpetool/show_measuring_info",  show);
5822         lpetool_show_measuring_info(lc, show);
5823         gtk_action_set_sensitive(GTK_ACTION(unitact), show);
5824     }
5825 }
5826
5827 static void lpetool_unit_changed(GtkAction* /*act*/, GObject* tbl)
5828 {
5829     UnitTracker* tracker = reinterpret_cast<UnitTracker*>(g_object_get_data(tbl, "tracker"));
5830     SPUnit const *unit = tracker->getActiveUnit();
5831     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5832     prefs->setInt("/tools/lpetool/unitid", unit->unit_id);
5833
5834     SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
5835     if (SP_IS_LPETOOL_CONTEXT(desktop->event_context)) {
5836         SPLPEToolContext *lc = SP_LPETOOL_CONTEXT(desktop->event_context);
5837         lpetool_delete_measuring_items(lc);
5838         lpetool_create_measuring_items(lc);
5839     }
5840 }
5841
5842 static void lpetool_toggle_set_bbox(GtkToggleAction *act, gpointer data)
5843 {
5844     SPDesktop *desktop = static_cast<SPDesktop *>(data);
5845     Inkscape::Selection *selection = desktop->selection;
5846
5847     Geom::OptRect bbox = selection->bounds();
5848
5849     if (bbox) {
5850         Geom::Point A(bbox->min());
5851         Geom::Point B(bbox->max());
5852
5853         A *= desktop->doc2dt();
5854         B *= desktop->doc2dt();
5855
5856         // TODO: should we provide a way to store points in prefs?
5857         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5858         prefs->setDouble("/tools/lpetool/bbox_upperleftx", A[Geom::X]);
5859         prefs->setDouble("/tools/lpetool/bbox_upperlefty", A[Geom::Y]);
5860         prefs->setDouble("/tools/lpetool/bbox_lowerrightx", B[Geom::X]);
5861         prefs->setDouble("/tools/lpetool/bbox_lowerrighty", B[Geom::Y]);
5862
5863         lpetool_context_reset_limiting_bbox(SP_LPETOOL_CONTEXT(desktop->event_context));
5864     }
5865
5866     gtk_toggle_action_set_active(act, false);
5867 }
5868
5869 static void sp_line_segment_build_list(GObject *tbl)
5870 {
5871     g_object_set_data(tbl, "line_segment_list_blocked", GINT_TO_POINTER(TRUE));
5872
5873     EgeSelectOneAction* selector = static_cast<EgeSelectOneAction *>(g_object_get_data(tbl, "lpetool_line_segment_action"));
5874     GtkListStore* model = GTK_LIST_STORE(ege_select_one_action_get_model(selector));
5875     gtk_list_store_clear (model);
5876
5877     // TODO: we add the entries of rht combo box manually; later this should be done automatically
5878     {
5879         GtkTreeIter iter;
5880         gtk_list_store_append( model, &iter );
5881         gtk_list_store_set( model, &iter, 0, _("Closed"), 1, 0, -1 );
5882         gtk_list_store_append( model, &iter );
5883         gtk_list_store_set( model, &iter, 0, _("Open start"), 1, 1, -1 );
5884         gtk_list_store_append( model, &iter );
5885         gtk_list_store_set( model, &iter, 0, _("Open end"), 1, 2, -1 );
5886         gtk_list_store_append( model, &iter );
5887         gtk_list_store_set( model, &iter, 0, _("Open both"), 1, 3, -1 );
5888     }
5889
5890     g_object_set_data(tbl, "line_segment_list_blocked", GINT_TO_POINTER(FALSE));
5891 }
5892
5893 static void sp_lpetool_change_line_segment_type(EgeSelectOneAction* act, GObject* tbl)
5894 {
5895     using namespace Inkscape::LivePathEffect;
5896
5897     // quit if run by the attr_changed listener
5898     if (g_object_get_data(tbl, "freeze")) {
5899         return;
5900     }
5901
5902     // in turn, prevent listener from responding
5903     g_object_set_data(tbl, "freeze", GINT_TO_POINTER(TRUE));
5904
5905     LPELineSegment *lpe = static_cast<LPELineSegment *>(g_object_get_data(tbl, "currentlpe"));
5906     SPLPEItem *lpeitem = static_cast<SPLPEItem *>(g_object_get_data(tbl, "currentlpeitem"));
5907     if (lpeitem) {
5908         SPLPEItem *lpeitem = static_cast<SPLPEItem *>(g_object_get_data(tbl, "currentlpeitem"));
5909         lpe->end_type.param_set_value(static_cast<Inkscape::LivePathEffect::EndType>(ege_select_one_action_get_active(act)));
5910         sp_lpe_item_update_patheffect(lpeitem, true, true);
5911     }
5912
5913     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
5914 }
5915
5916 static void lpetool_open_lpe_dialog(GtkToggleAction *act, gpointer data)
5917 {
5918     SPDesktop *desktop = static_cast<SPDesktop *>(data);
5919
5920     if (tools_isactive(desktop, TOOLS_LPETOOL)) {
5921         sp_action_perform(Inkscape::Verb::get(SP_VERB_DIALOG_LIVE_PATH_EFFECT)->get_action(desktop), NULL);
5922     }
5923     gtk_toggle_action_set_active(act, false);
5924 }
5925
5926 static void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
5927 {
5928     UnitTracker* tracker = new UnitTracker(SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE);
5929     tracker->setActiveUnit(sp_desktop_namedview(desktop)->doc_units);
5930     g_object_set_data(holder, "tracker", tracker);
5931     SPUnit const *unit = tracker->getActiveUnit();
5932
5933     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5934     prefs->setInt("/tools/lpetool/unitid", unit->unit_id);
5935
5936     /** Automatically create a list of LPEs that get added to the toolbar **/
5937     {
5938         GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
5939
5940         GtkTreeIter iter;
5941
5942         // the first toggle button represents the state that no subtool is active (remove this when
5943         // this can be modeled by EgeSelectOneAction or some other action)
5944         gtk_list_store_append( model, &iter );
5945         gtk_list_store_set( model, &iter,
5946                             0, _("All inactive"),
5947                             1, _("No geometric tool is active"),
5948                             2, "draw-geometry-inactive",
5949                             -1 );
5950
5951         Inkscape::LivePathEffect::EffectType type;
5952         for (int i = 1; i < num_subtools; ++i) { // we start with i = 1 because INVALID_LPE was already added
5953             type =  lpesubtools[i].type;
5954             gtk_list_store_append( model, &iter );
5955             gtk_list_store_set( model, &iter,
5956                                 0, Inkscape::LivePathEffect::LPETypeConverter.get_label(type).c_str(),
5957                                 1, Inkscape::LivePathEffect::LPETypeConverter.get_label(type).c_str(),
5958                                 2, lpesubtools[i].icon_name,
5959                                 -1 );
5960         }
5961
5962         EgeSelectOneAction* act = ege_select_one_action_new( "LPEToolModeAction", (""), (""), NULL, GTK_TREE_MODEL(model) );
5963         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
5964         g_object_set_data( holder, "lpetool_mode_action", act );
5965
5966         ege_select_one_action_set_appearance( act, "full" );
5967         ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
5968         g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
5969         ege_select_one_action_set_icon_column( act, 2 );
5970         ege_select_one_action_set_tooltip_column( act, 1  );
5971
5972         gint lpeToolMode = prefs->getInt("/tools/lpetool/mode", 0);
5973         ege_select_one_action_set_active( act, lpeToolMode );
5974         g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_lpetool_mode_changed), holder );
5975     }
5976
5977     /* Show limiting bounding box */
5978     {
5979         InkToggleAction* act = ink_toggle_action_new( "LPEShowBBoxAction",
5980                                                       _("Show limiting bounding box"),
5981                                                       _("Show bounding box (used to cut infinite lines)"),
5982                                                       "show-bounding-box",
5983                                                       Inkscape::ICON_SIZE_DECORATION );
5984         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
5985         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(lpetool_toggle_show_bbox), desktop );
5986         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool( "/tools/lpetool/show_bbox", true ) );
5987     }
5988
5989     /* Set limiting bounding box to bbox of current selection */
5990     {
5991         InkToggleAction* act = ink_toggle_action_new( "LPEBBoxFromSelectionAction",
5992                                                       _("Get limiting bounding box from selection"),
5993                                                       _("Set limiting bounding box (used to cut infinite lines) to the bounding box of current selection"),
5994                                                       "draw-geometry-set-bounding-box",
5995                                                       Inkscape::ICON_SIZE_DECORATION );
5996         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
5997         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(lpetool_toggle_set_bbox), desktop );
5998         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), FALSE );
5999     }
6000
6001
6002     /* Combo box to choose line segment type */
6003     {
6004         GtkListStore* model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
6005         EgeSelectOneAction* act = ege_select_one_action_new ("LPELineSegmentAction", "" , (_("Choose a line segment type")), NULL, GTK_TREE_MODEL(model));
6006         ege_select_one_action_set_appearance (act, "compact");
6007         g_object_set_data (holder, "lpetool_line_segment_action", act );
6008
6009         g_object_set_data(holder, "line_segment_list_blocked", GINT_TO_POINTER(FALSE));
6010
6011         sp_line_segment_build_list (holder);
6012
6013         g_signal_connect(G_OBJECT(act), "changed", G_CALLBACK(sp_lpetool_change_line_segment_type), holder);
6014         gtk_action_set_sensitive( GTK_ACTION(act), FALSE );
6015         gtk_action_group_add_action(mainActions, GTK_ACTION(act));
6016     }
6017
6018     /* Display measuring info for selected items */
6019     {
6020         InkToggleAction* act = ink_toggle_action_new( "LPEMeasuringAction",
6021                                                       _("Display measuring info"),
6022                                                       _("Display measuring info for selected items"),
6023                                                       "draw-geometry-show-measuring-info",
6024                                                       Inkscape::ICON_SIZE_DECORATION );
6025         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
6026         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(lpetool_toggle_show_measuring_info), holder );
6027         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool( "/tools/lpetool/show_measuring_info", true ) );
6028     }
6029
6030     // add the units menu
6031     {
6032         GtkAction* act = tracker->createAction( "LPEToolUnitsAction", _("Units"), ("") );
6033         gtk_action_group_add_action( mainActions, act );
6034         g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(lpetool_unit_changed), (GObject*)holder );
6035         g_object_set_data(holder, "lpetool_units_action", act);
6036         gtk_action_set_sensitive(act, prefs->getBool("/tools/lpetool/show_measuring_info", true));
6037     }
6038
6039     /* Open LPE dialog (to adapt parameters numerically) */
6040     {
6041         InkToggleAction* act = ink_toggle_action_new( "LPEOpenLPEDialogAction",
6042                                                       _("Open LPE dialog"),
6043                                                       _("Open LPE dialog (to adapt parameters numerically)"),
6044                                                       "dialog-geometry",
6045                                                       Inkscape::ICON_SIZE_DECORATION );
6046         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
6047         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(lpetool_open_lpe_dialog), desktop );
6048         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), FALSE );
6049     }
6050
6051     //watch selection
6052     Inkscape::ConnectionPool* pool = Inkscape::ConnectionPool::new_connection_pool ("ISNodeToolbox");
6053
6054     sigc::connection *c_selection_modified =
6055         new sigc::connection (sp_desktop_selection (desktop)->connectModified
6056                               (sigc::bind (sigc::ptr_fun (sp_lpetool_toolbox_sel_modified), (GObject*)holder)));
6057     pool->add_connection ("selection-modified", c_selection_modified);
6058
6059     sigc::connection *c_selection_changed =
6060         new sigc::connection (sp_desktop_selection (desktop)->connectChanged
6061                               (sigc::bind (sigc::ptr_fun(sp_lpetool_toolbox_sel_changed), (GObject*)holder)));
6062     pool->add_connection ("selection-changed", c_selection_changed);
6063 }
6064
6065 //########################
6066 //##       Eraser       ##
6067 //########################
6068
6069 static void sp_erc_width_value_changed( GtkAdjustment *adj, GObject *tbl )
6070 {
6071     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6072     prefs->setDouble( "/tools/eraser/width", adj->value );
6073     update_presets_list(tbl);
6074 }
6075
6076 static void sp_erasertb_mode_changed( EgeSelectOneAction *act, GObject *tbl )
6077 {
6078     SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
6079     bool eraserMode = ege_select_one_action_get_active( act ) != 0;
6080     if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
6081         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6082         prefs->setBool( "/tools/eraser/mode", eraserMode );
6083     }
6084
6085     // only take action if run by the attr_changed listener
6086     if (!g_object_get_data( tbl, "freeze" )) {
6087         // in turn, prevent listener from responding
6088         g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
6089
6090         if ( eraserMode != 0 ) {
6091         } else {
6092         }
6093         // TODO finish implementation
6094
6095         g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
6096     }
6097 }
6098
6099 static void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
6100 {
6101     {
6102         /* Width */
6103         gchar const* labels[] = {_("(hairline)"), 0, 0, 0, _("(default)"), 0, 0, 0, 0, _("(broad stroke)")};
6104         gdouble values[] = {1, 3, 5, 10, 15, 20, 30, 50, 75, 100};
6105         EgeAdjustmentAction *eact = create_adjustment_action( "EraserWidthAction",
6106                                                               _("Pen Width"), _("Width:"),
6107                                                               _("The width of the eraser pen (relative to the visible canvas area)"),
6108                                                               "/tools/eraser/width", 15,
6109                                                               GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-eraser",
6110                                                               1, 100, 1.0, 10.0,
6111                                                               labels, values, G_N_ELEMENTS(labels),
6112                                                               sp_erc_width_value_changed, 1, 0);
6113         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
6114         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
6115         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
6116     }
6117
6118     {
6119         GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
6120
6121         GtkTreeIter iter;
6122         gtk_list_store_append( model, &iter );
6123         gtk_list_store_set( model, &iter,
6124                             0, _("Delete"),
6125                             1, _("Delete objects touched by the eraser"),
6126                             2, INKSCAPE_ICON_DRAW_ERASER_DELETE_OBJECTS,
6127                             -1 );
6128
6129         gtk_list_store_append( model, &iter );
6130         gtk_list_store_set( model, &iter,
6131                             0, _("Cut"),
6132                             1, _("Cut out from objects"),
6133                             2, INKSCAPE_ICON_PATH_DIFFERENCE,
6134                             -1 );
6135
6136         EgeSelectOneAction* act = ege_select_one_action_new( "EraserModeAction", (""), (""), NULL, GTK_TREE_MODEL(model) );
6137         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
6138         g_object_set_data( holder, "eraser_mode_action", act );
6139
6140         ege_select_one_action_set_appearance( act, "full" );
6141         ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
6142         g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
6143         ege_select_one_action_set_icon_column( act, 2 );
6144         ege_select_one_action_set_tooltip_column( act, 1  );
6145
6146         /// @todo Convert to boolean?
6147         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6148         gint eraserMode = prefs->getBool("/tools/eraser/mode") ? 1 : 0;
6149         ege_select_one_action_set_active( act, eraserMode );
6150         g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_erasertb_mode_changed), holder );
6151     }
6152
6153 }
6154
6155 //########################
6156 //##    Text Toolbox    ##
6157 //########################
6158
6159 // Functions for debugging:
6160 #ifdef DEBUG_TEXT
6161
6162 static void       sp_print_font( SPStyle *query ) {
6163
6164     bool family_set   = query->text->font_family.set;
6165     bool style_set    = query->font_style.set;
6166     bool fontspec_set = query->text->font_specification.set;
6167
6168     std::cout << "    Family set? " << family_set
6169               << "    Style set? "  << style_set
6170               << "    FontSpec set? " << fontspec_set
6171               << std::endl;
6172     std::cout << "    Family: "
6173               << (query->text->font_family.value ? query->text->font_family.value : "No value")
6174               << "    Style: "    <<  query->font_style.computed
6175               << "    Weight: "   <<  query->font_weight.computed
6176               << "    FontSpec: "
6177               << (query->text->font_specification.value ? query->text->font_specification.value : "No value")
6178               << std::endl;
6179 }
6180
6181 static void       sp_print_fontweight( SPStyle *query ) {
6182     const gchar* names[] = {"100", "200", "300", "400", "500", "600", "700", "800", "900",
6183                             "NORMAL", "BOLD", "LIGHTER", "BOLDER", "Out of range"};
6184     // Missing book = 380
6185     int index = query->font_weight.computed;
6186     if( index < 0 || index > 13 ) index = 13;
6187     std::cout << "    Weight: " << names[ index ]
6188               << " (" << query->font_weight.computed << ")" << std::endl;
6189
6190 }
6191
6192 static void       sp_print_fontstyle( SPStyle *query ) {
6193
6194     const gchar* names[] = {"NORMAL", "ITALIC", "OBLIQUE", "Out of range"};
6195     int index = query->font_style.computed;
6196     if( index < 0 || index > 3 ) index = 3;
6197     std::cout << "    Style:  " << names[ index ] << std::endl;
6198
6199 }
6200 #endif
6201
6202 // Format family drop-down menu.
6203 static void cell_data_func(GtkCellLayout * /*cell_layout*/,
6204                            GtkCellRenderer   *cell,
6205                            GtkTreeModel      *tree_model,
6206                            GtkTreeIter       *iter,
6207                            gpointer           /*data*/)
6208 {
6209     gchar *family;
6210     gtk_tree_model_get(tree_model, iter, 0, &family, -1);
6211     gchar *const family_escaped = g_markup_escape_text(family, -1);
6212
6213     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6214     int show_sample = prefs->getInt("/tools/text/show_sample_in_list", 1);
6215     if (show_sample) {
6216
6217         Glib::ustring sample = prefs->getString("/tools/text/font_sample");
6218         gchar *const sample_escaped = g_markup_escape_text(sample.data(), -1);
6219
6220         std::stringstream markup;
6221         markup << family_escaped << "  <span foreground='gray' font_family='"
6222                << family_escaped << "'>" << sample_escaped << "</span>";
6223         g_object_set (G_OBJECT (cell), "markup", markup.str().c_str(), NULL);
6224
6225         g_free(sample_escaped);
6226     } else {
6227         g_object_set (G_OBJECT (cell), "markup", family_escaped, NULL);
6228     }
6229     // This doesn't work for two reasons... it set both selected and not selected backgrounds
6230     // to white.. which means that white foreground text is invisible. It also only effects
6231     // the text region, leaving the padding untouched.
6232     // g_object_set (G_OBJECT (cell), "cell-background", "white", "cell-background-set", true, NULL);
6233
6234     g_free(family);
6235     g_free(family_escaped);
6236 }
6237
6238 // Font family
6239 static void sp_text_fontfamily_value_changed( Ink_ComboBoxEntry_Action *act, GObject *tbl )
6240 {
6241 #ifdef DEBUG_TEXT
6242     std::cout << std::endl;
6243     std::cout << "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM" << std::endl;
6244     std::cout << "sp_text_fontfamily_value_changed: " << std::endl;
6245 #endif
6246
6247      // quit if run by the _changed callbacks
6248     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
6249         return;
6250     }
6251     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
6252
6253     gchar *family = ink_comboboxentry_action_get_active_text( act );
6254 #ifdef DEBUG_TEXT
6255     std::cout << "  New family: " << family << std::endl;
6256 #endif
6257
6258     // First try to get the old font spec from the stored value
6259     SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT);
6260     int result_fontspec = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONT_SPECIFICATION);
6261
6262     Glib::ustring fontSpec = query->text->font_specification.set ?  query->text->font_specification.value : "";
6263
6264     // If that didn't work, try to get font spec from style
6265     if (fontSpec.empty()) {
6266
6267         // Must query all to fill font-family, font-style, font-weight, font-specification
6268         sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTFAMILY);
6269         sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTSTYLE);
6270         sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
6271
6272         // Construct a new font specification if it does not yet exist
6273         font_instance * fontFromStyle = font_factory::Default()->FaceFromStyle(query);
6274         if( fontFromStyle ) {
6275             fontSpec = font_factory::Default()->ConstructFontSpecification(fontFromStyle);
6276             fontFromStyle->Unref();
6277         }
6278 #ifdef DEBUG_TEXT
6279         std::cout << "  Fontspec not defined, reconstructed from style :" << fontSpec << ":" << std::endl;
6280         sp_print_font( query );
6281 #endif
6282     }
6283
6284     // And if that didn't work use default
6285     if( fontSpec.empty() ) {
6286         sp_style_read_from_prefs(query, "/tools/text");
6287 #ifdef DEBUG_TEXT
6288         std::cout << "    read style from prefs:" << std::endl;
6289         sp_print_font( query );
6290 #endif
6291         // Construct a new font specification if it does not yet exist
6292         font_instance * fontFromStyle = font_factory::Default()->FaceFromStyle(query);
6293         if( fontFromStyle ) {
6294             fontSpec = font_factory::Default()->ConstructFontSpecification(fontFromStyle);
6295             fontFromStyle->Unref();
6296         }
6297 #ifdef DEBUG_TEXT
6298         std::cout << "  Fontspec not defined, reconstructed from style :" << fontSpec << ":" << std::endl;
6299         sp_print_font( query );
6300 #endif
6301     }
6302
6303     SPCSSAttr *css = sp_repr_css_attr_new ();
6304     if (!fontSpec.empty()) {
6305
6306         // Now we have a font specification, replace family.
6307         Glib::ustring  newFontSpec = font_factory::Default()->ReplaceFontSpecificationFamily(fontSpec, family);
6308
6309 #ifdef DEBUG_TEXT
6310         std::cout << "  New FontSpec from ReplaceFontSpecificationFamily :" << newFontSpec << ":" << std::endl;
6311 #endif
6312
6313         if (!newFontSpec.empty()) {
6314
6315             if (fontSpec != newFontSpec) {
6316
6317                 font_instance *font = font_factory::Default()->FaceFromFontSpecification(newFontSpec.c_str());
6318
6319                 if (font) {
6320                     sp_repr_css_set_property (css, "-inkscape-font-specification", newFontSpec.c_str());
6321
6322                     // Set all the these just in case they were altered when finding the best
6323                     // match for the new family and old style...
6324
6325                     gchar c[256];
6326
6327                     font->Family(c, 256);
6328
6329                     sp_repr_css_set_property (css, "font-family", c);
6330
6331                     font->Attribute( "weight", c, 256);
6332                     sp_repr_css_set_property (css, "font-weight", c);
6333
6334                     font->Attribute("style", c, 256);
6335                     sp_repr_css_set_property (css, "font-style", c);
6336
6337                     font->Attribute("stretch", c, 256);
6338                     sp_repr_css_set_property (css, "font-stretch", c);
6339
6340                     font->Attribute("variant", c, 256);
6341                     sp_repr_css_set_property (css, "font-variant", c);
6342
6343                     font->Unref();
6344                 }
6345             }
6346
6347         } else {
6348
6349             // newFontSpec empty
6350             // If the old font on selection (or default) does not exist on the system,
6351             // or the new font family does not exist,
6352             // ReplaceFontSpecificationFamily does not work. In that case we fall back to blindly
6353             // setting the family reported by the family chooser.
6354
6355             // g_print ("fallback setting family: %s\n", family);
6356             sp_repr_css_set_property (css, "-inkscape-font-specification", family);
6357             sp_repr_css_set_property (css, "font-family", family);
6358             // Shoud we set other css font attributes?
6359         }
6360
6361     }  // fontSpec not empty or not
6362
6363     // If querying returned nothing, update default style.
6364     if (result_fontspec == QUERY_STYLE_NOTHING)
6365     {
6366         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6367         prefs->mergeStyle("/tools/text/style", css);
6368         sp_text_edit_dialog_default_set_insensitive (); //FIXME: Replace through a verb
6369     }
6370     else
6371     {
6372         sp_desktop_set_style (SP_ACTIVE_DESKTOP, css, true, true);
6373     }
6374
6375     sp_style_unref(query);
6376
6377     g_free (family);
6378
6379     // Save for undo
6380     sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT,
6381                                    _("Text: Change font family"));
6382     sp_repr_css_attr_unref (css);
6383
6384     // unfreeze
6385     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
6386
6387     // focus to canvas
6388     gtk_widget_grab_focus (GTK_WIDGET((SP_ACTIVE_DESKTOP)->canvas));
6389
6390 #ifdef DEBUG_TEXT
6391     std::cout << "sp_text_toolbox_fontfamily_changes: exit"  << std::endl;
6392     std::cout << "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM" << std::endl;
6393     std::cout << std::endl;
6394 #endif
6395 }
6396
6397 // Font size
6398 static void sp_text_fontsize_value_changed( Ink_ComboBoxEntry_Action *act, GObject *tbl )
6399 {
6400      // quit if run by the _changed callbacks
6401     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
6402         return;
6403     }
6404     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
6405
6406     gchar *text = ink_comboboxentry_action_get_active_text( act );
6407     gchar *endptr;
6408     gdouble size = g_strtod( text, &endptr );
6409     if (endptr == text) {  // Conversion failed, non-numeric input.
6410         g_warning( "Conversion of size text to double failed, input: %s\n", text );
6411         g_free( text );
6412         return;
6413     }
6414     g_free( text );
6415
6416     // Set css font size.
6417     SPCSSAttr *css = sp_repr_css_attr_new ();
6418     Inkscape::CSSOStringStream osfs;
6419     osfs << size << "px"; // For now always use px
6420     sp_repr_css_set_property (css, "font-size", osfs.str().c_str());
6421
6422     // Apply font size to selected objects.
6423     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
6424     sp_desktop_set_style (desktop, css, true, true);
6425
6426     // Save for undo
6427     sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:size", SP_VERB_NONE,
6428                                    _("Text: Change font size"));
6429
6430     // If no selected objects, set default.
6431     SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT);
6432     int result_numbers =
6433         sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
6434     if (result_numbers == QUERY_STYLE_NOTHING)
6435     {
6436         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6437         prefs->mergeStyle("/tools/text/style", css);
6438     }
6439     sp_style_unref(query);
6440
6441     sp_repr_css_attr_unref (css);
6442
6443     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
6444 }
6445
6446 // Handles both Bold and Italic/Oblique
6447 static void sp_text_style_changed( InkToggleAction* act, GObject *tbl )
6448 {
6449     // quit if run by the _changed callbacks
6450     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
6451         return;
6452     }
6453     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
6454
6455     // Called by Bold or Italics button?
6456     const gchar* name = gtk_action_get_name( GTK_ACTION( act ) );
6457     gint prop = (strcmp(name, "TextBoldAction") == 0) ? 0 : 1;
6458
6459     // First query font-specification, this is the most complete font face description.
6460     SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT);
6461     int result_fontspec = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONT_SPECIFICATION);
6462
6463     // font_specification will not be set unless defined explicitely on a tspan.
6464     // This should be fixed!
6465     Glib::ustring fontSpec = query->text->font_specification.set ?  query->text->font_specification.value : "";
6466
6467     if (fontSpec.empty()) {
6468         // Construct a new font specification if it does not yet exist
6469         // Must query font-family, font-style, font-weight, to find correct font face.
6470         sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTFAMILY);
6471         sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTSTYLE);
6472         sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
6473
6474         font_instance * fontFromStyle = font_factory::Default()->FaceFromStyle(query);
6475         if( fontFromStyle ) {
6476             fontSpec = font_factory::Default()->ConstructFontSpecification(fontFromStyle);
6477             fontFromStyle->Unref();
6478         }
6479     }
6480
6481     // Now that we have the old face, find the new face.
6482     Glib::ustring newFontSpec = "";
6483     SPCSSAttr   *css        = sp_repr_css_attr_new ();
6484     gboolean nochange = true;
6485     gboolean active = gtk_toggle_action_get_active( GTK_TOGGLE_ACTION(act) );
6486
6487     switch (prop)
6488     {
6489         case 0:
6490         {
6491             // Bold
6492             if (!fontSpec.empty()) {
6493
6494                 newFontSpec = font_factory::Default()->FontSpecificationSetBold(fontSpec, active);
6495
6496                 if (!newFontSpec.empty()) {
6497
6498                     // Set weight if we found font.
6499                     font_instance * font = font_factory::Default()->FaceFromFontSpecification(newFontSpec.c_str());
6500                     if (font) {
6501                         gchar c[256];
6502                         font->Attribute( "weight", c, 256);
6503                         sp_repr_css_set_property (css, "font-weight", c);
6504                         font->Unref();
6505                         font = NULL;
6506                     }
6507                     nochange = false;
6508                 }
6509             }
6510             // Reset button if no change.
6511             // The reset code didn't work in 0.47 and doesn't here... one must prevent an infinite loop
6512             /*
6513             if(nochange) {
6514                 gtk_action_block_activate( GTK_ACTION(act) );
6515                 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), !active );
6516                 gtk_action_unblock_activate( GTK_ACTION(act) );
6517             }
6518             */
6519             break;
6520         }
6521
6522         case 1:
6523         {
6524             // Italic/Oblique
6525             if (!fontSpec.empty()) {
6526
6527                 newFontSpec = font_factory::Default()->FontSpecificationSetItalic(fontSpec, active);
6528
6529                 if (!newFontSpec.empty()) {
6530
6531                     // Don't even set the italic/oblique if the font didn't exist on the system
6532                     if( active ) {
6533                         if( newFontSpec.find( "Italic" ) != Glib::ustring::npos ) {
6534                             sp_repr_css_set_property (css, "font-style", "italic");
6535                         } else {
6536                             sp_repr_css_set_property (css, "font-style", "oblique");
6537                         }
6538                     } else {
6539                         sp_repr_css_set_property (css, "font-style", "normal");
6540                     }
6541                     nochange = false;
6542                 }
6543             }
6544             // Reset button if no change.
6545             // The reset code didn't work in 0.47... one must prevent an infinite loop
6546             /*
6547             if(nochange) {
6548                 gtk_action_block_activate( GTK_ACTION(act) );
6549                 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), !active );
6550                 gtk_action_unblock_activate( GTK_ACTION(act) );
6551             }
6552             */
6553             break;
6554         }
6555     }
6556
6557     if (!newFontSpec.empty()) {
6558         sp_repr_css_set_property (css, "-inkscape-font-specification", newFontSpec.c_str());
6559     }
6560
6561     // If querying returned nothing, update default style.
6562     if (result_fontspec == QUERY_STYLE_NOTHING)
6563     {
6564         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6565         prefs->mergeStyle("/tools/text/style", css);
6566     }
6567
6568     sp_style_unref(query);
6569
6570     // Do we need to update other CSS values?
6571     SPDesktop   *desktop    = SP_ACTIVE_DESKTOP;
6572     sp_desktop_set_style (desktop, css, true, true);
6573     sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT,
6574                                    _("Text: Change font style"));
6575     sp_repr_css_attr_unref (css);
6576
6577     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
6578 }
6579
6580 // Handles both Superscripts and Subscripts
6581 static void sp_text_script_changed( InkToggleAction* act, GObject *tbl )
6582 {
6583     // quit if run by the _changed callbacks
6584     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
6585         return;
6586     }
6587     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
6588
6589     // Called by Superscript or Subscript button?
6590     const gchar* name = gtk_action_get_name( GTK_ACTION( act ) );
6591     gint prop = (strcmp(name, "TextSuperscriptAction") == 0) ? 0 : 1;
6592
6593 #ifdef DEBUG_TEXT
6594     std::cout << "sp_text_script_changed: " << prop << std::endl;
6595 #endif
6596
6597     // Query baseline
6598     SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT);
6599     int result_baseline = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_BASELINES);
6600
6601     bool setSuper = false;
6602     bool setSub   = false;
6603
6604     if(result_baseline == QUERY_STYLE_NOTHING || result_baseline == QUERY_STYLE_MULTIPLE_DIFFERENT ) {
6605         // If not set or mixed, turn on superscript or subscript
6606         if( prop == 0 ) {
6607             setSuper = true;
6608         } else {
6609             setSub = true;
6610         }
6611     } else {
6612         // Superscript
6613         gboolean superscriptSet = (query->baseline_shift.set &&
6614                                    query->baseline_shift.type == SP_BASELINE_SHIFT_LITERAL &&
6615                                    query->baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUPER );
6616
6617         // Subscript
6618         gboolean subscriptSet = (query->baseline_shift.set &&
6619                                  query->baseline_shift.type == SP_BASELINE_SHIFT_LITERAL &&
6620                                  query->baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUB );
6621
6622         setSuper = !superscriptSet && prop == 0;
6623         setSub   = !subscriptSet   && prop == 1;
6624     }
6625
6626     // Set css properties
6627     SPCSSAttr *css = sp_repr_css_attr_new ();
6628     if( setSuper || setSub ) {
6629         // Openoffice 2.3 and Adobe use 58%, Microsoft Word 2002 uses 65%, LaTex about 70%.
6630         // 58% looks too small to me, especially if a superscript is placed on a superscript.
6631         // If you make a change here, consider making a change to baseline-shift amount
6632         // in style.cpp.
6633         sp_repr_css_set_property (css, "font-size", "65%");
6634     } else {
6635         sp_repr_css_set_property (css, "font-size", "");
6636     }
6637     if( setSuper ) {
6638         sp_repr_css_set_property (css, "baseline-shift", "super");
6639     } else if( setSub ) {
6640         sp_repr_css_set_property (css, "baseline-shift", "sub");
6641     } else {
6642         sp_repr_css_set_property (css, "baseline-shift", "baseline");
6643     }
6644
6645     // Apply css to selected objects.
6646     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
6647     sp_desktop_set_style (desktop, css, true, false);
6648
6649     // Save for undo
6650     sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:script", SP_VERB_NONE,
6651                                    _("Text: Change superscript or subscript"));
6652
6653     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
6654 }
6655
6656 static void sp_text_align_mode_changed( EgeSelectOneAction *act, GObject *tbl )
6657 {
6658     // quit if run by the _changed callbacks
6659     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
6660         return;
6661     }
6662     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
6663
6664     int mode = ege_select_one_action_get_active( act );
6665
6666     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6667     prefs->setInt("/tools/text/align_mode", mode);
6668
6669     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
6670
6671     // move the x of all texts to preserve the same bbox
6672     Inkscape::Selection *selection = sp_desktop_selection(desktop);
6673     for (GSList const *items = selection->itemList(); items != NULL; items = items->next) {
6674         if (SP_IS_TEXT((SPItem *) items->data)) {
6675             SPItem *item = SP_ITEM(items->data);
6676
6677             unsigned writing_mode = SP_OBJECT_STYLE(item)->writing_mode.value;
6678             // below, variable names suggest horizontal move, but we check the writing direction
6679             // and move in the corresponding axis
6680             int axis;
6681             if (writing_mode == SP_CSS_WRITING_MODE_LR_TB || writing_mode == SP_CSS_WRITING_MODE_RL_TB) {
6682                 axis = NR::X;
6683             } else {
6684                 axis = NR::Y;
6685             }
6686
6687             Geom::OptRect bbox
6688                   = item->getBounds(Geom::identity(), SPItem::GEOMETRIC_BBOX);
6689             if (!bbox)
6690                 continue;
6691             double width = bbox->dimensions()[axis];
6692             // If you want to align within some frame, other than the text's own bbox, calculate
6693             // the left and right (or top and bottom for tb text) slacks of the text inside that
6694             // frame (currently unused)
6695             double left_slack = 0;
6696             double right_slack = 0;
6697             unsigned old_align = SP_OBJECT_STYLE(item)->text_align.value;
6698             double move = 0;
6699             if (old_align == SP_CSS_TEXT_ALIGN_START || old_align == SP_CSS_TEXT_ALIGN_LEFT) {
6700                 switch (mode) {
6701                     case 0:
6702                         move = -left_slack;
6703                         break;
6704                     case 1:
6705                         move = width/2 + (right_slack - left_slack)/2;
6706                         break;
6707                     case 2:
6708                         move = width + right_slack;
6709                         break;
6710                 }
6711             } else if (old_align == SP_CSS_TEXT_ALIGN_CENTER) {
6712                 switch (mode) {
6713                     case 0:
6714                         move = -width/2 - left_slack;
6715                         break;
6716                     case 1:
6717                         move = (right_slack - left_slack)/2;
6718                         break;
6719                     case 2:
6720                         move = width/2 + right_slack;
6721                         break;
6722                 }
6723             } else if (old_align == SP_CSS_TEXT_ALIGN_END || old_align == SP_CSS_TEXT_ALIGN_RIGHT) {
6724                 switch (mode) {
6725                     case 0:
6726                         move = -width - left_slack;
6727                         break;
6728                     case 1:
6729                         move = -width/2 + (right_slack - left_slack)/2;
6730                         break;
6731                     case 2:
6732                         move = right_slack;
6733                         break;
6734                 }
6735             }
6736             Geom::Point XY = SP_TEXT(item)->attributes.firstXY();
6737             if (axis == NR::X) {
6738                 XY = XY + Geom::Point (move, 0);
6739             } else {
6740                 XY = XY + Geom::Point (0, move);
6741             }
6742             SP_TEXT(item)->attributes.setFirstXY(XY);
6743             SP_OBJECT(item)->updateRepr();
6744             SP_OBJECT(item)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
6745         }
6746     }
6747
6748     SPCSSAttr *css = sp_repr_css_attr_new ();
6749     switch (mode)
6750     {
6751         case 0:
6752         {
6753             sp_repr_css_set_property (css, "text-anchor", "start");
6754             sp_repr_css_set_property (css, "text-align", "start");
6755             break;
6756         }
6757         case 1:
6758         {
6759             sp_repr_css_set_property (css, "text-anchor", "middle");
6760             sp_repr_css_set_property (css, "text-align", "center");
6761             break;
6762         }
6763
6764         case 2:
6765         {
6766             sp_repr_css_set_property (css, "text-anchor", "end");
6767             sp_repr_css_set_property (css, "text-align", "end");
6768             break;
6769         }
6770
6771         case 3:
6772         {
6773             sp_repr_css_set_property (css, "text-anchor", "start");
6774             sp_repr_css_set_property (css, "text-align", "justify");
6775             break;
6776         }
6777     }
6778
6779     SPStyle *query =
6780         sp_style_new (SP_ACTIVE_DOCUMENT);
6781     int result_numbers =
6782         sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
6783
6784     // If querying returned nothing, update default style.
6785     if (result_numbers == QUERY_STYLE_NOTHING)
6786     {
6787         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6788         prefs->mergeStyle("/tools/text/style", css);
6789     }
6790
6791     sp_style_unref(query);
6792
6793     sp_desktop_set_style (desktop, css, true, true);
6794     sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT,
6795                                    _("Text: Change alignment"));
6796     sp_repr_css_attr_unref (css);
6797
6798     gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas));
6799
6800     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
6801 }
6802
6803 static void sp_text_lineheight_value_changed( GtkAdjustment *adj, GObject *tbl )
6804 {
6805     // quit if run by the _changed callbacks
6806     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
6807         return;
6808     }
6809     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
6810
6811     // At the moment this handles only numerical values (i.e. no percent).
6812     // Set css line height.
6813     SPCSSAttr *css = sp_repr_css_attr_new ();
6814     Inkscape::CSSOStringStream osfs;
6815     osfs << adj->value*100 << "%";
6816     sp_repr_css_set_property (css, "line-height", osfs.str().c_str());
6817
6818     // Apply line-height to selected objects.
6819     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
6820     sp_desktop_set_style (desktop, css, true, false);
6821
6822
6823     // Until deprecated sodipodi:linespacing purged:
6824     Inkscape::Selection *selection = sp_desktop_selection(desktop);
6825     GSList const *items = selection->itemList();
6826     for (; items != NULL; items = items->next) {
6827         if (SP_IS_TEXT (items->data)) {
6828             SP_OBJECT_REPR(items->data)->setAttribute("sodipodi:linespacing", sp_repr_css_property (css, "line-height", NULL));
6829         }
6830     }
6831
6832     // Save for undo
6833     sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:line-height", SP_VERB_NONE,
6834                                    _("Text: Change line-height"));
6835
6836     // If no selected objects, set default.
6837     SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT);
6838     int result_numbers =
6839         sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
6840     if (result_numbers == QUERY_STYLE_NOTHING)
6841     {
6842         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6843         prefs->mergeStyle("/tools/text/style", css);
6844     }
6845     sp_style_unref(query);
6846
6847     sp_repr_css_attr_unref (css);
6848
6849     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
6850 }
6851
6852 static void sp_text_wordspacing_value_changed( GtkAdjustment *adj, GObject *tbl )
6853 {
6854     // quit if run by the _changed callbacks
6855     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
6856         return;
6857     }
6858     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
6859
6860     // At the moment this handles only numerical values (i.e. no em unit).
6861     // Set css word-spacing
6862     SPCSSAttr *css = sp_repr_css_attr_new ();
6863     Inkscape::CSSOStringStream osfs;
6864     osfs << adj->value;
6865     sp_repr_css_set_property (css, "word-spacing", osfs.str().c_str());
6866
6867     // Apply word-spacing to selected objects.
6868     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
6869     sp_desktop_set_style (desktop, css, true, false);
6870
6871     // Save for undo
6872     sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:word-spacing", SP_VERB_NONE,
6873                                    _("Text: Change word-spacing"));
6874
6875     // If no selected objects, set default.
6876     SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT);
6877     int result_numbers =
6878         sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
6879     if (result_numbers == QUERY_STYLE_NOTHING)
6880     {
6881         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6882         prefs->mergeStyle("/tools/text/style", css);
6883     }
6884     sp_style_unref(query);
6885
6886     sp_repr_css_attr_unref (css);
6887
6888     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
6889 }
6890
6891 static void sp_text_letterspacing_value_changed( GtkAdjustment *adj, GObject *tbl )
6892 {
6893     // quit if run by the _changed callbacks
6894     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
6895         return;
6896     }
6897     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
6898
6899     // At the moment this handles only numerical values (i.e. no em unit).
6900     // Set css letter-spacing
6901     SPCSSAttr *css = sp_repr_css_attr_new ();
6902     Inkscape::CSSOStringStream osfs;
6903     osfs << adj->value;
6904     sp_repr_css_set_property (css, "letter-spacing", osfs.str().c_str());
6905
6906     // Apply letter-spacing to selected objects.
6907     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
6908     sp_desktop_set_style (desktop, css, true, false);
6909
6910     // Save for undo
6911     sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:letter-spacing", SP_VERB_NONE,
6912                                    _("Text: Change letter-spacing"));
6913
6914     // If no selected objects, set default.
6915     SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT);
6916     int result_numbers =
6917         sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
6918     if (result_numbers == QUERY_STYLE_NOTHING)
6919     {
6920         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6921         prefs->mergeStyle("/tools/text/style", css);
6922     }
6923     sp_style_unref(query);
6924
6925     sp_repr_css_attr_unref (css);
6926
6927     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
6928 }
6929
6930
6931 static void sp_text_dx_value_changed( GtkAdjustment *adj, GObject *tbl )
6932 {
6933     // quit if run by the _changed callbacks
6934     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
6935         return;
6936     }
6937     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
6938
6939     gdouble new_dx = adj->value;
6940
6941     if( SP_IS_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context) ) {
6942         SPTextContext *const tc = SP_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context);
6943         if( tc ) {
6944             unsigned char_index = -1;
6945             TextTagAttributes *attributes =
6946                 text_tag_attributes_at_position( tc->text, std::min(tc->text_sel_start, tc->text_sel_end), &char_index );
6947             if( attributes ) {
6948                 double old_dx = attributes->getDx( char_index );
6949                 double delta_dx = new_dx - old_dx;
6950                 sp_te_adjust_dx( tc->text, tc->text_sel_start, tc->text_sel_end, SP_ACTIVE_DESKTOP, delta_dx );
6951             }
6952         }
6953     }
6954
6955     // Save for undo
6956     sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:dx", SP_VERB_NONE,
6957                                    _("Text: Change dx (kern)"));
6958
6959     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
6960 }
6961
6962 static void sp_text_dy_value_changed( GtkAdjustment *adj, GObject *tbl )
6963 {
6964     // quit if run by the _changed callbacks
6965     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
6966         return;
6967     }
6968     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
6969
6970     gdouble new_dy = adj->value;
6971
6972     if( SP_IS_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context) ) {
6973         SPTextContext *const tc = SP_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context);
6974         if( tc ) {
6975             unsigned char_index = -1;
6976             TextTagAttributes *attributes =
6977                 text_tag_attributes_at_position( tc->text, std::min(tc->text_sel_start, tc->text_sel_end), &char_index );
6978             if( attributes ) {
6979                 double old_dy = attributes->getDy( char_index );
6980                 double delta_dy = new_dy - old_dy;
6981                 sp_te_adjust_dy( tc->text, tc->text_sel_start, tc->text_sel_end, SP_ACTIVE_DESKTOP, delta_dy );
6982             }
6983         }
6984     }
6985
6986     // Save for undo
6987     sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:dy", SP_VERB_NONE,
6988                                    _("Text: Change dy"));
6989
6990     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
6991 }
6992
6993 static void sp_text_rotation_value_changed( GtkAdjustment *adj, GObject *tbl )
6994 {
6995     // quit if run by the _changed callbacks
6996     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
6997         return;
6998     }
6999     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
7000
7001     gdouble new_degrees = adj->value;
7002
7003     if( SP_IS_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context) ) {
7004         SPTextContext *const tc = SP_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context);
7005         if( tc ) {
7006             unsigned char_index = -1;
7007             TextTagAttributes *attributes =
7008                 text_tag_attributes_at_position( tc->text, std::min(tc->text_sel_start, tc->text_sel_end), &char_index );
7009             if( attributes ) {
7010                 double old_degrees = attributes->getRotate( char_index );
7011                 double delta_deg = new_degrees - old_degrees;
7012                 sp_te_adjust_rotation( tc->text, tc->text_sel_start, tc->text_sel_end, SP_ACTIVE_DESKTOP, delta_deg );
7013             }
7014         }
7015     }
7016
7017     // Save for undo
7018     sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:rotate", SP_VERB_NONE,
7019                                    _("Text: Change rotate"));
7020
7021     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
7022 }
7023
7024 static void sp_text_orientation_mode_changed( EgeSelectOneAction *act, GObject *tbl )
7025 {
7026     // quit if run by the _changed callbacks
7027     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
7028         return;
7029     }
7030     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
7031
7032     int mode = ege_select_one_action_get_active( act );
7033
7034     SPCSSAttr   *css        = sp_repr_css_attr_new ();
7035     switch (mode)
7036     {
7037         case 0:
7038         {
7039             sp_repr_css_set_property (css, "writing-mode", "lr");
7040             break;
7041         }
7042
7043         case 1:
7044         {
7045             sp_repr_css_set_property (css, "writing-mode", "tb");
7046             break;
7047         }
7048     }
7049
7050     SPStyle *query =
7051         sp_style_new (SP_ACTIVE_DOCUMENT);
7052     int result_numbers =
7053         sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
7054
7055     // If querying returned nothing, update default style.
7056     if (result_numbers == QUERY_STYLE_NOTHING)
7057     {
7058         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
7059         prefs->mergeStyle("/tools/text/style", css);
7060     }
7061
7062     sp_desktop_set_style (SP_ACTIVE_DESKTOP, css, true, true);
7063     sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT,
7064                                    _("Text: Change orientation"));
7065     sp_repr_css_attr_unref (css);
7066
7067     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
7068 }
7069
7070 /*
7071  * This function sets up the text-tool tool-controls, setting the entry boxes
7072  * etc. to the values from the current selection or the default if no selection.
7073  * It is called whenever a text selection is changed, including stepping cursor
7074  * through text.
7075  */
7076 static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/, GObject *tbl)
7077 {
7078 #ifdef DEBUG_TEXT
7079     static int count = 0;
7080     ++count;
7081     std::cout << std::endl;
7082     std::cout << "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" << std::endl;
7083     std::cout << "sp_text_toolbox_selection_changed: start " << count << std::endl;
7084
7085     std::cout << "  Selected items:" << std::endl;
7086     for (GSList const *items = sp_desktop_selection(SP_ACTIVE_DESKTOP)->itemList();
7087          items != NULL;
7088          items = items->next)
7089     {
7090         const gchar* id = SP_OBJECT_ID((SPItem *) items->data);
7091         std::cout << "    " << id << std::endl;
7092     }
7093     Glib::ustring selected_text = sp_text_get_selected_text((SP_ACTIVE_DESKTOP)->event_context);
7094     std::cout << "  Selected text:" << std::endl;
7095     std::cout << selected_text << std::endl;
7096 #endif
7097
7098     // quit if run by the _changed callbacks
7099     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
7100 #ifdef DEBUG_TEXT
7101         std::cout << "    Frozen, returning" << std::endl;
7102         std::cout << "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" << std::endl;
7103         std::cout << std::endl;
7104 #endif
7105         return;
7106     }
7107     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
7108
7109     // Only flowed text can be justified, only normal text can be kerned...
7110     // Find out if we have flowed text now so we can use it several places
7111     gboolean isFlow = false;
7112     for (GSList const *items = sp_desktop_selection(SP_ACTIVE_DESKTOP)->itemList();
7113          items != NULL;
7114          items = items->next) {
7115         // const gchar* id = SP_OBJECT_ID((SPItem *) items->data);
7116         // std::cout << "    " << id << std::endl;
7117         if( SP_IS_FLOWTEXT(( SPItem *) items->data )) {
7118             isFlow = true;
7119             // std::cout << "   Found flowed text" << std::endl;
7120             break;
7121         }
7122     }
7123
7124     /*
7125      * Query from current selection:
7126      *   Font family (font-family)
7127      *   Style (font-weight, font-style, font-stretch, font-variant, font-align)
7128      *   Numbers (font-size, letter-spacing, word-spacing, line-height, text-anchor, writing-mode)
7129      *   Font specification (Inkscape private attribute)
7130      */
7131     SPStyle *query =
7132         sp_style_new (SP_ACTIVE_DOCUMENT);
7133     int result_family   = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTFAMILY);
7134     int result_style    = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTSTYLE);
7135     int result_numbers  = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
7136     int result_baseline = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_BASELINES);
7137
7138     // Used later:
7139     sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONT_SPECIFICATION);
7140
7141     /*
7142      * If no text in selection (querying returned nothing), read the style from
7143      * the /tools/text preferencess (default style for new texts). Return if
7144      * tool bar already set to these preferences.
7145      */
7146     if (result_family == QUERY_STYLE_NOTHING || result_style == QUERY_STYLE_NOTHING || result_numbers == QUERY_STYLE_NOTHING) {
7147         // There are no texts in selection, read from preferences.
7148         sp_style_read_from_prefs(query, "/tools/text");
7149 #ifdef DEBUG_TEXT
7150         std::cout << "    read style from prefs:" << std::endl;
7151         sp_print_font( query );
7152 #endif
7153         if (g_object_get_data(tbl, "text_style_from_prefs")) {
7154             // Do not reset the toolbar style from prefs if we already did it last time
7155             sp_style_unref(query);
7156             g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
7157 #ifdef DEBUG_TEXT
7158             std::cout << "    text_style_from_prefs: toolbar already set" << std:: endl;
7159             std::cout << "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" << std::endl;
7160             std::cout << std::endl;
7161 #endif
7162             return;
7163         }
7164
7165         g_object_set_data(tbl, "text_style_from_prefs", GINT_TO_POINTER(TRUE));
7166     } else {
7167         g_object_set_data(tbl, "text_style_from_prefs", GINT_TO_POINTER(FALSE));
7168     }
7169
7170     // If we have valid query data for text (font-family, font-specification) set toolbar accordingly.
7171     if (query->text)
7172     {
7173         // Font family
7174         if( query->text->font_family.value ) {
7175             gchar *fontFamily = query->text->font_family.value;
7176
7177             Ink_ComboBoxEntry_Action* fontFamilyAction =
7178                 INK_COMBOBOXENTRY_ACTION( g_object_get_data( tbl, "TextFontFamilyAction" ) );
7179             ink_comboboxentry_action_set_active_text( fontFamilyAction, fontFamily );
7180         }
7181
7182
7183         // Size (average of text selected)
7184         double size = query->font_size.computed;
7185         gchar size_text[G_ASCII_DTOSTR_BUF_SIZE];
7186         g_ascii_dtostr (size_text, sizeof (size_text), size);
7187
7188         Ink_ComboBoxEntry_Action* fontSizeAction =
7189             INK_COMBOBOXENTRY_ACTION( g_object_get_data( tbl, "TextFontSizeAction" ) );
7190         ink_comboboxentry_action_set_active_text( fontSizeAction, size_text );
7191
7192
7193         // Weight (Bold)
7194         // Note: in the enumeration, normal and lighter come at the end so we must explicitly test for them.
7195         gboolean boldSet = ((query->font_weight.computed >= SP_CSS_FONT_WEIGHT_700) &&
7196                             (query->font_weight.computed != SP_CSS_FONT_WEIGHT_NORMAL) &&
7197                             (query->font_weight.computed != SP_CSS_FONT_WEIGHT_LIGHTER));
7198
7199         InkToggleAction* textBoldAction = INK_TOGGLE_ACTION( g_object_get_data( tbl, "TextBoldAction" ) );
7200         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(textBoldAction), boldSet );
7201
7202
7203         // Style (Italic/Oblique)
7204         gboolean italicSet = (query->font_style.computed != SP_CSS_FONT_STYLE_NORMAL);
7205
7206         InkToggleAction* textItalicAction = INK_TOGGLE_ACTION( g_object_get_data( tbl, "TextItalicAction" ) );
7207         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(textItalicAction), italicSet );
7208
7209
7210         // Superscript
7211         gboolean superscriptSet =
7212             ((result_baseline == QUERY_STYLE_SINGLE || result_baseline == QUERY_STYLE_MULTIPLE_SAME ) &&
7213              query->baseline_shift.set &&
7214              query->baseline_shift.type == SP_BASELINE_SHIFT_LITERAL &&
7215              query->baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUPER );
7216
7217         InkToggleAction* textSuperscriptAction = INK_TOGGLE_ACTION( g_object_get_data( tbl, "TextSuperscriptAction" ) );
7218         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(textSuperscriptAction), superscriptSet );
7219
7220
7221         // Subscript
7222         gboolean subscriptSet =
7223             ((result_baseline == QUERY_STYLE_SINGLE || result_baseline == QUERY_STYLE_MULTIPLE_SAME ) &&
7224              query->baseline_shift.set &&
7225              query->baseline_shift.type == SP_BASELINE_SHIFT_LITERAL &&
7226              query->baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUB );
7227
7228         InkToggleAction* textSubscriptAction = INK_TOGGLE_ACTION( g_object_get_data( tbl, "TextSubscriptAction" ) );
7229         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(textSubscriptAction), subscriptSet );
7230
7231
7232         // Alignment
7233         EgeSelectOneAction* textAlignAction = EGE_SELECT_ONE_ACTION( g_object_get_data( tbl, "TextAlignAction" ) );
7234
7235         // Note: SVG 1.1 doesn't include text-align, SVG 1.2 Tiny doesn't include text-align="justify"
7236         // text-align="justify" was a draft SVG 1.2 item (along with flowed text).
7237         // Only flowed text can be left and right justified at the same time.
7238         // Disable button if we don't have flowed text.
7239
7240         // The GtkTreeModel class doesn't have a set function so we can't
7241         // simply add an ege_select_one_action_set_sensitive method!
7242         // We must set values directly with the GtkListStore and then
7243         // ask that the GtkAction update the sensitive parameters.
7244         GtkListStore * model = GTK_LIST_STORE( ege_select_one_action_get_model( textAlignAction ) );
7245         GtkTreePath * path = gtk_tree_path_new_from_string("3"); // Justify entry
7246         GtkTreeIter iter;
7247         gtk_tree_model_get_iter( GTK_TREE_MODEL (model), &iter, path );
7248         gtk_list_store_set( model, &iter, /* column */ 3, isFlow, -1 );
7249         ege_select_one_action_update_sensitive( textAlignAction );
7250         // ege_select_one_action_set_sensitive( textAlignAction, 3, isFlow );
7251
7252         int activeButton = 0;
7253         if (query->text_align.computed  == SP_CSS_TEXT_ALIGN_JUSTIFY)
7254         {
7255             activeButton = 3;
7256         } else {
7257             if (query->text_anchor.computed == SP_CSS_TEXT_ANCHOR_START)  activeButton = 0;
7258             if (query->text_anchor.computed == SP_CSS_TEXT_ANCHOR_MIDDLE) activeButton = 1;
7259             if (query->text_anchor.computed == SP_CSS_TEXT_ANCHOR_END)    activeButton = 2;
7260         }
7261         ege_select_one_action_set_active( textAlignAction, activeButton );
7262
7263
7264         // Line height (spacing)
7265         double height;
7266         if (query->line_height.normal) {
7267             height = Inkscape::Text::Layout::LINE_HEIGHT_NORMAL;
7268         } else {
7269             if (query->line_height.unit == SP_CSS_UNIT_PERCENT) {
7270                 height = query->line_height.value;
7271             } else {
7272                 height = query->line_height.computed;
7273             }
7274         }
7275
7276         GtkAction* lineHeightAction = GTK_ACTION( g_object_get_data( tbl, "TextLineHeightAction" ) );
7277         GtkAdjustment *lineHeightAdjustment =
7278             ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( lineHeightAction ));
7279         gtk_adjustment_set_value( lineHeightAdjustment, height );
7280
7281
7282         // Word spacing
7283         double wordSpacing;
7284         if (query->word_spacing.normal) wordSpacing = 0.0;
7285         else wordSpacing = query->word_spacing.computed; // Assume no units (change in desktop-style.cpp)
7286
7287         GtkAction* wordSpacingAction = GTK_ACTION( g_object_get_data( tbl, "TextWordSpacingAction" ) );
7288         GtkAdjustment *wordSpacingAdjustment =
7289             ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( wordSpacingAction ));
7290         gtk_adjustment_set_value( wordSpacingAdjustment, wordSpacing );
7291
7292
7293         // Letter spacing
7294         double letterSpacing;
7295         if (query->letter_spacing.normal) letterSpacing = 0.0;
7296         else letterSpacing = query->letter_spacing.computed; // Assume no units (change in desktop-style.cpp)
7297
7298         GtkAction* letterSpacingAction = GTK_ACTION( g_object_get_data( tbl, "TextLetterSpacingAction" ) );
7299         GtkAdjustment *letterSpacingAdjustment =
7300             ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( letterSpacingAction ));
7301         gtk_adjustment_set_value( letterSpacingAdjustment, letterSpacing );
7302
7303
7304         // Orientation
7305         int activeButton2 = (query->writing_mode.computed == SP_CSS_WRITING_MODE_LR_TB ? 0 : 1);
7306
7307         EgeSelectOneAction* textOrientationAction =
7308             EGE_SELECT_ONE_ACTION( g_object_get_data( tbl, "TextOrientationAction" ) );
7309         ege_select_one_action_set_active( textOrientationAction, activeButton2 );
7310
7311
7312     } // if( query->text )
7313
7314 #ifdef DEBUG_TEXT
7315     std::cout << "    GUI: fontfamily.value: "
7316               << (query->text->font_family.value ? query->text->font_family.value : "No value")
7317               << std::endl;
7318     std::cout << "    GUI: font_size.computed: "   << query->font_size.computed   << std::endl;
7319     std::cout << "    GUI: font_weight.computed: " << query->font_weight.computed << std::endl;
7320     std::cout << "    GUI: font_style.computed: "  << query->font_style.computed  << std::endl;
7321     std::cout << "    GUI: text_anchor.computed: " << query->text_anchor.computed << std::endl;
7322     std::cout << "    GUI: text_align.computed:  " << query->text_align.computed  << std::endl;
7323     std::cout << "    GUI: line_height.computed: " << query->line_height.computed
7324               << "  line_height.value: "    << query->line_height.value
7325               << "  line_height.unit: "     << query->line_height.unit  << std::endl;
7326     std::cout << "    GUI: word_spacing.computed: " << query->word_spacing.computed
7327               << "  word_spacing.value: "    << query->word_spacing.value
7328               << "  word_spacing.unit: "     << query->word_spacing.unit  << std::endl;
7329     std::cout << "    GUI: letter_spacing.computed: " << query->letter_spacing.computed
7330               << "  letter_spacing.value: "    << query->letter_spacing.value
7331               << "  letter_spacing.unit: "     << query->letter_spacing.unit  << std::endl;
7332     std::cout << "    GUI: writing_mode.computed: " << query->writing_mode.computed << std::endl;
7333 #endif
7334
7335     sp_style_unref(query);
7336
7337     // Kerning (xshift), yshift, rotation.  NB: These are not CSS attributes.
7338     if( SP_IS_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context) ) {
7339         SPTextContext *const tc = SP_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context);
7340         if( tc ) {
7341             unsigned char_index = -1;
7342             TextTagAttributes *attributes =
7343                 text_tag_attributes_at_position( tc->text, std::min(tc->text_sel_start, tc->text_sel_end), &char_index );
7344             if( attributes ) {
7345
7346                 // Dx
7347                 double dx = attributes->getDx( char_index );
7348                 GtkAction* dxAction = GTK_ACTION( g_object_get_data( tbl, "TextDxAction" ));
7349                 GtkAdjustment *dxAdjustment =
7350                     ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( dxAction ));
7351                 gtk_adjustment_set_value( dxAdjustment, dx );
7352
7353                 // Dy
7354                 double dy = attributes->getDy( char_index );
7355                 GtkAction* dyAction = GTK_ACTION( g_object_get_data( tbl, "TextDyAction" ));
7356                 GtkAdjustment *dyAdjustment =
7357                     ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( dyAction ));
7358                 gtk_adjustment_set_value( dyAdjustment, dy );
7359
7360                 // Rotation
7361                 double rotation = attributes->getRotate( char_index );
7362                 /* SVG value is between 0 and 360 but we're using -180 to 180 in widget */
7363                 if( rotation > 180.0 ) rotation -= 360.0;
7364                 GtkAction* rotationAction = GTK_ACTION( g_object_get_data( tbl, "TextRotationAction" ));
7365                 GtkAdjustment *rotationAdjustment =
7366                     ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( rotationAction ));
7367                 gtk_adjustment_set_value( rotationAdjustment, rotation );
7368
7369 #ifdef DEBUG_TEXT
7370                 std::cout << "    GUI: Dx: " << dx << std::endl;
7371                 std::cout << "    GUI: Dy: " << dy << std::endl;
7372                 std::cout << "    GUI: Rotation: " << rotation << std::endl;
7373 #endif
7374             }
7375         }
7376     }
7377
7378     {
7379         // Set these here as we don't always have kerning/rotating attributes
7380         GtkAction* dxAction = GTK_ACTION( g_object_get_data( tbl, "TextDxAction" ));
7381         gtk_action_set_sensitive( GTK_ACTION(dxAction), !isFlow );
7382
7383         GtkAction* dyAction = GTK_ACTION( g_object_get_data( tbl, "TextDyAction" ));
7384         gtk_action_set_sensitive( GTK_ACTION(dyAction), !isFlow );
7385
7386         GtkAction* rotationAction = GTK_ACTION( g_object_get_data( tbl, "TextRotationAction" ));
7387         gtk_action_set_sensitive( GTK_ACTION(rotationAction), !isFlow );
7388     }
7389
7390 #ifdef DEBUG_TEXT
7391     std::cout << "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" << std::endl;
7392     std::cout << std::endl;
7393 #endif
7394
7395     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
7396
7397 }
7398
7399 static void sp_text_toolbox_selection_modified(Inkscape::Selection *selection, guint /*flags*/, GObject *tbl)
7400 {
7401     sp_text_toolbox_selection_changed (selection, tbl);
7402 }
7403
7404 void
7405 sp_text_toolbox_subselection_changed (gpointer /*tc*/, GObject *tbl)
7406 {
7407     sp_text_toolbox_selection_changed (NULL, tbl);
7408 }
7409
7410 // Define all the "widgets" in the toolbar.
7411 static void sp_text_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
7412 {
7413     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
7414     Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
7415
7416     // Is this used?
7417     UnitTracker* tracker = new UnitTracker( SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE );
7418     tracker->setActiveUnit( sp_desktop_namedview(desktop)->doc_units );
7419     g_object_set_data( holder, "tracker", tracker );
7420
7421     /* Font family */
7422     {
7423         // Font list
7424         Glib::RefPtr<Gtk::ListStore> store = Inkscape::FontLister::get_instance()->get_font_list();
7425         GtkListStore* model = store->gobj();
7426
7427         Ink_ComboBoxEntry_Action* act = ink_comboboxentry_action_new( "TextFontFamilyAction",
7428                                                                       _("Font Family"),
7429                                                                       _("Select Font Family (Alt-X to access)"),
7430                                                                       NULL,
7431                                                                       GTK_TREE_MODEL(model),
7432                                                                       -1,                // Entry width
7433                                                                       50,                // Extra list width
7434                                                                       (gpointer)cell_data_func ); // Cell layout
7435         ink_comboboxentry_action_popup_enable( act ); // Enable entry completion
7436         gchar *const warning = _("Font not found on system");
7437         ink_comboboxentry_action_set_warning( act, warning ); // Show icon with tooltip if missing font
7438         ink_comboboxentry_action_set_altx_name( act, "altx-text" ); // Set Alt-X keyboard shortcut
7439         g_signal_connect( G_OBJECT(act), "changed", G_CALLBACK(sp_text_fontfamily_value_changed), holder );
7440         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
7441         g_object_set_data( holder, "TextFontFamilyAction", act );
7442
7443         // Change style of drop-down from menu to list
7444         gtk_rc_parse_string (
7445             "style \"dropdown-as-list-style\"\n"
7446             "{\n"
7447             "    GtkComboBox::appears-as-list = 1\n"
7448             "}\n"
7449             "widget \"*.TextFontFamilyAction_combobox\" style \"dropdown-as-list-style\"");
7450     }
7451
7452     /* Font size */
7453     {
7454         // List of font sizes for drop-down menu
7455         GtkListStore* model_size = gtk_list_store_new( 1, G_TYPE_STRING );
7456         gchar const *const sizes[] = {
7457             "4",  "6",  "8",  "9", "10", "11", "12", "13", "14", "16",
7458             "18", "20", "22", "24", "28", "32", "36", "40", "48", "56",
7459             "64", "72", "144"
7460         };
7461         for( unsigned int i = 0; i < G_N_ELEMENTS(sizes); ++i ) {
7462             GtkTreeIter iter;
7463             gtk_list_store_append( model_size, &iter );
7464             gtk_list_store_set( model_size, &iter, 0, sizes[i], -1 );
7465         }
7466
7467         Ink_ComboBoxEntry_Action* act = ink_comboboxentry_action_new( "TextFontSizeAction",
7468                                                                       _("Font Size"),
7469                                                                       _("Font size (px)"),
7470                                                                       NULL,
7471                                                                       GTK_TREE_MODEL(model_size),
7472                                                                       4 ); // Width in characters
7473         g_signal_connect( G_OBJECT(act), "changed", G_CALLBACK(sp_text_fontsize_value_changed), holder );
7474         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
7475         g_object_set_data( holder, "TextFontSizeAction", act );
7476     }
7477
7478     /* Style - Bold */
7479     {
7480         InkToggleAction* act = ink_toggle_action_new( "TextBoldAction",               // Name
7481                                                       _("Toggle Bold"),               // Label
7482                                                       _("Toggle bold or normal weight"),  // Tooltip
7483                                                       GTK_STOCK_BOLD,                 // Icon (inkId)
7484                                                       secondarySize );                // Icon size
7485         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
7486         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_text_style_changed), holder );
7487         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/text/bold", false) );
7488         g_object_set_data( holder, "TextBoldAction", act );
7489     }
7490
7491     /* Style - Italic/Oblique */
7492     {
7493         InkToggleAction* act = ink_toggle_action_new( "TextItalicAction",                     // Name
7494                                                       _("Toggle Italic/Oblique"),             // Label
7495                                                       _("Toggle italic/oblique style"),// Tooltip
7496                                                       GTK_STOCK_ITALIC,                       // Icon (inkId)
7497                                                       secondarySize );                        // Icon size
7498         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
7499         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_text_style_changed), holder );
7500         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/text/italic", false) );
7501         g_object_set_data( holder, "TextItalicAction", act );
7502     }
7503
7504     /* Style - Superscript */
7505     {
7506         InkToggleAction* act = ink_toggle_action_new( "TextSuperscriptAction",             // Name
7507                                                       _("Toggle Superscript"),             // Label
7508                                                       _("Toggle superscript"),             // Tooltip
7509                                                       "text_superscript",                  // Icon (inkId)
7510                                                       secondarySize );                     // Icon size
7511         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
7512         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_text_script_changed), holder );
7513         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/text/super", false) );
7514         g_object_set_data( holder, "TextSuperscriptAction", act );
7515     }
7516
7517     /* Style - Subscript */
7518     {
7519         InkToggleAction* act = ink_toggle_action_new( "TextSubscriptAction",             // Name
7520                                                       _("Toggle Subscript"),             // Label
7521                                                       _("Toggle subscript"),             // Tooltip
7522                                                       "text_subscript",                  // Icon (inkId)
7523                                                       secondarySize );                     // Icon size
7524         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
7525         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_text_script_changed), holder );
7526         gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/text/sub", false) );
7527         g_object_set_data( holder, "TextSubscriptAction", act );
7528     }
7529
7530     /* Alignment */
7531     {
7532         GtkListStore* model = gtk_list_store_new( 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN );
7533
7534         GtkTreeIter iter;
7535
7536         gtk_list_store_append( model, &iter );
7537         gtk_list_store_set( model, &iter,
7538                             0, _("Align left"),
7539                             1, _("Align left"),
7540                             2, GTK_STOCK_JUSTIFY_LEFT,
7541                             3, true,
7542                             -1 );
7543
7544         gtk_list_store_append( model, &iter );
7545         gtk_list_store_set( model, &iter,
7546                             0, _("Align center"),
7547                             1, _("Align center"),
7548                             2, GTK_STOCK_JUSTIFY_CENTER,
7549                             3, true,
7550                             -1 );
7551
7552         gtk_list_store_append( model, &iter );
7553         gtk_list_store_set( model, &iter,
7554                             0, _("Align right"),
7555                             1, _("Align right"),
7556                             2, GTK_STOCK_JUSTIFY_RIGHT,
7557                             3, true,
7558                             -1 );
7559
7560         gtk_list_store_append( model, &iter );
7561         gtk_list_store_set( model, &iter,
7562                             0, _("Justify"),
7563                             1, _("Justify (only flowed text)"),
7564                             2, GTK_STOCK_JUSTIFY_FILL,
7565                             3, false,
7566                             -1 );
7567
7568         EgeSelectOneAction* act = ege_select_one_action_new( "TextAlignAction",       // Name
7569                                                              _("Alignment"),          // Label
7570                                                              _("Text alignment"),     // Tooltip
7571                                                              NULL,                    // StockID
7572                                                              GTK_TREE_MODEL(model) ); // Model
7573         g_object_set( act, "short_label", "NotUsed", NULL );
7574         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
7575         g_object_set_data( holder, "TextAlignAction", act );
7576
7577         ege_select_one_action_set_appearance( act, "full" );
7578         ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
7579         g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
7580         ege_select_one_action_set_icon_column( act, 2 );
7581         ege_select_one_action_set_icon_size( act, secondarySize );
7582         ege_select_one_action_set_tooltip_column( act, 1  );
7583         ege_select_one_action_set_sensitive_column( act, 3 );
7584         gint mode = prefs->getInt("/tools/text/align_mode", 0);
7585         ege_select_one_action_set_active( act, mode );
7586         g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_text_align_mode_changed), holder );
7587     }
7588
7589     /* Orientation (Left to Right, Top to Bottom */
7590     {
7591         GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
7592
7593         GtkTreeIter iter;
7594
7595         gtk_list_store_append( model, &iter );
7596         gtk_list_store_set( model, &iter,
7597                             0, _("Horizontal"),
7598                             1, _("Horizontal text"),
7599                             2, INKSCAPE_ICON_FORMAT_TEXT_DIRECTION_HORIZONTAL,
7600                             -1 );
7601
7602         gtk_list_store_append( model, &iter );
7603         gtk_list_store_set( model, &iter,
7604                             0, _("Vertical"),
7605                             1, _("Vertical text"),
7606                             2, INKSCAPE_ICON_FORMAT_TEXT_DIRECTION_VERTICAL,
7607                             -1 );
7608
7609         EgeSelectOneAction* act = ege_select_one_action_new( "TextOrientationAction", // Name
7610                                                              _("Orientation"),        // Label
7611                                                              _("Text orientation"),   // Tooltip
7612                                                              NULL,                    // StockID
7613                                                              GTK_TREE_MODEL(model) ); // Model
7614
7615         g_object_set( act, "short_label", "NotUsed", NULL );
7616         gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
7617         g_object_set_data( holder, "TextOrientationAction", act );
7618
7619         ege_select_one_action_set_appearance( act, "full" );
7620         ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
7621         g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
7622         ege_select_one_action_set_icon_column( act, 2 );
7623         ege_select_one_action_set_icon_size( act, secondarySize );
7624         ege_select_one_action_set_tooltip_column( act, 1  );
7625
7626         gint mode = prefs->getInt("/tools/text/orientation", 0);
7627         ege_select_one_action_set_active( act, mode );
7628         g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_text_orientation_mode_changed), holder );
7629     }
7630
7631     /* Line height */
7632     {
7633         // Drop down menu
7634         gchar const* labels[] = {_("Smaller spacing"), 0, 0, 0, 0, _("Normal"), 0, 0, 0, 0, 0, _("Larger spacing")};
7635         gdouble values[] = { 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1,2, 1.3, 1.4, 1.5, 2.0};
7636
7637         EgeAdjustmentAction *eact = create_adjustment_action(
7638             "TextLineHeightAction",               /* name */
7639             _("Line Height"),                     /* label */
7640             _("Line:"),                           /* short label */
7641             _("Spacing between lines (times font size)"),      /* tooltip */
7642             "/tools/text/lineheight",             /* preferences path */
7643             0.0,                                  /* default */
7644             GTK_WIDGET(desktop->canvas),          /* focusTarget */
7645             NULL,                                 /* unit selector */
7646             holder,                               /* dataKludge */
7647             FALSE,                                /* set alt-x keyboard shortcut? */
7648             NULL,                                 /* altx_mark */
7649             0.0, 10.0, 0.01, 0.10,                /* lower, upper, step (arrow up/down), page up/down */
7650             labels, values, G_N_ELEMENTS(labels), /* drop down menu */
7651             sp_text_lineheight_value_changed,     /* callback */
7652             0.1,                                  /* step (used?) */
7653             2,                                    /* digits to show */
7654             1.0                                   /* factor (multiplies default) */
7655             );
7656         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
7657         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
7658         g_object_set_data( holder, "TextLineHeightAction", eact );
7659         g_object_set( G_OBJECT(eact), "iconId", "text_line_spacing", NULL );
7660     }
7661
7662     /* Word spacing */
7663     {
7664         // Drop down menu
7665         gchar const* labels[] = {_("Negative spacing"), 0, 0, 0, _("Normal"), 0, 0, 0, 0, 0, 0, 0, _("Positive spacing")};
7666         gdouble values[] = {-2.0, -1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0};
7667
7668         EgeAdjustmentAction *eact = create_adjustment_action(
7669             "TextWordSpacingAction",              /* name */
7670             _("Word spacing"),                    /* label */
7671             _("Word:"),                           /* short label */
7672             _("Spacing between words (px)"),     /* tooltip */
7673             "/tools/text/wordspacing",            /* preferences path */
7674             0.0,                                  /* default */
7675             GTK_WIDGET(desktop->canvas),          /* focusTarget */
7676             NULL,                                 /* unit selector */
7677             holder,                               /* dataKludge */
7678             FALSE,                                /* set alt-x keyboard shortcut? */
7679             NULL,                                 /* altx_mark */
7680             -100.0, 100.0, 0.01, 0.10,            /* lower, upper, step (arrow up/down), page up/down */
7681             labels, values, G_N_ELEMENTS(labels), /* drop down menu */
7682             sp_text_wordspacing_value_changed,    /* callback */
7683             0.1,                                  /* step (used?) */
7684             2,                                    /* digits to show */
7685             1.0                                   /* factor (multiplies default) */
7686             );
7687         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
7688         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
7689         g_object_set_data( holder, "TextWordSpacingAction", eact );
7690         g_object_set( G_OBJECT(eact), "iconId", "text_word_spacing", NULL );
7691     }
7692
7693     /* Letter spacing */
7694     {
7695         // Drop down menu
7696         gchar const* labels[] = {_("Negative spacing"), 0, 0, 0, _("Normal"), 0, 0, 0, 0, 0, 0, 0, _("Positive spacing")};
7697         gdouble values[] = {-2.0, -1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0};
7698
7699         EgeAdjustmentAction *eact = create_adjustment_action(
7700             "TextLetterSpacingAction",            /* name */
7701             _("Letter spacing"),                  /* label */
7702             _("Letter:"),                         /* short label */
7703             _("Spacing between letters (px)"),   /* tooltip */
7704             "/tools/text/letterspacing",          /* preferences path */
7705             0.0,                                  /* default */
7706             GTK_WIDGET(desktop->canvas),          /* focusTarget */
7707             NULL,                                 /* unit selector */
7708             holder,                               /* dataKludge */
7709             FALSE,                                /* set alt-x keyboard shortcut? */
7710             NULL,                                 /* altx_mark */
7711             -100.0, 100.0, 0.01, 0.10,            /* lower, upper, step (arrow up/down), page up/down */
7712             labels, values, G_N_ELEMENTS(labels), /* drop down menu */
7713             sp_text_letterspacing_value_changed,  /* callback */
7714             0.1,                                  /* step (used?) */
7715             2,                                    /* digits to show */
7716             1.0                                   /* factor (multiplies default) */
7717             );
7718         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
7719         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
7720         g_object_set_data( holder, "TextLetterSpacingAction", eact );
7721         g_object_set( G_OBJECT(eact), "iconId", "text_letter_spacing", NULL );
7722     }
7723
7724     /* Character kerning (horizontal shift) */
7725     {
7726         // Drop down menu
7727         gchar const* labels[] = {   0,   0,   0,   0,   0,   0,   0,   0,   0,   0 };
7728         gdouble values[]      = { -2.0, -1.5, -1.0, -0.5,   0,  0.5,  1.0,  1.5,  2.0, 2.5 };
7729
7730         EgeAdjustmentAction *eact = create_adjustment_action(
7731             "TextDxAction",                       /* name */
7732             _("Kerning"),                         /* label */
7733             _("Kern:"),                           /* short label */
7734             _("Horizontal kerning (px)"), /* tooltip */
7735             "/tools/text/dx",                     /* preferences path */
7736             0.0,                                  /* default */
7737             GTK_WIDGET(desktop->canvas),          /* focusTarget */
7738             NULL,                                 /* unit selector */
7739             holder,                               /* dataKludge */
7740             FALSE,                                /* set alt-x keyboard shortcut? */
7741             NULL,                                 /* altx_mark */
7742             -100.0, 100.0, 0.01, 0.1,             /* lower, upper, step (arrow up/down), page up/down */
7743             labels, values, G_N_ELEMENTS(labels), /* drop down menu */
7744             sp_text_dx_value_changed,             /* callback */
7745             0.1,                                  /* step (used?) */
7746             2,                                    /* digits to show */
7747             1.0                                   /* factor (multiplies default) */
7748             );
7749         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
7750         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
7751         g_object_set_data( holder, "TextDxAction", eact );
7752         g_object_set( G_OBJECT(eact), "iconId", "text_horz_kern", NULL );
7753     }
7754
7755     /* Character vertical shift */
7756     {
7757         // Drop down menu
7758         gchar const* labels[] = {   0,   0,   0,   0,   0,   0,   0,   0,   0,   0 };
7759         gdouble values[]      = { -2.0, -1.5, -1.0, -0.5,   0,  0.5,  1.0,  1.5,  2.0, 2.5 };
7760
7761         EgeAdjustmentAction *eact = create_adjustment_action(
7762             "TextDyAction",                       /* name */
7763             _("Vertical Shift"),                  /* label */
7764             _("Vert:"),                           /* short label */
7765             _("Vertical shift (px)"),   /* tooltip */
7766             "/tools/text/dy",                     /* preferences path */
7767             0.0,                                  /* default */
7768             GTK_WIDGET(desktop->canvas),          /* focusTarget */
7769             NULL,                                 /* unit selector */
7770             holder,                               /* dataKludge */
7771             FALSE,                                /* set alt-x keyboard shortcut? */
7772             NULL,                                 /* altx_mark */
7773             -100.0, 100.0, 0.01, 0.1,             /* lower, upper, step (arrow up/down), page up/down */
7774             labels, values, G_N_ELEMENTS(labels), /* drop down menu */
7775             sp_text_dy_value_changed,             /* callback */
7776             0.1,                                  /* step (used?) */
7777             2,                                    /* digits to show */
7778             1.0                                   /* factor (multiplies default) */
7779             );
7780         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
7781         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
7782         g_object_set_data( holder, "TextDyAction", eact );
7783         g_object_set( G_OBJECT(eact), "iconId", "text_vert_kern", NULL );
7784     }
7785
7786     /* Character rotation */
7787     {
7788         // Drop down menu
7789         gchar const* labels[] = {   0,   0,   0,   0,   0,   0,   0,   0,   0,   0 };
7790         gdouble values[]      = { -90, -45, -30, -15,   0,  15,  30,  45,  90, 180 };
7791
7792         EgeAdjustmentAction *eact = create_adjustment_action(
7793             "TextRotationAction",                 /* name */
7794             _("Letter rotation"),                 /* label */
7795             _("Rot:"),                            /* short label */
7796             _("Character rotation (degrees)"),/* tooltip */
7797             "/tools/text/rotation",               /* preferences path */
7798             0.0,                                  /* default */
7799             GTK_WIDGET(desktop->canvas),          /* focusTarget */
7800             NULL,                                 /* unit selector */
7801             holder,                               /* dataKludge */
7802             FALSE,                                /* set alt-x keyboard shortcut? */
7803             NULL,                                 /* altx_mark */
7804             -180.0, 180.0, 0.1, 1.0,              /* lower, upper, step (arrow up/down), page up/down */
7805             labels, values, G_N_ELEMENTS(labels), /* drop down menu */
7806             sp_text_rotation_value_changed,       /* callback */
7807             0.1,                                  /* step (used?) */
7808             2,                                    /* digits to show */
7809             1.0                                   /* factor (multiplies default) */
7810             );
7811         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
7812         gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
7813         g_object_set_data( holder, "TextRotationAction", eact );
7814         g_object_set( G_OBJECT(eact), "iconId", "text_rotation", NULL );
7815     }
7816
7817     // Is this necessary to call? Shouldn't hurt.
7818     sp_text_toolbox_selection_changed(sp_desktop_selection(desktop), holder);
7819
7820     // Watch selection
7821     Inkscape::ConnectionPool* pool = Inkscape::ConnectionPool::new_connection_pool ("ISTextToolboxGTK");
7822
7823     sigc::connection *c_selection_changed =
7824         new sigc::connection (sp_desktop_selection (desktop)->connectChanged
7825                               (sigc::bind (sigc::ptr_fun (sp_text_toolbox_selection_changed), (GObject*)holder)));
7826     pool->add_connection ("selection-changed", c_selection_changed);
7827
7828     sigc::connection *c_selection_modified =
7829         new sigc::connection (sp_desktop_selection (desktop)->connectModified
7830                               (sigc::bind (sigc::ptr_fun (sp_text_toolbox_selection_modified), (GObject*)holder)));
7831     pool->add_connection ("selection-modified", c_selection_modified);
7832
7833     sigc::connection *c_subselection_changed =
7834         new sigc::connection (desktop->connectToolSubselectionChanged
7835                               (sigc::bind (sigc::ptr_fun (sp_text_toolbox_subselection_changed), (GObject*)holder)));
7836     pool->add_connection ("tool-subselection-changed", c_subselection_changed);
7837
7838     Inkscape::ConnectionPool::connect_destroy (G_OBJECT (holder), pool);
7839
7840     g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );
7841
7842 }
7843
7844
7845 //#########################
7846 //##      Connector      ##
7847 //#########################
7848
7849 static void sp_connector_mode_toggled( GtkToggleAction* act, GtkObject * /*tbl*/ )
7850 {
7851     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
7852     prefs->setBool("/tools/connector/mode",
7853                 gtk_toggle_action_get_active( act ));
7854 }
7855
7856 static void sp_connector_path_set_avoid(void)
7857 {
7858     cc_selection_set_avoid(true);
7859 }
7860
7861
7862 static void sp_connector_path_set_ignore(void)
7863 {
7864     cc_selection_set_avoid(false);
7865 }
7866
7867 static void sp_connector_orthogonal_toggled( GtkToggleAction* act, GObject *tbl )
7868 {
7869     SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
7870     Inkscape::Selection * selection = sp_desktop_selection(desktop);
7871     SPDocument *doc = sp_desktop_document(desktop);
7872
7873     if (!sp_document_get_undo_sensitive(doc)) {
7874         return;
7875     }
7876
7877
7878     // quit if run by the _changed callbacks
7879     if (g_object_get_data( tbl, "freeze" )) {
7880         return;
7881     }
7882
7883     // in turn, prevent callbacks from responding
7884     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
7885
7886     bool is_orthog = gtk_toggle_action_get_active( act );
7887     gchar orthog_str[] = "orthogonal";
7888     gchar polyline_str[] = "polyline";
7889     gchar *value = is_orthog ? orthog_str : polyline_str ;
7890
7891     bool modmade = false;
7892     GSList *l = (GSList *) selection->itemList();
7893     while (l) {
7894         SPItem *item = (SPItem *) l->data;
7895
7896         if (cc_item_is_connector(item)) {
7897             sp_object_setAttribute(item, "inkscape:connector-type",
7898                     value, false);
7899             item->avoidRef->handleSettingChange();
7900             modmade = true;
7901         }
7902         l = l->next;
7903     }
7904
7905     if (!modmade) {
7906         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
7907         prefs->setBool("/tools/connector/orthogonal", is_orthog);
7908     }
7909
7910     sp_document_done(doc, SP_VERB_CONTEXT_CONNECTOR,
7911             is_orthog ? _("Set connector type: orthogonal"): _("Set connector type: polyline"));
7912
7913     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
7914 }
7915
7916 static void connector_curvature_changed(GtkAdjustment *adj, GObject* tbl)
7917 {
7918     SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
7919     Inkscape::Selection * selection = sp_desktop_selection(desktop);
7920     SPDocument *doc = sp_desktop_document(desktop);
7921
7922     if (!sp_document_get_undo_sensitive(doc)) {
7923         return;
7924     }
7925
7926
7927     // quit if run by the _changed callbacks
7928     if (g_object_get_data( tbl, "freeze" )) {
7929         return;
7930     }
7931
7932     // in turn, prevent callbacks from responding
7933     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
7934
7935     gdouble newValue = gtk_adjustment_get_value(adj);
7936     gchar value[G_ASCII_DTOSTR_BUF_SIZE];
7937     g_ascii_dtostr(value, G_ASCII_DTOSTR_BUF_SIZE, newValue);
7938
7939     bool modmade = false;
7940     GSList *l = (GSList *) selection->itemList();
7941     while (l) {
7942         SPItem *item = (SPItem *) l->data;
7943
7944         if (cc_item_is_connector(item)) {
7945             sp_object_setAttribute(item, "inkscape:connector-curvature",
7946                     value, false);
7947             item->avoidRef->handleSettingChange();
7948             modmade = true;
7949         }
7950         l = l->next;
7951     }
7952
7953     if (!modmade) {
7954         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
7955         prefs->setDouble(Glib::ustring("/tools/connector/curvature"), newValue);
7956     }
7957
7958     sp_document_done(doc, SP_VERB_CONTEXT_CONNECTOR,
7959             _("Change connector curvature"));
7960
7961     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
7962 }
7963
7964
7965 static void connector_spacing_changed(GtkAdjustment *adj, GObject* tbl)
7966 {
7967     SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
7968     SPDocument *doc = sp_desktop_document(desktop);
7969
7970     if (!sp_document_get_undo_sensitive(doc)) {
7971         return;
7972     }
7973
7974     Inkscape::XML::Node *repr = SP_OBJECT_REPR(desktop->namedview);
7975
7976     if ( !repr->attribute("inkscape:connector-spacing") &&
7977             ( adj->value == defaultConnSpacing )) {
7978         // Don't need to update the repr if the attribute doesn't
7979         // exist and it is being set to the default value -- as will
7980         // happen at startup.
7981         return;
7982     }
7983
7984     // quit if run by the attr_changed listener
7985     if (g_object_get_data( tbl, "freeze" )) {
7986         return;
7987     }
7988
7989     // in turn, prevent listener from responding
7990     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE));
7991
7992     sp_repr_set_css_double(repr, "inkscape:connector-spacing", adj->value);
7993     SP_OBJECT(desktop->namedview)->updateRepr();
7994
7995     GSList *items = get_avoided_items(NULL, desktop->currentRoot(), desktop);
7996     for ( GSList const *iter = items ; iter != NULL ; iter = iter->next ) {
7997         SPItem *item = reinterpret_cast<SPItem *>(iter->data);
7998         Geom::Matrix m = Geom::identity();
7999         avoid_item_move(&m, item);
8000     }
8001
8002     if (items) {
8003         g_slist_free(items);
8004     }
8005
8006     sp_document_done(doc, SP_VERB_CONTEXT_CONNECTOR,
8007             _("Change connector spacing"));
8008
8009     g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
8010 }
8011
8012 static void sp_connector_graph_layout(void)
8013 {
8014     if (!SP_ACTIVE_DESKTOP) {
8015         return;
8016     }
8017     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
8018
8019     // hack for clones, see comment in align-and-distribute.cpp
8020     int saved_compensation = prefs->getInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_UNMOVED);
8021     prefs->setInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_UNMOVED);
8022
8023     graphlayout(sp_desktop_selection(SP_ACTIVE_DESKTOP)->itemList());
8024
8025     prefs->setInt("/options/clonecompensation/value", saved_compensation);
8026
8027     sp_document_done(sp_desktop_document(SP_ACTIVE_DESKTOP), SP_VERB_DIALOG_ALIGN_DISTRIBUTE, _("Arrange connector network"));
8028 }
8029
8030 static void sp_directed_graph_layout_toggled( GtkToggleAction* act, GtkObject * /*tbl*/ )
8031 {
8032     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
8033     prefs->setBool("/tools/connector/directedlayout",
8034                 gtk_toggle_action_get_active( act ));
8035 }
8036
8037 static void sp_nooverlaps_graph_layout_toggled( GtkToggleAction* act, GtkObject * /*tbl*/ )
8038 {
8039     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
8040     prefs->setBool("/tools/connector/avoidoverlaplayout",
8041                 gtk_toggle_action_get_active( act ));
8042 }
8043
8044
8045 static void connector_length_changed(GtkAdjustment *adj, GObject* /*tbl*/)
8046 {
8047     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
8048     prefs->setDouble("/tools/connector/length", adj->value);
8049 }
8050
8051 static void connector_tb_event_attr_changed(Inkscape::XML::Node *repr,
8052                                             gchar const *name, gchar const * /*old_value*/, gchar const * /*new_value*/,
8053                                             bool /*is_interactive*/, gpointer data)
8054 {
8055     GtkWidget *tbl = GTK_WIDGET(data);
8056
8057     if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
8058         return;
8059     }
8060     if (strcmp(name, "inkscape:connector-spacing") == 0)
8061     {
8062         GtkAdjustment *adj = (GtkAdjustment*)
8063                 gtk_object_get_data(GTK_OBJECT(tbl), "spacing");
8064         gdouble spacing = defaultConnSpacing;
8065         sp_repr_get_double(repr, "inkscape:connector-spacing", &spacing);
8066
8067         gtk_adjustment_set_value(adj, spacing);
8068         gtk_adjustment_value_changed(adj);
8069     }
8070
8071     spinbutton_defocus(GTK_OBJECT(tbl));
8072 }
8073
8074 static void sp_connector_new_connection_point(GtkWidget *, GObject *tbl)
8075 {
8076     SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
8077     SPConnectorContext* cc = SP_CONNECTOR_CONTEXT(desktop->event_context);
8078
8079     if (cc->mode == SP_CONNECTOR_CONTEXT_EDITING_MODE) {
8080         cc_create_connection_point(cc);
8081     }
8082 }
8083
8084 static void sp_connector_remove_connection_point(GtkWidget *, GObject *tbl)
8085 {
8086     SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
8087     SPConnectorContext* cc = SP_CONNECTOR_CONTEXT(desktop->event_context);
8088
8089     if (cc->mode == SP_CONNECTOR_CONTEXT_EDITING_MODE) {
8090         cc_remove_connection_point(cc);
8091     }
8092 }
8093
8094 static Inkscape::XML::NodeEventVector connector_tb_repr_events = {
8095     NULL, /* child_added */
8096     NULL, /* child_removed */
8097     connector_tb_event_attr_changed,
8098     NULL, /* content_changed */
8099     NULL  /* order_changed */
8100 };
8101
8102 static void sp_connector_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
8103 {
8104     GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "curvature" ) );
8105     GtkToggleAction *act = GTK_TOGGLE_ACTION( g_object_get_data( tbl, "orthogonal" ) );
8106     SPItem *item = selection->singleItem();
8107     if (SP_IS_PATH(item))
8108     {
8109         gdouble curvature = SP_PATH(item)->connEndPair.getCurvature();
8110         bool is_orthog = SP_PATH(item)->connEndPair.isOrthogonal();
8111         gtk_toggle_action_set_active(act, is_orthog);
8112         gtk_adjustment_set_value(adj, curvature);
8113     }
8114
8115 }
8116
8117 static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder )
8118 {
8119     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
8120     Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
8121
8122     // Editing mode toggle button
8123     {
8124         InkToggleAction* act = ink_toggle_action_new( "ConnectorEditModeAction",
8125                                                       _("EditMode"),
8126                                                       _("Switch between connection point editing and connector drawing mode"),
8127                                                       INKSCAPE_ICON_CONNECTOR_EDIT,
8128                                                       Inkscape::ICON_SIZE_DECORATION );
8129         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
8130
8131         bool tbuttonstate = prefs->getBool("/tools/connector/mode");
8132         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act), ( tbuttonstate ? TRUE : FALSE ));
8133         g_object_set_data( holder, "mode", act );
8134         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_connector_mode_toggled), holder );
8135     }
8136
8137
8138     {
8139         InkAction* inky = ink_action_new( "ConnectorAvoidAction",
8140                                           _("Avoid"),
8141                                           _("Make connectors avoid selected objects"),
8142                                           INKSCAPE_ICON_CONNECTOR_AVOID,
8143                                           secondarySize );
8144         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_path_set_avoid), holder );
8145         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
8146     }
8147
8148     {
8149         InkAction* inky = ink_action_new( "ConnectorIgnoreAction",
8150                                           _("Ignore"),
8151                                           _("Make connectors ignore selected objects"),
8152                                           INKSCAPE_ICON_CONNECTOR_IGNORE,
8153                                           secondarySize );
8154         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_path_set_ignore), holder );
8155         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
8156     }
8157
8158     // Orthogonal connectors toggle button
8159     {
8160         InkToggleAction* act = ink_toggle_action_new( "ConnectorOrthogonalAction",
8161                                                       _("Orthogonal"),
8162                                                       _("Make connector orthogonal or polyline"),
8163                                                       INKSCAPE_ICON_CONNECTOR_ORTHOGONAL,
8164                                                       Inkscape::ICON_SIZE_DECORATION );
8165         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
8166
8167         bool tbuttonstate = prefs->getBool("/tools/connector/orthogonal");
8168         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act), ( tbuttonstate ? TRUE : FALSE ));
8169         g_object_set_data( holder, "orthogonal", act );
8170         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_connector_orthogonal_toggled), holder );
8171     }
8172
8173     EgeAdjustmentAction* eact = 0;
8174     // Curvature spinbox
8175     eact = create_adjustment_action( "ConnectorCurvatureAction",
8176                                     _("Connector Curvature"), _("Curvature:"),
8177                                     _("The amount of connectors curvature"),
8178                                     "/tools/connector/curvature", defaultConnCurvature,
8179                                     GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "inkscape:connector-curvature",
8180                                     0, 100, 1.0, 10.0,
8181                                     0, 0, 0,
8182                                     connector_curvature_changed, 1, 0 );
8183     gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
8184
8185     // Spacing spinbox
8186     eact = create_adjustment_action( "ConnectorSpacingAction",
8187                                     _("Connector Spacing"), _("Spacing:"),
8188                                     _("The amount of space left around objects by auto-routing connectors"),
8189                                     "/tools/connector/spacing", defaultConnSpacing,
8190                                     GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "inkscape:connector-spacing",
8191                                     0, 100, 1.0, 10.0,
8192                                     0, 0, 0,
8193                                     connector_spacing_changed, 1, 0 );
8194     gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
8195
8196     // Graph (connector network) layout
8197     {
8198         InkAction* inky = ink_action_new( "ConnectorGraphAction",
8199                                           _("Graph"),
8200                                           _("Nicely arrange selected connector network"),
8201                                           INKSCAPE_ICON_DISTRIBUTE_GRAPH,
8202                                           secondarySize );
8203         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_graph_layout), holder );
8204         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
8205     }
8206
8207     // Default connector length spinbox
8208     eact = create_adjustment_action( "ConnectorLengthAction",
8209                                      _("Connector Length"), _("Length:"),
8210                                      _("Ideal length for connectors when layout is applied"),
8211                                      "/tools/connector/length", 100,
8212                                      GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "inkscape:connector-length",
8213                                      10, 1000, 10.0, 100.0,
8214                                      0, 0, 0,
8215                                      connector_length_changed, 1, 0 );
8216     gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
8217
8218
8219     // Directed edges toggle button
8220     {
8221         InkToggleAction* act = ink_toggle_action_new( "ConnectorDirectedAction",
8222                                                       _("Downwards"),
8223                                                       _("Make connectors with end-markers (arrows) point downwards"),
8224                                                       INKSCAPE_ICON_DISTRIBUTE_GRAPH_DIRECTED,
8225                                                       Inkscape::ICON_SIZE_DECORATION );
8226         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
8227
8228         bool tbuttonstate = prefs->getBool("/tools/connector/directedlayout");
8229         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act), ( tbuttonstate ? TRUE : FALSE ));
8230
8231         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_directed_graph_layout_toggled), holder );
8232         sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_connector_toolbox_selection_changed), (GObject *)holder));
8233     }
8234
8235     // Avoid overlaps toggle button
8236     {
8237         InkToggleAction* act = ink_toggle_action_new( "ConnectorOverlapAction",
8238                                                       _("Remove overlaps"),
8239                                                       _("Do not allow overlapping shapes"),
8240                                                       INKSCAPE_ICON_DISTRIBUTE_REMOVE_OVERLAPS,
8241                                                       Inkscape::ICON_SIZE_DECORATION );
8242         gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
8243
8244         bool tbuttonstate = prefs->getBool("/tools/connector/avoidoverlaplayout");
8245         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act), (tbuttonstate ? TRUE : FALSE ));
8246
8247         g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_nooverlaps_graph_layout_toggled), holder );
8248     }
8249
8250
8251     // New connection point button
8252     {
8253         InkAction* inky = ink_action_new( "ConnectorNewConnPointAction",
8254                                           _("New connection point"),
8255                                           _("Add a new connection point to the currently selected item"),
8256                                           INKSCAPE_ICON_CONNECTOR_NEW_CONNPOINT,
8257                                           secondarySize );
8258         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_new_connection_point), holder );
8259         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
8260     }
8261
8262     // Remove selected connection point button
8263
8264     {
8265         InkAction* inky = ink_action_new( "ConnectorRemoveConnPointAction",
8266                                           _("Remove connection point"),
8267                                           _("Remove the currently selected connection point"),
8268                                           INKSCAPE_ICON_CONNECTOR_REMOVE_CONNPOINT,
8269                                           secondarySize );
8270         g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_remove_connection_point), holder );
8271         gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
8272     }
8273
8274
8275     // Code to watch for changes to the connector-spacing attribute in
8276     // the XML.
8277     Inkscape::XML::Node *repr = SP_OBJECT_REPR(desktop->namedview);
8278     g_assert(repr != NULL);
8279
8280     purge_repr_listener( holder, holder );
8281
8282     if (repr) {
8283         g_object_set_data( holder, "repr", repr );
8284         Inkscape::GC::anchor(repr);
8285         sp_repr_add_listener( repr, &connector_tb_repr_events, holder );
8286         sp_repr_synthesize_events( repr, &connector_tb_repr_events, holder );
8287     }
8288 } // end of sp_connector_toolbox_prep()
8289
8290
8291 //#########################
8292 //##     Paintbucket     ##
8293 //#########################
8294
8295 static void paintbucket_channels_changed(EgeSelectOneAction* act, GObject* /*tbl*/)
8296 {
8297     gint channels = ege_select_one_action_get_active( act );
8298     flood_channels_set_channels( channels );
8299 }
8300
8301 static void paintbucket_threshold_changed(GtkAdjustment *adj, GObject * /*tbl*/)
8302 {
8303     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
8304     prefs->setInt("/tools/paintbucket/threshold", (gint)adj->value);
8305 }
8306
8307 static void paintbucket_autogap_changed(EgeSelectOneAction* act, GObject * /*tbl*/)
8308 {
8309     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
8310     prefs->setBool("/tools/paintbucket/autogap", ege_select_one_action_get_active( act ));
8311 }
8312
8313 static void paintbucket_offset_changed(GtkAdjustment *adj, GObject *tbl)
8314 {
8315     UnitTracker* tracker = static_cast<UnitTracker*>(g_object_get_data( tbl, "tracker" ));
8316     SPUnit const *unit = tracker->getActiveUnit();
8317     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
8318
8319     prefs->setDouble("/tools/paintbucket/offset", (gdouble)sp_units_get_pixels(adj->value, *unit));
8320     prefs->setString("/tools/paintbucket/offsetunits", sp_unit_get_abbreviation(unit));
8321 }
8322
8323 static void paintbucket_defaults(GtkWidget *, GObject *tbl)
8324 {
8325     // FIXME: make defaults settable via Inkscape Options
8326     struct KeyValue {
8327         char const *key;
8328         double value;
8329     } const key_values[] = {
8330         {"threshold", 15},
8331         {"offset", 0.0}
8332     };
8333
8334     for (unsigned i = 0; i < G_N_ELEMENTS(key_values); ++i) {
8335         KeyValue const &kv = key_values[i];
8336         GtkAdjustment* adj = static_cast<GtkAdjustment *>(g_object_get_data(tbl, kv.key));
8337         if ( adj ) {
8338             gtk_adjustment_set_value(adj, kv.value);
8339         }
8340     }
8341
8342     EgeSelectOneAction* channels_action = EGE_SELECT_ONE_ACTION( g_object_get_data (tbl, "channels_action" ) );
8343     ege_select_one_action_set_active( channels_action, FLOOD_CHANNELS_RGB );
8344     EgeSelectOneAction* autogap_action = EGE_SELECT_ONE_ACTION( g_object_get_data (tbl, "autogap_action" ) );
8345     ege_select_one_action_set_active( autogap_action, 0 );
8346 }
8347
8348 static void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
8349 {
8350     EgeAdjustmentAction* eact = 0;
8351     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
8352
8353     {
8354         GtkListStore* model = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_INT );
8355
8356         GList* items = 0;
8357         gint count = 0;
8358         for ( items = flood_channels_dropdown_items_list(); items ; items = g_list_next(items) )
8359         {
8360             GtkTreeIter iter;
8361             gtk_list_store_append( model, &iter );
8362             gtk_list_store_set( model, &iter, 0, reinterpret_cast<gchar*>(items->data), 1, count, -1 );
8363             count++;
8364         }
8365         g_list_free( items );
8366         items = 0;
8367         EgeSelectOneAction* act1 = ege_select_one_action_new( "ChannelsAction", _("Fill by"), (""), NULL, GTK_TREE_MODEL(model) );
8368         g_object_set( act1, "short_label", _("Fill by:"), NULL );
8369         ege_select_one_action_set_appearance( act1, "compact" );
8370         ege_select_one_action_set_active( act1, prefs->getInt("/tools/paintbucket/channels", 0) );
8371         g_signal_connect( G_OBJECT(act1), "changed", G_CALLBACK(paintbucket_channels_changed), holder );
8372         gtk_action_group_add_action( mainActions, GTK_ACTION(act1) );
8373         g_object_set_data( holder, "channels_action", act1 );
8374     }
8375
8376     // Spacing spinbox
8377     {
8378         eact = create_adjustment_action(
8379             "ThresholdAction",
8380             _("Fill Threshold"), _("Threshold:"),
8381             _("The maximum allowed difference between the clicked pixel and the neighboring pixels to be counted in the fill"),
8382             "/tools/paintbucket/threshold", 5, GTK_WIDGET(desktop->canvas), NULL, holder, TRUE,
8383             "inkscape:paintbucket-threshold", 0, 100.0, 1.0, 10.0,
8384             0, 0, 0,
8385             paintbucket_threshold_changed, 1, 0 );
8386
8387         ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
8388         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
8389     }
8390
8391     // Create the units menu.
8392     UnitTracker* tracker = new UnitTracker( SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE );
8393     Glib::ustring stored_unit = prefs->getString("/tools/paintbucket/offsetunits");
8394     if (!stored_unit.empty()) {
8395         tracker->setActiveUnit(sp_unit_get_by_abbreviation(stored_unit.data()));
8396     }
8397     g_object_set_data( holder, "tracker", tracker );
8398     {
8399         GtkAction* act = tracker->createAction( "PaintbucketUnitsAction", _("Units"), ("") );
8400         gtk_action_group_add_action( mainActions, act );
8401     }
8402
8403     // Offset spinbox
8404     {
8405         eact = create_adjustment_action(
8406             "OffsetAction",
8407             _("Grow/shrink by"), _("Grow/shrink by:"),
8408             _("The amount to grow (positive) or shrink (negative) the created fill path"),
8409             "/tools/paintbucket/offset", 0, GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, TRUE,
8410             "inkscape:paintbucket-offset", -1e6, 1e6, 0.1, 0.5,
8411             0, 0, 0,
8412             paintbucket_offset_changed, 1, 2);
8413         tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );
8414
8415         gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
8416     }
8417
8418     /* Auto Gap */
8419     {
8420         GtkListStore* model = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_INT );
8421
8422         GList* items = 0;
8423         gint count = 0;
8424         for ( items = flood_autogap_dropdown_items_list(); items ; items = g_list_next(items) )
8425         {
8426             GtkTreeIter iter;
8427             gtk_list_store_append( model, &iter );
8428             gtk_list_store_set( model, &iter, 0, reinterpret_cast<gchar*>(items->data), 1, count, -1 );
8429             count++;
8430         }
8431         g_list_free( items );
8432         items = 0;
8433         EgeSelectOneAction* act2 = ege_select_one_action_new( "AutoGapAction", _("Close gaps"), (""), NULL, GTK_TREE_MODEL(model) );
8434         g_object_set( act2, "short_label", _("Close gaps:"), NULL );
8435         ege_select_one_action_set_appearance( act2, "compact" );
8436         ege_select_one_action_set_active( act2, prefs->getBool("/tools/paintbucket/autogap") );
8437         g_signal_connect( G_OBJECT(act2), "changed", G_CALLBACK(paintbucket_autogap_changed), holder );
8438         gtk_action_group_add_action( mainActions, GTK_ACTION(act2) );
8439         g_object_set_data( holder, "autogap_action", act2 );
8440     }
8441
8442     /* Reset */
8443     {
8444         GtkAction* act = gtk_action_new( "PaintbucketResetAction",
8445                                           _("Defaults"),
8446                                           _("Reset paint bucket parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
8447                                           GTK_STOCK_CLEAR );
8448         g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(paintbucket_defaults), holder );
8449         gtk_action_group_add_action( mainActions, act );
8450         gtk_action_set_sensitive( act, TRUE );
8451     }
8452
8453 }
8454
8455 /*
8456   Local Variables:
8457   mode:c++
8458   c-file-style:"stroustrup"
8459   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
8460   indent-tabs-mode:nil
8461   fill-column:99
8462   End:
8463 */
8464 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :