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