src/widgets/toolbox.cpp

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