src/widgets/toolbox.cpp

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