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