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