![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
5950bf8414f30b4d3f3d3cb20610265333ba65bc
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='TextSuperscriptAction' />"
493 " <toolitem action='TextSubscriptAction' />"
494 " <separator />"
495 " <toolitem action='TextLineHeightAction' />"
496 " <toolitem action='TextLetterSpacingAction' />"
497 " <toolitem action='TextWordSpacingAction' />"
498 " <toolitem action='TextDxAction' />"
499 " <toolitem action='TextDyAction' />"
500 " <toolitem action='TextRotationAction' />"
501 " <separator />"
502 " <toolitem action='TextOrientationAction' />"
503 " </toolbar>"
505 " <toolbar name='LPEToolToolbar'>"
506 " <toolitem action='LPEToolModeAction' />"
507 " <separator />"
508 " <toolitem action='LPEShowBBoxAction' />"
509 " <toolitem action='LPEBBoxFromSelectionAction' />"
510 " <separator />"
511 " <toolitem action='LPELineSegmentAction' />"
512 " <separator />"
513 " <toolitem action='LPEMeasuringAction' />"
514 " <toolitem action='LPEToolUnitsAction' />"
515 " <separator />"
516 " <toolitem action='LPEOpenLPEDialogAction' />"
517 " </toolbar>"
519 " <toolbar name='DropperToolbar'>"
520 " <toolitem action='DropperOpacityAction' />"
521 " <toolitem action='DropperPickAlphaAction' />"
522 " <toolitem action='DropperSetAlphaAction' />"
523 " </toolbar>"
525 " <toolbar name='ConnectorToolbar'>"
526 // " <toolitem action='ConnectorEditModeAction' />"
527 " <toolitem action='ConnectorAvoidAction' />"
528 " <toolitem action='ConnectorIgnoreAction' />"
529 " <toolitem action='ConnectorOrthogonalAction' />"
530 " <toolitem action='ConnectorCurvatureAction' />"
531 " <toolitem action='ConnectorSpacingAction' />"
532 " <toolitem action='ConnectorGraphAction' />"
533 " <toolitem action='ConnectorLengthAction' />"
534 " <toolitem action='ConnectorDirectedAction' />"
535 " <toolitem action='ConnectorOverlapAction' />"
536 // " <toolitem action='ConnectorNewConnPointAction' />"
537 // " <toolitem action='ConnectorRemoveConnPointAction' />"
538 " </toolbar>"
540 "</ui>"
541 ;
543 static Glib::RefPtr<Gtk::ActionGroup> create_or_fetch_actions( SPDesktop* desktop );
545 static void setup_snap_toolbox(GtkWidget *toolbox, SPDesktop *desktop);
547 static void setup_tool_toolbox(GtkWidget *toolbox, SPDesktop *desktop);
548 static void update_tool_toolbox(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox);
550 static void setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop);
551 static void update_aux_toolbox(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox);
553 static void setup_commands_toolbox(GtkWidget *toolbox, SPDesktop *desktop);
554 static void update_commands_toolbox(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox);
556 static GtkWidget * sp_toolbox_button_new_from_verb_with_doubleclick( GtkWidget *t, Inkscape::IconSize size, SPButtonType type,
557 Inkscape::Verb *verb, Inkscape::Verb *doubleclick_verb,
558 Inkscape::UI::View::View *view, GtkTooltips *tt);
560 class VerbAction : public Gtk::Action {
561 public:
562 static Glib::RefPtr<VerbAction> create(Inkscape::Verb* verb, Inkscape::Verb* verb2, Inkscape::UI::View::View *view, GtkTooltips *tooltips);
564 virtual ~VerbAction();
565 virtual void set_active(bool active = true);
567 protected:
568 virtual Gtk::Widget* create_menu_item_vfunc();
569 virtual Gtk::Widget* create_tool_item_vfunc();
571 virtual void connect_proxy_vfunc(Gtk::Widget* proxy);
572 virtual void disconnect_proxy_vfunc(Gtk::Widget* proxy);
574 virtual void on_activate();
576 private:
577 Inkscape::Verb* verb;
578 Inkscape::Verb* verb2;
579 Inkscape::UI::View::View *view;
580 GtkTooltips *tooltips;
581 bool active;
583 VerbAction(Inkscape::Verb* verb, Inkscape::Verb* verb2, Inkscape::UI::View::View *view, GtkTooltips *tooltips);
584 };
587 Glib::RefPtr<VerbAction> VerbAction::create(Inkscape::Verb* verb, Inkscape::Verb* verb2, Inkscape::UI::View::View *view, GtkTooltips *tooltips)
588 {
589 Glib::RefPtr<VerbAction> result;
590 SPAction *action = verb->get_action(view);
591 if ( action ) {
592 //SPAction* action2 = verb2 ? verb2->get_action(view) : 0;
593 result = Glib::RefPtr<VerbAction>(new VerbAction(verb, verb2, view, tooltips));
594 }
596 return result;
597 }
599 VerbAction::VerbAction(Inkscape::Verb* verb, Inkscape::Verb* verb2, Inkscape::UI::View::View *view, GtkTooltips *tooltips) :
600 Gtk::Action(Glib::ustring(verb->get_id()), Gtk::StockID(verb->get_image()), Glib::ustring(_(verb->get_name())), Glib::ustring(_(verb->get_tip()))),
601 verb(verb),
602 verb2(verb2),
603 view(view),
604 tooltips(tooltips),
605 active(false)
606 {
607 }
609 VerbAction::~VerbAction()
610 {
611 }
613 Gtk::Widget* VerbAction::create_menu_item_vfunc()
614 {
615 // First call in to get the icon rendered if present in SVG
616 Gtk::Widget *widget = sp_icon_get_icon( property_stock_id().get_value().get_string(), Inkscape::ICON_SIZE_MENU );
617 delete widget;
618 widget = 0;
620 Gtk::Widget* widg = Gtk::Action::create_menu_item_vfunc();
621 // g_message("create_menu_item_vfunc() = %p for '%s'", widg, verb->get_id());
622 return widg;
623 }
625 Gtk::Widget* VerbAction::create_tool_item_vfunc()
626 {
627 // Gtk::Widget* widg = Gtk::Action::create_tool_item_vfunc();
628 Inkscape::IconSize toolboxSize = ToolboxFactory::prefToSize("/toolbox/tools/small");
629 GtkWidget* toolbox = 0;
630 GtkWidget *button = sp_toolbox_button_new_from_verb_with_doubleclick( toolbox, toolboxSize,
631 SP_BUTTON_TYPE_TOGGLE,
632 verb,
633 verb2,
634 view,
635 tooltips );
636 if ( active ) {
637 sp_button_toggle_set_down( SP_BUTTON(button), active);
638 }
639 gtk_widget_show_all( button );
640 Gtk::Widget* wrapped = Glib::wrap(button);
641 Gtk::ToolItem* holder = Gtk::manage(new Gtk::ToolItem());
642 holder->add(*wrapped);
644 // g_message("create_tool_item_vfunc() = %p for '%s'", holder, verb->get_id());
645 return holder;
646 }
648 void VerbAction::connect_proxy_vfunc(Gtk::Widget* proxy)
649 {
650 // g_message("connect_proxy_vfunc(%p) for '%s'", proxy, verb->get_id());
651 Gtk::Action::connect_proxy_vfunc(proxy);
652 }
654 void VerbAction::disconnect_proxy_vfunc(Gtk::Widget* proxy)
655 {
656 // g_message("disconnect_proxy_vfunc(%p) for '%s'", proxy, verb->get_id());
657 Gtk::Action::disconnect_proxy_vfunc(proxy);
658 }
660 void VerbAction::set_active(bool active)
661 {
662 this->active = active;
663 Glib::SListHandle<Gtk::Widget*> proxies = get_proxies();
664 for ( Glib::SListHandle<Gtk::Widget*>::iterator it = proxies.begin(); it != proxies.end(); ++it ) {
665 Gtk::ToolItem* ti = dynamic_cast<Gtk::ToolItem*>(*it);
666 if (ti) {
667 // *should* have one child that is the SPButton
668 Gtk::Widget* child = ti->get_child();
669 if ( child && SP_IS_BUTTON(child->gobj()) ) {
670 SPButton* button = SP_BUTTON(child->gobj());
671 sp_button_toggle_set_down( button, active );
672 }
673 }
674 }
675 }
677 void VerbAction::on_activate()
678 {
679 if ( verb ) {
680 SPAction *action = verb->get_action(view);
681 if ( action ) {
682 sp_action_perform(action, 0);
683 }
684 }
685 }
687 /* Global text entry widgets necessary for update */
688 /* GtkWidget *dropper_rgb_entry,
689 *dropper_opacity_entry ; */
690 // should be made a private member once this is converted to class
692 static void delete_connection(GObject * /*obj*/, sigc::connection *connection)
693 {
694 connection->disconnect();
695 delete connection;
696 }
698 static void purge_repr_listener( GObject* /*obj*/, GObject* tbl )
699 {
700 Inkscape::XML::Node* oldrepr = reinterpret_cast<Inkscape::XML::Node *>( g_object_get_data( tbl, "repr" ) );
701 if (oldrepr) { // remove old listener
702 sp_repr_remove_listener_by_data(oldrepr, tbl);
703 Inkscape::GC::release(oldrepr);
704 oldrepr = 0;
705 g_object_set_data( tbl, "repr", NULL );
706 }
707 }
709 // ------------------------------------------------------
711 /**
712 * A simple mediator class that keeps UI controls matched to the preference values they set.
713 */
714 class PrefPusher : public Inkscape::Preferences::Observer
715 {
716 public:
717 /**
718 * Constructor for a boolean value that syncs to the supplied path.
719 * Initializes the widget to the current preference stored state and registers callbacks
720 * for widget changes and preference changes.
721 *
722 * @param act the widget to synchronize preference with.
723 * @param path the path to the preference the widget is synchronized with.
724 * @param callback function to invoke when changes are pushed.
725 * @param cbData data to be passed on to the callback function.
726 */
727 PrefPusher( GtkToggleAction *act, Glib::ustring const &path, void (*callback)(GObject*) = 0, GObject *cbData = 0 );
729 /**
730 * Destructor that unregisters the preference callback.
731 */
732 virtual ~PrefPusher();
734 /**
735 * Callback method invoked when the preference setting changes.
736 */
737 virtual void notify(Inkscape::Preferences::Entry const &new_val);
739 private:
740 /**
741 * Callback hook invoked when the widget changes.
742 *
743 * @param act the toggle action widget that was changed.
744 * @param self the PrefPusher instance the callback was registered to.
745 */
746 static void toggleCB( GtkToggleAction *act, PrefPusher *self );
748 /**
749 * Method to handle the widget change.
750 */
751 void handleToggled();
753 GtkToggleAction *act;
754 void (*callback)(GObject*);
755 GObject *cbData;
756 bool freeze;
757 };
759 PrefPusher::PrefPusher( GtkToggleAction *act, Glib::ustring const &path, void (*callback)(GObject*), GObject *cbData ) :
760 Observer(path),
761 act(act),
762 callback(callback),
763 cbData(cbData),
764 freeze(false)
765 {
766 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggleCB), this);
767 freeze = true;
768 gtk_toggle_action_set_active( act, Inkscape::Preferences::get()->getBool(observed_path) );
769 freeze = false;
771 Inkscape::Preferences::get()->addObserver(*this);
772 }
774 PrefPusher::~PrefPusher()
775 {
776 Inkscape::Preferences::get()->removeObserver(*this);
777 }
779 void PrefPusher::toggleCB( GtkToggleAction * /*act*/, PrefPusher *self )
780 {
781 if (self) {
782 self->handleToggled();
783 }
784 }
786 void PrefPusher::handleToggled()
787 {
788 if (!freeze) {
789 freeze = true;
790 Inkscape::Preferences::get()->setBool(observed_path, gtk_toggle_action_get_active( act ));
791 if (callback) {
792 (*callback)(cbData);
793 }
794 freeze = false;
795 }
796 }
798 void PrefPusher::notify(Inkscape::Preferences::Entry const &newVal)
799 {
800 bool newBool = newVal.getBool();
801 bool oldBool = gtk_toggle_action_get_active(act);
803 if (!freeze && (newBool != oldBool)) {
804 gtk_toggle_action_set_active( act, newBool );
805 }
806 }
808 static void delete_prefspusher(GtkObject * /*obj*/, PrefPusher *watcher )
809 {
810 delete watcher;
811 }
813 // ------------------------------------------------------
816 GtkWidget * sp_toolbox_button_new_from_verb_with_doubleclick(GtkWidget *t, Inkscape::IconSize size, SPButtonType type,
817 Inkscape::Verb *verb, Inkscape::Verb *doubleclick_verb,
818 Inkscape::UI::View::View *view, GtkTooltips *tt)
819 {
820 SPAction *action = verb->get_action(view);
821 if (!action) {
822 return NULL;
823 }
825 SPAction *doubleclick_action;
826 if (doubleclick_verb) {
827 doubleclick_action = doubleclick_verb->get_action(view);
828 } else {
829 doubleclick_action = NULL;
830 }
832 /* fixme: Handle sensitive/unsensitive */
833 /* fixme: Implement sp_button_new_from_action */
834 GtkWidget *b = sp_button_new(size, type, action, doubleclick_action, tt);
835 gtk_widget_show(b);
838 unsigned int shortcut = sp_shortcut_get_primary(verb);
839 if (shortcut) {
840 gchar key[256];
841 sp_ui_shortcut_string(shortcut, key);
842 gchar *tip = g_strdup_printf ("%s (%s)", action->tip, key);
843 if ( t ) {
844 gtk_toolbar_append_widget( GTK_TOOLBAR(t), b, tip, 0 );
845 }
846 g_free(tip);
847 } else {
848 if ( t ) {
849 gtk_toolbar_append_widget( GTK_TOOLBAR(t), b, action->tip, 0 );
850 }
851 }
853 return b;
854 }
857 static void trigger_sp_action( GtkAction* /*act*/, gpointer user_data )
858 {
859 SPAction* targetAction = SP_ACTION(user_data);
860 if ( targetAction ) {
861 sp_action_perform( targetAction, NULL );
862 }
863 }
865 static void sp_action_action_set_sensitive(SPAction * /*action*/, unsigned int sensitive, void *data)
866 {
867 if ( data ) {
868 GtkAction* act = GTK_ACTION(data);
869 gtk_action_set_sensitive( act, sensitive );
870 }
871 }
873 static SPActionEventVector action_event_vector = {
874 {NULL},
875 NULL,
876 NULL,
877 sp_action_action_set_sensitive,
878 NULL,
879 NULL
880 };
882 static GtkAction* create_action_for_verb( Inkscape::Verb* verb, Inkscape::UI::View::View* view, Inkscape::IconSize size )
883 {
884 GtkAction* act = 0;
886 SPAction* targetAction = verb->get_action(view);
887 InkAction* inky = ink_action_new( verb->get_id(), _(verb->get_name()), verb->get_tip(), verb->get_image(), size );
888 act = GTK_ACTION(inky);
889 gtk_action_set_sensitive( act, targetAction->sensitive );
891 g_signal_connect( G_OBJECT(inky), "activate", GTK_SIGNAL_FUNC(trigger_sp_action), targetAction );
893 SPAction*rebound = dynamic_cast<SPAction *>( nr_object_ref( dynamic_cast<NRObject *>(targetAction) ) );
894 nr_active_object_add_listener( (NRActiveObject *)rebound, (NRObjectEventVector *)&action_event_vector, sizeof(SPActionEventVector), inky );
896 return act;
897 }
899 static Glib::RefPtr<Gtk::ActionGroup> create_or_fetch_actions( SPDesktop* desktop )
900 {
901 Inkscape::UI::View::View *view = desktop;
902 gint verbsToUse[] = {
903 // disabled until we have icons for them:
904 //find
905 //SP_VERB_EDIT_TILE,
906 //SP_VERB_EDIT_UNTILE,
907 SP_VERB_DIALOG_ALIGN_DISTRIBUTE,
908 SP_VERB_DIALOG_DISPLAY,
909 SP_VERB_DIALOG_FILL_STROKE,
910 SP_VERB_DIALOG_NAMEDVIEW,
911 SP_VERB_DIALOG_TEXT,
912 SP_VERB_DIALOG_XML_EDITOR,
913 SP_VERB_DIALOG_LAYERS,
914 SP_VERB_EDIT_CLONE,
915 SP_VERB_EDIT_COPY,
916 SP_VERB_EDIT_CUT,
917 SP_VERB_EDIT_DUPLICATE,
918 SP_VERB_EDIT_PASTE,
919 SP_VERB_EDIT_REDO,
920 SP_VERB_EDIT_UNDO,
921 SP_VERB_EDIT_UNLINK_CLONE,
922 SP_VERB_FILE_EXPORT,
923 SP_VERB_FILE_IMPORT,
924 SP_VERB_FILE_NEW,
925 SP_VERB_FILE_OPEN,
926 SP_VERB_FILE_PRINT,
927 SP_VERB_FILE_SAVE,
928 SP_VERB_OBJECT_TO_CURVE,
929 SP_VERB_SELECTION_GROUP,
930 SP_VERB_SELECTION_OUTLINE,
931 SP_VERB_SELECTION_UNGROUP,
932 SP_VERB_ZOOM_1_1,
933 SP_VERB_ZOOM_1_2,
934 SP_VERB_ZOOM_2_1,
935 SP_VERB_ZOOM_DRAWING,
936 SP_VERB_ZOOM_IN,
937 SP_VERB_ZOOM_NEXT,
938 SP_VERB_ZOOM_OUT,
939 SP_VERB_ZOOM_PAGE,
940 SP_VERB_ZOOM_PAGE_WIDTH,
941 SP_VERB_ZOOM_PREV,
942 SP_VERB_ZOOM_SELECTION,
943 };
945 Inkscape::IconSize toolboxSize = ToolboxFactory::prefToSize("/toolbox/small");
947 static std::map<SPDesktop*, Glib::RefPtr<Gtk::ActionGroup> > groups;
948 Glib::RefPtr<Gtk::ActionGroup> mainActions;
949 if ( groups.find(desktop) != groups.end() ) {
950 mainActions = groups[desktop];
951 }
953 if ( !mainActions ) {
954 mainActions = Gtk::ActionGroup::create("main");
955 groups[desktop] = mainActions;
956 }
958 for ( guint i = 0; i < G_N_ELEMENTS(verbsToUse); i++ ) {
959 Inkscape::Verb* verb = Inkscape::Verb::get(verbsToUse[i]);
960 if ( verb ) {
961 if (!mainActions->get_action(verb->get_id())) {
962 GtkAction* act = create_action_for_verb( verb, view, toolboxSize );
963 mainActions->add(Glib::wrap(act));
964 }
965 }
966 }
968 if ( !mainActions->get_action("ToolZoom") ) {
969 GtkTooltips *tt = gtk_tooltips_new();
970 for ( guint i = 0; i < G_N_ELEMENTS(tools) && tools[i].type_name; i++ ) {
971 Glib::RefPtr<VerbAction> va = VerbAction::create(Inkscape::Verb::get(tools[i].verb), Inkscape::Verb::get(tools[i].doubleclick_verb), view, tt);
972 if ( va ) {
973 mainActions->add(va);
974 if ( i == 0 ) {
975 va->set_active(true);
976 }
977 }
978 }
979 }
981 #if ENABLE_TASK_SUPPORT
982 if ( !mainActions->get_action("TaskSetAction") ) {
983 GtkListStore* model = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_STRING );
985 GtkTreeIter iter;
986 gtk_list_store_append( model, &iter );
987 gtk_list_store_set( model, &iter,
988 0, _("Default"),
989 1, _("Default interface setup"),
990 -1 );
992 gtk_list_store_append( model, &iter );
993 gtk_list_store_set( model, &iter,
994 0, _("Custom"),
995 1, _("Set the custom task"),
996 -1 );
998 gtk_list_store_append( model, &iter );
999 gtk_list_store_set( model, &iter,
1000 0, _("Wide"),
1001 1, _("Setup for widescreen work"),
1002 -1 );
1004 EgeSelectOneAction* act = ege_select_one_action_new( "TaskSetAction", _("Task"), (""), NULL, GTK_TREE_MODEL(model) );
1005 g_object_set( act, "short_label", _("Task:"), NULL );
1006 mainActions->add(Glib::wrap(GTK_ACTION(act)));
1007 //g_object_set_data( holder, "mode_action", act );
1009 ege_select_one_action_set_appearance( act, "minimal" );
1010 ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
1011 //ege_select_one_action_set_icon_size( act, secondarySize );
1012 ege_select_one_action_set_tooltip_column( act, 1 );
1014 //ege_select_one_action_set_active( act, mode );
1015 g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(fireTaskChange), desktop );
1016 }
1017 #endif // ENABLE_TASK_SUPPORT
1019 return mainActions;
1020 }
1023 static void handlebox_detached(GtkHandleBox* /*handlebox*/, GtkWidget* widget, gpointer /*userData*/)
1024 {
1025 gtk_widget_set_size_request( widget,
1026 widget->allocation.width,
1027 widget->allocation.height );
1028 }
1030 static void handlebox_attached(GtkHandleBox* /*handlebox*/, GtkWidget* widget, gpointer /*userData*/)
1031 {
1032 gtk_widget_set_size_request( widget, -1, -1 );
1033 }
1035 static GtkWidget* toolboxNewCommon( GtkWidget* tb, BarId id, GtkPositionType handlePos )
1036 {
1037 g_object_set_data(G_OBJECT(tb), "desktop", NULL);
1039 gtk_widget_set_sensitive(tb, FALSE);
1041 GtkWidget *hb = 0;
1042 if ( UXManager::getInstance()->isFloatWindowProblem() ) {
1043 hb = gtk_event_box_new(); // A simple, neutral container.
1044 } else {
1045 hb = gtk_handle_box_new();
1046 gtk_handle_box_set_handle_position(GTK_HANDLE_BOX(hb), handlePos);
1047 gtk_handle_box_set_shadow_type(GTK_HANDLE_BOX(hb), GTK_SHADOW_OUT);
1048 gtk_handle_box_set_snap_edge(GTK_HANDLE_BOX(hb), GTK_POS_LEFT);
1049 }
1051 gtk_container_add(GTK_CONTAINER(hb), tb);
1052 gtk_widget_show(GTK_WIDGET(tb));
1054 sigc::connection* conn = new sigc::connection;
1055 g_object_set_data(G_OBJECT(hb), "event_context_connection", conn);
1057 if ( GTK_IS_HANDLE_BOX(hb) ) {
1058 g_signal_connect(G_OBJECT(hb), "child_detached", G_CALLBACK(handlebox_detached), static_cast<gpointer>(0));
1059 g_signal_connect(G_OBJECT(hb), "child_attached", G_CALLBACK(handlebox_attached), static_cast<gpointer>(0));
1060 }
1062 gpointer val = GINT_TO_POINTER(id);
1063 g_object_set_data(G_OBJECT(hb), BAR_ID_KEY, val);
1065 return hb;
1066 }
1068 GtkWidget *ToolboxFactory::createToolToolbox()
1069 {
1070 GtkWidget *tb = gtk_vbox_new(FALSE, 0);
1072 return toolboxNewCommon( tb, BAR_TOOL, GTK_POS_TOP );
1073 }
1075 GtkWidget *ToolboxFactory::createAuxToolbox()
1076 {
1077 GtkWidget *tb = gtk_vbox_new(FALSE, 0);
1079 return toolboxNewCommon( tb, BAR_AUX, GTK_POS_LEFT );
1080 }
1082 //####################################
1083 //# Commands Bar
1084 //####################################
1086 GtkWidget *ToolboxFactory::createCommandsToolbox()
1087 {
1088 GtkWidget *tb = gtk_vbox_new(FALSE, 0);
1090 return toolboxNewCommon( tb, BAR_COMMANDS, GTK_POS_LEFT );
1091 }
1093 GtkWidget *ToolboxFactory::createSnapToolbox()
1094 {
1095 GtkWidget *tb = gtk_vbox_new(FALSE, 0);
1097 return toolboxNewCommon( tb, BAR_SNAP, GTK_POS_LEFT );
1098 }
1100 static EgeAdjustmentAction * create_adjustment_action( gchar const *name,
1101 gchar const *label, gchar const *shortLabel, gchar const *tooltip,
1102 Glib::ustring const &path, gdouble def,
1103 GtkWidget *focusTarget,
1104 GtkWidget *us,
1105 GObject *dataKludge,
1106 gboolean altx, gchar const *altx_mark,
1107 gdouble lower, gdouble upper, gdouble step, gdouble page,
1108 gchar const** descrLabels, gdouble const* descrValues, guint descrCount,
1109 void (*callback)(GtkAdjustment *, GObject *),
1110 gdouble climb = 0.1, guint digits = 3, double factor = 1.0 )
1111 {
1112 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1113 GtkAdjustment* adj = GTK_ADJUSTMENT( gtk_adjustment_new( prefs->getDouble(path, def) * factor,
1114 lower, upper, step, page, 0 ) );
1115 if (us) {
1116 sp_unit_selector_add_adjustment( SP_UNIT_SELECTOR(us), adj );
1117 }
1119 gtk_signal_connect( GTK_OBJECT(adj), "value-changed", GTK_SIGNAL_FUNC(callback), dataKludge );
1121 EgeAdjustmentAction* act = ege_adjustment_action_new( adj, name, label, tooltip, 0, climb, digits );
1122 if ( shortLabel ) {
1123 g_object_set( act, "short_label", shortLabel, NULL );
1124 }
1126 if ( (descrCount > 0) && descrLabels && descrValues ) {
1127 ege_adjustment_action_set_descriptions( act, descrLabels, descrValues, descrCount );
1128 }
1130 if ( focusTarget ) {
1131 ege_adjustment_action_set_focuswidget( act, focusTarget );
1132 }
1134 if ( altx && altx_mark ) {
1135 g_object_set( G_OBJECT(act), "self-id", altx_mark, NULL );
1136 }
1138 if ( dataKludge ) {
1139 // Rather lame, but it's the only place where we need to get the entry name
1140 // but we don't have an Entry
1141 g_object_set_data( dataKludge, prefs->getEntry(path).getEntryName().data(), adj );
1142 }
1144 // Using a cast just to make sure we pass in the right kind of function pointer
1145 g_object_set( G_OBJECT(act), "tool-post", static_cast<EgeWidgetFixup>(sp_set_font_size_smaller), NULL );
1147 return act;
1148 }
1151 //####################################
1152 //# node editing callbacks
1153 //####################################
1155 /** Temporary hack: Returns the node tool in the active desktop.
1156 * Will go away during tool refactoring. */
1157 static InkNodeTool *get_node_tool()
1158 {
1159 InkNodeTool *tool = 0;
1160 if (SP_ACTIVE_DESKTOP ) {
1161 SPEventContext *ec = SP_ACTIVE_DESKTOP->event_context;
1162 if (INK_IS_NODE_TOOL(ec)) {
1163 tool = static_cast<InkNodeTool*>(ec);
1164 }
1165 }
1166 return tool;
1167 }
1169 static void sp_node_path_edit_add(void)
1170 {
1171 InkNodeTool *nt = get_node_tool();
1172 if (nt) {
1173 nt->_multipath->insertNodes();
1174 }
1175 }
1177 static void sp_node_path_edit_delete(void)
1178 {
1179 InkNodeTool *nt = get_node_tool();
1180 if (nt) {
1181 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1182 nt->_multipath->deleteNodes(prefs->getBool("/tools/nodes/delete_preserves_shape", true));
1183 }
1184 }
1186 static void sp_node_path_edit_delete_segment(void)
1187 {
1188 InkNodeTool *nt = get_node_tool();
1189 if (nt) {
1190 nt->_multipath->deleteSegments();
1191 }
1192 }
1194 static void sp_node_path_edit_break(void)
1195 {
1196 InkNodeTool *nt = get_node_tool();
1197 if (nt) {
1198 nt->_multipath->breakNodes();
1199 }
1200 }
1202 static void sp_node_path_edit_join(void)
1203 {
1204 InkNodeTool *nt = get_node_tool();
1205 if (nt) {
1206 nt->_multipath->joinNodes();
1207 }
1208 }
1210 static void sp_node_path_edit_join_segment(void)
1211 {
1212 InkNodeTool *nt = get_node_tool();
1213 if (nt) {
1214 nt->_multipath->joinSegments();
1215 }
1216 }
1218 static void sp_node_path_edit_toline(void)
1219 {
1220 InkNodeTool *nt = get_node_tool();
1221 if (nt) {
1222 nt->_multipath->setSegmentType(Inkscape::UI::SEGMENT_STRAIGHT);
1223 }
1224 }
1226 static void sp_node_path_edit_tocurve(void)
1227 {
1228 InkNodeTool *nt = get_node_tool();
1229 if (nt) {
1230 nt->_multipath->setSegmentType(Inkscape::UI::SEGMENT_CUBIC_BEZIER);
1231 }
1232 }
1234 static void sp_node_path_edit_cusp(void)
1235 {
1236 InkNodeTool *nt = get_node_tool();
1237 if (nt) {
1238 nt->_multipath->setNodeType(Inkscape::UI::NODE_CUSP);
1239 }
1240 }
1242 static void sp_node_path_edit_smooth(void)
1243 {
1244 InkNodeTool *nt = get_node_tool();
1245 if (nt) {
1246 nt->_multipath->setNodeType(Inkscape::UI::NODE_SMOOTH);
1247 }
1248 }
1250 static void sp_node_path_edit_symmetrical(void)
1251 {
1252 InkNodeTool *nt = get_node_tool();
1253 if (nt) {
1254 nt->_multipath->setNodeType(Inkscape::UI::NODE_SYMMETRIC);
1255 }
1256 }
1258 static void sp_node_path_edit_auto(void)
1259 {
1260 InkNodeTool *nt = get_node_tool();
1261 if (nt) {
1262 nt->_multipath->setNodeType(Inkscape::UI::NODE_AUTO);
1263 }
1264 }
1266 static void sp_node_path_edit_nextLPEparam(GtkAction * /*act*/, gpointer data) {
1267 sp_selection_next_patheffect_param( reinterpret_cast<SPDesktop*>(data) );
1268 }
1270 /* is called when the node selection is modified */
1271 static void sp_node_toolbox_coord_changed(gpointer /*shape_editor*/, GObject *tbl)
1272 {
1273 GtkAction* xact = GTK_ACTION( g_object_get_data( tbl, "nodes_x_action" ) );
1274 GtkAction* yact = GTK_ACTION( g_object_get_data( tbl, "nodes_y_action" ) );
1275 GtkAdjustment *xadj = ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION(xact));
1276 GtkAdjustment *yadj = ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION(yact));
1278 // quit if run by the attr_changed listener
1279 if (g_object_get_data( tbl, "freeze" )) {
1280 return;
1281 }
1283 // in turn, prevent listener from responding
1284 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE));
1286 UnitTracker* tracker = reinterpret_cast<UnitTracker*>( g_object_get_data( tbl, "tracker" ) );
1287 SPUnit const *unit = tracker->getActiveUnit();
1289 InkNodeTool *nt = get_node_tool();
1290 if (!nt || nt->_selected_nodes->empty()) {
1291 // no path selected
1292 gtk_action_set_sensitive(xact, FALSE);
1293 gtk_action_set_sensitive(yact, FALSE);
1294 } else {
1295 gtk_action_set_sensitive(xact, TRUE);
1296 gtk_action_set_sensitive(yact, TRUE);
1297 Geom::Coord oldx = sp_units_get_pixels(gtk_adjustment_get_value(xadj), *unit);
1298 Geom::Coord oldy = sp_units_get_pixels(gtk_adjustment_get_value(xadj), *unit);
1299 Geom::Point mid = nt->_selected_nodes->pointwiseBounds()->midpoint();
1301 if (oldx != mid[Geom::X]) {
1302 gtk_adjustment_set_value(xadj, sp_pixels_get_units(mid[Geom::X], *unit));
1303 }
1304 if (oldy != mid[Geom::Y]) {
1305 gtk_adjustment_set_value(yadj, sp_pixels_get_units(mid[Geom::Y], *unit));
1306 }
1307 }
1309 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
1310 }
1312 static void sp_node_path_value_changed(GtkAdjustment *adj, GObject *tbl, Geom::Dim2 d)
1313 {
1314 SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
1315 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1317 UnitTracker* tracker = reinterpret_cast<UnitTracker*>(g_object_get_data( tbl, "tracker" ));
1318 SPUnit const *unit = tracker->getActiveUnit();
1320 if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
1321 prefs->setDouble(Glib::ustring("/tools/nodes/") + (d == Geom::X ? "x" : "y"),
1322 sp_units_get_pixels(adj->value, *unit));
1323 }
1325 // quit if run by the attr_changed listener
1326 if (g_object_get_data( tbl, "freeze" )) {
1327 return;
1328 }
1330 // in turn, prevent listener from responding
1331 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE));
1333 InkNodeTool *nt = get_node_tool();
1334 if (nt && !nt->_selected_nodes->empty()) {
1335 double val = sp_units_get_pixels(gtk_adjustment_get_value(adj), *unit);
1336 double oldval = nt->_selected_nodes->pointwiseBounds()->midpoint()[d];
1337 Geom::Point delta(0,0);
1338 delta[d] = val - oldval;
1339 nt->_multipath->move(delta);
1340 }
1342 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
1343 }
1345 static void sp_node_path_x_value_changed(GtkAdjustment *adj, GObject *tbl)
1346 {
1347 sp_node_path_value_changed(adj, tbl, Geom::X);
1348 }
1350 static void sp_node_path_y_value_changed(GtkAdjustment *adj, GObject *tbl)
1351 {
1352 sp_node_path_value_changed(adj, tbl, Geom::Y);
1353 }
1355 static void sp_node_toolbox_sel_changed(Inkscape::Selection *selection, GObject *tbl)
1356 {
1357 {
1358 GtkAction* w = GTK_ACTION( g_object_get_data( tbl, "nodes_lpeedit" ) );
1359 SPItem *item = selection->singleItem();
1360 if (item && SP_IS_LPE_ITEM(item)) {
1361 if (sp_lpe_item_has_path_effect(SP_LPE_ITEM(item))) {
1362 gtk_action_set_sensitive(w, TRUE);
1363 } else {
1364 gtk_action_set_sensitive(w, FALSE);
1365 }
1366 } else {
1367 gtk_action_set_sensitive(w, FALSE);
1368 }
1369 }
1370 }
1372 static void sp_node_toolbox_sel_modified(Inkscape::Selection *selection, guint /*flags*/, GObject *tbl)
1373 {
1374 sp_node_toolbox_sel_changed (selection, tbl);
1375 }
1379 //################################
1380 //## Node Editing Toolbox ##
1381 //################################
1383 static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
1384 {
1385 UnitTracker* tracker = new UnitTracker( SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE );
1386 tracker->setActiveUnit( sp_desktop_namedview(desktop)->doc_units );
1387 g_object_set_data( holder, "tracker", tracker );
1389 Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
1391 {
1392 InkAction* inky = ink_action_new( "NodeInsertAction",
1393 _("Insert node"),
1394 _("Insert new nodes into selected segments"),
1395 INKSCAPE_ICON_NODE_ADD,
1396 secondarySize );
1397 g_object_set( inky, "short_label", _("Insert"), NULL );
1398 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_add), 0 );
1399 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1400 }
1402 {
1403 InkAction* inky = ink_action_new( "NodeDeleteAction",
1404 _("Delete node"),
1405 _("Delete selected nodes"),
1406 INKSCAPE_ICON_NODE_DELETE,
1407 secondarySize );
1408 g_object_set( inky, "short_label", _("Delete"), NULL );
1409 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_delete), 0 );
1410 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1411 }
1413 {
1414 InkAction* inky = ink_action_new( "NodeJoinAction",
1415 _("Join nodes"),
1416 _("Join selected nodes"),
1417 INKSCAPE_ICON_NODE_JOIN,
1418 secondarySize );
1419 g_object_set( inky, "short_label", _("Join"), NULL );
1420 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_join), 0 );
1421 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1422 }
1424 {
1425 InkAction* inky = ink_action_new( "NodeBreakAction",
1426 _("Break nodes"),
1427 _("Break path at selected nodes"),
1428 INKSCAPE_ICON_NODE_BREAK,
1429 secondarySize );
1430 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_break), 0 );
1431 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1432 }
1435 {
1436 InkAction* inky = ink_action_new( "NodeJoinSegmentAction",
1437 _("Join with segment"),
1438 _("Join selected endnodes with a new segment"),
1439 INKSCAPE_ICON_NODE_JOIN_SEGMENT,
1440 secondarySize );
1441 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_join_segment), 0 );
1442 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1443 }
1445 {
1446 InkAction* inky = ink_action_new( "NodeDeleteSegmentAction",
1447 _("Delete segment"),
1448 _("Delete segment between two non-endpoint nodes"),
1449 INKSCAPE_ICON_NODE_DELETE_SEGMENT,
1450 secondarySize );
1451 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_delete_segment), 0 );
1452 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1453 }
1455 {
1456 InkAction* inky = ink_action_new( "NodeCuspAction",
1457 _("Node Cusp"),
1458 _("Make selected nodes corner"),
1459 INKSCAPE_ICON_NODE_TYPE_CUSP,
1460 secondarySize );
1461 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_cusp), 0 );
1462 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1463 }
1465 {
1466 InkAction* inky = ink_action_new( "NodeSmoothAction",
1467 _("Node Smooth"),
1468 _("Make selected nodes smooth"),
1469 INKSCAPE_ICON_NODE_TYPE_SMOOTH,
1470 secondarySize );
1471 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_smooth), 0 );
1472 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1473 }
1475 {
1476 InkAction* inky = ink_action_new( "NodeSymmetricAction",
1477 _("Node Symmetric"),
1478 _("Make selected nodes symmetric"),
1479 INKSCAPE_ICON_NODE_TYPE_SYMMETRIC,
1480 secondarySize );
1481 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_symmetrical), 0 );
1482 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1483 }
1485 {
1486 InkAction* inky = ink_action_new( "NodeAutoAction",
1487 _("Node Auto"),
1488 _("Make selected nodes auto-smooth"),
1489 INKSCAPE_ICON_NODE_TYPE_AUTO_SMOOTH,
1490 secondarySize );
1491 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_auto), 0 );
1492 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1493 }
1495 {
1496 InkAction* inky = ink_action_new( "NodeLineAction",
1497 _("Node Line"),
1498 _("Make selected segments lines"),
1499 INKSCAPE_ICON_NODE_SEGMENT_LINE,
1500 secondarySize );
1501 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_toline), 0 );
1502 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1503 }
1505 {
1506 InkAction* inky = ink_action_new( "NodeCurveAction",
1507 _("Node Curve"),
1508 _("Make selected segments curves"),
1509 INKSCAPE_ICON_NODE_SEGMENT_CURVE,
1510 secondarySize );
1511 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_tocurve), 0 );
1512 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1513 }
1515 {
1516 InkToggleAction* act = ink_toggle_action_new( "NodesShowTransformHandlesAction",
1517 _("Show Transform Handles"),
1518 _("Show transformation handles for selected nodes"),
1519 "node-transform",
1520 secondarySize );
1521 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
1522 PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/nodes/show_transform_handles");
1523 g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
1524 }
1526 {
1527 InkToggleAction* act = ink_toggle_action_new( "NodesShowHandlesAction",
1528 _("Show Handles"),
1529 _("Show Bezier handles of selected nodes"),
1530 INKSCAPE_ICON_SHOW_NODE_HANDLES,
1531 secondarySize );
1532 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
1533 PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/nodes/show_handles");
1534 g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
1535 }
1537 {
1538 InkToggleAction* act = ink_toggle_action_new( "NodesShowHelperpath",
1539 _("Show Outline"),
1540 _("Show path outline (without path effects)"),
1541 INKSCAPE_ICON_SHOW_PATH_OUTLINE,
1542 secondarySize );
1543 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
1544 PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/nodes/show_outline");
1545 g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
1546 }
1548 {
1549 InkAction* inky = ink_action_new( "EditNextLPEParameterAction",
1550 _("Next path effect parameter"),
1551 _("Show next editable path effect parameter"),
1552 INKSCAPE_ICON_PATH_EFFECT_PARAMETER_NEXT,
1553 secondarySize );
1554 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_nextLPEparam), desktop );
1555 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1556 g_object_set_data( holder, "nodes_lpeedit", inky);
1557 }
1559 {
1560 InkToggleAction* inky = ink_toggle_action_new( "ObjectEditClipPathAction",
1561 _("Edit clipping paths"),
1562 _("Show clipping path(s) of selected object(s)"),
1563 INKSCAPE_ICON_PATH_CLIP_EDIT,
1564 secondarySize );
1565 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1566 PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(inky), "/tools/nodes/edit_clipping_paths");
1567 g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
1568 }
1570 {
1571 InkToggleAction* inky = ink_toggle_action_new( "ObjectEditMaskPathAction",
1572 _("Edit masks"),
1573 _("Show mask(s) of selected object(s)"),
1574 INKSCAPE_ICON_PATH_MASK_EDIT,
1575 secondarySize );
1576 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
1577 PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(inky), "/tools/nodes/edit_masks");
1578 g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
1579 }
1581 /* X coord of selected node(s) */
1582 {
1583 EgeAdjustmentAction* eact = 0;
1584 gchar const* labels[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1585 gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
1586 eact = create_adjustment_action( "NodeXAction",
1587 _("X coordinate:"), _("X:"), _("X coordinate of selected node(s)"),
1588 "/tools/nodes/Xcoord", 0,
1589 GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, TRUE, "altx-nodes",
1590 -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
1591 labels, values, G_N_ELEMENTS(labels),
1592 sp_node_path_x_value_changed );
1593 tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );
1594 g_object_set_data( holder, "nodes_x_action", eact );
1595 gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
1596 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
1597 }
1599 /* Y coord of selected node(s) */
1600 {
1601 EgeAdjustmentAction* eact = 0;
1602 gchar const* labels[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1603 gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
1604 eact = create_adjustment_action( "NodeYAction",
1605 _("Y coordinate:"), _("Y:"), _("Y coordinate of selected node(s)"),
1606 "/tools/nodes/Ycoord", 0,
1607 GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL,
1608 -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
1609 labels, values, G_N_ELEMENTS(labels),
1610 sp_node_path_y_value_changed );
1611 tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );
1612 g_object_set_data( holder, "nodes_y_action", eact );
1613 gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
1614 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
1615 }
1617 // add the units menu
1618 {
1619 GtkAction* act = tracker->createAction( "NodeUnitsAction", _("Units"), ("") );
1620 gtk_action_group_add_action( mainActions, act );
1621 }
1624 sp_node_toolbox_sel_changed(sp_desktop_selection(desktop), holder);
1626 //watch selection
1627 Inkscape::ConnectionPool* pool = Inkscape::ConnectionPool::new_connection_pool ("ISNodeToolbox");
1629 sigc::connection *c_selection_changed =
1630 new sigc::connection (sp_desktop_selection (desktop)->connectChanged
1631 (sigc::bind (sigc::ptr_fun (sp_node_toolbox_sel_changed), (GObject*)holder)));
1632 pool->add_connection ("selection-changed", c_selection_changed);
1634 sigc::connection *c_selection_modified =
1635 new sigc::connection (sp_desktop_selection (desktop)->connectModified
1636 (sigc::bind (sigc::ptr_fun (sp_node_toolbox_sel_modified), (GObject*)holder)));
1637 pool->add_connection ("selection-modified", c_selection_modified);
1639 sigc::connection *c_subselection_changed =
1640 new sigc::connection (desktop->connectToolSubselectionChanged
1641 (sigc::bind (sigc::ptr_fun (sp_node_toolbox_coord_changed), (GObject*)holder)));
1642 pool->add_connection ("tool-subselection-changed", c_subselection_changed);
1644 Inkscape::ConnectionPool::connect_destroy (G_OBJECT (holder), pool);
1646 g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );
1647 } // end of sp_node_toolbox_prep()
1650 //########################
1651 //## Zoom Toolbox ##
1652 //########################
1654 static void sp_zoom_toolbox_prep(SPDesktop * /*desktop*/, GtkActionGroup* /*mainActions*/, GObject* /*holder*/)
1655 {
1656 // no custom GtkAction setup needed
1657 } // end of sp_zoom_toolbox_prep()
1659 void ToolboxFactory::setToolboxDesktop(GtkWidget *toolbox, SPDesktop *desktop)
1660 {
1661 sigc::connection *conn = static_cast<sigc::connection*>(g_object_get_data(G_OBJECT(toolbox),
1662 "event_context_connection"));
1664 BarId id = static_cast<BarId>( GPOINTER_TO_INT(g_object_get_data(G_OBJECT(toolbox), BAR_ID_KEY)) );
1666 SetupFunction setup_func = 0;
1667 UpdateFunction update_func = 0;
1669 switch (id) {
1670 case BAR_TOOL:
1671 setup_func = setup_tool_toolbox;
1672 update_func = update_tool_toolbox;
1673 break;
1675 case BAR_AUX:
1676 toolbox = gtk_bin_get_child(GTK_BIN(toolbox));
1677 setup_func = setup_aux_toolbox;
1678 update_func = update_aux_toolbox;
1679 break;
1681 case BAR_COMMANDS:
1682 setup_func = setup_commands_toolbox;
1683 update_func = update_commands_toolbox;
1684 break;
1686 case BAR_SNAP:
1687 setup_func = setup_snap_toolbox;
1688 update_func = updateSnapToolbox;
1689 break;
1690 default:
1691 g_warning("Unexpected toolbox id encountered.");
1692 }
1694 gpointer ptr = g_object_get_data(G_OBJECT(toolbox), "desktop");
1695 SPDesktop *old_desktop = static_cast<SPDesktop*>(ptr);
1697 if (old_desktop) {
1698 GList *children, *iter;
1700 children = gtk_container_get_children(GTK_CONTAINER(toolbox));
1701 for ( iter = children ; iter ; iter = iter->next ) {
1702 gtk_container_remove( GTK_CONTAINER(toolbox), GTK_WIDGET(iter->data) );
1703 }
1704 g_list_free(children);
1705 }
1707 g_object_set_data(G_OBJECT(toolbox), "desktop", (gpointer)desktop);
1709 if (desktop && setup_func && update_func) {
1710 gtk_widget_set_sensitive(toolbox, TRUE);
1711 setup_func(toolbox, desktop);
1712 update_func(desktop, desktop->event_context, toolbox);
1713 *conn = desktop->connectEventContextChanged(sigc::bind (sigc::ptr_fun(update_func), toolbox));
1714 } else {
1715 gtk_widget_set_sensitive(toolbox, FALSE);
1716 }
1718 } // end of sp_toolbox_set_desktop()
1721 static void setupToolboxCommon( GtkWidget *toolbox,
1722 SPDesktop *desktop,
1723 gchar const *descr,
1724 gchar const* toolbarName,
1725 gchar const* sizePref )
1726 {
1727 Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions( desktop );
1728 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1730 GtkUIManager* mgr = gtk_ui_manager_new();
1731 GError* errVal = 0;
1733 GtkOrientation orientation = GTK_ORIENTATION_HORIZONTAL;
1735 gtk_ui_manager_insert_action_group( mgr, mainActions->gobj(), 0 );
1736 gtk_ui_manager_add_ui_from_string( mgr, descr, -1, &errVal );
1738 GtkWidget* toolBar = gtk_ui_manager_get_widget( mgr, toolbarName );
1739 if ( prefs->getBool("/toolbox/icononly", true) ) {
1740 gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS );
1741 }
1743 Inkscape::IconSize toolboxSize = ToolboxFactory::prefToSize(sizePref);
1744 gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), static_cast<GtkIconSize>(toolboxSize) );
1746 if (GTK_IS_HANDLE_BOX(toolbox)) {
1747 // g_message("GRABBING ORIENTATION [%s]", toolbarName);
1748 GtkPositionType pos = gtk_handle_box_get_handle_position(GTK_HANDLE_BOX(toolbox));
1749 orientation = ((pos == GTK_POS_LEFT) || (pos == GTK_POS_RIGHT)) ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL;
1750 } else {
1751 GtkPositionType pos = static_cast<GtkPositionType>(GPOINTER_TO_INT(g_object_get_data( G_OBJECT(toolbox), HANDLE_POS_MARK )));
1752 orientation = ((pos == GTK_POS_LEFT) || (pos == GTK_POS_RIGHT)) ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL;
1753 }
1754 gtk_toolbar_set_orientation(GTK_TOOLBAR(toolBar), orientation);
1755 gtk_toolbar_set_show_arrow(GTK_TOOLBAR(toolBar), TRUE);
1757 g_object_set_data(G_OBJECT(toolBar), "desktop", NULL);
1759 GtkWidget* child = gtk_bin_get_child(GTK_BIN(toolbox));
1760 if ( child ) {
1761 gtk_container_remove( GTK_CONTAINER(toolbox), child );
1762 }
1764 gtk_container_add( GTK_CONTAINER(toolbox), toolBar );
1765 }
1767 #define noDUMP_DETAILS 1
1769 void ToolboxFactory::setOrientation(GtkWidget* toolbox, GtkOrientation orientation)
1770 {
1771 #if DUMP_DETAILS
1772 g_message("Set orientation for %p to be %d", toolbox, orientation);
1773 GType type = GTK_WIDGET_TYPE(toolbox);
1774 g_message(" [%s]", g_type_name(type));
1775 g_message(" %p", g_object_get_data(G_OBJECT(toolbox), BAR_ID_KEY));
1776 #endif
1778 GtkPositionType pos = (orientation == GTK_ORIENTATION_HORIZONTAL) ? GTK_POS_LEFT : GTK_POS_TOP;
1779 GtkHandleBox* handleBox = 0;
1781 if (GTK_IS_BIN(toolbox)) {
1782 #if DUMP_DETAILS
1783 g_message(" is a BIN");
1784 #endif // DUMP_DETAILS
1785 GtkWidget* child = gtk_bin_get_child(GTK_BIN(toolbox));
1786 if (child) {
1787 #if DUMP_DETAILS
1788 GType type2 = GTK_WIDGET_TYPE(child);
1789 g_message(" child [%s]", g_type_name(type2));
1790 #endif // DUMP_DETAILS
1792 if (GTK_IS_BOX(child)) {
1793 #if DUMP_DETAILS
1794 g_message(" is a BOX");
1795 #endif // DUMP_DETAILS
1797 GList* children = gtk_container_get_children(GTK_CONTAINER(child));
1798 if (children) {
1799 for (GList* curr = children; curr; curr = g_list_next(curr)) {
1800 GtkWidget* child2 = GTK_WIDGET(curr->data);
1801 #if DUMP_DETAILS
1802 GType type3 = GTK_WIDGET_TYPE(child2);
1803 g_message(" child2 [%s]", g_type_name(type3));
1804 #endif // DUMP_DETAILS
1806 if (GTK_IS_CONTAINER(child2)) {
1807 GList* children2 = gtk_container_get_children(GTK_CONTAINER(child2));
1808 if (children2) {
1809 for (GList* curr2 = children2; curr2; curr2 = g_list_next(curr2)) {
1810 GtkWidget* child3 = GTK_WIDGET(curr2->data);
1811 #if DUMP_DETAILS
1812 GType type4 = GTK_WIDGET_TYPE(child3);
1813 g_message(" child3 [%s]", g_type_name(type4));
1814 #endif // DUMP_DETAILS
1815 if (GTK_IS_TOOLBAR(child3)) {
1816 GtkToolbar* childBar = GTK_TOOLBAR(child3);
1817 gtk_toolbar_set_orientation(childBar, orientation);
1818 }
1819 }
1820 g_list_free(children2);
1821 }
1822 }
1825 if (GTK_IS_TOOLBAR(child2)) {
1826 GtkToolbar* childBar = GTK_TOOLBAR(child2);
1827 gtk_toolbar_set_orientation(childBar, orientation);
1828 if (GTK_IS_HANDLE_BOX(toolbox)) {
1829 handleBox = GTK_HANDLE_BOX(toolbox);
1830 }
1831 } else {
1832 g_message("need to add dynamic switch");
1833 }
1834 }
1835 g_list_free(children);
1836 } else {
1837 // The call is being made before the toolbox proper has been setup.
1838 if (GTK_IS_HANDLE_BOX(toolbox)) {
1839 handleBox = GTK_HANDLE_BOX(toolbox);
1840 } else {
1841 g_object_set_data(G_OBJECT(toolbox), HANDLE_POS_MARK, GINT_TO_POINTER(pos));
1842 }
1843 }
1844 } else if (GTK_IS_TOOLBAR(child)) {
1845 GtkToolbar* toolbar = GTK_TOOLBAR(child);
1846 gtk_toolbar_set_orientation( toolbar, orientation );
1847 if (GTK_IS_HANDLE_BOX(toolbox)) {
1848 handleBox = GTK_HANDLE_BOX(toolbox);
1849 }
1850 }
1851 }
1852 }
1854 if (handleBox) {
1855 gtk_handle_box_set_handle_position(handleBox, pos);
1856 }
1857 }
1859 void setup_tool_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
1860 {
1861 gchar const * descr =
1862 "<ui>"
1863 " <toolbar name='ToolToolbar'>"
1865 " <!-- Basics -->"
1866 " <toolitem action='ToolSelector' />"
1867 " <toolitem action='ToolNode' />"
1868 " <toolitem action='ToolTweak' />"
1869 " <toolitem action='ToolZoom' />"
1871 " <!-- Shapes -->"
1872 " <toolitem action='ToolRect' />"
1873 " <toolitem action='Tool3DBox' />"
1874 " <toolitem action='ToolArc' />"
1875 " <toolitem action='ToolStar' />"
1876 " <toolitem action='ToolSpiral' />"
1878 " <!-- Paths -->"
1879 " <toolitem action='ToolPencil' />"
1880 " <toolitem action='ToolPen' />"
1881 " <toolitem action='ToolCalligraphic' />"
1883 " <!-- Text -->"
1884 " <toolitem action='ToolText' />"
1886 " <!-- Paint large areas -->"
1887 " <toolitem action='ToolSpray' />"
1888 " <toolitem action='ToolEraser' />"
1890 " <!-- Fill -->"
1891 " <toolitem action='ToolPaintBucket' />"
1892 " <toolitem action='ToolGradient' />"
1893 " <toolitem action='ToolDropper' />"
1895 " <toolitem action='ToolConnector' />"
1897 // " <toolitem action='ToolLPETool' />"
1898 " </toolbar>"
1899 "</ui>";
1901 setupToolboxCommon( toolbox, desktop, descr,
1902 "/ui/ToolToolbar",
1903 "/toolbox/tools/small");
1904 }
1906 void update_tool_toolbox( SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget * /*toolbox*/ )
1907 {
1908 gchar const *const tname = ( eventcontext
1909 ? gtk_type_name(GTK_OBJECT_TYPE(eventcontext))
1910 : NULL );
1911 Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions( desktop );
1913 for (int i = 0 ; tools[i].type_name ; i++ ) {
1914 Glib::RefPtr<Gtk::Action> act = mainActions->get_action( Inkscape::Verb::get(tools[i].verb)->get_id() );
1915 if ( act ) {
1916 bool setActive = tname && !strcmp(tname, tools[i].type_name);
1917 Glib::RefPtr<VerbAction> verbAct = Glib::RefPtr<VerbAction>::cast_dynamic(act);
1918 if ( verbAct ) {
1919 verbAct->set_active(setActive);
1920 }
1921 }
1922 }
1923 }
1925 void setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
1926 {
1927 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1928 GtkSizeGroup* grouper = gtk_size_group_new( GTK_SIZE_GROUP_BOTH );
1929 Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions( desktop );
1930 GtkUIManager* mgr = gtk_ui_manager_new();
1931 GError* errVal = 0;
1932 gtk_ui_manager_insert_action_group( mgr, mainActions->gobj(), 0 );
1933 gtk_ui_manager_add_ui_from_string( mgr, ui_descr, -1, &errVal );
1935 std::map<std::string, GtkWidget*> dataHolders;
1937 for (int i = 0 ; aux_toolboxes[i].type_name ; i++ ) {
1938 if ( aux_toolboxes[i].prep_func ) {
1939 // converted to GtkActions and UIManager
1941 GtkWidget* kludge = gtk_toolbar_new();
1942 g_object_set_data( G_OBJECT(kludge), "dtw", desktop->canvas);
1943 g_object_set_data( G_OBJECT(kludge), "desktop", desktop);
1944 dataHolders[aux_toolboxes[i].type_name] = kludge;
1945 aux_toolboxes[i].prep_func( desktop, mainActions->gobj(), G_OBJECT(kludge) );
1946 } else {
1948 GtkWidget *sub_toolbox = 0;
1949 if (aux_toolboxes[i].create_func == NULL) {
1950 sub_toolbox = sp_empty_toolbox_new(desktop);
1951 } else {
1952 sub_toolbox = aux_toolboxes[i].create_func(desktop);
1953 }
1955 gtk_size_group_add_widget( grouper, sub_toolbox );
1957 gtk_container_add(GTK_CONTAINER(toolbox), sub_toolbox);
1958 g_object_set_data(G_OBJECT(toolbox), aux_toolboxes[i].data_name, sub_toolbox);
1960 }
1961 }
1963 // Second pass to create toolbars *after* all GtkActions are created
1964 for (int i = 0 ; aux_toolboxes[i].type_name ; i++ ) {
1965 if ( aux_toolboxes[i].prep_func ) {
1966 // converted to GtkActions and UIManager
1968 GtkWidget* kludge = dataHolders[aux_toolboxes[i].type_name];
1970 GtkWidget* holder = gtk_table_new( 1, 3, FALSE );
1971 gtk_table_attach( GTK_TABLE(holder), kludge, 2, 3, 0, 1, GTK_SHRINK, GTK_SHRINK, 0, 0 );
1973 gchar* tmp = g_strdup_printf( "/ui/%s", aux_toolboxes[i].ui_name );
1974 GtkWidget* toolBar = gtk_ui_manager_get_widget( mgr, tmp );
1975 g_free( tmp );
1976 tmp = 0;
1978 if ( prefs->getBool( "/toolbox/icononly", true) ) {
1979 gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS );
1980 }
1982 Inkscape::IconSize toolboxSize = ToolboxFactory::prefToSize("/toolbox/small");
1983 gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), static_cast<GtkIconSize>(toolboxSize) );
1985 gtk_table_attach( GTK_TABLE(holder), toolBar, 0, 1, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0 );
1987 if ( aux_toolboxes[i].swatch_verb_id != SP_VERB_INVALID ) {
1988 Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch( NULL, _(aux_toolboxes[i].swatch_tip) );
1989 swatch->setDesktop( desktop );
1990 swatch->setClickVerb( aux_toolboxes[i].swatch_verb_id );
1991 swatch->setWatchedTool( aux_toolboxes[i].swatch_tool, true );
1992 GtkWidget *swatch_ = GTK_WIDGET( swatch->gobj() );
1993 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 );
1994 }
1996 gtk_widget_show_all( holder );
1997 sp_set_font_size_smaller( holder );
1999 gtk_size_group_add_widget( grouper, holder );
2001 gtk_container_add( GTK_CONTAINER(toolbox), holder );
2002 g_object_set_data( G_OBJECT(toolbox), aux_toolboxes[i].data_name, holder );
2003 }
2004 }
2006 g_object_unref( G_OBJECT(grouper) );
2007 }
2009 void update_aux_toolbox(SPDesktop * /*desktop*/, SPEventContext *eventcontext, GtkWidget *toolbox)
2010 {
2011 gchar const *tname = ( eventcontext
2012 ? gtk_type_name(GTK_OBJECT_TYPE(eventcontext))
2013 : NULL );
2014 for (int i = 0 ; aux_toolboxes[i].type_name ; i++ ) {
2015 GtkWidget *sub_toolbox = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbox), aux_toolboxes[i].data_name));
2016 if (tname && !strcmp(tname, aux_toolboxes[i].type_name)) {
2017 gtk_widget_show_all(sub_toolbox);
2018 g_object_set_data(G_OBJECT(toolbox), "shows", sub_toolbox);
2019 } else {
2020 gtk_widget_hide(sub_toolbox);
2021 }
2022 }
2023 }
2025 void setup_commands_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
2026 {
2027 gchar const * descr =
2028 "<ui>"
2029 " <toolbar name='CommandsToolbar'>"
2030 " <toolitem action='FileNew' />"
2031 " <toolitem action='FileOpen' />"
2032 " <toolitem action='FileSave' />"
2033 " <toolitem action='FilePrint' />"
2034 " <separator />"
2035 " <toolitem action='FileImport' />"
2036 " <toolitem action='FileExport' />"
2037 " <separator />"
2038 " <toolitem action='EditUndo' />"
2039 " <toolitem action='EditRedo' />"
2040 " <separator />"
2041 " <toolitem action='EditCopy' />"
2042 " <toolitem action='EditCut' />"
2043 " <toolitem action='EditPaste' />"
2044 " <separator />"
2045 " <toolitem action='ZoomSelection' />"
2046 " <toolitem action='ZoomDrawing' />"
2047 " <toolitem action='ZoomPage' />"
2048 " <separator />"
2049 " <toolitem action='EditDuplicate' />"
2050 " <toolitem action='EditClone' />"
2051 " <toolitem action='EditUnlinkClone' />"
2052 " <separator />"
2053 " <toolitem action='SelectionGroup' />"
2054 " <toolitem action='SelectionUnGroup' />"
2055 " <separator />"
2056 " <toolitem action='DialogFillStroke' />"
2057 " <toolitem action='DialogText' />"
2058 " <toolitem action='DialogLayers' />"
2059 " <toolitem action='DialogXMLEditor' />"
2060 " <toolitem action='DialogAlignDistribute' />"
2061 " <separator />"
2062 " <toolitem action='DialogPreferences' />"
2063 " <toolitem action='DialogDocumentProperties' />"
2064 #if ENABLE_TASK_SUPPORT
2065 " <separator />"
2066 " <toolitem action='TaskSetAction' />"
2067 #endif // ENABLE_TASK_SUPPORT
2068 " </toolbar>"
2069 "</ui>";
2071 setupToolboxCommon( toolbox, desktop, descr,
2072 "/ui/CommandsToolbar",
2073 "/toolbox/small" );
2074 }
2076 void update_commands_toolbox(SPDesktop * /*desktop*/, SPEventContext * /*eventcontext*/, GtkWidget * /*toolbox*/)
2077 {
2078 }
2080 static void toggle_snap_callback(GtkToggleAction *act, gpointer data) //data points to the toolbox
2081 {
2082 if (g_object_get_data(G_OBJECT(data), "freeze" )) {
2083 return;
2084 }
2086 gpointer ptr = g_object_get_data(G_OBJECT(data), "desktop");
2087 g_assert(ptr != NULL);
2089 SPDesktop *dt = reinterpret_cast<SPDesktop*>(ptr);
2090 SPNamedView *nv = sp_desktop_namedview(dt);
2091 SPDocument *doc = SP_OBJECT_DOCUMENT(nv);
2093 if (dt == NULL || nv == NULL) {
2094 g_warning("No desktop or namedview specified (in toggle_snap_callback)!");
2095 return;
2096 }
2098 Inkscape::XML::Node *repr = SP_OBJECT_REPR(nv);
2100 if (repr == NULL) {
2101 g_warning("This namedview doesn't have a xml representation attached!");
2102 return;
2103 }
2105 bool saved = sp_document_get_undo_sensitive(doc);
2106 sp_document_set_undo_sensitive(doc, false);
2108 bool v = false;
2109 SPAttributeEnum attr = (SPAttributeEnum) GPOINTER_TO_INT(g_object_get_data(G_OBJECT(act), "SP_ATTR_INKSCAPE"));
2111 switch (attr) {
2112 case SP_ATTR_INKSCAPE_SNAP_GLOBAL:
2113 dt->toggleSnapGlobal();
2114 break;
2115 case SP_ATTR_INKSCAPE_SNAP_BBOX:
2116 v = nv->snap_manager.snapprefs.getSnapModeBBox();
2117 sp_repr_set_boolean(repr, "inkscape:snap-bbox", !v);
2118 break;
2119 case SP_ATTR_INKSCAPE_BBOX_PATHS:
2120 v = nv->snap_manager.snapprefs.getSnapToBBoxPath();
2121 sp_repr_set_boolean(repr, "inkscape:bbox-paths", !v);
2122 break;
2123 case SP_ATTR_INKSCAPE_BBOX_NODES:
2124 v = nv->snap_manager.snapprefs.getSnapToBBoxNode();
2125 sp_repr_set_boolean(repr, "inkscape:bbox-nodes", !v);
2126 break;
2127 case SP_ATTR_INKSCAPE_SNAP_NODES:
2128 v = nv->snap_manager.snapprefs.getSnapModeNode();
2129 sp_repr_set_boolean(repr, "inkscape:snap-nodes", !v);
2130 break;
2131 case SP_ATTR_INKSCAPE_OBJECT_PATHS:
2132 v = nv->snap_manager.snapprefs.getSnapToItemPath();
2133 sp_repr_set_boolean(repr, "inkscape:object-paths", !v);
2134 break;
2135 case SP_ATTR_INKSCAPE_OBJECT_NODES:
2136 v = nv->snap_manager.snapprefs.getSnapToItemNode();
2137 sp_repr_set_boolean(repr, "inkscape:object-nodes", !v);
2138 break;
2139 case SP_ATTR_INKSCAPE_SNAP_SMOOTH_NODES:
2140 v = nv->snap_manager.snapprefs.getSnapSmoothNodes();
2141 sp_repr_set_boolean(repr, "inkscape:snap-smooth-nodes", !v);
2142 break;
2143 case SP_ATTR_INKSCAPE_SNAP_INTERS_PATHS:
2144 v = nv->snap_manager.snapprefs.getSnapIntersectionCS();
2145 sp_repr_set_boolean(repr, "inkscape:snap-intersection-paths", !v);
2146 break;
2147 case SP_ATTR_INKSCAPE_SNAP_CENTER:
2148 v = nv->snap_manager.snapprefs.getIncludeItemCenter();
2149 sp_repr_set_boolean(repr, "inkscape:snap-center", !v);
2150 break;
2151 case SP_ATTR_INKSCAPE_SNAP_GRIDS:
2152 v = nv->snap_manager.snapprefs.getSnapToGrids();
2153 sp_repr_set_boolean(repr, "inkscape:snap-grids", !v);
2154 break;
2155 case SP_ATTR_INKSCAPE_SNAP_TO_GUIDES:
2156 v = nv->snap_manager.snapprefs.getSnapToGuides();
2157 sp_repr_set_boolean(repr, "inkscape:snap-to-guides", !v);
2158 break;
2159 case SP_ATTR_INKSCAPE_SNAP_PAGE:
2160 v = nv->snap_manager.snapprefs.getSnapToPageBorder();
2161 sp_repr_set_boolean(repr, "inkscape:snap-page", !v);
2162 break;
2163 /*case SP_ATTR_INKSCAPE_SNAP_INTERS_GRIDGUIDE:
2164 v = nv->snap_manager.snapprefs.getSnapIntersectionGG();
2165 sp_repr_set_boolean(repr, "inkscape:snap-intersection-grid-guide", !v);
2166 break;*/
2167 case SP_ATTR_INKSCAPE_SNAP_LINE_MIDPOINTS:
2168 v = nv->snap_manager.snapprefs.getSnapLineMidpoints();
2169 sp_repr_set_boolean(repr, "inkscape:snap-midpoints", !v);
2170 break;
2171 case SP_ATTR_INKSCAPE_SNAP_OBJECT_MIDPOINTS:
2172 v = nv->snap_manager.snapprefs.getSnapObjectMidpoints();
2173 sp_repr_set_boolean(repr, "inkscape:snap-object-midpoints", !v);
2174 break;
2175 case SP_ATTR_INKSCAPE_SNAP_BBOX_EDGE_MIDPOINTS:
2176 v = nv->snap_manager.snapprefs.getSnapBBoxEdgeMidpoints();
2177 sp_repr_set_boolean(repr, "inkscape:snap-bbox-edge-midpoints", !v);
2178 break;
2179 case SP_ATTR_INKSCAPE_SNAP_BBOX_MIDPOINTS:
2180 v = nv->snap_manager.snapprefs.getSnapBBoxMidpoints();
2181 sp_repr_set_boolean(repr, "inkscape:snap-bbox-midpoints", !v);
2182 break;
2183 default:
2184 g_warning("toggle_snap_callback has been called with an ID for which no action has been defined");
2185 break;
2186 }
2188 // The snapping preferences are stored in the document, and therefore toggling makes the document dirty
2189 doc->setModifiedSinceSave();
2191 sp_document_set_undo_sensitive(doc, saved);
2192 }
2194 void setup_snap_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
2195 {
2196 Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions(desktop);
2198 gchar const * descr =
2199 "<ui>"
2200 " <toolbar name='SnapToolbar'>"
2201 " <toolitem action='ToggleSnapGlobal' />"
2202 " <separator />"
2203 " <toolitem action='ToggleSnapFromBBoxCorner' />"
2204 " <toolitem action='ToggleSnapToBBoxPath' />"
2205 " <toolitem action='ToggleSnapToBBoxNode' />"
2206 " <toolitem action='ToggleSnapToFromBBoxEdgeMidpoints' />"
2207 " <toolitem action='ToggleSnapToFromBBoxCenters' />"
2208 " <separator />"
2209 " <toolitem action='ToggleSnapFromNode' />"
2210 " <toolitem action='ToggleSnapToItemPath' />"
2211 " <toolitem action='ToggleSnapToPathIntersections' />"
2212 " <toolitem action='ToggleSnapToItemNode' />"
2213 " <toolitem action='ToggleSnapToSmoothNodes' />"
2214 " <toolitem action='ToggleSnapToFromLineMidpoints' />"
2215 " <toolitem action='ToggleSnapToFromObjectCenters' />"
2216 " <toolitem action='ToggleSnapToFromRotationCenter' />"
2217 " <separator />"
2218 " <toolitem action='ToggleSnapToPageBorder' />"
2219 " <toolitem action='ToggleSnapToGrids' />"
2220 " <toolitem action='ToggleSnapToGuides' />"
2221 //" <toolitem action='ToggleSnapToGridGuideIntersections' />"
2222 " </toolbar>"
2223 "</ui>";
2225 Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
2227 {
2228 InkToggleAction* act = ink_toggle_action_new("ToggleSnapGlobal",
2229 _("Snap"), _("Enable snapping"), INKSCAPE_ICON_SNAP, secondarySize,
2230 SP_ATTR_INKSCAPE_SNAP_GLOBAL);
2232 gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2233 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2234 }
2236 {
2237 InkToggleAction* act = ink_toggle_action_new("ToggleSnapFromBBoxCorner",
2238 _("Bounding box"), _("Snap bounding box corners"), INKSCAPE_ICON_SNAP_BOUNDING_BOX,
2239 secondarySize, SP_ATTR_INKSCAPE_SNAP_BBOX);
2241 gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2242 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2243 }
2245 {
2246 InkToggleAction* act = ink_toggle_action_new("ToggleSnapToBBoxPath",
2247 _("Bounding box edges"), _("Snap to edges of a bounding box"),
2248 INKSCAPE_ICON_SNAP_BOUNDING_BOX_EDGES, secondarySize, SP_ATTR_INKSCAPE_BBOX_PATHS);
2250 gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2251 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2252 }
2254 {
2255 InkToggleAction* act = ink_toggle_action_new("ToggleSnapToBBoxNode",
2256 _("Bounding box corners"), _("Snap to bounding box corners"),
2257 INKSCAPE_ICON_SNAP_BOUNDING_BOX_CORNERS, secondarySize, SP_ATTR_INKSCAPE_BBOX_NODES);
2259 gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2260 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2261 }
2263 {
2264 InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromBBoxEdgeMidpoints",
2265 _("BBox Edge Midpoints"), _("Snap from and to midpoints of bounding box edges"),
2266 INKSCAPE_ICON_SNAP_BOUNDING_BOX_MIDPOINTS, secondarySize,
2267 SP_ATTR_INKSCAPE_SNAP_BBOX_EDGE_MIDPOINTS);
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("ToggleSnapToFromBBoxCenters",
2275 _("BBox Centers"), _("Snapping from and to centers of bounding boxes"),
2276 INKSCAPE_ICON_SNAP_BOUNDING_BOX_CENTER, secondarySize, SP_ATTR_INKSCAPE_SNAP_BBOX_MIDPOINTS);
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("ToggleSnapFromNode",
2284 _("Nodes"), _("Snap nodes or handles"), INKSCAPE_ICON_SNAP_NODES, secondarySize, SP_ATTR_INKSCAPE_SNAP_NODES);
2286 gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2287 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2288 }
2290 {
2291 InkToggleAction* act = ink_toggle_action_new("ToggleSnapToItemPath",
2292 _("Paths"), _("Snap to paths"), INKSCAPE_ICON_SNAP_NODES_PATH, secondarySize,
2293 SP_ATTR_INKSCAPE_OBJECT_PATHS);
2295 gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2296 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2297 }
2299 {
2300 InkToggleAction* act = ink_toggle_action_new("ToggleSnapToPathIntersections",
2301 _("Path intersections"), _("Snap to path intersections"),
2302 INKSCAPE_ICON_SNAP_NODES_INTERSECTION, secondarySize, SP_ATTR_INKSCAPE_SNAP_INTERS_PATHS);
2304 gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2305 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2306 }
2308 {
2309 InkToggleAction* act = ink_toggle_action_new("ToggleSnapToItemNode",
2310 _("To nodes"), _("Snap to cusp nodes"), INKSCAPE_ICON_SNAP_NODES_CUSP, secondarySize,
2311 SP_ATTR_INKSCAPE_OBJECT_NODES);
2313 gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2314 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2315 }
2317 {
2318 InkToggleAction* act = ink_toggle_action_new("ToggleSnapToSmoothNodes",
2319 _("Smooth nodes"), _("Snap to smooth nodes"), INKSCAPE_ICON_SNAP_NODES_SMOOTH,
2320 secondarySize, SP_ATTR_INKSCAPE_SNAP_SMOOTH_NODES);
2322 gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2323 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2324 }
2326 {
2327 InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromLineMidpoints",
2328 _("Line Midpoints"), _("Snap from and to midpoints of line segments"),
2329 INKSCAPE_ICON_SNAP_NODES_MIDPOINT, secondarySize, SP_ATTR_INKSCAPE_SNAP_LINE_MIDPOINTS);
2331 gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2332 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2333 }
2335 {
2336 InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromObjectCenters",
2337 _("Object Centers"), _("Snap from and to centers of objects"),
2338 INKSCAPE_ICON_SNAP_NODES_CENTER, secondarySize, SP_ATTR_INKSCAPE_SNAP_OBJECT_MIDPOINTS);
2340 gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2341 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2342 }
2344 {
2345 InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromRotationCenter",
2346 _("Rotation Centers"), _("Snap from and to an item's rotation center"),
2347 INKSCAPE_ICON_SNAP_NODES_ROTATION_CENTER, secondarySize, SP_ATTR_INKSCAPE_SNAP_CENTER);
2349 gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2350 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2351 }
2353 {
2354 InkToggleAction* act = ink_toggle_action_new("ToggleSnapToPageBorder",
2355 _("Page border"), _("Snap to the page border"), INKSCAPE_ICON_SNAP_PAGE,
2356 secondarySize, SP_ATTR_INKSCAPE_SNAP_PAGE);
2358 gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2359 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2360 }
2362 {
2363 InkToggleAction* act = ink_toggle_action_new("ToggleSnapToGrids",
2364 _("Grids"), _("Snap to grids"), INKSCAPE_ICON_GRID_RECTANGULAR, secondarySize,
2365 SP_ATTR_INKSCAPE_SNAP_GRIDS);
2367 gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2368 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2369 }
2371 {
2372 InkToggleAction* act = ink_toggle_action_new("ToggleSnapToGuides",
2373 _("Guides"), _("Snap to guides"), INKSCAPE_ICON_GUIDES, secondarySize,
2374 SP_ATTR_INKSCAPE_SNAP_TO_GUIDES);
2376 gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2377 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2378 }
2380 /*{
2381 InkToggleAction* act = ink_toggle_action_new("ToggleSnapToGridGuideIntersections",
2382 _("Grid/guide intersections"), _("Snap to intersections of a grid with a guide"),
2383 INKSCAPE_ICON_SNAP_GRID_GUIDE_INTERSECTIONS, secondarySize,
2384 SP_ATTR_INKSCAPE_SNAP_INTERS_GRIDGUIDE);
2386 gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) );
2387 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox );
2388 }*/
2390 setupToolboxCommon( toolbox, desktop, descr,
2391 "/ui/SnapToolbar",
2392 "/toolbox/secondary" );
2393 }
2395 Glib::ustring ToolboxFactory::getToolboxName(GtkWidget* toolbox)
2396 {
2397 Glib::ustring name;
2398 BarId id = static_cast<BarId>( GPOINTER_TO_INT(g_object_get_data(G_OBJECT(toolbox), BAR_ID_KEY)) );
2399 switch(id) {
2400 case BAR_TOOL:
2401 name = "ToolToolbar";
2402 break;
2403 case BAR_AUX:
2404 name = "AuxToolbar";
2405 break;
2406 case BAR_COMMANDS:
2407 name = "CommandsToolbar";
2408 break;
2409 case BAR_SNAP:
2410 name = "SnapToolbar";
2411 break;
2412 }
2414 return name;
2415 }
2417 void ToolboxFactory::updateSnapToolbox(SPDesktop *desktop, SPEventContext * /*eventcontext*/, GtkWidget *toolbox)
2418 {
2419 g_assert(desktop != NULL);
2420 g_assert(toolbox != NULL);
2422 SPNamedView *nv = sp_desktop_namedview(desktop);
2423 if (nv == NULL) {
2424 g_warning("Namedview cannot be retrieved (in updateSnapToolbox)!");
2425 return;
2426 }
2428 Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions(desktop);
2430 Glib::RefPtr<Gtk::Action> act1 = mainActions->get_action("ToggleSnapGlobal");
2431 Glib::RefPtr<Gtk::Action> act2 = mainActions->get_action("ToggleSnapFromBBoxCorner");
2432 Glib::RefPtr<Gtk::Action> act3 = mainActions->get_action("ToggleSnapToBBoxPath");
2433 Glib::RefPtr<Gtk::Action> act4 = mainActions->get_action("ToggleSnapToBBoxNode");
2434 Glib::RefPtr<Gtk::Action> act4b = mainActions->get_action("ToggleSnapToFromBBoxEdgeMidpoints");
2435 Glib::RefPtr<Gtk::Action> act4c = mainActions->get_action("ToggleSnapToFromBBoxCenters");
2436 Glib::RefPtr<Gtk::Action> act5 = mainActions->get_action("ToggleSnapFromNode");
2437 Glib::RefPtr<Gtk::Action> act6 = mainActions->get_action("ToggleSnapToItemPath");
2438 Glib::RefPtr<Gtk::Action> act6b = mainActions->get_action("ToggleSnapToPathIntersections");
2439 Glib::RefPtr<Gtk::Action> act7 = mainActions->get_action("ToggleSnapToItemNode");
2440 Glib::RefPtr<Gtk::Action> act8 = mainActions->get_action("ToggleSnapToSmoothNodes");
2441 Glib::RefPtr<Gtk::Action> act9 = mainActions->get_action("ToggleSnapToFromLineMidpoints");
2442 Glib::RefPtr<Gtk::Action> act10 = mainActions->get_action("ToggleSnapToFromObjectCenters");
2443 Glib::RefPtr<Gtk::Action> act11 = mainActions->get_action("ToggleSnapToFromRotationCenter");
2444 Glib::RefPtr<Gtk::Action> act12 = mainActions->get_action("ToggleSnapToPageBorder");
2445 //Glib::RefPtr<Gtk::Action> act13 = mainActions->get_action("ToggleSnapToGridGuideIntersections");
2446 Glib::RefPtr<Gtk::Action> act14 = mainActions->get_action("ToggleSnapToGrids");
2447 Glib::RefPtr<Gtk::Action> act15 = mainActions->get_action("ToggleSnapToGuides");
2450 if (!act1) {
2451 return; // The snap actions haven't been defined yet (might be the case during startup)
2452 }
2454 // The ..._set_active calls below will toggle the buttons, but this shouldn't lead to
2455 // changes in our document because we're only updating the UI;
2456 // Setting the "freeze" parameter to true will block the code in toggle_snap_callback()
2457 g_object_set_data(G_OBJECT(toolbox), "freeze", GINT_TO_POINTER(TRUE));
2459 bool const c1 = nv->snap_manager.snapprefs.getSnapEnabledGlobally();
2460 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act1->gobj()), c1);
2462 bool const c2 = nv->snap_manager.snapprefs.getSnapModeBBox();
2463 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act2->gobj()), c2);
2464 gtk_action_set_sensitive(GTK_ACTION(act2->gobj()), c1);
2466 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act3->gobj()), nv->snap_manager.snapprefs.getSnapToBBoxPath());
2467 gtk_action_set_sensitive(GTK_ACTION(act3->gobj()), c1 && c2);
2468 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act4->gobj()), nv->snap_manager.snapprefs.getSnapToBBoxNode());
2469 gtk_action_set_sensitive(GTK_ACTION(act4->gobj()), c1 && c2);
2470 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act4b->gobj()), nv->snap_manager.snapprefs.getSnapBBoxEdgeMidpoints());
2471 gtk_action_set_sensitive(GTK_ACTION(act4b->gobj()), c1 && c2);
2472 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act4c->gobj()), nv->snap_manager.snapprefs.getSnapBBoxMidpoints());
2473 gtk_action_set_sensitive(GTK_ACTION(act4c->gobj()), c1 && c2);
2475 bool const c3 = nv->snap_manager.snapprefs.getSnapModeNode();
2476 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act5->gobj()), c3);
2477 gtk_action_set_sensitive(GTK_ACTION(act5->gobj()), c1);
2479 bool const c4 = nv->snap_manager.snapprefs.getSnapToItemPath();
2480 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act6->gobj()), c4);
2481 gtk_action_set_sensitive(GTK_ACTION(act6->gobj()), c1 && c3);
2482 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act6b->gobj()), nv->snap_manager.snapprefs.getSnapIntersectionCS());
2483 gtk_action_set_sensitive(GTK_ACTION(act6b->gobj()), c1 && c3 && c4);
2484 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act7->gobj()), nv->snap_manager.snapprefs.getSnapToItemNode());
2485 gtk_action_set_sensitive(GTK_ACTION(act7->gobj()), c1 && c3);
2486 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act8->gobj()), nv->snap_manager.snapprefs.getSnapSmoothNodes());
2487 gtk_action_set_sensitive(GTK_ACTION(act8->gobj()), c1 && c3);
2488 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act9->gobj()), nv->snap_manager.snapprefs.getSnapLineMidpoints());
2489 gtk_action_set_sensitive(GTK_ACTION(act9->gobj()), c1 && c3);
2490 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act10->gobj()), nv->snap_manager.snapprefs.getSnapObjectMidpoints());
2491 gtk_action_set_sensitive(GTK_ACTION(act10->gobj()), c1 && c3);
2492 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act11->gobj()), nv->snap_manager.snapprefs.getIncludeItemCenter());
2493 gtk_action_set_sensitive(GTK_ACTION(act11->gobj()), c1 && c3);
2495 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act12->gobj()), nv->snap_manager.snapprefs.getSnapToPageBorder());
2496 gtk_action_set_sensitive(GTK_ACTION(act12->gobj()), c1);
2497 //gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act13->gobj()), nv->snap_manager.snapprefs.getSnapIntersectionGG());
2498 //gtk_action_set_sensitive(GTK_ACTION(act13->gobj()), c1);
2500 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act14->gobj()), nv->snap_manager.snapprefs.getSnapToGrids());
2501 gtk_action_set_sensitive(GTK_ACTION(act14->gobj()), c1);
2502 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act15->gobj()), nv->snap_manager.snapprefs.getSnapToGuides());
2503 gtk_action_set_sensitive(GTK_ACTION(act15->gobj()), c1);
2506 g_object_set_data(G_OBJECT(toolbox), "freeze", GINT_TO_POINTER(FALSE)); // unfreeze (see above)
2507 }
2509 void ToolboxFactory::showAuxToolbox(GtkWidget *toolbox_toplevel)
2510 {
2511 gtk_widget_show(toolbox_toplevel);
2512 GtkWidget *toolbox = gtk_bin_get_child(GTK_BIN(toolbox_toplevel));
2514 GtkWidget *shown_toolbox = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbox), "shows"));
2515 if (!shown_toolbox) {
2516 return;
2517 }
2518 gtk_widget_show(toolbox);
2520 gtk_widget_show_all(shown_toolbox);
2521 }
2523 static GtkWidget *sp_empty_toolbox_new(SPDesktop *desktop)
2524 {
2525 GtkWidget *tbl = gtk_toolbar_new();
2526 gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas);
2527 gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop);
2529 gtk_widget_show_all(tbl);
2530 sp_set_font_size_smaller (tbl);
2532 return tbl;
2533 }
2535 #define MODE_LABEL_WIDTH 70
2537 //########################
2538 //## Star ##
2539 //########################
2541 static void sp_stb_magnitude_value_changed( GtkAdjustment *adj, GObject *dataKludge )
2542 {
2543 SPDesktop *desktop = (SPDesktop *) g_object_get_data( dataKludge, "desktop" );
2545 if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
2546 // do not remember prefs if this call is initiated by an undo change, because undoing object
2547 // creation sets bogus values to its attributes before it is deleted
2548 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
2549 prefs->setInt("/tools/shapes/star/magnitude", (gint)adj->value);
2550 }
2552 // quit if run by the attr_changed listener
2553 if (g_object_get_data( dataKludge, "freeze" )) {
2554 return;
2555 }
2557 // in turn, prevent listener from responding
2558 g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(TRUE) );
2560 bool modmade = false;
2562 Inkscape::Selection *selection = sp_desktop_selection(desktop);
2563 GSList const *items = selection->itemList();
2564 for (; items != NULL; items = items->next) {
2565 if (SP_IS_STAR((SPItem *) items->data)) {
2566 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
2567 sp_repr_set_int(repr,"sodipodi:sides",(gint)adj->value);
2568 sp_repr_set_svg_double(repr, "sodipodi:arg2",
2569 (sp_repr_get_double_attribute(repr, "sodipodi:arg1", 0.5)
2570 + M_PI / (gint)adj->value));
2571 SP_OBJECT((SPItem *) items->data)->updateRepr();
2572 modmade = true;
2573 }
2574 }
2575 if (modmade) {
2576 sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
2577 _("Star: Change number of corners"));
2578 }
2580 g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) );
2581 }
2583 static void sp_stb_proportion_value_changed( GtkAdjustment *adj, GObject *dataKludge )
2584 {
2585 SPDesktop *desktop = (SPDesktop *) g_object_get_data( dataKludge, "desktop" );
2587 if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
2588 if (!IS_NAN(adj->value)) {
2589 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
2590 prefs->setDouble("/tools/shapes/star/proportion", adj->value);
2591 }
2592 }
2594 // quit if run by the attr_changed listener
2595 if (g_object_get_data( dataKludge, "freeze" )) {
2596 return;
2597 }
2599 // in turn, prevent listener from responding
2600 g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(TRUE) );
2602 bool modmade = false;
2603 Inkscape::Selection *selection = sp_desktop_selection(desktop);
2604 GSList const *items = selection->itemList();
2605 for (; items != NULL; items = items->next) {
2606 if (SP_IS_STAR((SPItem *) items->data)) {
2607 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
2609 gdouble r1 = sp_repr_get_double_attribute(repr, "sodipodi:r1", 1.0);
2610 gdouble r2 = sp_repr_get_double_attribute(repr, "sodipodi:r2", 1.0);
2611 if (r2 < r1) {
2612 sp_repr_set_svg_double(repr, "sodipodi:r2", r1*adj->value);
2613 } else {
2614 sp_repr_set_svg_double(repr, "sodipodi:r1", r2*adj->value);
2615 }
2617 SP_OBJECT((SPItem *) items->data)->updateRepr();
2618 modmade = true;
2619 }
2620 }
2622 if (modmade) {
2623 sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
2624 _("Star: Change spoke ratio"));
2625 }
2627 g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) );
2628 }
2630 static void sp_stb_sides_flat_state_changed( EgeSelectOneAction *act, GObject *dataKludge )
2631 {
2632 SPDesktop *desktop = (SPDesktop *) g_object_get_data( dataKludge, "desktop" );
2633 bool flat = ege_select_one_action_get_active( act ) == 0;
2635 if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
2636 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
2637 prefs->setBool( "/tools/shapes/star/isflatsided", flat);
2638 }
2640 // quit if run by the attr_changed listener
2641 if (g_object_get_data( dataKludge, "freeze" )) {
2642 return;
2643 }
2645 // in turn, prevent listener from responding
2646 g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(TRUE) );
2648 Inkscape::Selection *selection = sp_desktop_selection(desktop);
2649 GSList const *items = selection->itemList();
2650 GtkAction* prop_action = GTK_ACTION( g_object_get_data( dataKludge, "prop_action" ) );
2651 bool modmade = false;
2653 if ( prop_action ) {
2654 gtk_action_set_sensitive( prop_action, !flat );
2655 }
2657 for (; items != NULL; items = items->next) {
2658 if (SP_IS_STAR((SPItem *) items->data)) {
2659 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
2660 repr->setAttribute("inkscape:flatsided", flat ? "true" : "false" );
2661 SP_OBJECT((SPItem *) items->data)->updateRepr();
2662 modmade = true;
2663 }
2664 }
2666 if (modmade) {
2667 sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
2668 flat ? _("Make polygon") : _("Make star"));
2669 }
2671 g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) );
2672 }
2674 static void sp_stb_rounded_value_changed( GtkAdjustment *adj, GObject *dataKludge )
2675 {
2676 SPDesktop *desktop = (SPDesktop *) g_object_get_data( dataKludge, "desktop" );
2678 if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
2679 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
2680 prefs->setDouble("/tools/shapes/star/rounded", (gdouble) adj->value);
2681 }
2683 // quit if run by the attr_changed listener
2684 if (g_object_get_data( dataKludge, "freeze" )) {
2685 return;
2686 }
2688 // in turn, prevent listener from responding
2689 g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(TRUE) );
2691 bool modmade = false;
2693 Inkscape::Selection *selection = sp_desktop_selection(desktop);
2694 GSList const *items = selection->itemList();
2695 for (; items != NULL; items = items->next) {
2696 if (SP_IS_STAR((SPItem *) items->data)) {
2697 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
2698 sp_repr_set_svg_double(repr, "inkscape:rounded", (gdouble) adj->value);
2699 SP_OBJECT(items->data)->updateRepr();
2700 modmade = true;
2701 }
2702 }
2703 if (modmade) {
2704 sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
2705 _("Star: Change rounding"));
2706 }
2708 g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) );
2709 }
2711 static void sp_stb_randomized_value_changed( GtkAdjustment *adj, GObject *dataKludge )
2712 {
2713 SPDesktop *desktop = (SPDesktop *) g_object_get_data( dataKludge, "desktop" );
2715 if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
2716 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
2717 prefs->setDouble("/tools/shapes/star/randomized", (gdouble) adj->value);
2718 }
2720 // quit if run by the attr_changed listener
2721 if (g_object_get_data( dataKludge, "freeze" )) {
2722 return;
2723 }
2725 // in turn, prevent listener from responding
2726 g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(TRUE) );
2728 bool modmade = false;
2730 Inkscape::Selection *selection = sp_desktop_selection(desktop);
2731 GSList const *items = selection->itemList();
2732 for (; items != NULL; items = items->next) {
2733 if (SP_IS_STAR((SPItem *) items->data)) {
2734 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
2735 sp_repr_set_svg_double(repr, "inkscape:randomized", (gdouble) adj->value);
2736 SP_OBJECT(items->data)->updateRepr();
2737 modmade = true;
2738 }
2739 }
2740 if (modmade) {
2741 sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
2742 _("Star: Change randomization"));
2743 }
2745 g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) );
2746 }
2749 static void star_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const *name,
2750 gchar const * /*old_value*/, gchar const * /*new_value*/,
2751 bool /*is_interactive*/, gpointer data)
2752 {
2753 GtkWidget *tbl = GTK_WIDGET(data);
2755 // quit if run by the _changed callbacks
2756 if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
2757 return;
2758 }
2760 // in turn, prevent callbacks from responding
2761 g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE));
2763 GtkAdjustment *adj = 0;
2765 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
2766 bool isFlatSided = prefs->getBool("/tools/shapes/star/isflatsided", true);
2768 if (!strcmp(name, "inkscape:randomized")) {
2769 adj = GTK_ADJUSTMENT( gtk_object_get_data(GTK_OBJECT(tbl), "randomized") );
2770 gtk_adjustment_set_value(adj, sp_repr_get_double_attribute(repr, "inkscape:randomized", 0.0));
2771 } else if (!strcmp(name, "inkscape:rounded")) {
2772 adj = GTK_ADJUSTMENT( gtk_object_get_data(GTK_OBJECT(tbl), "rounded") );
2773 gtk_adjustment_set_value(adj, sp_repr_get_double_attribute(repr, "inkscape:rounded", 0.0));
2774 } else if (!strcmp(name, "inkscape:flatsided")) {
2775 GtkAction* prop_action = GTK_ACTION( g_object_get_data(G_OBJECT(tbl), "prop_action") );
2776 char const *flatsides = repr->attribute("inkscape:flatsided");
2777 EgeSelectOneAction* flat_action = EGE_SELECT_ONE_ACTION( g_object_get_data( G_OBJECT(tbl), "flat_action" ) );
2778 if ( flatsides && !strcmp(flatsides,"false") ) {
2779 ege_select_one_action_set_active( flat_action, 1 );
2780 gtk_action_set_sensitive( prop_action, TRUE );
2781 } else {
2782 ege_select_one_action_set_active( flat_action, 0 );
2783 gtk_action_set_sensitive( prop_action, FALSE );
2784 }
2785 } else if ((!strcmp(name, "sodipodi:r1") || !strcmp(name, "sodipodi:r2")) && (!isFlatSided) ) {
2786 adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "proportion");
2787 gdouble r1 = sp_repr_get_double_attribute(repr, "sodipodi:r1", 1.0);
2788 gdouble r2 = sp_repr_get_double_attribute(repr, "sodipodi:r2", 1.0);
2789 if (r2 < r1) {
2790 gtk_adjustment_set_value(adj, r2/r1);
2791 } else {
2792 gtk_adjustment_set_value(adj, r1/r2);
2793 }
2794 } else if (!strcmp(name, "sodipodi:sides")) {
2795 adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "magnitude");
2796 gtk_adjustment_set_value(adj, sp_repr_get_int_attribute(repr, "sodipodi:sides", 0));
2797 }
2799 g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
2800 }
2803 static Inkscape::XML::NodeEventVector star_tb_repr_events =
2804 {
2805 NULL, /* child_added */
2806 NULL, /* child_removed */
2807 star_tb_event_attr_changed,
2808 NULL, /* content_changed */
2809 NULL /* order_changed */
2810 };
2813 /**
2814 * \param selection Should not be NULL.
2815 */
2816 static void
2817 sp_star_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
2818 {
2819 int n_selected = 0;
2820 Inkscape::XML::Node *repr = NULL;
2822 purge_repr_listener( tbl, tbl );
2824 for (GSList const *items = selection->itemList();
2825 items != NULL;
2826 items = items->next)
2827 {
2828 if (SP_IS_STAR((SPItem *) items->data)) {
2829 n_selected++;
2830 repr = SP_OBJECT_REPR((SPItem *) items->data);
2831 }
2832 }
2834 EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) );
2836 if (n_selected == 0) {
2837 g_object_set( G_OBJECT(act), "label", _("<b>New:</b>"), NULL );
2838 } else if (n_selected == 1) {
2839 g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
2841 if (repr) {
2842 g_object_set_data( tbl, "repr", repr );
2843 Inkscape::GC::anchor(repr);
2844 sp_repr_add_listener(repr, &star_tb_repr_events, tbl);
2845 sp_repr_synthesize_events(repr, &star_tb_repr_events, tbl);
2846 }
2847 } else {
2848 // FIXME: implement averaging of all parameters for multiple selected stars
2849 //gtk_label_set_markup(GTK_LABEL(l), _("<b>Average:</b>"));
2850 //gtk_label_set_markup(GTK_LABEL(l), _("<b>Change:</b>"));
2851 }
2852 }
2855 static void sp_stb_defaults( GtkWidget * /*widget*/, GObject *dataKludge )
2856 {
2857 // FIXME: in this and all other _default functions, set some flag telling the value_changed
2858 // callbacks to lump all the changes for all selected objects in one undo step
2860 GtkAdjustment *adj = 0;
2862 // fixme: make settable in prefs!
2863 gint mag = 5;
2864 gdouble prop = 0.5;
2865 gboolean flat = FALSE;
2866 gdouble randomized = 0;
2867 gdouble rounded = 0;
2869 EgeSelectOneAction* flat_action = EGE_SELECT_ONE_ACTION( g_object_get_data( dataKludge, "flat_action" ) );
2870 ege_select_one_action_set_active( flat_action, flat ? 0 : 1 );
2872 GtkAction* sb2 = GTK_ACTION( g_object_get_data( dataKludge, "prop_action" ) );
2873 gtk_action_set_sensitive( sb2, !flat );
2875 adj = GTK_ADJUSTMENT( g_object_get_data( dataKludge, "magnitude" ) );
2876 gtk_adjustment_set_value(adj, mag);
2877 gtk_adjustment_value_changed(adj);
2879 adj = GTK_ADJUSTMENT( g_object_get_data( dataKludge, "proportion" ) );
2880 gtk_adjustment_set_value(adj, prop);
2881 gtk_adjustment_value_changed(adj);
2883 adj = GTK_ADJUSTMENT( g_object_get_data( dataKludge, "rounded" ) );
2884 gtk_adjustment_set_value(adj, rounded);
2885 gtk_adjustment_value_changed(adj);
2887 adj = GTK_ADJUSTMENT( g_object_get_data( dataKludge, "randomized" ) );
2888 gtk_adjustment_set_value(adj, randomized);
2889 gtk_adjustment_value_changed(adj);
2890 }
2893 // public:
2894 void sp_toolbox_add_label(GtkWidget *tbl, gchar const *title, bool wide)
2895 {
2896 GtkWidget *boxl = gtk_hbox_new(FALSE, 0);
2897 if (wide) {
2898 gtk_widget_set_size_request(boxl, MODE_LABEL_WIDTH, -1);
2899 }
2900 GtkWidget *l = gtk_label_new(NULL);
2901 gtk_label_set_markup(GTK_LABEL(l), title);
2902 gtk_box_pack_end(GTK_BOX(boxl), l, FALSE, FALSE, 0);
2903 if ( GTK_IS_TOOLBAR(tbl) ) {
2904 gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), boxl, "", "" );
2905 } else {
2906 gtk_box_pack_start(GTK_BOX(tbl), boxl, FALSE, FALSE, 0);
2907 }
2908 gtk_object_set_data(GTK_OBJECT(tbl), "mode_label", l);
2909 }
2912 static void sp_star_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
2913 {
2914 Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
2916 {
2917 EgeOutputAction* act = ege_output_action_new( "StarStateAction", _("<b>New:</b>"), "", 0 );
2918 ege_output_action_set_use_markup( act, TRUE );
2919 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
2920 g_object_set_data( holder, "mode_action", act );
2921 }
2923 {
2924 EgeAdjustmentAction* eact = 0;
2925 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
2926 bool isFlatSided = prefs->getBool("/tools/shapes/star/isflatsided", true);
2928 /* Flatsided checkbox */
2929 {
2930 GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
2932 GtkTreeIter iter;
2933 gtk_list_store_append( model, &iter );
2934 gtk_list_store_set( model, &iter,
2935 0, _("Polygon"),
2936 1, _("Regular polygon (with one handle) instead of a star"),
2937 2, INKSCAPE_ICON_DRAW_POLYGON,
2938 -1 );
2940 gtk_list_store_append( model, &iter );
2941 gtk_list_store_set( model, &iter,
2942 0, _("Star"),
2943 1, _("Star instead of a regular polygon (with one handle)"),
2944 2, INKSCAPE_ICON_DRAW_STAR,
2945 -1 );
2947 EgeSelectOneAction* act = ege_select_one_action_new( "FlatAction", (""), (""), NULL, GTK_TREE_MODEL(model) );
2948 gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
2949 g_object_set_data( holder, "flat_action", act );
2951 ege_select_one_action_set_appearance( act, "full" );
2952 ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
2953 g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
2954 ege_select_one_action_set_icon_column( act, 2 );
2955 ege_select_one_action_set_icon_size( act, secondarySize );
2956 ege_select_one_action_set_tooltip_column( act, 1 );
2958 ege_select_one_action_set_active( act, isFlatSided ? 0 : 1 );
2959 g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_stb_sides_flat_state_changed), holder);
2960 }
2962 /* Magnitude */
2963 {
2964 gchar const* labels[] = {_("triangle/tri-star"), _("square/quad-star"), _("pentagon/five-pointed star"), _("hexagon/six-pointed star"), 0, 0, 0, 0, 0};
2965 gdouble values[] = {3, 4, 5, 6, 7, 8, 10, 12, 20};
2966 eact = create_adjustment_action( "MagnitudeAction",
2967 _("Corners"), _("Corners:"), _("Number of corners of a polygon or star"),
2968 "/tools/shapes/star/magnitude", 3,
2969 GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
2970 3, 1024, 1, 5,
2971 labels, values, G_N_ELEMENTS(labels),
2972 sp_stb_magnitude_value_changed,
2973 1.0, 0 );
2974 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
2975 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
2976 }
2978 /* Spoke ratio */
2979 {
2980 gchar const* labels[] = {_("thin-ray star"), 0, _("pentagram"), _("hexagram"), _("heptagram"), _("octagram"), _("regular polygon")};
2981 gdouble values[] = {0.01, 0.2, 0.382, 0.577, 0.692, 0.765, 1};
2982 eact = create_adjustment_action( "SpokeAction",
2983 _("Spoke ratio"), _("Spoke ratio:"),
2984 // TRANSLATORS: Tip radius of a star is the distance from the center to the farthest handle.
2985 // Base radius is the same for the closest handle.
2986 _("Base radius to tip radius ratio"),
2987 "/tools/shapes/star/proportion", 0.5,
2988 GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
2989 0.01, 1.0, 0.01, 0.1,
2990 labels, values, G_N_ELEMENTS(labels),
2991 sp_stb_proportion_value_changed );
2992 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
2993 g_object_set_data( holder, "prop_action", eact );
2994 }
2996 if ( !isFlatSided ) {
2997 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
2998 } else {
2999 gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
3000 }
3002 /* Roundedness */
3003 {
3004 gchar const* labels[] = {_("stretched"), _("twisted"), _("slightly pinched"), _("NOT rounded"), _("slightly rounded"), _("visibly rounded"), _("well rounded"), _("amply rounded"), 0, _("stretched"), _("blown up")};
3005 gdouble values[] = {-1, -0.2, -0.03, 0, 0.05, 0.1, 0.2, 0.3, 0.5, 1, 10};
3006 eact = create_adjustment_action( "RoundednessAction",
3007 _("Rounded"), _("Rounded:"), _("How much rounded are the corners (0 for sharp)"),
3008 "/tools/shapes/star/rounded", 0.0,
3009 GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
3010 -10.0, 10.0, 0.01, 0.1,
3011 labels, values, G_N_ELEMENTS(labels),
3012 sp_stb_rounded_value_changed );
3013 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3014 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
3015 }
3017 /* Randomization */
3018 {
3019 gchar const* labels[] = {_("NOT randomized"), _("slightly irregular"), _("visibly randomized"), _("strongly randomized"), _("blown up")};
3020 gdouble values[] = {0, 0.01, 0.1, 0.5, 10};
3021 eact = create_adjustment_action( "RandomizationAction",
3022 _("Randomized"), _("Randomized:"), _("Scatter randomly the corners and angles"),
3023 "/tools/shapes/star/randomized", 0.0,
3024 GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
3025 -10.0, 10.0, 0.001, 0.01,
3026 labels, values, G_N_ELEMENTS(labels),
3027 sp_stb_randomized_value_changed, 0.1, 3 );
3028 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3029 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
3030 }
3031 }
3033 {
3034 /* Reset */
3035 {
3036 GtkAction* act = gtk_action_new( "StarResetAction",
3037 _("Defaults"),
3038 _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
3039 GTK_STOCK_CLEAR );
3040 g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(sp_stb_defaults), holder );
3041 gtk_action_group_add_action( mainActions, act );
3042 gtk_action_set_sensitive( act, TRUE );
3043 }
3044 }
3046 sigc::connection *connection = new sigc::connection(
3047 sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_star_toolbox_selection_changed), (GObject *)holder))
3048 );
3049 g_signal_connect( holder, "destroy", G_CALLBACK(delete_connection), connection );
3050 g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );
3051 }
3054 //########################
3055 //## Rect ##
3056 //########################
3058 static void sp_rtb_sensitivize( GObject *tbl )
3059 {
3060 GtkAdjustment *adj1 = GTK_ADJUSTMENT( g_object_get_data(tbl, "rx") );
3061 GtkAdjustment *adj2 = GTK_ADJUSTMENT( g_object_get_data(tbl, "ry") );
3062 GtkAction* not_rounded = GTK_ACTION( g_object_get_data(tbl, "not_rounded") );
3064 if (adj1->value == 0 && adj2->value == 0 && g_object_get_data(tbl, "single")) { // only for a single selected rect (for now)
3065 gtk_action_set_sensitive( not_rounded, FALSE );
3066 } else {
3067 gtk_action_set_sensitive( not_rounded, TRUE );
3068 }
3069 }
3072 static void sp_rtb_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_name,
3073 void (*setter)(SPRect *, gdouble))
3074 {
3075 SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
3077 UnitTracker* tracker = reinterpret_cast<UnitTracker*>(g_object_get_data( tbl, "tracker" ));
3078 SPUnit const *unit = tracker->getActiveUnit();
3080 if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
3081 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
3082 prefs->setDouble(Glib::ustring("/tools/shapes/rect/") + value_name, sp_units_get_pixels(adj->value, *unit));
3083 }
3085 // quit if run by the attr_changed listener
3086 if (g_object_get_data( tbl, "freeze" )) {
3087 return;
3088 }
3090 // in turn, prevent listener from responding
3091 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE));
3093 bool modmade = false;
3094 Inkscape::Selection *selection = sp_desktop_selection(desktop);
3095 for (GSList const *items = selection->itemList(); items != NULL; items = items->next) {
3096 if (SP_IS_RECT(items->data)) {
3097 if (adj->value != 0) {
3098 setter(SP_RECT(items->data), sp_units_get_pixels(adj->value, *unit));
3099 } else {
3100 SP_OBJECT_REPR(items->data)->setAttribute(value_name, NULL);
3101 }
3102 modmade = true;
3103 }
3104 }
3106 sp_rtb_sensitivize( tbl );
3108 if (modmade) {
3109 sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_RECT,
3110 _("Change rectangle"));
3111 }
3113 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
3114 }
3116 static void sp_rtb_rx_value_changed(GtkAdjustment *adj, GObject *tbl)
3117 {
3118 sp_rtb_value_changed(adj, tbl, "rx", sp_rect_set_visible_rx);
3119 }
3121 static void sp_rtb_ry_value_changed(GtkAdjustment *adj, GObject *tbl)
3122 {
3123 sp_rtb_value_changed(adj, tbl, "ry", sp_rect_set_visible_ry);
3124 }
3126 static void sp_rtb_width_value_changed(GtkAdjustment *adj, GObject *tbl)
3127 {
3128 sp_rtb_value_changed(adj, tbl, "width", sp_rect_set_visible_width);
3129 }
3131 static void sp_rtb_height_value_changed(GtkAdjustment *adj, GObject *tbl)
3132 {
3133 sp_rtb_value_changed(adj, tbl, "height", sp_rect_set_visible_height);
3134 }
3138 static void sp_rtb_defaults( GtkWidget * /*widget*/, GObject *obj)
3139 {
3140 GtkAdjustment *adj = 0;
3142 adj = GTK_ADJUSTMENT( g_object_get_data(obj, "rx") );
3143 gtk_adjustment_set_value(adj, 0.0);
3144 // this is necessary if the previous value was 0, but we still need to run the callback to change all selected objects
3145 gtk_adjustment_value_changed(adj);
3147 adj = GTK_ADJUSTMENT( g_object_get_data(obj, "ry") );
3148 gtk_adjustment_set_value(adj, 0.0);
3149 gtk_adjustment_value_changed(adj);
3151 sp_rtb_sensitivize( obj );
3152 }
3154 static void rect_tb_event_attr_changed(Inkscape::XML::Node * /*repr*/, gchar const * /*name*/,
3155 gchar const * /*old_value*/, gchar const * /*new_value*/,
3156 bool /*is_interactive*/, gpointer data)
3157 {
3158 GObject *tbl = G_OBJECT(data);
3160 // quit if run by the _changed callbacks
3161 if (g_object_get_data( tbl, "freeze" )) {
3162 return;
3163 }
3165 // in turn, prevent callbacks from responding
3166 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
3168 UnitTracker* tracker = reinterpret_cast<UnitTracker*>( g_object_get_data( tbl, "tracker" ) );
3169 SPUnit const *unit = tracker->getActiveUnit();
3171 gpointer item = g_object_get_data( tbl, "item" );
3172 if (item && SP_IS_RECT(item)) {
3173 {
3174 GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "rx" ) );
3175 gdouble rx = sp_rect_get_visible_rx(SP_RECT(item));
3176 gtk_adjustment_set_value(adj, sp_pixels_get_units(rx, *unit));
3177 }
3179 {
3180 GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "ry" ) );
3181 gdouble ry = sp_rect_get_visible_ry(SP_RECT(item));
3182 gtk_adjustment_set_value(adj, sp_pixels_get_units(ry, *unit));
3183 }
3185 {
3186 GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "width" ) );
3187 gdouble width = sp_rect_get_visible_width (SP_RECT(item));
3188 gtk_adjustment_set_value(adj, sp_pixels_get_units(width, *unit));
3189 }
3191 {
3192 GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "height" ) );
3193 gdouble height = sp_rect_get_visible_height (SP_RECT(item));
3194 gtk_adjustment_set_value(adj, sp_pixels_get_units(height, *unit));
3195 }
3196 }
3198 sp_rtb_sensitivize( tbl );
3200 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
3201 }
3204 static Inkscape::XML::NodeEventVector rect_tb_repr_events = {
3205 NULL, /* child_added */
3206 NULL, /* child_removed */
3207 rect_tb_event_attr_changed,
3208 NULL, /* content_changed */
3209 NULL /* order_changed */
3210 };
3212 /**
3213 * \param selection should not be NULL.
3214 */
3215 static void sp_rect_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
3216 {
3217 int n_selected = 0;
3218 Inkscape::XML::Node *repr = NULL;
3219 SPItem *item = NULL;
3221 if ( g_object_get_data( tbl, "repr" ) ) {
3222 g_object_set_data( tbl, "item", NULL );
3223 }
3224 purge_repr_listener( tbl, tbl );
3226 for (GSList const *items = selection->itemList();
3227 items != NULL;
3228 items = items->next) {
3229 if (SP_IS_RECT((SPItem *) items->data)) {
3230 n_selected++;
3231 item = (SPItem *) items->data;
3232 repr = SP_OBJECT_REPR(item);
3233 }
3234 }
3236 EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) );
3238 g_object_set_data( tbl, "single", GINT_TO_POINTER(FALSE) );
3240 if (n_selected == 0) {
3241 g_object_set( G_OBJECT(act), "label", _("<b>New:</b>"), NULL );
3243 GtkAction* w = GTK_ACTION( g_object_get_data( tbl, "width_action" ) );
3244 gtk_action_set_sensitive(w, FALSE);
3245 GtkAction* h = GTK_ACTION( g_object_get_data( tbl, "height_action" ) );
3246 gtk_action_set_sensitive(h, FALSE);
3248 } else if (n_selected == 1) {
3249 g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
3250 g_object_set_data( tbl, "single", GINT_TO_POINTER(TRUE) );
3252 GtkAction* w = GTK_ACTION( g_object_get_data( tbl, "width_action" ) );
3253 gtk_action_set_sensitive(w, TRUE);
3254 GtkAction* h = GTK_ACTION( g_object_get_data( tbl, "height_action" ) );
3255 gtk_action_set_sensitive(h, TRUE);
3257 if (repr) {
3258 g_object_set_data( tbl, "repr", repr );
3259 g_object_set_data( tbl, "item", item );
3260 Inkscape::GC::anchor(repr);
3261 sp_repr_add_listener(repr, &rect_tb_repr_events, tbl);
3262 sp_repr_synthesize_events(repr, &rect_tb_repr_events, tbl);
3263 }
3264 } else {
3265 // FIXME: implement averaging of all parameters for multiple selected
3266 //gtk_label_set_markup(GTK_LABEL(l), _("<b>Average:</b>"));
3267 g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
3268 sp_rtb_sensitivize( tbl );
3269 }
3270 }
3273 static void sp_rect_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
3274 {
3275 EgeAdjustmentAction* eact = 0;
3276 Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
3278 {
3279 EgeOutputAction* act = ege_output_action_new( "RectStateAction", _("<b>New:</b>"), "", 0 );
3280 ege_output_action_set_use_markup( act, TRUE );
3281 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
3282 g_object_set_data( holder, "mode_action", act );
3283 }
3285 // rx/ry units menu: create
3286 UnitTracker* tracker = new UnitTracker( SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE );
3287 //tracker->addUnit( SP_UNIT_PERCENT, 0 );
3288 // fixme: add % meaning per cent of the width/height
3289 tracker->setActiveUnit( sp_desktop_namedview(desktop)->doc_units );
3290 g_object_set_data( holder, "tracker", tracker );
3292 /* W */
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( "RectWidthAction",
3297 _("Width"), _("W:"), _("Width of rectangle"),
3298 "/tools/shapes/rect/width", 0,
3299 GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, TRUE, "altx-rect",
3300 0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
3301 labels, values, G_N_ELEMENTS(labels),
3302 sp_rtb_width_value_changed );
3303 tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );
3304 g_object_set_data( holder, "width_action", eact );
3305 gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
3306 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3307 }
3309 /* H */
3310 {
3311 gchar const* labels[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
3312 gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500};
3313 eact = create_adjustment_action( "RectHeightAction",
3314 _("Height"), _("H:"), _("Height of rectangle"),
3315 "/tools/shapes/rect/height", 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_height_value_changed );
3320 tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );
3321 g_object_set_data( holder, "height_action", eact );
3322 gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
3323 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3324 }
3326 /* rx */
3327 {
3328 gchar const* labels[] = {_("not rounded"), 0, 0, 0, 0, 0, 0, 0, 0};
3329 gdouble values[] = {0.5, 1, 2, 3, 5, 10, 20, 50, 100};
3330 eact = create_adjustment_action( "RadiusXAction",
3331 _("Horizontal radius"), _("Rx:"), _("Horizontal radius of rounded corners"),
3332 "/tools/shapes/rect/rx", 0,
3333 GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL,
3334 0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
3335 labels, values, G_N_ELEMENTS(labels),
3336 sp_rtb_rx_value_changed);
3337 tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );
3338 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3339 }
3341 /* ry */
3342 {
3343 gchar const* labels[] = {_("not rounded"), 0, 0, 0, 0, 0, 0, 0, 0};
3344 gdouble values[] = {0.5, 1, 2, 3, 5, 10, 20, 50, 100};
3345 eact = create_adjustment_action( "RadiusYAction",
3346 _("Vertical radius"), _("Ry:"), _("Vertical radius of rounded corners"),
3347 "/tools/shapes/rect/ry", 0,
3348 GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL,
3349 0, 1e6, SPIN_STEP, SPIN_PAGE_STEP,
3350 labels, values, G_N_ELEMENTS(labels),
3351 sp_rtb_ry_value_changed);
3352 tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );
3353 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3354 }
3356 // add the units menu
3357 {
3358 GtkAction* act = tracker->createAction( "RectUnitsAction", _("Units"), ("") );
3359 gtk_action_group_add_action( mainActions, act );
3360 }
3362 /* Reset */
3363 {
3364 InkAction* inky = ink_action_new( "RectResetAction",
3365 _("Not rounded"),
3366 _("Make corners sharp"),
3367 INKSCAPE_ICON_RECTANGLE_MAKE_CORNERS_SHARP,
3368 secondarySize );
3369 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_rtb_defaults), holder );
3370 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
3371 gtk_action_set_sensitive( GTK_ACTION(inky), TRUE );
3372 g_object_set_data( holder, "not_rounded", inky );
3373 }
3375 g_object_set_data( holder, "single", GINT_TO_POINTER(TRUE) );
3376 sp_rtb_sensitivize( holder );
3378 sigc::connection *connection = new sigc::connection(
3379 sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_rect_toolbox_selection_changed), (GObject *)holder))
3380 );
3381 g_signal_connect( holder, "destroy", G_CALLBACK(delete_connection), connection );
3382 g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );
3383 }
3385 //########################
3386 //## 3D Box ##
3387 //########################
3389 // normalize angle so that it lies in the interval [0,360]
3390 static double box3d_normalize_angle (double a) {
3391 double angle = a + ((int) (a/360.0))*360;
3392 if (angle < 0) {
3393 angle += 360.0;
3394 }
3395 return angle;
3396 }
3398 static void box3d_set_button_and_adjustment(Persp3D *persp,
3399 Proj::Axis axis,
3400 GtkAdjustment *adj,
3401 GtkAction *act,
3402 GtkToggleAction *tact)
3403 {
3404 // TODO: Take all selected perspectives into account but don't touch the state button if not all of them
3405 // have the same state (otherwise a call to box3d_vp_z_state_changed() is triggered and the states
3406 // are reset).
3407 bool is_infinite = !persp3d_VP_is_finite(persp->perspective_impl, axis);
3409 if (is_infinite) {
3410 gtk_toggle_action_set_active(tact, TRUE);
3411 gtk_action_set_sensitive(act, TRUE);
3413 double angle = persp3d_get_infinite_angle(persp, axis);
3414 if (angle != NR_HUGE) { // FIXME: We should catch this error earlier (don't show the spinbutton at all)
3415 gtk_adjustment_set_value(adj, box3d_normalize_angle(angle));
3416 }
3417 } else {
3418 gtk_toggle_action_set_active(tact, FALSE);
3419 gtk_action_set_sensitive(act, FALSE);
3420 }
3421 }
3423 static void box3d_resync_toolbar(Inkscape::XML::Node *persp_repr, GObject *data)
3424 {
3425 if (!persp_repr) {
3426 g_print ("No perspective given to box3d_resync_toolbar().\n");
3427 return;
3428 }
3430 GtkWidget *tbl = GTK_WIDGET(data);
3431 GtkAdjustment *adj = 0;
3432 GtkAction *act = 0;
3433 GtkToggleAction *tact = 0;
3434 Persp3D *persp = persp3d_get_from_repr(persp_repr);
3435 if (!persp) {
3436 // Hmm, is it an error if this happens?
3437 return;
3438 }
3439 {
3440 adj = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(tbl), "box3d_angle_x"));
3441 act = GTK_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_angle_x_action"));
3442 tact = &INK_TOGGLE_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_vp_x_state_action"))->action;
3444 box3d_set_button_and_adjustment(persp, Proj::X, adj, act, tact);
3445 }
3446 {
3447 adj = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(tbl), "box3d_angle_y"));
3448 act = GTK_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_angle_y_action"));
3449 tact = &INK_TOGGLE_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_vp_y_state_action"))->action;
3451 box3d_set_button_and_adjustment(persp, Proj::Y, adj, act, tact);
3452 }
3453 {
3454 adj = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(tbl), "box3d_angle_z"));
3455 act = GTK_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_angle_z_action"));
3456 tact = &INK_TOGGLE_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_vp_z_state_action"))->action;
3458 box3d_set_button_and_adjustment(persp, Proj::Z, adj, act, tact);
3459 }
3460 }
3462 static void box3d_persp_tb_event_attr_changed(Inkscape::XML::Node *repr,
3463 gchar const * /*name*/,
3464 gchar const * /*old_value*/,
3465 gchar const * /*new_value*/,
3466 bool /*is_interactive*/,
3467 gpointer data)
3468 {
3469 GtkWidget *tbl = GTK_WIDGET(data);
3471 // quit if run by the attr_changed or selection changed listener
3472 if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
3473 return;
3474 }
3476 // set freeze so that it can be caught in box3d_angle_z_value_changed() (to avoid calling
3477 // sp_document_maybe_done() when the document is undo insensitive)
3478 g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE));
3480 // TODO: Only update the appropriate part of the toolbar
3481 // if (!strcmp(name, "inkscape:vp_z")) {
3482 box3d_resync_toolbar(repr, G_OBJECT(tbl));
3483 // }
3485 Persp3D *persp = persp3d_get_from_repr(repr);
3486 persp3d_update_box_reprs(persp);
3488 g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
3489 }
3491 static Inkscape::XML::NodeEventVector box3d_persp_tb_repr_events =
3492 {
3493 NULL, /* child_added */
3494 NULL, /* child_removed */
3495 box3d_persp_tb_event_attr_changed,
3496 NULL, /* content_changed */
3497 NULL /* order_changed */
3498 };
3500 /**
3501 * \param selection Should not be NULL.
3502 */
3503 // FIXME: This should rather be put into persp3d-reference.cpp or something similar so that it reacts upon each
3504 // Change of the perspective, and not of the current selection (but how to refer to the toolbar then?)
3505 static void box3d_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
3506 {
3507 // Here the following should be done: If all selected boxes have finite VPs in a certain direction,
3508 // disable the angle entry fields for this direction (otherwise entering a value in them should only
3509 // update the perspectives with infinite VPs and leave the other ones untouched).
3511 Inkscape::XML::Node *persp_repr = NULL;
3512 purge_repr_listener(tbl, tbl);
3514 SPItem *item = selection->singleItem();
3515 if (item && SP_IS_BOX3D(item)) {
3516 // FIXME: Also deal with multiple selected boxes
3517 SPBox3D *box = SP_BOX3D(item);
3518 Persp3D *persp = box3d_get_perspective(box);
3519 persp_repr = SP_OBJECT_REPR(persp);
3520 if (persp_repr) {
3521 g_object_set_data(tbl, "repr", persp_repr);
3522 Inkscape::GC::anchor(persp_repr);
3523 sp_repr_add_listener(persp_repr, &box3d_persp_tb_repr_events, tbl);
3524 sp_repr_synthesize_events(persp_repr, &box3d_persp_tb_repr_events, tbl);
3525 }
3527 inkscape_active_document()->setCurrentPersp3D(persp3d_get_from_repr(persp_repr));
3528 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
3529 prefs->setString("/tools/shapes/3dbox/persp", persp_repr->attribute("id"));
3531 g_object_set_data(tbl, "freeze", GINT_TO_POINTER(TRUE));
3532 box3d_resync_toolbar(persp_repr, tbl);
3533 g_object_set_data(tbl, "freeze", GINT_TO_POINTER(FALSE));
3534 }
3535 }
3537 static void box3d_angle_value_changed(GtkAdjustment *adj, GObject *dataKludge, Proj::Axis axis)
3538 {
3539 SPDesktop *desktop = (SPDesktop *) g_object_get_data( dataKludge, "desktop" );
3540 SPDocument *document = sp_desktop_document(desktop);
3542 // quit if run by the attr_changed or selection changed listener
3543 if (g_object_get_data( dataKludge, "freeze" )) {
3544 return;
3545 }
3547 // in turn, prevent listener from responding
3548 g_object_set_data(dataKludge, "freeze", GINT_TO_POINTER(TRUE));
3550 std::list<Persp3D *> sel_persps = sp_desktop_selection(desktop)->perspList();
3551 if (sel_persps.empty()) {
3552 // this can happen when the document is created; we silently ignore it
3553 return;
3554 }
3555 Persp3D *persp = sel_persps.front();
3557 persp->perspective_impl->tmat.set_infinite_direction (axis, adj->value);
3558 SP_OBJECT(persp)->updateRepr();
3560 // TODO: use the correct axis here, too
3561 sp_document_maybe_done(document, "perspangle", SP_VERB_CONTEXT_3DBOX, _("3D Box: Change perspective (angle of infinite axis)"));
3563 g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) );
3564 }
3567 static void box3d_angle_x_value_changed(GtkAdjustment *adj, GObject *dataKludge)
3568 {
3569 box3d_angle_value_changed(adj, dataKludge, Proj::X);
3570 }
3572 static void box3d_angle_y_value_changed(GtkAdjustment *adj, GObject *dataKludge)
3573 {
3574 box3d_angle_value_changed(adj, dataKludge, Proj::Y);
3575 }
3577 static void box3d_angle_z_value_changed(GtkAdjustment *adj, GObject *dataKludge)
3578 {
3579 box3d_angle_value_changed(adj, dataKludge, Proj::Z);
3580 }
3583 static void box3d_vp_state_changed( GtkToggleAction *act, GtkAction * /*box3d_angle*/, Proj::Axis axis )
3584 {
3585 // TODO: Take all selected perspectives into account
3586 std::list<Persp3D *> sel_persps = sp_desktop_selection(inkscape_active_desktop())->perspList();
3587 if (sel_persps.empty()) {
3588 // this can happen when the document is created; we silently ignore it
3589 return;
3590 }
3591 Persp3D *persp = sel_persps.front();
3593 bool set_infinite = gtk_toggle_action_get_active(act);
3594 persp3d_set_VP_state (persp, axis, set_infinite ? Proj::VP_INFINITE : Proj::VP_FINITE);
3595 }
3597 static void box3d_vp_x_state_changed( GtkToggleAction *act, GtkAction *box3d_angle )
3598 {
3599 box3d_vp_state_changed(act, box3d_angle, Proj::X);
3600 }
3602 static void box3d_vp_y_state_changed( GtkToggleAction *act, GtkAction *box3d_angle )
3603 {
3604 box3d_vp_state_changed(act, box3d_angle, Proj::Y);
3605 }
3607 static void box3d_vp_z_state_changed( GtkToggleAction *act, GtkAction *box3d_angle )
3608 {
3609 box3d_vp_state_changed(act, box3d_angle, Proj::Z);
3610 }
3612 static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
3613 {
3614 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
3615 EgeAdjustmentAction* eact = 0;
3616 SPDocument *document = sp_desktop_document (desktop);
3617 Persp3DImpl *persp_impl = document->getCurrentPersp3DImpl();
3619 EgeAdjustmentAction* box3d_angle_x = 0;
3620 EgeAdjustmentAction* box3d_angle_y = 0;
3621 EgeAdjustmentAction* box3d_angle_z = 0;
3623 /* Angle X */
3624 {
3625 gchar const* labels[] = { 0, 0, 0, 0, 0, 0, 0 };
3626 gdouble values[] = {-90, -60, -30, 0, 30, 60, 90};
3627 eact = create_adjustment_action( "3DBoxAngleXAction",
3628 _("Angle in X direction"), _("Angle X:"),
3629 // Translators: PL is short for 'perspective line'
3630 _("Angle of PLs in X direction"),
3631 "/tools/shapes/3dbox/box3d_angle_x", 30,
3632 GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-box3d",
3633 -360.0, 360.0, 1.0, 10.0,
3634 labels, values, G_N_ELEMENTS(labels),
3635 box3d_angle_x_value_changed );
3636 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3637 g_object_set_data( holder, "box3d_angle_x_action", eact );
3638 box3d_angle_x = eact;
3639 }
3641 if (!persp_impl || !persp3d_VP_is_finite(persp_impl, Proj::X)) {
3642 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
3643 } else {
3644 gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
3645 }
3648 /* VP X state */
3649 {
3650 InkToggleAction* act = ink_toggle_action_new( "3DBoxVPXStateAction",
3651 // Translators: VP is short for 'vanishing point'
3652 _("State of VP in X direction"),
3653 _("Toggle VP in X direction between 'finite' and 'infinite' (=parallel)"),
3654 INKSCAPE_ICON_PERSPECTIVE_PARALLEL,
3655 Inkscape::ICON_SIZE_DECORATION );
3656 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
3657 g_object_set_data( holder, "box3d_vp_x_state_action", act );
3658 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(box3d_vp_x_state_changed), box3d_angle_x );
3659 gtk_action_set_sensitive( GTK_ACTION(box3d_angle_x), !prefs->getBool("/tools/shapes/3dbox/vp_x_state", true) );
3660 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/shapes/3dbox/vp_x_state", true) );
3661 }
3663 /* Angle Y */
3664 {
3665 gchar const* labels[] = { 0, 0, 0, 0, 0, 0, 0 };
3666 gdouble values[] = {-90, -60, -30, 0, 30, 60, 90};
3667 eact = create_adjustment_action( "3DBoxAngleYAction",
3668 _("Angle in Y direction"), _("Angle Y:"),
3669 // Translators: PL is short for 'perspective line'
3670 _("Angle of PLs in Y direction"),
3671 "/tools/shapes/3dbox/box3d_angle_y", 30,
3672 GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
3673 -360.0, 360.0, 1.0, 10.0,
3674 labels, values, G_N_ELEMENTS(labels),
3675 box3d_angle_y_value_changed );
3676 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3677 g_object_set_data( holder, "box3d_angle_y_action", eact );
3678 box3d_angle_y = eact;
3679 }
3681 if (!persp_impl || !persp3d_VP_is_finite(persp_impl, Proj::Y)) {
3682 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
3683 } else {
3684 gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
3685 }
3687 /* VP Y state */
3688 {
3689 InkToggleAction* act = ink_toggle_action_new( "3DBoxVPYStateAction",
3690 // Translators: VP is short for 'vanishing point'
3691 _("State of VP in Y direction"),
3692 _("Toggle VP in Y direction between 'finite' and 'infinite' (=parallel)"),
3693 INKSCAPE_ICON_PERSPECTIVE_PARALLEL,
3694 Inkscape::ICON_SIZE_DECORATION );
3695 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
3696 g_object_set_data( holder, "box3d_vp_y_state_action", act );
3697 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(box3d_vp_y_state_changed), box3d_angle_y );
3698 gtk_action_set_sensitive( GTK_ACTION(box3d_angle_y), !prefs->getBool("/tools/shapes/3dbox/vp_y_state", true) );
3699 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/shapes/3dbox/vp_y_state", true) );
3700 }
3702 /* Angle Z */
3703 {
3704 gchar const* labels[] = { 0, 0, 0, 0, 0, 0, 0 };
3705 gdouble values[] = {-90, -60, -30, 0, 30, 60, 90};
3706 eact = create_adjustment_action( "3DBoxAngleZAction",
3707 _("Angle in Z direction"), _("Angle Z:"),
3708 // Translators: PL is short for 'perspective line'
3709 _("Angle of PLs in Z direction"),
3710 "/tools/shapes/3dbox/box3d_angle_z", 30,
3711 GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
3712 -360.0, 360.0, 1.0, 10.0,
3713 labels, values, G_N_ELEMENTS(labels),
3714 box3d_angle_z_value_changed );
3715 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3716 g_object_set_data( holder, "box3d_angle_z_action", eact );
3717 box3d_angle_z = eact;
3718 }
3720 if (!persp_impl || !persp3d_VP_is_finite(persp_impl, Proj::Z)) {
3721 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
3722 } else {
3723 gtk_action_set_sensitive( GTK_ACTION(eact), FALSE );
3724 }
3726 /* VP Z state */
3727 {
3728 InkToggleAction* act = ink_toggle_action_new( "3DBoxVPZStateAction",
3729 // Translators: VP is short for 'vanishing point'
3730 _("State of VP in Z direction"),
3731 _("Toggle VP in Z direction between 'finite' and 'infinite' (=parallel)"),
3732 INKSCAPE_ICON_PERSPECTIVE_PARALLEL,
3733 Inkscape::ICON_SIZE_DECORATION );
3734 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
3735 g_object_set_data( holder, "box3d_vp_z_state_action", act );
3736 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(box3d_vp_z_state_changed), box3d_angle_z );
3737 gtk_action_set_sensitive( GTK_ACTION(box3d_angle_z), !prefs->getBool("/tools/shapes/3dbox/vp_z_state", true) );
3738 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/shapes/3dbox/vp_z_state", true) );
3739 }
3741 sigc::connection *connection = new sigc::connection(
3742 sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(box3d_toolbox_selection_changed), (GObject *)holder))
3743 );
3744 g_signal_connect(holder, "destroy", G_CALLBACK(delete_connection), connection);
3745 g_signal_connect(holder, "destroy", G_CALLBACK(purge_repr_listener), holder);
3746 }
3748 //########################
3749 //## Spiral ##
3750 //########################
3752 static void sp_spl_tb_value_changed(GtkAdjustment *adj, GObject *tbl, Glib::ustring const &value_name)
3753 {
3754 SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
3756 if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
3757 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
3758 prefs->setDouble("/tools/shapes/spiral/" + value_name, adj->value);
3759 }
3761 // quit if run by the attr_changed listener
3762 if (g_object_get_data( tbl, "freeze" )) {
3763 return;
3764 }
3766 // in turn, prevent listener from responding
3767 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
3769 gchar* namespaced_name = g_strconcat("sodipodi:", value_name.data(), NULL);
3771 bool modmade = false;
3772 for (GSList const *items = sp_desktop_selection(desktop)->itemList();
3773 items != NULL;
3774 items = items->next)
3775 {
3776 if (SP_IS_SPIRAL((SPItem *) items->data)) {
3777 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
3778 sp_repr_set_svg_double( repr, namespaced_name, adj->value );
3779 SP_OBJECT((SPItem *) items->data)->updateRepr();
3780 modmade = true;
3781 }
3782 }
3784 g_free(namespaced_name);
3786 if (modmade) {
3787 sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_SPIRAL,
3788 _("Change spiral"));
3789 }
3791 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
3792 }
3794 static void sp_spl_tb_revolution_value_changed(GtkAdjustment *adj, GObject *tbl)
3795 {
3796 sp_spl_tb_value_changed(adj, tbl, "revolution");
3797 }
3799 static void sp_spl_tb_expansion_value_changed(GtkAdjustment *adj, GObject *tbl)
3800 {
3801 sp_spl_tb_value_changed(adj, tbl, "expansion");
3802 }
3804 static void sp_spl_tb_t0_value_changed(GtkAdjustment *adj, GObject *tbl)
3805 {
3806 sp_spl_tb_value_changed(adj, tbl, "t0");
3807 }
3809 static void sp_spl_tb_defaults(GtkWidget * /*widget*/, GtkObject *obj)
3810 {
3811 GtkWidget *tbl = GTK_WIDGET(obj);
3813 GtkAdjustment *adj;
3815 // fixme: make settable
3816 gdouble rev = 5;
3817 gdouble exp = 1.0;
3818 gdouble t0 = 0.0;
3820 adj = (GtkAdjustment*)gtk_object_get_data(obj, "revolution");
3821 gtk_adjustment_set_value(adj, rev);
3822 gtk_adjustment_value_changed(adj);
3824 adj = (GtkAdjustment*)gtk_object_get_data(obj, "expansion");
3825 gtk_adjustment_set_value(adj, exp);
3826 gtk_adjustment_value_changed(adj);
3828 adj = (GtkAdjustment*)gtk_object_get_data(obj, "t0");
3829 gtk_adjustment_set_value(adj, t0);
3830 gtk_adjustment_value_changed(adj);
3832 spinbutton_defocus(GTK_OBJECT(tbl));
3833 }
3836 static void spiral_tb_event_attr_changed(Inkscape::XML::Node *repr,
3837 gchar const * /*name*/,
3838 gchar const * /*old_value*/,
3839 gchar const * /*new_value*/,
3840 bool /*is_interactive*/,
3841 gpointer data)
3842 {
3843 GtkWidget *tbl = GTK_WIDGET(data);
3845 // quit if run by the _changed callbacks
3846 if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
3847 return;
3848 }
3850 // in turn, prevent callbacks from responding
3851 g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE));
3853 GtkAdjustment *adj;
3854 adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "revolution");
3855 gtk_adjustment_set_value(adj, (sp_repr_get_double_attribute(repr, "sodipodi:revolution", 3.0)));
3857 adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "expansion");
3858 gtk_adjustment_set_value(adj, (sp_repr_get_double_attribute(repr, "sodipodi:expansion", 1.0)));
3860 adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "t0");
3861 gtk_adjustment_set_value(adj, (sp_repr_get_double_attribute(repr, "sodipodi:t0", 0.0)));
3863 g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
3864 }
3867 static Inkscape::XML::NodeEventVector spiral_tb_repr_events = {
3868 NULL, /* child_added */
3869 NULL, /* child_removed */
3870 spiral_tb_event_attr_changed,
3871 NULL, /* content_changed */
3872 NULL /* order_changed */
3873 };
3875 static void sp_spiral_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
3876 {
3877 int n_selected = 0;
3878 Inkscape::XML::Node *repr = NULL;
3880 purge_repr_listener( tbl, tbl );
3882 for (GSList const *items = selection->itemList();
3883 items != NULL;
3884 items = items->next)
3885 {
3886 if (SP_IS_SPIRAL((SPItem *) items->data)) {
3887 n_selected++;
3888 repr = SP_OBJECT_REPR((SPItem *) items->data);
3889 }
3890 }
3892 EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) );
3894 if (n_selected == 0) {
3895 g_object_set( G_OBJECT(act), "label", _("<b>New:</b>"), NULL );
3896 } else if (n_selected == 1) {
3897 g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
3899 if (repr) {
3900 g_object_set_data( tbl, "repr", repr );
3901 Inkscape::GC::anchor(repr);
3902 sp_repr_add_listener(repr, &spiral_tb_repr_events, tbl);
3903 sp_repr_synthesize_events(repr, &spiral_tb_repr_events, tbl);
3904 }
3905 } else {
3906 // FIXME: implement averaging of all parameters for multiple selected
3907 //gtk_label_set_markup(GTK_LABEL(l), _("<b>Average:</b>"));
3908 g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
3909 }
3910 }
3913 static void sp_spiral_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
3914 {
3915 EgeAdjustmentAction* eact = 0;
3916 Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
3918 {
3919 EgeOutputAction* act = ege_output_action_new( "SpiralStateAction", _("<b>New:</b>"), "", 0 );
3920 ege_output_action_set_use_markup( act, TRUE );
3921 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
3922 g_object_set_data( holder, "mode_action", act );
3923 }
3925 /* Revolution */
3926 {
3927 gchar const* labels[] = {_("just a curve"), 0, _("one full revolution"), 0, 0, 0, 0, 0, 0};
3928 gdouble values[] = {0.01, 0.5, 1, 2, 3, 5, 10, 20, 50, 100};
3929 eact = create_adjustment_action( "SpiralRevolutionAction",
3930 _("Number of turns"), _("Turns:"), _("Number of revolutions"),
3931 "/tools/shapes/spiral/revolution", 3.0,
3932 GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-spiral",
3933 0.01, 1024.0, 0.1, 1.0,
3934 labels, values, G_N_ELEMENTS(labels),
3935 sp_spl_tb_revolution_value_changed, 1, 2);
3936 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3937 }
3939 /* Expansion */
3940 {
3941 gchar const* labels[] = {_("circle"), _("edge is much denser"), _("edge is denser"), _("even"), _("center is denser"), _("center is much denser"), 0};
3942 gdouble values[] = {0, 0.1, 0.5, 1, 1.5, 5, 20};
3943 eact = create_adjustment_action( "SpiralExpansionAction",
3944 _("Divergence"), _("Divergence:"), _("How much denser/sparser are outer revolutions; 1 = uniform"),
3945 "/tools/shapes/spiral/expansion", 1.0,
3946 GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
3947 0.0, 1000.0, 0.01, 1.0,
3948 labels, values, G_N_ELEMENTS(labels),
3949 sp_spl_tb_expansion_value_changed);
3950 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3951 }
3953 /* T0 */
3954 {
3955 gchar const* labels[] = {_("starts from center"), _("starts mid-way"), _("starts near edge")};
3956 gdouble values[] = {0, 0.5, 0.9};
3957 eact = create_adjustment_action( "SpiralT0Action",
3958 _("Inner radius"), _("Inner radius:"), _("Radius of the innermost revolution (relative to the spiral size)"),
3959 "/tools/shapes/spiral/t0", 0.0,
3960 GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
3961 0.0, 0.999, 0.01, 1.0,
3962 labels, values, G_N_ELEMENTS(labels),
3963 sp_spl_tb_t0_value_changed);
3964 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
3965 }
3967 /* Reset */
3968 {
3969 InkAction* inky = ink_action_new( "SpiralResetAction",
3970 _("Defaults"),
3971 _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
3972 GTK_STOCK_CLEAR,
3973 secondarySize );
3974 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_spl_tb_defaults), holder );
3975 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
3976 }
3979 sigc::connection *connection = new sigc::connection(
3980 sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_spiral_toolbox_selection_changed), (GObject *)holder))
3981 );
3982 g_signal_connect( holder, "destroy", G_CALLBACK(delete_connection), connection );
3983 g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );
3984 }
3986 //########################
3987 //## Pen/Pencil ##
3988 //########################
3990 /* This is used in generic functions below to share large portions of code between pen and pencil tool */
3991 static Glib::ustring const freehand_tool_name(GObject *dataKludge)
3992 {
3993 SPDesktop *desktop = (SPDesktop *) g_object_get_data(dataKludge, "desktop");
3994 return ( tools_isactive(desktop, TOOLS_FREEHAND_PEN)
3995 ? "/tools/freehand/pen"
3996 : "/tools/freehand/pencil" );
3997 }
3999 static void freehand_mode_changed(EgeSelectOneAction* act, GObject* tbl)
4000 {
4001 gint mode = ege_select_one_action_get_active(act);
4003 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4004 prefs->setInt(freehand_tool_name(tbl) + "/freehand-mode", mode);
4006 SPDesktop *desktop = (SPDesktop *) g_object_get_data(tbl, "desktop");
4008 // in pen tool we have more options than in pencil tool; if one of them was chosen, we do any
4009 // preparatory work here
4010 if (SP_IS_PEN_CONTEXT(desktop->event_context)) {
4011 SPPenContext *pc = SP_PEN_CONTEXT(desktop->event_context);
4012 sp_pen_context_set_polyline_mode(pc);
4013 }
4014 }
4016 static void sp_add_freehand_mode_toggle(GtkActionGroup* mainActions, GObject* holder, bool tool_is_pencil)
4017 {
4018 /* Freehand mode toggle buttons */
4019 {
4020 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4021 guint freehandMode = prefs->getInt(( tool_is_pencil ? "/tools/freehand/pencil/freehand-mode" : "/tools/freehand/pen/freehand-mode" ), 0);
4022 Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
4024 {
4025 GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
4027 GtkTreeIter iter;
4028 gtk_list_store_append( model, &iter );
4029 gtk_list_store_set( model, &iter,
4030 0, _("Bezier"),
4031 1, _("Create regular Bezier path"),
4032 2, INKSCAPE_ICON_PATH_MODE_BEZIER,
4033 -1 );
4035 gtk_list_store_append( model, &iter );
4036 gtk_list_store_set( model, &iter,
4037 0, _("Spiro"),
4038 1, _("Create Spiro path"),
4039 2, INKSCAPE_ICON_PATH_MODE_SPIRO,
4040 -1 );
4042 if (!tool_is_pencil) {
4043 gtk_list_store_append( model, &iter );
4044 gtk_list_store_set( model, &iter,
4045 0, _("Zigzag"),
4046 1, _("Create a sequence of straight line segments"),
4047 2, INKSCAPE_ICON_PATH_MODE_POLYLINE,
4048 -1 );
4050 gtk_list_store_append( model, &iter );
4051 gtk_list_store_set( model, &iter,
4052 0, _("Paraxial"),
4053 1, _("Create a sequence of paraxial line segments"),
4054 2, INKSCAPE_ICON_PATH_MODE_POLYLINE_PARAXIAL,
4055 -1 );
4056 }
4058 EgeSelectOneAction* act = ege_select_one_action_new(tool_is_pencil ?
4059 "FreehandModeActionPencil" :
4060 "FreehandModeActionPen",
4061 (_("Mode:")), (_("Mode of new lines drawn by this tool")), NULL, GTK_TREE_MODEL(model) );
4062 gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
4064 ege_select_one_action_set_appearance( act, "full" );
4065 ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
4066 g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
4067 ege_select_one_action_set_icon_column( act, 2 );
4068 ege_select_one_action_set_icon_size( act, secondarySize );
4069 ege_select_one_action_set_tooltip_column( act, 1 );
4071 ege_select_one_action_set_active( act, freehandMode);
4072 g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(freehand_mode_changed), holder);
4073 }
4074 }
4075 }
4077 static void freehand_change_shape(EgeSelectOneAction* act, GObject *dataKludge) {
4078 gint shape = ege_select_one_action_get_active( act );
4079 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4080 prefs->setInt(freehand_tool_name(dataKludge) + "/shape", shape);
4081 }
4083 /**
4084 * \brief Generate the list of freehand advanced shape option entries.
4085 */
4086 static GList * freehand_shape_dropdown_items_list() {
4087 GList *glist = NULL;
4089 glist = g_list_append (glist, _("None"));
4090 glist = g_list_append (glist, _("Triangle in"));
4091 glist = g_list_append (glist, _("Triangle out"));
4092 glist = g_list_append (glist, _("Ellipse"));
4093 glist = g_list_append (glist, _("From clipboard"));
4095 return glist;
4096 }
4098 static void freehand_add_advanced_shape_options(GtkActionGroup* mainActions, GObject* holder, bool tool_is_pencil)
4099 {
4100 /*advanced shape options */
4101 {
4102 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4103 GtkListStore* model = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_INT );
4105 GList* items = 0;
4106 gint count = 0;
4107 for ( items = freehand_shape_dropdown_items_list(); items ; items = g_list_next(items) )
4108 {
4109 GtkTreeIter iter;
4110 gtk_list_store_append( model, &iter );
4111 gtk_list_store_set( model, &iter, 0, reinterpret_cast<gchar*>(items->data), 1, count, -1 );
4112 count++;
4113 }
4114 g_list_free( items );
4115 items = 0;
4116 EgeSelectOneAction* act1 = ege_select_one_action_new(
4117 tool_is_pencil ? "SetPencilShapeAction" : "SetPenShapeAction",
4118 _("Shape:"), (_("Shape of new paths drawn by this tool")), NULL, GTK_TREE_MODEL(model));
4119 g_object_set( act1, "short_label", _("Shape:"), NULL );
4120 ege_select_one_action_set_appearance( act1, "compact" );
4121 ege_select_one_action_set_active( act1, prefs->getInt(( tool_is_pencil ? "/tools/freehand/pencil/shape" : "/tools/freehand/pen/shape" ), 0) );
4122 g_signal_connect( G_OBJECT(act1), "changed", G_CALLBACK(freehand_change_shape), holder );
4123 gtk_action_group_add_action( mainActions, GTK_ACTION(act1) );
4124 g_object_set_data( holder, "shape_action", act1 );
4125 }
4126 }
4128 static void sp_pen_toolbox_prep(SPDesktop * /*desktop*/, GtkActionGroup* mainActions, GObject* holder)
4129 {
4130 sp_add_freehand_mode_toggle(mainActions, holder, false);
4131 freehand_add_advanced_shape_options(mainActions, holder, false);
4132 }
4135 static void sp_pencil_tb_defaults(GtkWidget * /*widget*/, GtkObject *obj)
4136 {
4137 GtkWidget *tbl = GTK_WIDGET(obj);
4139 GtkAdjustment *adj;
4141 // fixme: make settable
4142 gdouble tolerance = 4;
4144 adj = (GtkAdjustment*)gtk_object_get_data(obj, "tolerance");
4145 gtk_adjustment_set_value(adj, tolerance);
4146 gtk_adjustment_value_changed(adj);
4148 spinbutton_defocus(GTK_OBJECT(tbl));
4149 }
4151 static void sp_pencil_tb_tolerance_value_changed(GtkAdjustment *adj, GObject *tbl)
4152 {
4153 // quit if run by the attr_changed listener
4154 if (g_object_get_data( tbl, "freeze" )) {
4155 return;
4156 }
4157 // in turn, prevent listener from responding
4158 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4159 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
4160 prefs->setDouble("/tools/freehand/pencil/tolerance", adj->value);
4161 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
4162 }
4164 /*
4165 class PencilToleranceObserver : public Inkscape::Preferences::Observer {
4166 public:
4167 PencilToleranceObserver(Glib::ustring const &path, GObject *x) : Observer(path), _obj(x)
4168 {
4169 g_object_set_data(_obj, "prefobserver", this);
4170 }
4171 virtual ~PencilToleranceObserver() {
4172 if (g_object_get_data(_obj, "prefobserver") == this) {
4173 g_object_set_data(_obj, "prefobserver", NULL);
4174 }
4175 }
4176 virtual void notify(Inkscape::Preferences::Entry const &val) {
4177 GObject* tbl = _obj;
4178 if (g_object_get_data( tbl, "freeze" )) {
4179 return;
4180 }
4181 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
4183 GtkAdjustment * adj = (GtkAdjustment*)g_object_get_data(tbl, "tolerance");
4185 double v = val.getDouble(adj->value);
4186 gtk_adjustment_set_value(adj, v);
4187 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
4188 }
4189 private:
4190 GObject *_obj;
4191 };
4192 */
4194 static void sp_pencil_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
4195 {
4196 sp_add_freehand_mode_toggle(mainActions, holder, true);
4198 EgeAdjustmentAction* eact = 0;
4200 /* Tolerance */
4201 {
4202 gchar const* labels[] = {_("(many nodes, rough)"), _("(default)"), 0, 0, 0, 0, _("(few nodes, smooth)")};
4203 gdouble values[] = {1, 10, 20, 30, 50, 75, 100};
4204 eact = create_adjustment_action( "PencilToleranceAction",
4205 _("Smoothing:"), _("Smoothing: "),
4206 _("How much smoothing (simplifying) is applied to the line"),
4207 "/tools/freehand/pencil/tolerance",
4208 3.0,
4209 GTK_WIDGET(desktop->canvas), NULL,
4210 holder, TRUE, "altx-pencil",
4211 1, 100.0, 0.5, 1.0,
4212 labels, values, G_N_ELEMENTS(labels),
4213 sp_pencil_tb_tolerance_value_changed,
4214 1, 2);
4215 ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
4216 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
4217 }
4219 /* advanced shape options */
4220 freehand_add_advanced_shape_options(mainActions, holder, true);
4222 /* Reset */
4223 {
4224 InkAction* inky = ink_action_new( "PencilResetAction",
4225 _("Defaults"),
4226 _("Reset pencil parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
4227 GTK_STOCK_CLEAR,
4228 Inkscape::ICON_SIZE_SMALL_TOOLBAR );
4229 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_pencil_tb_defaults), holder );
4230 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
4231 }
4233 g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );
4235 }
4238 //########################
4239 //## Tweak ##
4240 //########################
4242 static void sp_tweak_width_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
4243 {
4244 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4245 prefs->setDouble( "/tools/tweak/width", adj->value * 0.01 );
4246 }
4248 static void sp_tweak_force_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
4249 {
4250 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4251 prefs->setDouble( "/tools/tweak/force", adj->value * 0.01 );
4252 }
4254 static void sp_tweak_pressure_state_changed( GtkToggleAction *act, gpointer /*data*/ )
4255 {
4256 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4257 prefs->setBool("/tools/tweak/usepressure", gtk_toggle_action_get_active(act));
4258 }
4260 static void sp_tweak_mode_changed( EgeSelectOneAction *act, GObject *tbl )
4261 {
4262 int mode = ege_select_one_action_get_active( act );
4263 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4264 prefs->setInt("/tools/tweak/mode", mode);
4266 static gchar const* names[] = {"tweak_doh", "tweak_dos", "tweak_dol", "tweak_doo", "tweak_channels_label"};
4267 bool flag = ((mode == TWEAK_MODE_COLORPAINT) || (mode == TWEAK_MODE_COLORJITTER));
4268 for (size_t i = 0; i < G_N_ELEMENTS(names); ++i) {
4269 GtkAction *act = GTK_ACTION(g_object_get_data( tbl, names[i] ));
4270 if (act) {
4271 gtk_action_set_sensitive(act, flag);
4272 }
4273 }
4274 GtkAction *fid = GTK_ACTION(g_object_get_data( tbl, "tweak_fidelity"));
4275 if (fid) {
4276 gtk_action_set_sensitive(fid, !flag);
4277 }
4278 }
4280 static void sp_tweak_fidelity_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
4281 {
4282 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4283 prefs->setDouble( "/tools/tweak/fidelity", adj->value * 0.01 );
4284 }
4286 static void tweak_toggle_doh(GtkToggleAction *act, gpointer /*data*/) {
4287 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4288 prefs->setBool("/tools/tweak/doh", gtk_toggle_action_get_active(act));
4289 }
4290 static void tweak_toggle_dos(GtkToggleAction *act, gpointer /*data*/) {
4291 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4292 prefs->setBool("/tools/tweak/dos", gtk_toggle_action_get_active(act));
4293 }
4294 static void tweak_toggle_dol(GtkToggleAction *act, gpointer /*data*/) {
4295 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4296 prefs->setBool("/tools/tweak/dol", gtk_toggle_action_get_active(act));
4297 }
4298 static void tweak_toggle_doo(GtkToggleAction *act, gpointer /*data*/) {
4299 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4300 prefs->setBool("/tools/tweak/doo", gtk_toggle_action_get_active(act));
4301 }
4303 static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
4304 {
4305 Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
4306 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4308 {
4309 /* Width */
4310 gchar const* labels[] = {_("(pinch tweak)"), 0, 0, 0, _("(default)"), 0, 0, 0, 0, _("(broad tweak)")};
4311 gdouble values[] = {1, 3, 5, 10, 15, 20, 30, 50, 75, 100};
4312 EgeAdjustmentAction *eact = create_adjustment_action( "TweakWidthAction",
4313 _("Width"), _("Width:"), _("The width of the tweak area (relative to the visible canvas area)"),
4314 "/tools/tweak/width", 15,
4315 GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-tweak",
4316 1, 100, 1.0, 10.0,
4317 labels, values, G_N_ELEMENTS(labels),
4318 sp_tweak_width_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 }
4325 {
4326 /* Force */
4327 gchar const* labels[] = {_("(minimum force)"), 0, 0, _("(default)"), 0, 0, 0, _("(maximum force)")};
4328 gdouble values[] = {1, 5, 10, 20, 30, 50, 70, 100};
4329 EgeAdjustmentAction *eact = create_adjustment_action( "TweakForceAction",
4330 _("Force"), _("Force:"), _("The force of the tweak action"),
4331 "/tools/tweak/force", 20,
4332 GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "tweak-force",
4333 1, 100, 1.0, 10.0,
4334 labels, values, G_N_ELEMENTS(labels),
4335 sp_tweak_force_value_changed, 0.01, 0, 100 );
4336 ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
4337 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
4338 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
4339 }
4341 /* Mode */
4342 {
4343 GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
4345 GtkTreeIter iter;
4346 gtk_list_store_append( model, &iter );
4347 gtk_list_store_set( model, &iter,
4348 0, _("Move mode"),
4349 1, _("Move objects in any direction"),
4350 2, INKSCAPE_ICON_OBJECT_TWEAK_PUSH,
4351 -1 );
4353 gtk_list_store_append( model, &iter );
4354 gtk_list_store_set( model, &iter,
4355 0, _("Move in/out mode"),
4356 1, _("Move objects towards cursor; with Shift from cursor"),
4357 2, INKSCAPE_ICON_OBJECT_TWEAK_ATTRACT,
4358 -1 );
4360 gtk_list_store_append( model, &iter );
4361 gtk_list_store_set( model, &iter,
4362 0, _("Move jitter mode"),
4363 1, _("Move objects in random directions"),
4364 2, INKSCAPE_ICON_OBJECT_TWEAK_RANDOMIZE,
4365 -1 );
4367 gtk_list_store_append( model, &iter );
4368 gtk_list_store_set( model, &iter,
4369 0, _("Scale mode"),
4370 1, _("Shrink objects, with Shift enlarge"),
4371 2, INKSCAPE_ICON_OBJECT_TWEAK_SHRINK,
4372 -1 );
4374 gtk_list_store_append( model, &iter );
4375 gtk_list_store_set( model, &iter,
4376 0, _("Rotate mode"),
4377 1, _("Rotate objects, with Shift counterclockwise"),
4378 2, INKSCAPE_ICON_OBJECT_TWEAK_ROTATE,
4379 -1 );
4381 gtk_list_store_append( model, &iter );
4382 gtk_list_store_set( model, &iter,
4383 0, _("Duplicate/delete mode"),
4384 1, _("Duplicate objects, with Shift delete"),
4385 2, INKSCAPE_ICON_OBJECT_TWEAK_DUPLICATE,
4386 -1 );
4388 gtk_list_store_append( model, &iter );
4389 gtk_list_store_set( model, &iter,
4390 0, _("Push mode"),
4391 1, _("Push parts of paths in any direction"),
4392 2, INKSCAPE_ICON_PATH_TWEAK_PUSH,
4393 -1 );
4395 gtk_list_store_append( model, &iter );
4396 gtk_list_store_set( model, &iter,
4397 0, _("Shrink/grow mode"),
4398 1, _("Shrink (inset) parts of paths; with Shift grow (outset)"),
4399 2, INKSCAPE_ICON_PATH_TWEAK_SHRINK,
4400 -1 );
4402 gtk_list_store_append( model, &iter );
4403 gtk_list_store_set( model, &iter,
4404 0, _("Attract/repel mode"),
4405 1, _("Attract parts of paths towards cursor; with Shift from cursor"),
4406 2, INKSCAPE_ICON_PATH_TWEAK_ATTRACT,
4407 -1 );
4409 gtk_list_store_append( model, &iter );
4410 gtk_list_store_set( model, &iter,
4411 0, _("Roughen mode"),
4412 1, _("Roughen parts of paths"),
4413 2, INKSCAPE_ICON_PATH_TWEAK_ROUGHEN,
4414 -1 );
4416 gtk_list_store_append( model, &iter );
4417 gtk_list_store_set( model, &iter,
4418 0, _("Color paint mode"),
4419 1, _("Paint the tool's color upon selected objects"),
4420 2, INKSCAPE_ICON_OBJECT_TWEAK_PAINT,
4421 -1 );
4423 gtk_list_store_append( model, &iter );
4424 gtk_list_store_set( model, &iter,
4425 0, _("Color jitter mode"),
4426 1, _("Jitter the colors of selected objects"),
4427 2, INKSCAPE_ICON_OBJECT_TWEAK_JITTER_COLOR,
4428 -1 );
4430 gtk_list_store_append( model, &iter );
4431 gtk_list_store_set( model, &iter,
4432 0, _("Blur mode"),
4433 1, _("Blur selected objects more; with Shift, blur less"),
4434 2, INKSCAPE_ICON_OBJECT_TWEAK_BLUR,
4435 -1 );
4438 EgeSelectOneAction* act = ege_select_one_action_new( "TweakModeAction", _("Mode"), (""), NULL, GTK_TREE_MODEL(model) );
4439 g_object_set( act, "short_label", _("Mode:"), NULL );
4440 gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
4441 g_object_set_data( holder, "mode_action", act );
4443 ege_select_one_action_set_appearance( act, "full" );
4444 ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
4445 g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
4446 ege_select_one_action_set_icon_column( act, 2 );
4447 ege_select_one_action_set_icon_size( act, secondarySize );
4448 ege_select_one_action_set_tooltip_column( act, 1 );
4450 gint mode = prefs->getInt("/tools/tweak/mode", 0);
4451 ege_select_one_action_set_active( act, mode );
4452 g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_tweak_mode_changed), holder );
4454 g_object_set_data( G_OBJECT(holder), "tweak_tool_mode", act);
4455 }
4457 guint mode = prefs->getInt("/tools/tweak/mode", 0);
4459 {
4460 EgeOutputAction* act = ege_output_action_new( "TweakChannelsLabel", _("Channels:"), "", 0 );
4461 ege_output_action_set_use_markup( act, TRUE );
4462 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
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_channels_label", act);
4467 }
4469 {
4470 InkToggleAction* act = ink_toggle_action_new( "TweakDoH",
4471 _("Hue"),
4472 _("In color mode, act on objects' hue"),
4473 NULL,
4474 Inkscape::ICON_SIZE_DECORATION );
4475 //TRANSLATORS: "H" here stands for hue
4476 g_object_set( act, "short_label", _("H"), NULL );
4477 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
4478 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_doh), desktop );
4479 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/doh", true) );
4480 if (mode != TWEAK_MODE_COLORPAINT && mode != TWEAK_MODE_COLORJITTER) {
4481 gtk_action_set_sensitive (GTK_ACTION(act), FALSE);
4482 }
4483 g_object_set_data( holder, "tweak_doh", act);
4484 }
4485 {
4486 InkToggleAction* act = ink_toggle_action_new( "TweakDoS",
4487 _("Saturation"),
4488 _("In color mode, act on objects' saturation"),
4489 NULL,
4490 Inkscape::ICON_SIZE_DECORATION );
4491 //TRANSLATORS: "S" here stands for Saturation
4492 g_object_set( act, "short_label", _("S"), NULL );
4493 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
4494 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_dos), desktop );
4495 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/dos", true) );
4496 if (mode != TWEAK_MODE_COLORPAINT && mode != TWEAK_MODE_COLORJITTER) {
4497 gtk_action_set_sensitive (GTK_ACTION(act), FALSE);
4498 }
4499 g_object_set_data( holder, "tweak_dos", act );
4500 }
4501 {
4502 InkToggleAction* act = ink_toggle_action_new( "TweakDoL",
4503 _("Lightness"),
4504 _("In color mode, act on objects' lightness"),
4505 NULL,
4506 Inkscape::ICON_SIZE_DECORATION );
4507 //TRANSLATORS: "L" here stands for Lightness
4508 g_object_set( act, "short_label", _("L"), NULL );
4509 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
4510 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_dol), desktop );
4511 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/dol", true) );
4512 if (mode != TWEAK_MODE_COLORPAINT && mode != TWEAK_MODE_COLORJITTER) {
4513 gtk_action_set_sensitive (GTK_ACTION(act), FALSE);
4514 }
4515 g_object_set_data( holder, "tweak_dol", act );
4516 }
4517 {
4518 InkToggleAction* act = ink_toggle_action_new( "TweakDoO",
4519 _("Opacity"),
4520 _("In color mode, act on objects' opacity"),
4521 NULL,
4522 Inkscape::ICON_SIZE_DECORATION );
4523 //TRANSLATORS: "O" here stands for Opacity
4524 g_object_set( act, "short_label", _("O"), NULL );
4525 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
4526 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_doo), desktop );
4527 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/doo", true) );
4528 if (mode != TWEAK_MODE_COLORPAINT && mode != TWEAK_MODE_COLORJITTER) {
4529 gtk_action_set_sensitive (GTK_ACTION(act), FALSE);
4530 }
4531 g_object_set_data( holder, "tweak_doo", act );
4532 }
4534 { /* Fidelity */
4535 gchar const* labels[] = {_("(rough, simplified)"), 0, 0, _("(default)"), 0, 0, _("(fine, but many nodes)")};
4536 gdouble values[] = {10, 25, 35, 50, 60, 80, 100};
4537 EgeAdjustmentAction *eact = create_adjustment_action( "TweakFidelityAction",
4538 _("Fidelity"), _("Fidelity:"),
4539 _("Low fidelity simplifies paths; high fidelity preserves path features but may generate a lot of new nodes"),
4540 "/tools/tweak/fidelity", 50,
4541 GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "tweak-fidelity",
4542 1, 100, 1.0, 10.0,
4543 labels, values, G_N_ELEMENTS(labels),
4544 sp_tweak_fidelity_value_changed, 0.01, 0, 100 );
4545 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
4546 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
4547 if (mode == TWEAK_MODE_COLORPAINT || mode == TWEAK_MODE_COLORJITTER) {
4548 gtk_action_set_sensitive (GTK_ACTION(eact), FALSE);
4549 }
4550 g_object_set_data( holder, "tweak_fidelity", eact );
4551 }
4554 /* Use Pressure button */
4555 {
4556 InkToggleAction* act = ink_toggle_action_new( "TweakPressureAction",
4557 _("Pressure"),
4558 _("Use the pressure of the input device to alter the force of tweak action"),
4559 INKSCAPE_ICON_DRAW_USE_PRESSURE,
4560 Inkscape::ICON_SIZE_DECORATION );
4561 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
4562 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_tweak_pressure_state_changed), NULL);
4563 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/usepressure", true) );
4564 }
4566 }
4569 //########################
4570 //## Spray ##
4571 //########################
4573 static void sp_spray_width_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
4574 {
4575 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4576 prefs->setDouble( "/tools/spray/width", adj->value );
4577 }
4579 static void sp_spray_mean_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
4580 {
4581 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4582 prefs->setDouble( "/tools/spray/mean", adj->value );
4583 }
4585 static void sp_spray_standard_deviation_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
4586 {
4587 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4588 prefs->setDouble( "/tools/spray/standard_deviation", adj->value );
4589 }
4591 static void sp_spray_pressure_state_changed( GtkToggleAction *act, gpointer /*data*/ )
4592 {
4593 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4594 prefs->setBool("/tools/spray/usepressure", gtk_toggle_action_get_active(act));
4595 }
4597 static void sp_spray_mode_changed( EgeSelectOneAction *act, GObject * /*tbl*/ )
4598 {
4599 int mode = ege_select_one_action_get_active( act );
4600 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4601 prefs->setInt("/tools/spray/mode", mode);
4602 }
4604 static void sp_spray_population_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
4605 {
4606 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4607 prefs->setDouble( "/tools/spray/population", adj->value );
4608 }
4610 static void sp_spray_rotation_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
4611 {
4612 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4613 prefs->setDouble( "/tools/spray/rotation_variation", adj->value );
4614 }
4616 static void sp_spray_scale_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ )
4617 {
4618 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4619 prefs->setDouble( "/tools/spray/scale_variation", adj->value );
4620 }
4623 static void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
4624 {
4625 Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
4626 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4628 {
4629 /* Width */
4630 gchar const* labels[] = {_("(narrow spray)"), 0, 0, 0, _("(default)"), 0, 0, 0, 0, _("(broad spray)")};
4631 gdouble values[] = {1, 3, 5, 10, 15, 20, 30, 50, 75, 100};
4632 EgeAdjustmentAction *eact = create_adjustment_action( "SprayWidthAction",
4633 _("Width"), _("Width:"), _("The width of the spray area (relative to the visible canvas area)"),
4634 "/tools/spray/width", 15,
4635 GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-spray",
4636 1, 100, 1.0, 10.0,
4637 labels, values, G_N_ELEMENTS(labels),
4638 sp_spray_width_value_changed, 1, 0 );
4639 ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
4640 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
4641 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
4642 }
4644 {
4645 /* Mean */
4646 gchar const* labels[] = {_("(minimum mean)"), 0, 0, _("(default)"), 0, 0, 0, _("(maximum mean)")};
4647 gdouble values[] = {1, 5, 10, 20, 30, 50, 70, 100};
4648 EgeAdjustmentAction *eact = create_adjustment_action( "SprayMeanAction",
4649 _("Focus"), _("Focus:"), _("0 to spray a spot. Increase to enlarge the ring radius."),
4650 "/tools/spray/mean", 0,
4651 GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "spray-mean",
4652 0, 100, 1.0, 10.0,
4653 labels, values, G_N_ELEMENTS(labels),
4654 sp_spray_mean_value_changed, 1, 0 );
4655 ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
4656 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
4657 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
4658 }
4660 {
4661 /* Standard_deviation */
4662 gchar const* labels[] = {_("(minimum scatter)"), 0, 0, _("(default)"), 0, 0, 0, _("(maximum scatter)")};
4663 gdouble values[] = {1, 5, 10, 20, 30, 50, 70, 100};
4665 //TRANSLATORS: only translate "string" in "context|string".
4666 // For more details, see http://developer.gnome.org/doc/API/2.0/glib/glib-I18N.html#Q-:CAPS
4667 EgeAdjustmentAction *eact = create_adjustment_action( "SprayStandard_deviationAction",
4668 Q_("Toolbox|Scatter"), Q_("Toolbox|Scatter:"), _("Increase to scatter sprayed objects."),
4669 "/tools/spray/standard_deviation", 70,
4670 GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "spray-standard_deviation",
4671 1, 100, 1.0, 10.0,
4672 labels, values, G_N_ELEMENTS(labels),
4673 sp_spray_standard_deviation_value_changed, 1, 0 );
4674 ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
4675 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
4676 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
4677 }
4679 /* Mode */
4680 {
4681 GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
4683 GtkTreeIter iter;
4684 gtk_list_store_append( model, &iter );
4685 gtk_list_store_set( model, &iter,
4686 0, _("Spray with copies"),
4687 1, _("Spray copies of the initial selection"),
4688 2, INKSCAPE_ICON_SPRAY_COPY_MODE,
4689 -1 );
4691 gtk_list_store_append( model, &iter );
4692 gtk_list_store_set( model, &iter,
4693 0, _("Spray with clones"),
4694 1, _("Spray clones of the initial selection"),
4695 2, INKSCAPE_ICON_SPRAY_CLONE_MODE,
4696 -1 );
4698 gtk_list_store_append( model, &iter );
4699 gtk_list_store_set( model, &iter,
4700 0, _("Spray single path"),
4701 1, _("Spray objects in a single path"),
4702 2, INKSCAPE_ICON_SPRAY_UNION_MODE,
4703 -1 );
4705 EgeSelectOneAction* act = ege_select_one_action_new( "SprayModeAction", _("Mode"), (""), NULL, GTK_TREE_MODEL(model) );
4706 g_object_set( act, "short_label", _("Mode:"), NULL );
4707 gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
4708 g_object_set_data( holder, "mode_action", act );
4710 ege_select_one_action_set_appearance( act, "full" );
4711 ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
4712 g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
4713 ege_select_one_action_set_icon_column( act, 2 );
4714 ege_select_one_action_set_icon_size( act, secondarySize );
4715 ege_select_one_action_set_tooltip_column( act, 1 );
4717 gint mode = prefs->getInt("/tools/spray/mode", 1);
4718 ege_select_one_action_set_active( act, mode );
4719 g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_spray_mode_changed), holder );
4721 g_object_set_data( G_OBJECT(holder), "spray_tool_mode", act);
4722 }
4724 { /* Population */
4725 gchar const* labels[] = {_("(low population)"), 0, 0, _("(default)"), 0, 0, _("(high population)")};
4726 gdouble values[] = {10, 25, 35, 50, 60, 80, 100};
4727 EgeAdjustmentAction *eact = create_adjustment_action( "SprayPopulationAction",
4728 _("Amount"), _("Amount:"),
4729 _("Adjusts the number of items sprayed per clic."),
4730 "/tools/spray/population", 70,
4731 GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "spray-population",
4732 1, 100, 1.0, 10.0,
4733 labels, values, G_N_ELEMENTS(labels),
4734 sp_spray_population_value_changed, 1, 0 );
4735 ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
4736 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
4737 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
4738 g_object_set_data( holder, "spray_population", eact );
4739 }
4741 /* Use Pressure button */
4742 {
4743 InkToggleAction* act = ink_toggle_action_new( "SprayPressureAction",
4744 _("Pressure"),
4745 _("Use the pressure of the input device to alter the amount of sprayed objects."),
4746 "use_pressure",
4747 Inkscape::ICON_SIZE_DECORATION );
4748 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
4749 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_spray_pressure_state_changed), NULL);
4750 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/usepressure", true) );
4751 }
4753 { /* Rotation */
4754 gchar const* labels[] = {_("(low rotation variation)"), 0, 0, _("(default)"), 0, 0, _("(high rotation variation)")};
4755 gdouble values[] = {10, 25, 35, 50, 60, 80, 100};
4756 EgeAdjustmentAction *eact = create_adjustment_action( "SprayRotationAction",
4757 _("Rotation"), _("Rotation:"),
4758 // xgettext:no-c-format
4759 _("Variation of the rotation of the sprayed objects. 0% for the same rotation than the original object."),
4760 "/tools/spray/rotation_variation", 0,
4761 GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "spray-rotation",
4762 0, 100, 1.0, 10.0,
4763 labels, values, G_N_ELEMENTS(labels),
4764 sp_spray_rotation_value_changed, 1, 0 );
4765 ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
4766 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
4767 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
4768 g_object_set_data( holder, "spray_rotation", eact );
4769 }
4771 { /* Scale */
4772 gchar const* labels[] = {_("(low scale variation)"), 0, 0, _("(default)"), 0, 0, _("(high scale variation)")};
4773 gdouble values[] = {10, 25, 35, 50, 60, 80, 100};
4775 //TRANSLATORS: only translate "string" in "context|string".
4776 // For more details, see http://developer.gnome.org/doc/API/2.0/glib/glib-I18N.html#Q-:CAPS
4777 EgeAdjustmentAction *eact = create_adjustment_action( "SprayScaleAction",
4778 Q_("Toolbox|Scale"), Q_("Toolbox|Scale:"),
4779 // xgettext:no-c-format
4780 _("Variation in the scale of the sprayed objects. 0% for the same scale than the original object."),
4781 "/tools/spray/scale_variation", 0,
4782 GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "spray-scale",
4783 0, 100, 1.0, 10.0,
4784 labels, values, G_N_ELEMENTS(labels),
4785 sp_spray_scale_value_changed, 1, 0 );
4786 ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
4787 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
4788 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
4789 g_object_set_data( holder, "spray_scale", eact );
4790 }
4794 }
4797 //########################
4798 //## Calligraphy ##
4799 //########################
4800 static void update_presets_list(GObject *tbl)
4801 {
4802 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4803 if (g_object_get_data(tbl, "presets_blocked")) {
4804 return;
4805 }
4807 EgeSelectOneAction *sel = static_cast<EgeSelectOneAction *>(g_object_get_data(tbl, "profile_selector"));
4808 if (!sel) {
4809 // WTF!? This will cause a segfault if ever reached
4810 //ege_select_one_action_set_active(sel, 0);
4811 return;
4812 }
4814 std::vector<Glib::ustring> presets = prefs->getAllDirs("/tools/calligraphic/preset");
4816 int ege_index = 1;
4817 for (std::vector<Glib::ustring>::iterator i = presets.begin(); i != presets.end(); ++i, ++ege_index) {
4818 bool match = true;
4820 std::vector<Inkscape::Preferences::Entry> preset = prefs->getAllEntries(*i);
4821 for (std::vector<Inkscape::Preferences::Entry>::iterator j = preset.begin(); j != preset.end(); ++j) {
4822 Glib::ustring entry_name = j->getEntryName();
4823 if (entry_name == "id" || entry_name == "name") {
4824 continue;
4825 }
4827 void *widget = g_object_get_data(tbl, entry_name.data());
4828 if (widget) {
4829 if (GTK_IS_ADJUSTMENT(widget)) {
4830 double v = j->getDouble();
4831 GtkAdjustment* adj = static_cast<GtkAdjustment *>(widget);
4832 //std::cout << "compared adj " << attr_name << gtk_adjustment_get_value(adj) << " to " << v << "\n";
4833 if (fabs(gtk_adjustment_get_value(adj) - v) > 1e-6) {
4834 match = false;
4835 break;
4836 }
4837 } else if (GTK_IS_TOGGLE_ACTION(widget)) {
4838 bool v = j->getBool();
4839 GtkToggleAction* toggle = static_cast<GtkToggleAction *>(widget);
4840 //std::cout << "compared toggle " << attr_name << gtk_toggle_action_get_active(toggle) << " to " << v << "\n";
4841 if ( static_cast<bool>(gtk_toggle_action_get_active(toggle)) != v ) {
4842 match = false;
4843 break;
4844 }
4845 }
4846 }
4847 }
4849 if (match) {
4850 // newly added item is at the same index as the
4851 // save command, so we need to change twice for it to take effect
4852 ege_select_one_action_set_active(sel, 0);
4853 ege_select_one_action_set_active(sel, ege_index); // one-based index
4854 return;
4855 }
4856 }
4858 // no match found
4859 ege_select_one_action_set_active(sel, 0);
4860 }
4862 static void sp_ddc_mass_value_changed( GtkAdjustment *adj, GObject* tbl )
4863 {
4864 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4865 prefs->setDouble( "/tools/calligraphic/mass", adj->value );
4866 update_presets_list(tbl);
4867 }
4869 static void sp_ddc_wiggle_value_changed( GtkAdjustment *adj, GObject* tbl )
4870 {
4871 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4872 prefs->setDouble( "/tools/calligraphic/wiggle", adj->value );
4873 update_presets_list(tbl);
4874 }
4876 static void sp_ddc_angle_value_changed( GtkAdjustment *adj, GObject* tbl )
4877 {
4878 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4879 prefs->setDouble( "/tools/calligraphic/angle", adj->value );
4880 update_presets_list(tbl);
4881 }
4883 static void sp_ddc_width_value_changed( GtkAdjustment *adj, GObject *tbl )
4884 {
4885 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4886 prefs->setDouble( "/tools/calligraphic/width", adj->value );
4887 update_presets_list(tbl);
4888 }
4890 static void sp_ddc_velthin_value_changed( GtkAdjustment *adj, GObject* tbl )
4891 {
4892 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4893 prefs->setDouble("/tools/calligraphic/thinning", adj->value );
4894 update_presets_list(tbl);
4895 }
4897 static void sp_ddc_flatness_value_changed( GtkAdjustment *adj, GObject* tbl )
4898 {
4899 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4900 prefs->setDouble( "/tools/calligraphic/flatness", adj->value );
4901 update_presets_list(tbl);
4902 }
4904 static void sp_ddc_tremor_value_changed( GtkAdjustment *adj, GObject* tbl )
4905 {
4906 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4907 prefs->setDouble( "/tools/calligraphic/tremor", adj->value );
4908 update_presets_list(tbl);
4909 }
4911 static void sp_ddc_cap_rounding_value_changed( GtkAdjustment *adj, GObject* tbl )
4912 {
4913 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4914 prefs->setDouble( "/tools/calligraphic/cap_rounding", adj->value );
4915 update_presets_list(tbl);
4916 }
4918 static void sp_ddc_tilt_state_changed( GtkToggleAction *act, GObject* tbl )
4919 {
4920 // TODO merge into PrefPusher
4921 GtkAction * calligraphy_angle = static_cast<GtkAction *> (g_object_get_data(tbl,"angle_action"));
4922 if (calligraphy_angle ) {
4923 gtk_action_set_sensitive( calligraphy_angle, !gtk_toggle_action_get_active( act ) );
4924 }
4925 }
4928 static gchar const *const widget_names[] = {
4929 "width",
4930 "mass",
4931 "wiggle",
4932 "angle",
4933 "thinning",
4934 "tremor",
4935 "flatness",
4936 "cap_rounding",
4937 "usepressure",
4938 "tracebackground",
4939 "usetilt"
4940 };
4943 static void sp_dcc_build_presets_list(GObject *tbl)
4944 {
4945 g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(TRUE));
4947 EgeSelectOneAction* selector = static_cast<EgeSelectOneAction *>(g_object_get_data(tbl, "profile_selector"));
4948 GtkListStore* model = GTK_LIST_STORE(ege_select_one_action_get_model(selector));
4949 gtk_list_store_clear (model);
4951 {
4952 GtkTreeIter iter;
4953 gtk_list_store_append( model, &iter );
4954 gtk_list_store_set( model, &iter, 0, _("No preset"), 1, 0, -1 );
4955 }
4957 // iterate over all presets to populate the list
4958 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4959 std::vector<Glib::ustring> presets = prefs->getAllDirs("/tools/calligraphic/preset");
4960 int ii=1;
4962 for (std::vector<Glib::ustring>::iterator i = presets.begin(); i != presets.end(); ++i) {
4963 GtkTreeIter iter;
4964 Glib::ustring preset_name = prefs->getString(*i + "/name");
4965 gtk_list_store_append( model, &iter );
4966 gtk_list_store_set( model, &iter, 0, _(preset_name.data()), 1, ii++, -1 );
4967 }
4969 {
4970 GtkTreeIter iter;
4971 gtk_list_store_append( model, &iter );
4972 gtk_list_store_set( model, &iter, 0, _("Save..."), 1, ii, -1 );
4973 g_object_set_data(tbl, "save_presets_index", GINT_TO_POINTER(ii));
4974 }
4976 g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(FALSE));
4978 update_presets_list (tbl);
4979 }
4981 static void sp_dcc_save_profile(GtkWidget * /*widget*/, GObject *tbl)
4982 {
4983 using Inkscape::UI::Dialog::CalligraphicProfileRename;
4984 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
4985 SPDesktop *desktop = (SPDesktop *) g_object_get_data(tbl, "desktop" );
4986 if (! desktop) {
4987 return;
4988 }
4990 if (g_object_get_data(tbl, "presets_blocked")) {
4991 return;
4992 }
4994 CalligraphicProfileRename::show(desktop);
4995 if ( !CalligraphicProfileRename::applied()) {
4996 // dialog cancelled
4997 update_presets_list (tbl);
4998 return;
4999 }
5000 Glib::ustring profile_name = CalligraphicProfileRename::getProfileName();
5002 if (profile_name.empty()) {
5003 // empty name entered
5004 update_presets_list (tbl);
5005 return;
5006 }
5008 g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(TRUE));
5010 // If there's a preset with the given name, find it and set save_path appropriately
5011 std::vector<Glib::ustring> presets = prefs->getAllDirs("/tools/calligraphic/preset");
5012 int total_presets = presets.size();
5013 int new_index = -1;
5014 Glib::ustring save_path; // profile pref path without a trailing slash
5016 int temp_index = 0;
5017 for (std::vector<Glib::ustring>::iterator i = presets.begin(); i != presets.end(); ++i, ++temp_index) {
5018 Glib::ustring name = prefs->getString(*i + "/name");
5019 if (!name.empty() && profile_name == name) {
5020 new_index = temp_index;
5021 save_path = *i;
5022 break;
5023 }
5024 }
5026 if (new_index == -1) {
5027 // no preset with this name, create
5028 new_index = total_presets + 1;
5029 gchar *profile_id = g_strdup_printf("/dcc%d", new_index);
5030 save_path = Glib::ustring("/tools/calligraphic/preset") + profile_id;
5031 g_free(profile_id);
5032 }
5034 for (unsigned i = 0; i < G_N_ELEMENTS(widget_names); ++i) {
5035 gchar const *const widget_name = widget_names[i];
5036 void *widget = g_object_get_data(tbl, widget_name);
5037 if (widget) {
5038 if (GTK_IS_ADJUSTMENT(widget)) {
5039 GtkAdjustment* adj = static_cast<GtkAdjustment *>(widget);
5040 prefs->setDouble(save_path + "/" + widget_name, gtk_adjustment_get_value(adj));
5041 //std::cout << "wrote adj " << widget_name << ": " << v << "\n";
5042 } else if (GTK_IS_TOGGLE_ACTION(widget)) {
5043 GtkToggleAction* toggle = static_cast<GtkToggleAction *>(widget);
5044 prefs->setBool(save_path + "/" + widget_name, gtk_toggle_action_get_active(toggle));
5045 //std::cout << "wrote tog " << widget_name << ": " << v << "\n";
5046 } else {
5047 g_warning("Unknown widget type for preset: %s\n", widget_name);
5048 }
5049 } else {
5050 g_warning("Bad key when writing preset: %s\n", widget_name);
5051 }
5052 }
5053 prefs->setString(save_path + "/name", profile_name);
5055 g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(FALSE));
5056 sp_dcc_build_presets_list (tbl);
5057 }
5060 static void sp_ddc_change_profile(EgeSelectOneAction* act, GObject* tbl)
5061 {
5062 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5064 gint preset_index = ege_select_one_action_get_active( act );
5065 // This is necessary because EgeSelectOneAction spams us with GObject "changed" signal calls
5066 // even when the preset is not changed. It would be good to replace it with something more
5067 // modern. Index 0 means "No preset", so we don't do anything.
5068 if (preset_index == 0) {
5069 return;
5070 }
5072 gint save_presets_index = GPOINTER_TO_INT(g_object_get_data(tbl, "save_presets_index"));
5074 if (preset_index == save_presets_index) {
5075 // this is the Save command
5076 sp_dcc_save_profile(NULL, tbl);
5077 return;
5078 }
5080 if (g_object_get_data(tbl, "presets_blocked")) {
5081 return;
5082 }
5084 // preset_index is one-based so we subtract 1
5085 std::vector<Glib::ustring> presets = prefs->getAllDirs("/tools/calligraphic/preset");
5086 Glib::ustring preset_path = presets.at(preset_index - 1);
5088 if (!preset_path.empty()) {
5089 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
5091 std::vector<Inkscape::Preferences::Entry> preset = prefs->getAllEntries(preset_path);
5093 // Shouldn't this be std::map?
5094 for (std::vector<Inkscape::Preferences::Entry>::iterator i = preset.begin(); i != preset.end(); ++i) {
5095 Glib::ustring entry_name = i->getEntryName();
5096 if (entry_name == "id" || entry_name == "name") {
5097 continue;
5098 }
5099 void *widget = g_object_get_data(tbl, entry_name.data());
5100 if (widget) {
5101 if (GTK_IS_ADJUSTMENT(widget)) {
5102 GtkAdjustment* adj = static_cast<GtkAdjustment *>(widget);
5103 gtk_adjustment_set_value(adj, i->getDouble());
5104 //std::cout << "set adj " << attr_name << " to " << v << "\n";
5105 } else if (GTK_IS_TOGGLE_ACTION(widget)) {
5106 GtkToggleAction* toggle = static_cast<GtkToggleAction *>(widget);
5107 gtk_toggle_action_set_active(toggle, i->getBool());
5108 //std::cout << "set toggle " << attr_name << " to " << v << "\n";
5109 } else {
5110 g_warning("Unknown widget type for preset: %s\n", entry_name.data());
5111 }
5112 } else {
5113 g_warning("Bad key found in a preset record: %s\n", entry_name.data());
5114 }
5115 }
5116 g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(FALSE));
5117 }
5118 }
5120 static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
5121 {
5122 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5123 {
5124 g_object_set_data(holder, "presets_blocked", GINT_TO_POINTER(TRUE));
5126 EgeAdjustmentAction* calligraphy_angle = 0;
5128 {
5129 /* Width */
5130 gchar const* labels[] = {_("(hairline)"), 0, 0, 0, _("(default)"), 0, 0, 0, 0, _("(broad stroke)")};
5131 gdouble values[] = {1, 3, 5, 10, 15, 20, 30, 50, 75, 100};
5132 EgeAdjustmentAction *eact = create_adjustment_action( "CalligraphyWidthAction",
5133 _("Pen Width"), _("Width:"),
5134 _("The width of the calligraphic pen (relative to the visible canvas area)"),
5135 "/tools/calligraphic/width", 15,
5136 GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-calligraphy",
5137 1, 100, 1.0, 10.0,
5138 labels, values, G_N_ELEMENTS(labels),
5139 sp_ddc_width_value_changed, 1, 0 );
5140 ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
5141 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
5142 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
5143 }
5145 {
5146 /* Thinning */
5147 gchar const* labels[] = {_("(speed blows up stroke)"), 0, 0, _("(slight widening)"), _("(constant width)"), _("(slight thinning, default)"), 0, 0, _("(speed deflates stroke)")};
5148 gdouble values[] = {-100, -40, -20, -10, 0, 10, 20, 40, 100};
5149 EgeAdjustmentAction* eact = create_adjustment_action( "ThinningAction",
5150 _("Stroke Thinning"), _("Thinning:"),
5151 _("How much velocity thins the stroke (> 0 makes fast strokes thinner, < 0 makes them broader, 0 makes width independent of velocity)"),
5152 "/tools/calligraphic/thinning", 10,
5153 GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
5154 -100, 100, 1, 10.0,
5155 labels, values, G_N_ELEMENTS(labels),
5156 sp_ddc_velthin_value_changed, 1, 0);
5157 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
5158 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
5159 }
5161 {
5162 /* Angle */
5163 gchar const* labels[] = {_("(left edge up)"), 0, 0, _("(horizontal)"), _("(default)"), 0, _("(right edge up)")};
5164 gdouble values[] = {-90, -60, -30, 0, 30, 60, 90};
5165 EgeAdjustmentAction* eact = create_adjustment_action( "AngleAction",
5166 _("Pen Angle"), _("Angle:"),
5167 _("The angle of the pen's nib (in degrees; 0 = horizontal; has no effect if fixation = 0)"),
5168 "/tools/calligraphic/angle", 30,
5169 GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "calligraphy-angle",
5170 -90.0, 90.0, 1.0, 10.0,
5171 labels, values, G_N_ELEMENTS(labels),
5172 sp_ddc_angle_value_changed, 1, 0 );
5173 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
5174 g_object_set_data( holder, "angle_action", eact );
5175 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
5176 calligraphy_angle = eact;
5177 }
5179 {
5180 /* Fixation */
5181 gchar const* labels[] = {_("(perpendicular to stroke, \"brush\")"), 0, 0, 0, _("(almost fixed, default)"), _("(fixed by Angle, \"pen\")")};
5182 gdouble values[] = {0, 20, 40, 60, 90, 100};
5183 EgeAdjustmentAction* eact = create_adjustment_action( "FixationAction",
5184 _("Fixation"), _("Fixation:"),
5185 _("Angle behavior (0 = nib always perpendicular to stroke direction, 100 = fixed angle)"),
5186 "/tools/calligraphic/flatness", 90,
5187 GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
5188 0.0, 100, 1.0, 10.0,
5189 labels, values, G_N_ELEMENTS(labels),
5190 sp_ddc_flatness_value_changed, 1, 0);
5191 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
5192 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
5193 }
5195 {
5196 /* Cap Rounding */
5197 gchar const* labels[] = {_("(blunt caps, default)"), _("(slightly bulging)"), 0, 0, _("(approximately round)"), _("(long protruding caps)")};
5198 gdouble values[] = {0, 0.3, 0.5, 1.0, 1.4, 5.0};
5199 // TRANSLATORS: "cap" means "end" (both start and finish) here
5200 EgeAdjustmentAction* eact = create_adjustment_action( "CapRoundingAction",
5201 _("Cap rounding"), _("Caps:"),
5202 _("Increase to make caps at the ends of strokes protrude more (0 = no caps, 1 = round caps)"),
5203 "/tools/calligraphic/cap_rounding", 0.0,
5204 GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
5205 0.0, 5.0, 0.01, 0.1,
5206 labels, values, G_N_ELEMENTS(labels),
5207 sp_ddc_cap_rounding_value_changed, 0.01, 2 );
5208 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
5209 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
5210 }
5212 {
5213 /* Tremor */
5214 gchar const* labels[] = {_("(smooth line)"), _("(slight tremor)"), _("(noticeable tremor)"), 0, 0, _("(maximum tremor)")};
5215 gdouble values[] = {0, 10, 20, 40, 60, 100};
5216 EgeAdjustmentAction* eact = create_adjustment_action( "TremorAction",
5217 _("Stroke Tremor"), _("Tremor:"),
5218 _("Increase to make strokes rugged and trembling"),
5219 "/tools/calligraphic/tremor", 0.0,
5220 GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
5221 0.0, 100, 1, 10.0,
5222 labels, values, G_N_ELEMENTS(labels),
5223 sp_ddc_tremor_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 /* Wiggle */
5232 gchar const* labels[] = {_("(no wiggle)"), _("(slight deviation)"), 0, 0, _("(wild waves and curls)")};
5233 gdouble values[] = {0, 20, 40, 60, 100};
5234 EgeAdjustmentAction* eact = create_adjustment_action( "WiggleAction",
5235 _("Pen Wiggle"), _("Wiggle:"),
5236 _("Increase to make the pen waver and wiggle"),
5237 "/tools/calligraphic/wiggle", 0.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_wiggle_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 }
5247 {
5248 /* Mass */
5249 gchar const* labels[] = {_("(no inertia)"), _("(slight smoothing, default)"), _("(noticeable lagging)"), 0, 0, _("(maximum inertia)")};
5250 gdouble values[] = {0.0, 2, 10, 20, 50, 100};
5251 EgeAdjustmentAction* eact = create_adjustment_action( "MassAction",
5252 _("Pen Mass"), _("Mass:"),
5253 _("Increase to make the pen drag behind, as if slowed by inertia"),
5254 "/tools/calligraphic/mass", 2.0,
5255 GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
5256 0.0, 100, 1, 10.0,
5257 labels, values, G_N_ELEMENTS(labels),
5258 sp_ddc_mass_value_changed, 1, 0);
5259 ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
5260 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
5261 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
5262 }
5265 /* Trace Background button */
5266 {
5267 InkToggleAction* act = ink_toggle_action_new( "TraceAction",
5268 _("Trace Background"),
5269 _("Trace the lightness of the background by the width of the pen (white - minimum width, black - maximum width)"),
5270 INKSCAPE_ICON_DRAW_TRACE_BACKGROUND,
5271 Inkscape::ICON_SIZE_DECORATION );
5272 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
5273 PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/calligraphic/tracebackground", update_presets_list, holder);
5274 g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
5275 g_object_set_data( holder, "tracebackground", act );
5276 }
5278 /* Use Pressure button */
5279 {
5280 InkToggleAction* act = ink_toggle_action_new( "PressureAction",
5281 _("Pressure"),
5282 _("Use the pressure of the input device to alter the width of the pen"),
5283 INKSCAPE_ICON_DRAW_USE_PRESSURE,
5284 Inkscape::ICON_SIZE_DECORATION );
5285 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
5286 PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/calligraphic/usepressure", update_presets_list, holder);
5287 g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
5288 g_object_set_data( holder, "usepressure", act );
5289 }
5291 /* Use Tilt button */
5292 {
5293 InkToggleAction* act = ink_toggle_action_new( "TiltAction",
5294 _("Tilt"),
5295 _("Use the tilt of the input device to alter the angle of the pen's nib"),
5296 INKSCAPE_ICON_DRAW_USE_TILT,
5297 Inkscape::ICON_SIZE_DECORATION );
5298 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
5299 PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/calligraphic/usetilt", update_presets_list, holder);
5300 g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher);
5301 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_ddc_tilt_state_changed), holder );
5302 gtk_action_set_sensitive( GTK_ACTION(calligraphy_angle), !prefs->getBool("/tools/calligraphic/usetilt", true) );
5303 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/calligraphic/usetilt", true) );
5304 g_object_set_data( holder, "usetilt", act );
5305 }
5307 /*calligraphic profile */
5308 {
5309 GtkListStore* model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
5310 EgeSelectOneAction* act1 = ege_select_one_action_new ("SetProfileAction", "" , (_("Choose a preset")), NULL, GTK_TREE_MODEL(model));
5311 ege_select_one_action_set_appearance (act1, "compact");
5312 g_object_set_data (holder, "profile_selector", act1 );
5314 g_object_set_data(holder, "presets_blocked", GINT_TO_POINTER(FALSE));
5316 sp_dcc_build_presets_list (holder);
5318 g_signal_connect(G_OBJECT(act1), "changed", G_CALLBACK(sp_ddc_change_profile), holder);
5319 gtk_action_group_add_action(mainActions, GTK_ACTION(act1));
5320 }
5321 }
5322 }
5325 //########################
5326 //## Circle / Arc ##
5327 //########################
5329 static void sp_arctb_sensitivize( GObject *tbl, double v1, double v2 )
5330 {
5331 GtkAction *ocb = GTK_ACTION( g_object_get_data( tbl, "open_action" ) );
5332 GtkAction *make_whole = GTK_ACTION( g_object_get_data( tbl, "make_whole" ) );
5334 if (v1 == 0 && v2 == 0) {
5335 if (g_object_get_data( tbl, "single" )) { // only for a single selected ellipse (for now)
5336 gtk_action_set_sensitive( ocb, FALSE );
5337 gtk_action_set_sensitive( make_whole, FALSE );
5338 }
5339 } else {
5340 gtk_action_set_sensitive( ocb, TRUE );
5341 gtk_action_set_sensitive( make_whole, TRUE );
5342 }
5343 }
5345 static void
5346 sp_arctb_startend_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_name, gchar const *other_name)
5347 {
5348 SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
5350 if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
5351 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5352 prefs->setDouble(Glib::ustring("/tools/shapes/arc/") + value_name, adj->value);
5353 }
5355 // quit if run by the attr_changed listener
5356 if (g_object_get_data( tbl, "freeze" )) {
5357 return;
5358 }
5360 // in turn, prevent listener from responding
5361 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
5363 gchar* namespaced_name = g_strconcat("sodipodi:", value_name, NULL);
5365 bool modmade = false;
5366 for (GSList const *items = sp_desktop_selection(desktop)->itemList();
5367 items != NULL;
5368 items = items->next)
5369 {
5370 SPItem *item = SP_ITEM(items->data);
5372 if (SP_IS_ARC(item) && SP_IS_GENERICELLIPSE(item)) {
5374 SPGenericEllipse *ge = SP_GENERICELLIPSE(item);
5375 SPArc *arc = SP_ARC(item);
5377 if (!strcmp(value_name, "start")) {
5378 ge->start = (adj->value * M_PI)/ 180;
5379 } else {
5380 ge->end = (adj->value * M_PI)/ 180;
5381 }
5383 sp_genericellipse_normalize(ge);
5384 ((SPObject *)arc)->updateRepr();
5385 ((SPObject *)arc)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
5387 modmade = true;
5388 }
5389 }
5391 g_free(namespaced_name);
5393 GtkAdjustment *other = GTK_ADJUSTMENT( g_object_get_data( tbl, other_name ) );
5395 sp_arctb_sensitivize( tbl, adj->value, other->value );
5397 if (modmade) {
5398 sp_document_maybe_done(sp_desktop_document(desktop), value_name, SP_VERB_CONTEXT_ARC,
5399 _("Arc: Change start/end"));
5400 }
5402 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
5403 }
5406 static void sp_arctb_start_value_changed(GtkAdjustment *adj, GObject *tbl)
5407 {
5408 sp_arctb_startend_value_changed(adj, tbl, "start", "end");
5409 }
5411 static void sp_arctb_end_value_changed(GtkAdjustment *adj, GObject *tbl)
5412 {
5413 sp_arctb_startend_value_changed(adj, tbl, "end", "start");
5414 }
5417 static void sp_arctb_open_state_changed( EgeSelectOneAction *act, GObject *tbl )
5418 {
5419 SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
5420 if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
5421 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5422 prefs->setBool("/tools/shapes/arc/open", ege_select_one_action_get_active(act) != 0);
5423 }
5425 // quit if run by the attr_changed listener
5426 if (g_object_get_data( tbl, "freeze" )) {
5427 return;
5428 }
5430 // in turn, prevent listener from responding
5431 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
5433 bool modmade = false;
5435 if ( ege_select_one_action_get_active(act) != 0 ) {
5436 for (GSList const *items = sp_desktop_selection(desktop)->itemList();
5437 items != NULL;
5438 items = items->next)
5439 {
5440 if (SP_IS_ARC((SPItem *) items->data)) {
5441 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
5442 repr->setAttribute("sodipodi:open", "true");
5443 SP_OBJECT((SPItem *) items->data)->updateRepr();
5444 modmade = true;
5445 }
5446 }
5447 } else {
5448 for (GSList const *items = sp_desktop_selection(desktop)->itemList();
5449 items != NULL;
5450 items = items->next)
5451 {
5452 if (SP_IS_ARC((SPItem *) items->data)) {
5453 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data);
5454 repr->setAttribute("sodipodi:open", NULL);
5455 SP_OBJECT((SPItem *) items->data)->updateRepr();
5456 modmade = true;
5457 }
5458 }
5459 }
5461 if (modmade) {
5462 sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_ARC,
5463 _("Arc: Change open/closed"));
5464 }
5466 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
5467 }
5469 static void sp_arctb_defaults(GtkWidget *, GObject *obj)
5470 {
5471 GtkAdjustment *adj;
5472 adj = GTK_ADJUSTMENT( g_object_get_data(obj, "start") );
5473 gtk_adjustment_set_value(adj, 0.0);
5474 gtk_adjustment_value_changed(adj);
5476 adj = GTK_ADJUSTMENT( g_object_get_data(obj, "end") );
5477 gtk_adjustment_set_value(adj, 0.0);
5478 gtk_adjustment_value_changed(adj);
5480 spinbutton_defocus( GTK_OBJECT(obj) );
5481 }
5483 static void arc_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const * /*name*/,
5484 gchar const * /*old_value*/, gchar const * /*new_value*/,
5485 bool /*is_interactive*/, gpointer data)
5486 {
5487 GObject *tbl = G_OBJECT(data);
5489 // quit if run by the _changed callbacks
5490 if (g_object_get_data( tbl, "freeze" )) {
5491 return;
5492 }
5494 // in turn, prevent callbacks from responding
5495 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
5497 gdouble start = sp_repr_get_double_attribute(repr, "sodipodi:start", 0.0);
5498 gdouble end = sp_repr_get_double_attribute(repr, "sodipodi:end", 0.0);
5500 GtkAdjustment *adj1,*adj2;
5501 adj1 = GTK_ADJUSTMENT( g_object_get_data( tbl, "start" ) );
5502 gtk_adjustment_set_value(adj1, mod360((start * 180)/M_PI));
5503 adj2 = GTK_ADJUSTMENT( g_object_get_data( tbl, "end" ) );
5504 gtk_adjustment_set_value(adj2, mod360((end * 180)/M_PI));
5506 sp_arctb_sensitivize( tbl, adj1->value, adj2->value );
5508 char const *openstr = NULL;
5509 openstr = repr->attribute("sodipodi:open");
5510 EgeSelectOneAction *ocb = EGE_SELECT_ONE_ACTION( g_object_get_data( tbl, "open_action" ) );
5512 if (openstr) {
5513 ege_select_one_action_set_active( ocb, 1 );
5514 } else {
5515 ege_select_one_action_set_active( ocb, 0 );
5516 }
5518 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
5519 }
5521 static Inkscape::XML::NodeEventVector arc_tb_repr_events = {
5522 NULL, /* child_added */
5523 NULL, /* child_removed */
5524 arc_tb_event_attr_changed,
5525 NULL, /* content_changed */
5526 NULL /* order_changed */
5527 };
5530 static void sp_arc_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
5531 {
5532 int n_selected = 0;
5533 Inkscape::XML::Node *repr = NULL;
5535 purge_repr_listener( tbl, tbl );
5537 for (GSList const *items = selection->itemList();
5538 items != NULL;
5539 items = items->next)
5540 {
5541 if (SP_IS_ARC((SPItem *) items->data)) {
5542 n_selected++;
5543 repr = SP_OBJECT_REPR((SPItem *) items->data);
5544 }
5545 }
5547 EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) );
5549 g_object_set_data( tbl, "single", GINT_TO_POINTER(FALSE) );
5550 if (n_selected == 0) {
5551 g_object_set( G_OBJECT(act), "label", _("<b>New:</b>"), NULL );
5552 } else if (n_selected == 1) {
5553 g_object_set_data( tbl, "single", GINT_TO_POINTER(TRUE) );
5554 g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
5556 if (repr) {
5557 g_object_set_data( tbl, "repr", repr );
5558 Inkscape::GC::anchor(repr);
5559 sp_repr_add_listener(repr, &arc_tb_repr_events, tbl);
5560 sp_repr_synthesize_events(repr, &arc_tb_repr_events, tbl);
5561 }
5562 } else {
5563 // FIXME: implement averaging of all parameters for multiple selected
5564 //gtk_label_set_markup(GTK_LABEL(l), _("<b>Average:</b>"));
5565 g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
5566 sp_arctb_sensitivize( tbl, 1, 0 );
5567 }
5568 }
5571 static void sp_arc_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
5572 {
5573 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5575 EgeAdjustmentAction* eact = 0;
5576 Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
5579 {
5580 EgeOutputAction* act = ege_output_action_new( "ArcStateAction", _("<b>New:</b>"), "", 0 );
5581 ege_output_action_set_use_markup( act, TRUE );
5582 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
5583 g_object_set_data( holder, "mode_action", act );
5584 }
5586 /* Start */
5587 {
5588 eact = create_adjustment_action( "ArcStartAction",
5589 _("Start"), _("Start:"),
5590 _("The angle (in degrees) from the horizontal to the arc's start point"),
5591 "/tools/shapes/arc/start", 0.0,
5592 GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, TRUE, "altx-arc",
5593 -360.0, 360.0, 1.0, 10.0,
5594 0, 0, 0,
5595 sp_arctb_start_value_changed);
5596 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
5597 }
5599 /* End */
5600 {
5601 eact = create_adjustment_action( "ArcEndAction",
5602 _("End"), _("End:"),
5603 _("The angle (in degrees) from the horizontal to the arc's end point"),
5604 "/tools/shapes/arc/end", 0.0,
5605 GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL,
5606 -360.0, 360.0, 1.0, 10.0,
5607 0, 0, 0,
5608 sp_arctb_end_value_changed);
5609 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
5610 }
5612 /* Segments / Pie checkbox */
5613 {
5614 GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
5616 GtkTreeIter iter;
5617 gtk_list_store_append( model, &iter );
5618 gtk_list_store_set( model, &iter,
5619 0, _("Closed arc"),
5620 1, _("Switch to segment (closed shape with two radii)"),
5621 2, INKSCAPE_ICON_DRAW_ELLIPSE_SEGMENT,
5622 -1 );
5624 gtk_list_store_append( model, &iter );
5625 gtk_list_store_set( model, &iter,
5626 0, _("Open Arc"),
5627 1, _("Switch to arc (unclosed shape)"),
5628 2, INKSCAPE_ICON_DRAW_ELLIPSE_ARC,
5629 -1 );
5631 EgeSelectOneAction* act = ege_select_one_action_new( "ArcOpenAction", (""), (""), NULL, GTK_TREE_MODEL(model) );
5632 gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
5633 g_object_set_data( holder, "open_action", act );
5635 ege_select_one_action_set_appearance( act, "full" );
5636 ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
5637 g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
5638 ege_select_one_action_set_icon_column( act, 2 );
5639 ege_select_one_action_set_icon_size( act, secondarySize );
5640 ege_select_one_action_set_tooltip_column( act, 1 );
5642 bool isClosed = !prefs->getBool("/tools/shapes/arc/open", false);
5643 ege_select_one_action_set_active( act, isClosed ? 0 : 1 );
5644 g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_arctb_open_state_changed), holder );
5645 }
5647 /* Make Whole */
5648 {
5649 InkAction* inky = ink_action_new( "ArcResetAction",
5650 _("Make whole"),
5651 _("Make the shape a whole ellipse, not arc or segment"),
5652 INKSCAPE_ICON_DRAW_ELLIPSE_WHOLE,
5653 secondarySize );
5654 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_arctb_defaults), holder );
5655 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
5656 gtk_action_set_sensitive( GTK_ACTION(inky), TRUE );
5657 g_object_set_data( holder, "make_whole", inky );
5658 }
5660 g_object_set_data( G_OBJECT(holder), "single", GINT_TO_POINTER(TRUE) );
5661 // sensitivize make whole and open checkbox
5662 {
5663 GtkAdjustment *adj1 = GTK_ADJUSTMENT( g_object_get_data( holder, "start" ) );
5664 GtkAdjustment *adj2 = GTK_ADJUSTMENT( g_object_get_data( holder, "end" ) );
5665 sp_arctb_sensitivize( holder, adj1->value, adj2->value );
5666 }
5669 sigc::connection *connection = new sigc::connection(
5670 sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_arc_toolbox_selection_changed), (GObject *)holder))
5671 );
5672 g_signal_connect( holder, "destroy", G_CALLBACK(delete_connection), connection );
5673 g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );
5674 }
5679 // toggle button callbacks and updaters
5681 //########################
5682 //## Dropper ##
5683 //########################
5685 static void toggle_dropper_pick_alpha( GtkToggleAction* act, gpointer tbl )
5686 {
5687 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5688 prefs->setInt( "/tools/dropper/pick", gtk_toggle_action_get_active( act ) );
5689 GtkAction* set_action = GTK_ACTION( g_object_get_data(G_OBJECT(tbl), "set_action") );
5690 if ( set_action ) {
5691 if ( gtk_toggle_action_get_active( act ) ) {
5692 gtk_action_set_sensitive( set_action, TRUE );
5693 } else {
5694 gtk_action_set_sensitive( set_action, FALSE );
5695 }
5696 }
5698 spinbutton_defocus(GTK_OBJECT(tbl));
5699 }
5701 static void toggle_dropper_set_alpha( GtkToggleAction* act, gpointer tbl )
5702 {
5703 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5704 prefs->setBool( "/tools/dropper/setalpha", gtk_toggle_action_get_active( act ) );
5705 spinbutton_defocus(GTK_OBJECT(tbl));
5706 }
5709 /**
5710 * Dropper auxiliary toolbar construction and setup.
5711 *
5712 * TODO: Would like to add swatch of current color.
5713 * TODO: Add queue of last 5 or so colors selected with new swatches so that
5714 * can drag and drop places. Will provide a nice mixing palette.
5715 */
5716 static void sp_dropper_toolbox_prep(SPDesktop * /*desktop*/, GtkActionGroup* mainActions, GObject* holder)
5717 {
5718 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5719 gint pickAlpha = prefs->getInt( "/tools/dropper/pick", 1 );
5721 {
5722 EgeOutputAction* act = ege_output_action_new( "DropperOpacityAction", _("Opacity:"), "", 0 );
5723 ege_output_action_set_use_markup( act, TRUE );
5724 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
5725 }
5727 {
5728 InkToggleAction* act = ink_toggle_action_new( "DropperPickAlphaAction",
5729 _("Pick opacity"),
5730 _("Pick both the color and the alpha (transparency) under cursor; otherwise, pick only the visible color premultiplied by alpha"),
5731 NULL,
5732 Inkscape::ICON_SIZE_DECORATION );
5733 g_object_set( act, "short_label", _("Pick"), NULL );
5734 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
5735 g_object_set_data( holder, "pick_action", act );
5736 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), pickAlpha );
5737 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_dropper_pick_alpha), holder );
5738 }
5740 {
5741 InkToggleAction* act = ink_toggle_action_new( "DropperSetAlphaAction",
5742 _("Assign opacity"),
5743 _("If alpha was picked, assign it to selection as fill or stroke transparency"),
5744 NULL,
5745 Inkscape::ICON_SIZE_DECORATION );
5746 g_object_set( act, "short_label", _("Assign"), NULL );
5747 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
5748 g_object_set_data( holder, "set_action", act );
5749 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool( "/tools/dropper/setalpha", true) );
5750 // make sure it's disabled if we're not picking alpha
5751 gtk_action_set_sensitive( GTK_ACTION(act), pickAlpha );
5752 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_dropper_set_alpha), holder );
5753 }
5754 }
5757 //########################
5758 //## LPETool ##
5759 //########################
5761 // the subtools from which the toolbar is built automatically are listed in lpe-tool-context.h
5763 // this is called when the mode is changed via the toolbar (i.e., one of the subtool buttons is pressed)
5764 static void sp_lpetool_mode_changed(EgeSelectOneAction *act, GObject *tbl)
5765 {
5766 using namespace Inkscape::LivePathEffect;
5768 SPDesktop *desktop = (SPDesktop *) g_object_get_data(tbl, "desktop");
5769 SPEventContext *ec = desktop->event_context;
5770 if (!SP_IS_LPETOOL_CONTEXT(ec)) {
5771 return;
5772 }
5774 // only take action if run by the attr_changed listener
5775 if (!g_object_get_data(tbl, "freeze")) {
5776 // in turn, prevent listener from responding
5777 g_object_set_data(tbl, "freeze", GINT_TO_POINTER(TRUE));
5779 gint mode = ege_select_one_action_get_active(act);
5780 EffectType type = lpesubtools[mode].type;
5782 SPLPEToolContext *lc = SP_LPETOOL_CONTEXT(desktop->event_context);
5783 bool success = lpetool_try_construction(lc, type);
5784 if (success) {
5785 // since the construction was already performed, we set the state back to inactive
5786 ege_select_one_action_set_active(act, 0);
5787 mode = 0;
5788 } else {
5789 // switch to the chosen subtool
5790 SP_LPETOOL_CONTEXT(desktop->event_context)->mode = type;
5791 }
5793 if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
5794 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5795 prefs->setInt( "/tools/lpetool/mode", mode );
5796 }
5798 g_object_set_data(tbl, "freeze", GINT_TO_POINTER(FALSE));
5799 }
5800 }
5802 static void sp_lpetool_toolbox_sel_modified(Inkscape::Selection *selection, guint /*flags*/, GObject * /*tbl*/)
5803 {
5804 SPEventContext *ec = selection->desktop()->event_context;
5805 if (SP_IS_LPETOOL_CONTEXT(ec)) {
5806 lpetool_update_measuring_items(SP_LPETOOL_CONTEXT(ec));
5807 }
5808 }
5810 static void sp_lpetool_toolbox_sel_changed(Inkscape::Selection *selection, GObject *tbl)
5811 {
5812 using namespace Inkscape::LivePathEffect;
5813 SPEventContext *ec = selection->desktop()->event_context;
5814 if (!SP_IS_LPETOOL_CONTEXT(ec)) {
5815 return;
5816 }
5817 SPLPEToolContext *lc = SP_LPETOOL_CONTEXT(ec);
5819 lpetool_delete_measuring_items(lc);
5820 lpetool_create_measuring_items(lc, selection);
5822 // activate line segment combo box if a single item with LPELineSegment is selected
5823 GtkAction* w = GTK_ACTION(g_object_get_data(tbl, "lpetool_line_segment_action"));
5824 SPItem *item = selection->singleItem();
5825 if (item && SP_IS_LPE_ITEM(item) && lpetool_item_has_construction(lc, item)) {
5826 SPLPEItem *lpeitem = SP_LPE_ITEM(item);
5827 Effect* lpe = sp_lpe_item_get_current_lpe(lpeitem);
5828 if (lpe && lpe->effectType() == LINE_SEGMENT) {
5829 LPELineSegment *lpels = static_cast<LPELineSegment*>(lpe);
5830 g_object_set_data(tbl, "currentlpe", lpe);
5831 g_object_set_data(tbl, "currentlpeitem", lpeitem);
5832 gtk_action_set_sensitive(w, TRUE);
5833 ege_select_one_action_set_active(EGE_SELECT_ONE_ACTION(w), lpels->end_type.get_value());
5834 } else {
5835 g_object_set_data(tbl, "currentlpe", NULL);
5836 g_object_set_data(tbl, "currentlpeitem", NULL);
5837 gtk_action_set_sensitive(w, FALSE);
5838 }
5839 } else {
5840 g_object_set_data(tbl, "currentlpe", NULL);
5841 g_object_set_data(tbl, "currentlpeitem", NULL);
5842 gtk_action_set_sensitive(w, FALSE);
5843 }
5844 }
5846 static void lpetool_toggle_show_bbox(GtkToggleAction *act, gpointer data) {
5847 SPDesktop *desktop = static_cast<SPDesktop *>(data);
5848 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5850 bool show = gtk_toggle_action_get_active( act );
5851 prefs->setBool("/tools/lpetool/show_bbox", show);
5853 if (tools_isactive(desktop, TOOLS_LPETOOL)) {
5854 SPLPEToolContext *lc = SP_LPETOOL_CONTEXT(desktop->event_context);
5855 lpetool_context_reset_limiting_bbox(lc);
5856 }
5857 }
5859 static void lpetool_toggle_show_measuring_info(GtkToggleAction *act, GObject *tbl)
5860 {
5861 SPDesktop *desktop = static_cast<SPDesktop *>(g_object_get_data(tbl, "desktop"));
5862 if (!tools_isactive(desktop, TOOLS_LPETOOL)) {
5863 return;
5864 }
5866 GtkAction *unitact = static_cast<GtkAction*>(g_object_get_data(tbl, "lpetool_units_action"));
5867 SPLPEToolContext *lc = SP_LPETOOL_CONTEXT(desktop->event_context);
5868 if (tools_isactive(desktop, TOOLS_LPETOOL)) {
5869 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5870 bool show = gtk_toggle_action_get_active( act );
5871 prefs->setBool("/tools/lpetool/show_measuring_info", show);
5872 lpetool_show_measuring_info(lc, show);
5873 gtk_action_set_sensitive(GTK_ACTION(unitact), show);
5874 }
5875 }
5877 static void lpetool_unit_changed(GtkAction* /*act*/, GObject* tbl)
5878 {
5879 UnitTracker* tracker = reinterpret_cast<UnitTracker*>(g_object_get_data(tbl, "tracker"));
5880 SPUnit const *unit = tracker->getActiveUnit();
5881 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5882 prefs->setInt("/tools/lpetool/unitid", unit->unit_id);
5884 SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
5885 if (SP_IS_LPETOOL_CONTEXT(desktop->event_context)) {
5886 SPLPEToolContext *lc = SP_LPETOOL_CONTEXT(desktop->event_context);
5887 lpetool_delete_measuring_items(lc);
5888 lpetool_create_measuring_items(lc);
5889 }
5890 }
5892 static void lpetool_toggle_set_bbox(GtkToggleAction *act, gpointer data)
5893 {
5894 SPDesktop *desktop = static_cast<SPDesktop *>(data);
5895 Inkscape::Selection *selection = desktop->selection;
5897 Geom::OptRect bbox = selection->bounds();
5899 if (bbox) {
5900 Geom::Point A(bbox->min());
5901 Geom::Point B(bbox->max());
5903 A *= desktop->doc2dt();
5904 B *= desktop->doc2dt();
5906 // TODO: should we provide a way to store points in prefs?
5907 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5908 prefs->setDouble("/tools/lpetool/bbox_upperleftx", A[Geom::X]);
5909 prefs->setDouble("/tools/lpetool/bbox_upperlefty", A[Geom::Y]);
5910 prefs->setDouble("/tools/lpetool/bbox_lowerrightx", B[Geom::X]);
5911 prefs->setDouble("/tools/lpetool/bbox_lowerrighty", B[Geom::Y]);
5913 lpetool_context_reset_limiting_bbox(SP_LPETOOL_CONTEXT(desktop->event_context));
5914 }
5916 gtk_toggle_action_set_active(act, false);
5917 }
5919 static void sp_line_segment_build_list(GObject *tbl)
5920 {
5921 g_object_set_data(tbl, "line_segment_list_blocked", GINT_TO_POINTER(TRUE));
5923 EgeSelectOneAction* selector = static_cast<EgeSelectOneAction *>(g_object_get_data(tbl, "lpetool_line_segment_action"));
5924 GtkListStore* model = GTK_LIST_STORE(ege_select_one_action_get_model(selector));
5925 gtk_list_store_clear (model);
5927 // TODO: we add the entries of rht combo box manually; later this should be done automatically
5928 {
5929 GtkTreeIter iter;
5930 gtk_list_store_append( model, &iter );
5931 gtk_list_store_set( model, &iter, 0, _("Closed"), 1, 0, -1 );
5932 gtk_list_store_append( model, &iter );
5933 gtk_list_store_set( model, &iter, 0, _("Open start"), 1, 1, -1 );
5934 gtk_list_store_append( model, &iter );
5935 gtk_list_store_set( model, &iter, 0, _("Open end"), 1, 2, -1 );
5936 gtk_list_store_append( model, &iter );
5937 gtk_list_store_set( model, &iter, 0, _("Open both"), 1, 3, -1 );
5938 }
5940 g_object_set_data(tbl, "line_segment_list_blocked", GINT_TO_POINTER(FALSE));
5941 }
5943 static void sp_lpetool_change_line_segment_type(EgeSelectOneAction* act, GObject* tbl)
5944 {
5945 using namespace Inkscape::LivePathEffect;
5947 // quit if run by the attr_changed listener
5948 if (g_object_get_data(tbl, "freeze")) {
5949 return;
5950 }
5952 // in turn, prevent listener from responding
5953 g_object_set_data(tbl, "freeze", GINT_TO_POINTER(TRUE));
5955 LPELineSegment *lpe = static_cast<LPELineSegment *>(g_object_get_data(tbl, "currentlpe"));
5956 SPLPEItem *lpeitem = static_cast<SPLPEItem *>(g_object_get_data(tbl, "currentlpeitem"));
5957 if (lpeitem) {
5958 SPLPEItem *lpeitem = static_cast<SPLPEItem *>(g_object_get_data(tbl, "currentlpeitem"));
5959 lpe->end_type.param_set_value(static_cast<Inkscape::LivePathEffect::EndType>(ege_select_one_action_get_active(act)));
5960 sp_lpe_item_update_patheffect(lpeitem, true, true);
5961 }
5963 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
5964 }
5966 static void lpetool_open_lpe_dialog(GtkToggleAction *act, gpointer data)
5967 {
5968 SPDesktop *desktop = static_cast<SPDesktop *>(data);
5970 if (tools_isactive(desktop, TOOLS_LPETOOL)) {
5971 sp_action_perform(Inkscape::Verb::get(SP_VERB_DIALOG_LIVE_PATH_EFFECT)->get_action(desktop), NULL);
5972 }
5973 gtk_toggle_action_set_active(act, false);
5974 }
5976 static void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
5977 {
5978 UnitTracker* tracker = new UnitTracker(SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE);
5979 tracker->setActiveUnit(sp_desktop_namedview(desktop)->doc_units);
5980 g_object_set_data(holder, "tracker", tracker);
5981 SPUnit const *unit = tracker->getActiveUnit();
5983 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
5984 prefs->setInt("/tools/lpetool/unitid", unit->unit_id);
5986 /** Automatically create a list of LPEs that get added to the toolbar **/
5987 {
5988 GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
5990 GtkTreeIter iter;
5992 // the first toggle button represents the state that no subtool is active (remove this when
5993 // this can be modeled by EgeSelectOneAction or some other action)
5994 gtk_list_store_append( model, &iter );
5995 gtk_list_store_set( model, &iter,
5996 0, _("All inactive"),
5997 1, _("No geometric tool is active"),
5998 2, "draw-geometry-inactive",
5999 -1 );
6001 Inkscape::LivePathEffect::EffectType type;
6002 for (int i = 1; i < num_subtools; ++i) { // we start with i = 1 because INVALID_LPE was already added
6003 type = lpesubtools[i].type;
6004 gtk_list_store_append( model, &iter );
6005 gtk_list_store_set( model, &iter,
6006 0, Inkscape::LivePathEffect::LPETypeConverter.get_label(type).c_str(),
6007 1, Inkscape::LivePathEffect::LPETypeConverter.get_label(type).c_str(),
6008 2, lpesubtools[i].icon_name,
6009 -1 );
6010 }
6012 EgeSelectOneAction* act = ege_select_one_action_new( "LPEToolModeAction", (""), (""), NULL, GTK_TREE_MODEL(model) );
6013 gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
6014 g_object_set_data( holder, "lpetool_mode_action", act );
6016 ege_select_one_action_set_appearance( act, "full" );
6017 ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
6018 g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
6019 ege_select_one_action_set_icon_column( act, 2 );
6020 ege_select_one_action_set_tooltip_column( act, 1 );
6022 gint lpeToolMode = prefs->getInt("/tools/lpetool/mode", 0);
6023 ege_select_one_action_set_active( act, lpeToolMode );
6024 g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_lpetool_mode_changed), holder );
6025 }
6027 /* Show limiting bounding box */
6028 {
6029 InkToggleAction* act = ink_toggle_action_new( "LPEShowBBoxAction",
6030 _("Show limiting bounding box"),
6031 _("Show bounding box (used to cut infinite lines)"),
6032 "show-bounding-box",
6033 Inkscape::ICON_SIZE_DECORATION );
6034 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
6035 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(lpetool_toggle_show_bbox), desktop );
6036 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool( "/tools/lpetool/show_bbox", true ) );
6037 }
6039 /* Set limiting bounding box to bbox of current selection */
6040 {
6041 InkToggleAction* act = ink_toggle_action_new( "LPEBBoxFromSelectionAction",
6042 _("Get limiting bounding box from selection"),
6043 _("Set limiting bounding box (used to cut infinite lines) to the bounding box of current selection"),
6044 "draw-geometry-set-bounding-box",
6045 Inkscape::ICON_SIZE_DECORATION );
6046 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
6047 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(lpetool_toggle_set_bbox), desktop );
6048 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), FALSE );
6049 }
6052 /* Combo box to choose line segment type */
6053 {
6054 GtkListStore* model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
6055 EgeSelectOneAction* act = ege_select_one_action_new ("LPELineSegmentAction", "" , (_("Choose a line segment type")), NULL, GTK_TREE_MODEL(model));
6056 ege_select_one_action_set_appearance (act, "compact");
6057 g_object_set_data (holder, "lpetool_line_segment_action", act );
6059 g_object_set_data(holder, "line_segment_list_blocked", GINT_TO_POINTER(FALSE));
6061 sp_line_segment_build_list (holder);
6063 g_signal_connect(G_OBJECT(act), "changed", G_CALLBACK(sp_lpetool_change_line_segment_type), holder);
6064 gtk_action_set_sensitive( GTK_ACTION(act), FALSE );
6065 gtk_action_group_add_action(mainActions, GTK_ACTION(act));
6066 }
6068 /* Display measuring info for selected items */
6069 {
6070 InkToggleAction* act = ink_toggle_action_new( "LPEMeasuringAction",
6071 _("Display measuring info"),
6072 _("Display measuring info for selected items"),
6073 "draw-geometry-show-measuring-info",
6074 Inkscape::ICON_SIZE_DECORATION );
6075 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
6076 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(lpetool_toggle_show_measuring_info), holder );
6077 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool( "/tools/lpetool/show_measuring_info", true ) );
6078 }
6080 // add the units menu
6081 {
6082 GtkAction* act = tracker->createAction( "LPEToolUnitsAction", _("Units"), ("") );
6083 gtk_action_group_add_action( mainActions, act );
6084 g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(lpetool_unit_changed), (GObject*)holder );
6085 g_object_set_data(holder, "lpetool_units_action", act);
6086 gtk_action_set_sensitive(act, prefs->getBool("/tools/lpetool/show_measuring_info", true));
6087 }
6089 /* Open LPE dialog (to adapt parameters numerically) */
6090 {
6091 InkToggleAction* act = ink_toggle_action_new( "LPEOpenLPEDialogAction",
6092 _("Open LPE dialog"),
6093 _("Open LPE dialog (to adapt parameters numerically)"),
6094 "dialog-geometry",
6095 Inkscape::ICON_SIZE_DECORATION );
6096 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
6097 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(lpetool_open_lpe_dialog), desktop );
6098 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), FALSE );
6099 }
6101 //watch selection
6102 Inkscape::ConnectionPool* pool = Inkscape::ConnectionPool::new_connection_pool ("ISNodeToolbox");
6104 sigc::connection *c_selection_modified =
6105 new sigc::connection (sp_desktop_selection (desktop)->connectModified
6106 (sigc::bind (sigc::ptr_fun (sp_lpetool_toolbox_sel_modified), (GObject*)holder)));
6107 pool->add_connection ("selection-modified", c_selection_modified);
6109 sigc::connection *c_selection_changed =
6110 new sigc::connection (sp_desktop_selection (desktop)->connectChanged
6111 (sigc::bind (sigc::ptr_fun(sp_lpetool_toolbox_sel_changed), (GObject*)holder)));
6112 pool->add_connection ("selection-changed", c_selection_changed);
6113 }
6115 //########################
6116 //## Eraser ##
6117 //########################
6119 static void sp_erc_width_value_changed( GtkAdjustment *adj, GObject *tbl )
6120 {
6121 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6122 prefs->setDouble( "/tools/eraser/width", adj->value );
6123 update_presets_list(tbl);
6124 }
6126 static void sp_erasertb_mode_changed( EgeSelectOneAction *act, GObject *tbl )
6127 {
6128 SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
6129 bool eraserMode = ege_select_one_action_get_active( act ) != 0;
6130 if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) {
6131 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6132 prefs->setBool( "/tools/eraser/mode", eraserMode );
6133 }
6135 // only take action if run by the attr_changed listener
6136 if (!g_object_get_data( tbl, "freeze" )) {
6137 // in turn, prevent listener from responding
6138 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
6140 if ( eraserMode != 0 ) {
6141 } else {
6142 }
6143 // TODO finish implementation
6145 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
6146 }
6147 }
6149 static void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
6150 {
6151 {
6152 /* Width */
6153 gchar const* labels[] = {_("(hairline)"), 0, 0, 0, _("(default)"), 0, 0, 0, 0, _("(broad stroke)")};
6154 gdouble values[] = {1, 3, 5, 10, 15, 20, 30, 50, 75, 100};
6155 EgeAdjustmentAction *eact = create_adjustment_action( "EraserWidthAction",
6156 _("Pen Width"), _("Width:"),
6157 _("The width of the eraser pen (relative to the visible canvas area)"),
6158 "/tools/eraser/width", 15,
6159 GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-eraser",
6160 1, 100, 1.0, 10.0,
6161 labels, values, G_N_ELEMENTS(labels),
6162 sp_erc_width_value_changed, 1, 0);
6163 ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
6164 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
6165 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
6166 }
6168 {
6169 GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
6171 GtkTreeIter iter;
6172 gtk_list_store_append( model, &iter );
6173 gtk_list_store_set( model, &iter,
6174 0, _("Delete"),
6175 1, _("Delete objects touched by the eraser"),
6176 2, INKSCAPE_ICON_DRAW_ERASER_DELETE_OBJECTS,
6177 -1 );
6179 gtk_list_store_append( model, &iter );
6180 gtk_list_store_set( model, &iter,
6181 0, _("Cut"),
6182 1, _("Cut out from objects"),
6183 2, INKSCAPE_ICON_PATH_DIFFERENCE,
6184 -1 );
6186 EgeSelectOneAction* act = ege_select_one_action_new( "EraserModeAction", (""), (""), NULL, GTK_TREE_MODEL(model) );
6187 gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
6188 g_object_set_data( holder, "eraser_mode_action", act );
6190 ege_select_one_action_set_appearance( act, "full" );
6191 ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
6192 g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
6193 ege_select_one_action_set_icon_column( act, 2 );
6194 ege_select_one_action_set_tooltip_column( act, 1 );
6196 /// @todo Convert to boolean?
6197 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6198 gint eraserMode = prefs->getBool("/tools/eraser/mode") ? 1 : 0;
6199 ege_select_one_action_set_active( act, eraserMode );
6200 g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_erasertb_mode_changed), holder );
6201 }
6203 }
6205 //########################
6206 //## Text Toolbox ##
6207 //########################
6209 // Functions for debugging:
6210 #ifdef DEBUG_TEXT
6212 static void sp_print_font( SPStyle *query ) {
6214 bool family_set = query->text->font_family.set;
6215 bool style_set = query->font_style.set;
6216 bool fontspec_set = query->text->font_specification.set;
6218 std::cout << " Family set? " << family_set
6219 << " Style set? " << style_set
6220 << " FontSpec set? " << fontspec_set
6221 << std::endl;
6222 std::cout << " Family: "
6223 << (query->text->font_family.value ? query->text->font_family.value : "No value")
6224 << " Style: " << query->font_style.computed
6225 << " Weight: " << query->font_weight.computed
6226 << " FontSpec: "
6227 << (query->text->font_specification.value ? query->text->font_specification.value : "No value")
6228 << std::endl;
6229 }
6231 static void sp_print_fontweight( SPStyle *query ) {
6232 const gchar* names[] = {"100", "200", "300", "400", "500", "600", "700", "800", "900",
6233 "NORMAL", "BOLD", "LIGHTER", "BOLDER", "Out of range"};
6234 // Missing book = 380
6235 int index = query->font_weight.computed;
6236 if( index < 0 || index > 13 ) index = 13;
6237 std::cout << " Weight: " << names[ index ]
6238 << " (" << query->font_weight.computed << ")" << std::endl;
6240 }
6242 static void sp_print_fontstyle( SPStyle *query ) {
6244 const gchar* names[] = {"NORMAL", "ITALIC", "OBLIQUE", "Out of range"};
6245 int index = query->font_style.computed;
6246 if( index < 0 || index > 3 ) index = 3;
6247 std::cout << " Style: " << names[ index ] << std::endl;
6249 }
6250 #endif
6252 // Format family drop-down menu.
6253 static void cell_data_func(GtkCellLayout * /*cell_layout*/,
6254 GtkCellRenderer *cell,
6255 GtkTreeModel *tree_model,
6256 GtkTreeIter *iter,
6257 gpointer /*data*/)
6258 {
6259 gchar *family;
6260 gtk_tree_model_get(tree_model, iter, 0, &family, -1);
6261 gchar *const family_escaped = g_markup_escape_text(family, -1);
6263 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6264 int show_sample = prefs->getInt("/tools/text/show_sample_in_list", 1);
6265 if (show_sample) {
6267 Glib::ustring sample = prefs->getString("/tools/text/font_sample");
6268 gchar *const sample_escaped = g_markup_escape_text(sample.data(), -1);
6270 std::stringstream markup;
6271 markup << family_escaped << " <span foreground='gray' font_family='"
6272 << family_escaped << "'>" << sample_escaped << "</span>";
6273 g_object_set (G_OBJECT (cell), "markup", markup.str().c_str(), NULL);
6275 g_free(sample_escaped);
6276 } else {
6277 g_object_set (G_OBJECT (cell), "markup", family_escaped, NULL);
6278 }
6279 // This doesn't work for two reasons... it set both selected and not selected backgrounds
6280 // to white.. which means that white foreground text is invisible. It also only effects
6281 // the text region, leaving the padding untouched.
6282 // g_object_set (G_OBJECT (cell), "cell-background", "white", "cell-background-set", true, NULL);
6284 g_free(family);
6285 g_free(family_escaped);
6286 }
6288 // Font family
6289 static void sp_text_fontfamily_value_changed( Ink_ComboBoxEntry_Action *act, GObject *tbl )
6290 {
6291 #ifdef DEBUG_TEXT
6292 std::cout << std::endl;
6293 std::cout << "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM" << std::endl;
6294 std::cout << "sp_text_fontfamily_value_changed: " << std::endl;
6295 #endif
6297 // quit if run by the _changed callbacks
6298 if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
6299 return;
6300 }
6301 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
6303 gchar *family = ink_comboboxentry_action_get_active_text( act );
6304 #ifdef DEBUG_TEXT
6305 std::cout << " New family: " << family << std::endl;
6306 #endif
6308 // First try to get the old font spec from the stored value
6309 SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT);
6310 int result_fontspec = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONT_SPECIFICATION);
6312 Glib::ustring fontSpec = query->text->font_specification.set ? query->text->font_specification.value : "";
6314 // If that didn't work, try to get font spec from style
6315 if (fontSpec.empty()) {
6317 // Must query all to fill font-family, font-style, font-weight, font-specification
6318 sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTFAMILY);
6319 sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTSTYLE);
6320 sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
6322 // Construct a new font specification if it does not yet exist
6323 font_instance * fontFromStyle = font_factory::Default()->FaceFromStyle(query);
6324 if( fontFromStyle ) {
6325 fontSpec = font_factory::Default()->ConstructFontSpecification(fontFromStyle);
6326 fontFromStyle->Unref();
6327 }
6328 #ifdef DEBUG_TEXT
6329 std::cout << " Fontspec not defined, reconstructed from style :" << fontSpec << ":" << std::endl;
6330 sp_print_font( query );
6331 #endif
6332 }
6334 // And if that didn't work use default
6335 if( fontSpec.empty() ) {
6336 sp_style_read_from_prefs(query, "/tools/text");
6337 #ifdef DEBUG_TEXT
6338 std::cout << " read style from prefs:" << std::endl;
6339 sp_print_font( query );
6340 #endif
6341 // Construct a new font specification if it does not yet exist
6342 font_instance * fontFromStyle = font_factory::Default()->FaceFromStyle(query);
6343 if( fontFromStyle ) {
6344 fontSpec = font_factory::Default()->ConstructFontSpecification(fontFromStyle);
6345 fontFromStyle->Unref();
6346 }
6347 #ifdef DEBUG_TEXT
6348 std::cout << " Fontspec not defined, reconstructed from style :" << fontSpec << ":" << std::endl;
6349 sp_print_font( query );
6350 #endif
6351 }
6353 SPCSSAttr *css = sp_repr_css_attr_new ();
6354 if (!fontSpec.empty()) {
6356 // Now we have a font specification, replace family.
6357 Glib::ustring newFontSpec = font_factory::Default()->ReplaceFontSpecificationFamily(fontSpec, family);
6359 #ifdef DEBUG_TEXT
6360 std::cout << " New FontSpec from ReplaceFontSpecificationFamily :" << newFontSpec << ":" << std::endl;
6361 #endif
6363 if (!newFontSpec.empty()) {
6365 if (fontSpec != newFontSpec) {
6367 font_instance *font = font_factory::Default()->FaceFromFontSpecification(newFontSpec.c_str());
6369 if (font) {
6370 sp_repr_css_set_property (css, "-inkscape-font-specification", newFontSpec.c_str());
6372 // Set all the these just in case they were altered when finding the best
6373 // match for the new family and old style...
6375 gchar c[256];
6377 font->Family(c, 256);
6379 sp_repr_css_set_property (css, "font-family", c);
6381 font->Attribute( "weight", c, 256);
6382 sp_repr_css_set_property (css, "font-weight", c);
6384 font->Attribute("style", c, 256);
6385 sp_repr_css_set_property (css, "font-style", c);
6387 font->Attribute("stretch", c, 256);
6388 sp_repr_css_set_property (css, "font-stretch", c);
6390 font->Attribute("variant", c, 256);
6391 sp_repr_css_set_property (css, "font-variant", c);
6393 font->Unref();
6394 }
6395 }
6397 } else {
6399 // newFontSpec empty
6400 // If the old font on selection (or default) does not exist on the system,
6401 // or the new font family does not exist,
6402 // ReplaceFontSpecificationFamily does not work. In that case we fall back to blindly
6403 // setting the family reported by the family chooser.
6405 // g_print ("fallback setting family: %s\n", family);
6406 sp_repr_css_set_property (css, "-inkscape-font-specification", family);
6407 sp_repr_css_set_property (css, "font-family", family);
6408 // Shoud we set other css font attributes?
6409 }
6411 } // fontSpec not empty or not
6413 // If querying returned nothing, update default style.
6414 if (result_fontspec == QUERY_STYLE_NOTHING)
6415 {
6416 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6417 prefs->mergeStyle("/tools/text/style", css);
6418 sp_text_edit_dialog_default_set_insensitive (); //FIXME: Replace through a verb
6419 }
6420 else
6421 {
6422 sp_desktop_set_style (SP_ACTIVE_DESKTOP, css, true, true);
6423 }
6425 sp_style_unref(query);
6427 g_free (family);
6429 // Save for undo
6430 sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT,
6431 _("Text: Change font family"));
6432 sp_repr_css_attr_unref (css);
6434 // unfreeze
6435 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
6437 // focus to canvas
6438 gtk_widget_grab_focus (GTK_WIDGET((SP_ACTIVE_DESKTOP)->canvas));
6440 #ifdef DEBUG_TEXT
6441 std::cout << "sp_text_toolbox_fontfamily_changes: exit" << std::endl;
6442 std::cout << "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM" << std::endl;
6443 std::cout << std::endl;
6444 #endif
6445 }
6447 // Font size
6448 static void sp_text_fontsize_value_changed( Ink_ComboBoxEntry_Action *act, GObject *tbl )
6449 {
6450 // quit if run by the _changed callbacks
6451 if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
6452 return;
6453 }
6454 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
6456 gchar *text = ink_comboboxentry_action_get_active_text( act );
6457 gchar *endptr;
6458 gdouble size = g_strtod( text, &endptr );
6459 if (endptr == text) { // Conversion failed, non-numeric input.
6460 g_warning( "Conversion of size text to double failed, input: %s\n", text );
6461 g_free( text );
6462 return;
6463 }
6464 g_free( text );
6466 // Set css font size.
6467 SPCSSAttr *css = sp_repr_css_attr_new ();
6468 Inkscape::CSSOStringStream osfs;
6469 osfs << size << "px"; // For now always use px
6470 sp_repr_css_set_property (css, "font-size", osfs.str().c_str());
6472 // Apply font size to selected objects.
6473 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
6474 sp_desktop_set_style (desktop, css, true, true);
6476 // Save for undo
6477 sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:size", SP_VERB_NONE,
6478 _("Text: Change font size"));
6480 // If no selected objects, set default.
6481 SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT);
6482 int result_numbers =
6483 sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
6484 if (result_numbers == QUERY_STYLE_NOTHING)
6485 {
6486 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6487 prefs->mergeStyle("/tools/text/style", css);
6488 }
6489 sp_style_unref(query);
6491 sp_repr_css_attr_unref (css);
6493 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
6494 }
6496 // Handles both Bold and Italic/Oblique
6497 static void sp_text_style_changed( InkToggleAction* act, GObject *tbl )
6498 {
6499 // quit if run by the _changed callbacks
6500 if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
6501 return;
6502 }
6503 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
6505 // Called by Bold or Italics button?
6506 const gchar* name = gtk_action_get_name( GTK_ACTION( act ) );
6507 gint prop = (strcmp(name, "TextBoldAction") == 0) ? 0 : 1;
6509 // First query font-specification, this is the most complete font face description.
6510 SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT);
6511 int result_fontspec = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONT_SPECIFICATION);
6513 // font_specification will not be set unless defined explicitely on a tspan.
6514 // This should be fixed!
6515 Glib::ustring fontSpec = query->text->font_specification.set ? query->text->font_specification.value : "";
6517 if (fontSpec.empty()) {
6518 // Construct a new font specification if it does not yet exist
6519 // Must query font-family, font-style, font-weight, to find correct font face.
6520 sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTFAMILY);
6521 sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTSTYLE);
6522 sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
6524 font_instance * fontFromStyle = font_factory::Default()->FaceFromStyle(query);
6525 if( fontFromStyle ) {
6526 fontSpec = font_factory::Default()->ConstructFontSpecification(fontFromStyle);
6527 fontFromStyle->Unref();
6528 }
6529 }
6531 // Now that we have the old face, find the new face.
6532 Glib::ustring newFontSpec = "";
6533 SPCSSAttr *css = sp_repr_css_attr_new ();
6534 gboolean nochange = true;
6535 gboolean active = gtk_toggle_action_get_active( GTK_TOGGLE_ACTION(act) );
6537 switch (prop)
6538 {
6539 case 0:
6540 {
6541 // Bold
6542 if (!fontSpec.empty()) {
6544 newFontSpec = font_factory::Default()->FontSpecificationSetBold(fontSpec, active);
6546 if (!newFontSpec.empty()) {
6548 // Set weight if we found font.
6549 font_instance * font = font_factory::Default()->FaceFromFontSpecification(newFontSpec.c_str());
6550 if (font) {
6551 gchar c[256];
6552 font->Attribute( "weight", c, 256);
6553 sp_repr_css_set_property (css, "font-weight", c);
6554 font->Unref();
6555 font = NULL;
6556 }
6557 nochange = false;
6558 }
6559 }
6560 // Reset button if no change.
6561 // The reset code didn't work in 0.47 and doesn't here... one must prevent an infinite loop
6562 /*
6563 if(nochange) {
6564 gtk_action_block_activate( GTK_ACTION(act) );
6565 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), !active );
6566 gtk_action_unblock_activate( GTK_ACTION(act) );
6567 }
6568 */
6569 break;
6570 }
6572 case 1:
6573 {
6574 // Italic/Oblique
6575 if (!fontSpec.empty()) {
6577 newFontSpec = font_factory::Default()->FontSpecificationSetItalic(fontSpec, active);
6579 if (!newFontSpec.empty()) {
6581 // Don't even set the italic/oblique if the font didn't exist on the system
6582 if( active ) {
6583 if( newFontSpec.find( "Italic" ) != Glib::ustring::npos ) {
6584 sp_repr_css_set_property (css, "font-style", "italic");
6585 } else {
6586 sp_repr_css_set_property (css, "font-style", "oblique");
6587 }
6588 } else {
6589 sp_repr_css_set_property (css, "font-style", "normal");
6590 }
6591 nochange = false;
6592 }
6593 }
6594 // Reset button if no change.
6595 // The reset code didn't work in 0.47... one must prevent an infinite loop
6596 /*
6597 if(nochange) {
6598 gtk_action_block_activate( GTK_ACTION(act) );
6599 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), !active );
6600 gtk_action_unblock_activate( GTK_ACTION(act) );
6601 }
6602 */
6603 break;
6604 }
6605 }
6607 if (!newFontSpec.empty()) {
6608 sp_repr_css_set_property (css, "-inkscape-font-specification", newFontSpec.c_str());
6609 }
6611 // If querying returned nothing, update default style.
6612 if (result_fontspec == QUERY_STYLE_NOTHING)
6613 {
6614 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6615 prefs->mergeStyle("/tools/text/style", css);
6616 }
6618 sp_style_unref(query);
6620 // Do we need to update other CSS values?
6621 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
6622 sp_desktop_set_style (desktop, css, true, true);
6623 sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT,
6624 _("Text: Change font style"));
6625 sp_repr_css_attr_unref (css);
6627 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
6628 }
6630 // Handles both Superscripts and Subscripts
6631 static void sp_text_script_changed( InkToggleAction* act, GObject *tbl )
6632 {
6633 // quit if run by the _changed callbacks
6634 if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
6635 return;
6636 }
6637 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
6639 // Called by Superscript or Subscript button?
6640 const gchar* name = gtk_action_get_name( GTK_ACTION( act ) );
6641 gint prop = (strcmp(name, "TextSuperscriptAction") == 0) ? 0 : 1;
6643 #ifdef DEBUG_TEXT
6644 std::cout << "sp_text_script_changed: " << prop << std::endl;
6645 #endif
6647 // Query baseline
6648 SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT);
6649 int result_baseline = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_BASELINES);
6651 bool setSuper = false;
6652 bool setSub = false;
6654 if(result_baseline == QUERY_STYLE_NOTHING || result_baseline == QUERY_STYLE_MULTIPLE_DIFFERENT ) {
6655 // If not set or mixed, turn on superscript or subscript
6656 if( prop == 0 ) {
6657 setSuper = true;
6658 } else {
6659 setSub = true;
6660 }
6661 } else {
6662 // Superscript
6663 gboolean superscriptSet = (query->baseline_shift.set &&
6664 query->baseline_shift.type == SP_BASELINE_SHIFT_LITERAL &&
6665 query->baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUPER );
6667 // Subscript
6668 gboolean subscriptSet = (query->baseline_shift.set &&
6669 query->baseline_shift.type == SP_BASELINE_SHIFT_LITERAL &&
6670 query->baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUB );
6672 setSuper = !superscriptSet && prop == 0;
6673 setSub = !subscriptSet && prop == 1;
6674 }
6676 // Set css properties
6677 SPCSSAttr *css = sp_repr_css_attr_new ();
6678 if( setSuper || setSub ) {
6679 // Openoffice 2.3 and Adobe use 58%, Microsoft Word 2002 uses 65%, LaTex about 70%.
6680 // 58% looks too small to me, especially if a superscript is placed on a superscript.
6681 // If you make a change here, consider making a change to baseline-shift amount
6682 // in style.cpp.
6683 sp_repr_css_set_property (css, "font-size", "65%");
6684 } else {
6685 sp_repr_css_set_property (css, "font-size", "");
6686 }
6687 if( setSuper ) {
6688 sp_repr_css_set_property (css, "baseline-shift", "super");
6689 } else if( setSub ) {
6690 sp_repr_css_set_property (css, "baseline-shift", "sub");
6691 } else {
6692 sp_repr_css_set_property (css, "baseline-shift", "baseline");
6693 }
6695 // Apply css to selected objects.
6696 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
6697 sp_desktop_set_style (desktop, css, true, false);
6699 // Save for undo
6700 sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:script", SP_VERB_NONE,
6701 _("Text: Change superscript or subscript"));
6703 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
6704 }
6706 static void sp_text_align_mode_changed( EgeSelectOneAction *act, GObject *tbl )
6707 {
6708 // quit if run by the _changed callbacks
6709 if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
6710 return;
6711 }
6712 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
6714 int mode = ege_select_one_action_get_active( act );
6716 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6717 prefs->setInt("/tools/text/align_mode", mode);
6719 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
6721 // move the x of all texts to preserve the same bbox
6722 Inkscape::Selection *selection = sp_desktop_selection(desktop);
6723 for (GSList const *items = selection->itemList(); items != NULL; items = items->next) {
6724 if (SP_IS_TEXT((SPItem *) items->data)) {
6725 SPItem *item = SP_ITEM(items->data);
6727 unsigned writing_mode = SP_OBJECT_STYLE(item)->writing_mode.value;
6728 // below, variable names suggest horizontal move, but we check the writing direction
6729 // and move in the corresponding axis
6730 int axis;
6731 if (writing_mode == SP_CSS_WRITING_MODE_LR_TB || writing_mode == SP_CSS_WRITING_MODE_RL_TB) {
6732 axis = NR::X;
6733 } else {
6734 axis = NR::Y;
6735 }
6737 Geom::OptRect bbox
6738 = item->getBounds(Geom::identity(), SPItem::GEOMETRIC_BBOX);
6739 if (!bbox)
6740 continue;
6741 double width = bbox->dimensions()[axis];
6742 // If you want to align within some frame, other than the text's own bbox, calculate
6743 // the left and right (or top and bottom for tb text) slacks of the text inside that
6744 // frame (currently unused)
6745 double left_slack = 0;
6746 double right_slack = 0;
6747 unsigned old_align = SP_OBJECT_STYLE(item)->text_align.value;
6748 double move = 0;
6749 if (old_align == SP_CSS_TEXT_ALIGN_START || old_align == SP_CSS_TEXT_ALIGN_LEFT) {
6750 switch (mode) {
6751 case 0:
6752 move = -left_slack;
6753 break;
6754 case 1:
6755 move = width/2 + (right_slack - left_slack)/2;
6756 break;
6757 case 2:
6758 move = width + right_slack;
6759 break;
6760 }
6761 } else if (old_align == SP_CSS_TEXT_ALIGN_CENTER) {
6762 switch (mode) {
6763 case 0:
6764 move = -width/2 - left_slack;
6765 break;
6766 case 1:
6767 move = (right_slack - left_slack)/2;
6768 break;
6769 case 2:
6770 move = width/2 + right_slack;
6771 break;
6772 }
6773 } else if (old_align == SP_CSS_TEXT_ALIGN_END || old_align == SP_CSS_TEXT_ALIGN_RIGHT) {
6774 switch (mode) {
6775 case 0:
6776 move = -width - left_slack;
6777 break;
6778 case 1:
6779 move = -width/2 + (right_slack - left_slack)/2;
6780 break;
6781 case 2:
6782 move = right_slack;
6783 break;
6784 }
6785 }
6786 Geom::Point XY = SP_TEXT(item)->attributes.firstXY();
6787 if (axis == NR::X) {
6788 XY = XY + Geom::Point (move, 0);
6789 } else {
6790 XY = XY + Geom::Point (0, move);
6791 }
6792 SP_TEXT(item)->attributes.setFirstXY(XY);
6793 SP_OBJECT(item)->updateRepr();
6794 SP_OBJECT(item)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
6795 }
6796 }
6798 SPCSSAttr *css = sp_repr_css_attr_new ();
6799 switch (mode)
6800 {
6801 case 0:
6802 {
6803 sp_repr_css_set_property (css, "text-anchor", "start");
6804 sp_repr_css_set_property (css, "text-align", "start");
6805 break;
6806 }
6807 case 1:
6808 {
6809 sp_repr_css_set_property (css, "text-anchor", "middle");
6810 sp_repr_css_set_property (css, "text-align", "center");
6811 break;
6812 }
6814 case 2:
6815 {
6816 sp_repr_css_set_property (css, "text-anchor", "end");
6817 sp_repr_css_set_property (css, "text-align", "end");
6818 break;
6819 }
6821 case 3:
6822 {
6823 sp_repr_css_set_property (css, "text-anchor", "start");
6824 sp_repr_css_set_property (css, "text-align", "justify");
6825 break;
6826 }
6827 }
6829 SPStyle *query =
6830 sp_style_new (SP_ACTIVE_DOCUMENT);
6831 int result_numbers =
6832 sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
6834 // If querying returned nothing, update default style.
6835 if (result_numbers == QUERY_STYLE_NOTHING)
6836 {
6837 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6838 prefs->mergeStyle("/tools/text/style", css);
6839 }
6841 sp_style_unref(query);
6843 sp_desktop_set_style (desktop, css, true, true);
6844 sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT,
6845 _("Text: Change alignment"));
6846 sp_repr_css_attr_unref (css);
6848 gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas));
6850 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
6851 }
6853 static void sp_text_lineheight_value_changed( GtkAdjustment *adj, GObject *tbl )
6854 {
6855 // quit if run by the _changed callbacks
6856 if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
6857 return;
6858 }
6859 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
6861 // At the moment this handles only numerical values (i.e. no percent).
6862 // Set css line height.
6863 SPCSSAttr *css = sp_repr_css_attr_new ();
6864 Inkscape::CSSOStringStream osfs;
6865 osfs << adj->value*100 << "%";
6866 sp_repr_css_set_property (css, "line-height", osfs.str().c_str());
6868 // Apply line-height to selected objects.
6869 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
6870 sp_desktop_set_style (desktop, css, true, false);
6873 // Until deprecated sodipodi:linespacing purged:
6874 Inkscape::Selection *selection = sp_desktop_selection(desktop);
6875 GSList const *items = selection->itemList();
6876 for (; items != NULL; items = items->next) {
6877 if (SP_IS_TEXT (items->data)) {
6878 SP_OBJECT_REPR(items->data)->setAttribute("sodipodi:linespacing", sp_repr_css_property (css, "line-height", NULL));
6879 }
6880 }
6882 // Save for undo
6883 sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:line-height", SP_VERB_NONE,
6884 _("Text: Change line-height"));
6886 // If no selected objects, set default.
6887 SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT);
6888 int result_numbers =
6889 sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
6890 if (result_numbers == QUERY_STYLE_NOTHING)
6891 {
6892 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6893 prefs->mergeStyle("/tools/text/style", css);
6894 }
6895 sp_style_unref(query);
6897 sp_repr_css_attr_unref (css);
6899 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
6900 }
6902 static void sp_text_wordspacing_value_changed( GtkAdjustment *adj, GObject *tbl )
6903 {
6904 // quit if run by the _changed callbacks
6905 if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
6906 return;
6907 }
6908 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
6910 // At the moment this handles only numerical values (i.e. no em unit).
6911 // Set css word-spacing
6912 SPCSSAttr *css = sp_repr_css_attr_new ();
6913 Inkscape::CSSOStringStream osfs;
6914 osfs << adj->value;
6915 sp_repr_css_set_property (css, "word-spacing", osfs.str().c_str());
6917 // Apply word-spacing to selected objects.
6918 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
6919 sp_desktop_set_style (desktop, css, true, false);
6921 // Save for undo
6922 sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:word-spacing", SP_VERB_NONE,
6923 _("Text: Change word-spacing"));
6925 // If no selected objects, set default.
6926 SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT);
6927 int result_numbers =
6928 sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
6929 if (result_numbers == QUERY_STYLE_NOTHING)
6930 {
6931 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6932 prefs->mergeStyle("/tools/text/style", css);
6933 }
6934 sp_style_unref(query);
6936 sp_repr_css_attr_unref (css);
6938 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
6939 }
6941 static void sp_text_letterspacing_value_changed( GtkAdjustment *adj, GObject *tbl )
6942 {
6943 // quit if run by the _changed callbacks
6944 if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
6945 return;
6946 }
6947 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
6949 // At the moment this handles only numerical values (i.e. no em unit).
6950 // Set css letter-spacing
6951 SPCSSAttr *css = sp_repr_css_attr_new ();
6952 Inkscape::CSSOStringStream osfs;
6953 osfs << adj->value;
6954 sp_repr_css_set_property (css, "letter-spacing", osfs.str().c_str());
6956 // Apply letter-spacing to selected objects.
6957 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
6958 sp_desktop_set_style (desktop, css, true, false);
6960 // Save for undo
6961 sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:letter-spacing", SP_VERB_NONE,
6962 _("Text: Change letter-spacing"));
6964 // If no selected objects, set default.
6965 SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT);
6966 int result_numbers =
6967 sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
6968 if (result_numbers == QUERY_STYLE_NOTHING)
6969 {
6970 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
6971 prefs->mergeStyle("/tools/text/style", css);
6972 }
6973 sp_style_unref(query);
6975 sp_repr_css_attr_unref (css);
6977 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
6978 }
6981 static void sp_text_dx_value_changed( GtkAdjustment *adj, 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 gdouble new_dx = adj->value;
6991 if( SP_IS_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context) ) {
6992 SPTextContext *const tc = SP_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context);
6993 if( tc ) {
6994 unsigned char_index = -1;
6995 TextTagAttributes *attributes =
6996 text_tag_attributes_at_position( tc->text, std::min(tc->text_sel_start, tc->text_sel_end), &char_index );
6997 if( attributes ) {
6998 double old_dx = attributes->getDx( char_index );
6999 double delta_dx = new_dx - old_dx;
7000 sp_te_adjust_dx( tc->text, tc->text_sel_start, tc->text_sel_end, SP_ACTIVE_DESKTOP, delta_dx );
7001 }
7002 }
7003 }
7005 // Save for undo
7006 sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:dx", SP_VERB_NONE,
7007 _("Text: Change dx (kern)"));
7009 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
7010 }
7012 static void sp_text_dy_value_changed( GtkAdjustment *adj, GObject *tbl )
7013 {
7014 // quit if run by the _changed callbacks
7015 if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
7016 return;
7017 }
7018 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
7020 gdouble new_dy = adj->value;
7022 if( SP_IS_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context) ) {
7023 SPTextContext *const tc = SP_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context);
7024 if( tc ) {
7025 unsigned char_index = -1;
7026 TextTagAttributes *attributes =
7027 text_tag_attributes_at_position( tc->text, std::min(tc->text_sel_start, tc->text_sel_end), &char_index );
7028 if( attributes ) {
7029 double old_dy = attributes->getDy( char_index );
7030 double delta_dy = new_dy - old_dy;
7031 sp_te_adjust_dy( tc->text, tc->text_sel_start, tc->text_sel_end, SP_ACTIVE_DESKTOP, delta_dy );
7032 }
7033 }
7034 }
7036 // Save for undo
7037 sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:dy", SP_VERB_NONE,
7038 _("Text: Change dy"));
7040 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
7041 }
7043 static void sp_text_rotation_value_changed( GtkAdjustment *adj, GObject *tbl )
7044 {
7045 // quit if run by the _changed callbacks
7046 if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
7047 return;
7048 }
7049 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
7051 gdouble new_degrees = adj->value;
7053 if( SP_IS_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context) ) {
7054 SPTextContext *const tc = SP_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context);
7055 if( tc ) {
7056 unsigned char_index = -1;
7057 TextTagAttributes *attributes =
7058 text_tag_attributes_at_position( tc->text, std::min(tc->text_sel_start, tc->text_sel_end), &char_index );
7059 if( attributes ) {
7060 double old_degrees = attributes->getRotate( char_index );
7061 double delta_deg = new_degrees - old_degrees;
7062 sp_te_adjust_rotation( tc->text, tc->text_sel_start, tc->text_sel_end, SP_ACTIVE_DESKTOP, delta_deg );
7063 }
7064 }
7065 }
7067 // Save for undo
7068 sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:rotate", SP_VERB_NONE,
7069 _("Text: Change rotate"));
7071 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
7072 }
7074 static void sp_text_orientation_mode_changed( EgeSelectOneAction *act, GObject *tbl )
7075 {
7076 // quit if run by the _changed callbacks
7077 if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
7078 return;
7079 }
7080 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
7082 int mode = ege_select_one_action_get_active( act );
7084 SPCSSAttr *css = sp_repr_css_attr_new ();
7085 switch (mode)
7086 {
7087 case 0:
7088 {
7089 sp_repr_css_set_property (css, "writing-mode", "lr");
7090 break;
7091 }
7093 case 1:
7094 {
7095 sp_repr_css_set_property (css, "writing-mode", "tb");
7096 break;
7097 }
7098 }
7100 SPStyle *query =
7101 sp_style_new (SP_ACTIVE_DOCUMENT);
7102 int result_numbers =
7103 sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
7105 // If querying returned nothing, update default style.
7106 if (result_numbers == QUERY_STYLE_NOTHING)
7107 {
7108 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
7109 prefs->mergeStyle("/tools/text/style", css);
7110 }
7112 sp_desktop_set_style (SP_ACTIVE_DESKTOP, css, true, true);
7113 sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT,
7114 _("Text: Change orientation"));
7115 sp_repr_css_attr_unref (css);
7117 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
7118 }
7120 /*
7121 * This function sets up the text-tool tool-controls, setting the entry boxes
7122 * etc. to the values from the current selection or the default if no selection.
7123 * It is called whenever a text selection is changed, including stepping cursor
7124 * through text.
7125 */
7126 static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/, GObject *tbl)
7127 {
7128 #ifdef DEBUG_TEXT
7129 static int count = 0;
7130 ++count;
7131 std::cout << std::endl;
7132 std::cout << "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" << std::endl;
7133 std::cout << "sp_text_toolbox_selection_changed: start " << count << std::endl;
7135 std::cout << " Selected items:" << std::endl;
7136 for (GSList const *items = sp_desktop_selection(SP_ACTIVE_DESKTOP)->itemList();
7137 items != NULL;
7138 items = items->next)
7139 {
7140 const gchar* id = SP_OBJECT_ID((SPItem *) items->data);
7141 std::cout << " " << id << std::endl;
7142 }
7143 Glib::ustring selected_text = sp_text_get_selected_text((SP_ACTIVE_DESKTOP)->event_context);
7144 std::cout << " Selected text:" << std::endl;
7145 std::cout << selected_text << std::endl;
7146 #endif
7148 // quit if run by the _changed callbacks
7149 if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
7150 #ifdef DEBUG_TEXT
7151 std::cout << " Frozen, returning" << std::endl;
7152 std::cout << "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" << std::endl;
7153 std::cout << std::endl;
7154 #endif
7155 return;
7156 }
7157 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
7159 // Only flowed text can be justified, only normal text can be kerned...
7160 // Find out if we have flowed text now so we can use it several places
7161 gboolean isFlow = false;
7162 for (GSList const *items = sp_desktop_selection(SP_ACTIVE_DESKTOP)->itemList();
7163 items != NULL;
7164 items = items->next) {
7165 // const gchar* id = SP_OBJECT_ID((SPItem *) items->data);
7166 // std::cout << " " << id << std::endl;
7167 if( SP_IS_FLOWTEXT(( SPItem *) items->data )) {
7168 isFlow = true;
7169 // std::cout << " Found flowed text" << std::endl;
7170 break;
7171 }
7172 }
7174 /*
7175 * Query from current selection:
7176 * Font family (font-family)
7177 * Style (font-weight, font-style, font-stretch, font-variant, font-align)
7178 * Numbers (font-size, letter-spacing, word-spacing, line-height, text-anchor, writing-mode)
7179 * Font specification (Inkscape private attribute)
7180 */
7181 SPStyle *query =
7182 sp_style_new (SP_ACTIVE_DOCUMENT);
7183 int result_family = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTFAMILY);
7184 int result_style = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTSTYLE);
7185 int result_numbers = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
7186 int result_baseline = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_BASELINES);
7188 // Used later:
7189 sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONT_SPECIFICATION);
7191 /*
7192 * If no text in selection (querying returned nothing), read the style from
7193 * the /tools/text preferencess (default style for new texts). Return if
7194 * tool bar already set to these preferences.
7195 */
7196 if (result_family == QUERY_STYLE_NOTHING || result_style == QUERY_STYLE_NOTHING || result_numbers == QUERY_STYLE_NOTHING) {
7197 // There are no texts in selection, read from preferences.
7198 sp_style_read_from_prefs(query, "/tools/text");
7199 #ifdef DEBUG_TEXT
7200 std::cout << " read style from prefs:" << std::endl;
7201 sp_print_font( query );
7202 #endif
7203 if (g_object_get_data(tbl, "text_style_from_prefs")) {
7204 // Do not reset the toolbar style from prefs if we already did it last time
7205 sp_style_unref(query);
7206 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
7207 #ifdef DEBUG_TEXT
7208 std::cout << " text_style_from_prefs: toolbar already set" << std:: endl;
7209 std::cout << "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" << std::endl;
7210 std::cout << std::endl;
7211 #endif
7212 return;
7213 }
7215 g_object_set_data(tbl, "text_style_from_prefs", GINT_TO_POINTER(TRUE));
7216 } else {
7217 g_object_set_data(tbl, "text_style_from_prefs", GINT_TO_POINTER(FALSE));
7218 }
7220 // If we have valid query data for text (font-family, font-specification) set toolbar accordingly.
7221 if (query->text)
7222 {
7223 // Font family
7224 if( query->text->font_family.value ) {
7225 gchar *fontFamily = query->text->font_family.value;
7227 Ink_ComboBoxEntry_Action* fontFamilyAction =
7228 INK_COMBOBOXENTRY_ACTION( g_object_get_data( tbl, "TextFontFamilyAction" ) );
7229 ink_comboboxentry_action_set_active_text( fontFamilyAction, fontFamily );
7230 }
7233 // Size (average of text selected)
7234 double size = query->font_size.computed;
7235 gchar size_text[G_ASCII_DTOSTR_BUF_SIZE];
7236 g_ascii_dtostr (size_text, sizeof (size_text), size);
7238 Ink_ComboBoxEntry_Action* fontSizeAction =
7239 INK_COMBOBOXENTRY_ACTION( g_object_get_data( tbl, "TextFontSizeAction" ) );
7240 ink_comboboxentry_action_set_active_text( fontSizeAction, size_text );
7243 // Weight (Bold)
7244 // Note: in the enumeration, normal and lighter come at the end so we must explicitly test for them.
7245 gboolean boldSet = ((query->font_weight.computed >= SP_CSS_FONT_WEIGHT_700) &&
7246 (query->font_weight.computed != SP_CSS_FONT_WEIGHT_NORMAL) &&
7247 (query->font_weight.computed != SP_CSS_FONT_WEIGHT_LIGHTER));
7249 InkToggleAction* textBoldAction = INK_TOGGLE_ACTION( g_object_get_data( tbl, "TextBoldAction" ) );
7250 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(textBoldAction), boldSet );
7253 // Style (Italic/Oblique)
7254 gboolean italicSet = (query->font_style.computed != SP_CSS_FONT_STYLE_NORMAL);
7256 InkToggleAction* textItalicAction = INK_TOGGLE_ACTION( g_object_get_data( tbl, "TextItalicAction" ) );
7257 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(textItalicAction), italicSet );
7260 // Superscript
7261 gboolean superscriptSet =
7262 ((result_baseline == QUERY_STYLE_SINGLE || result_baseline == QUERY_STYLE_MULTIPLE_SAME ) &&
7263 query->baseline_shift.set &&
7264 query->baseline_shift.type == SP_BASELINE_SHIFT_LITERAL &&
7265 query->baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUPER );
7267 InkToggleAction* textSuperscriptAction = INK_TOGGLE_ACTION( g_object_get_data( tbl, "TextSuperscriptAction" ) );
7268 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(textSuperscriptAction), superscriptSet );
7271 // Subscript
7272 gboolean subscriptSet =
7273 ((result_baseline == QUERY_STYLE_SINGLE || result_baseline == QUERY_STYLE_MULTIPLE_SAME ) &&
7274 query->baseline_shift.set &&
7275 query->baseline_shift.type == SP_BASELINE_SHIFT_LITERAL &&
7276 query->baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUB );
7278 InkToggleAction* textSubscriptAction = INK_TOGGLE_ACTION( g_object_get_data( tbl, "TextSubscriptAction" ) );
7279 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(textSubscriptAction), subscriptSet );
7282 // Alignment
7283 EgeSelectOneAction* textAlignAction = EGE_SELECT_ONE_ACTION( g_object_get_data( tbl, "TextAlignAction" ) );
7285 // Note: SVG 1.1 doesn't include text-align, SVG 1.2 Tiny doesn't include text-align="justify"
7286 // text-align="justify" was a draft SVG 1.2 item (along with flowed text).
7287 // Only flowed text can be left and right justified at the same time.
7288 // Disable button if we don't have flowed text.
7290 // The GtkTreeModel class doesn't have a set function so we can't
7291 // simply add an ege_select_one_action_set_sensitive method!
7292 // We must set values directly with the GtkListStore and then
7293 // ask that the GtkAction update the sensitive parameters.
7294 GtkListStore * model = GTK_LIST_STORE( ege_select_one_action_get_model( textAlignAction ) );
7295 GtkTreePath * path = gtk_tree_path_new_from_string("3"); // Justify entry
7296 GtkTreeIter iter;
7297 gtk_tree_model_get_iter( GTK_TREE_MODEL (model), &iter, path );
7298 gtk_list_store_set( model, &iter, /* column */ 3, isFlow, -1 );
7299 ege_select_one_action_update_sensitive( textAlignAction );
7300 // ege_select_one_action_set_sensitive( textAlignAction, 3, isFlow );
7302 int activeButton = 0;
7303 if (query->text_align.computed == SP_CSS_TEXT_ALIGN_JUSTIFY)
7304 {
7305 activeButton = 3;
7306 } else {
7307 if (query->text_anchor.computed == SP_CSS_TEXT_ANCHOR_START) activeButton = 0;
7308 if (query->text_anchor.computed == SP_CSS_TEXT_ANCHOR_MIDDLE) activeButton = 1;
7309 if (query->text_anchor.computed == SP_CSS_TEXT_ANCHOR_END) activeButton = 2;
7310 }
7311 ege_select_one_action_set_active( textAlignAction, activeButton );
7314 // Line height (spacing)
7315 double height;
7316 if (query->line_height.normal) {
7317 height = Inkscape::Text::Layout::LINE_HEIGHT_NORMAL;
7318 } else {
7319 if (query->line_height.unit == SP_CSS_UNIT_PERCENT) {
7320 height = query->line_height.value;
7321 } else {
7322 height = query->line_height.computed;
7323 }
7324 }
7326 GtkAction* lineHeightAction = GTK_ACTION( g_object_get_data( tbl, "TextLineHeightAction" ) );
7327 GtkAdjustment *lineHeightAdjustment =
7328 ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( lineHeightAction ));
7329 gtk_adjustment_set_value( lineHeightAdjustment, height );
7332 // Word spacing
7333 double wordSpacing;
7334 if (query->word_spacing.normal) wordSpacing = 0.0;
7335 else wordSpacing = query->word_spacing.computed; // Assume no units (change in desktop-style.cpp)
7337 GtkAction* wordSpacingAction = GTK_ACTION( g_object_get_data( tbl, "TextWordSpacingAction" ) );
7338 GtkAdjustment *wordSpacingAdjustment =
7339 ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( wordSpacingAction ));
7340 gtk_adjustment_set_value( wordSpacingAdjustment, wordSpacing );
7343 // Letter spacing
7344 double letterSpacing;
7345 if (query->letter_spacing.normal) letterSpacing = 0.0;
7346 else letterSpacing = query->letter_spacing.computed; // Assume no units (change in desktop-style.cpp)
7348 GtkAction* letterSpacingAction = GTK_ACTION( g_object_get_data( tbl, "TextLetterSpacingAction" ) );
7349 GtkAdjustment *letterSpacingAdjustment =
7350 ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( letterSpacingAction ));
7351 gtk_adjustment_set_value( letterSpacingAdjustment, letterSpacing );
7354 // Orientation
7355 int activeButton2 = (query->writing_mode.computed == SP_CSS_WRITING_MODE_LR_TB ? 0 : 1);
7357 EgeSelectOneAction* textOrientationAction =
7358 EGE_SELECT_ONE_ACTION( g_object_get_data( tbl, "TextOrientationAction" ) );
7359 ege_select_one_action_set_active( textOrientationAction, activeButton2 );
7362 } // if( query->text )
7364 #ifdef DEBUG_TEXT
7365 std::cout << " GUI: fontfamily.value: "
7366 << (query->text->font_family.value ? query->text->font_family.value : "No value")
7367 << std::endl;
7368 std::cout << " GUI: font_size.computed: " << query->font_size.computed << std::endl;
7369 std::cout << " GUI: font_weight.computed: " << query->font_weight.computed << std::endl;
7370 std::cout << " GUI: font_style.computed: " << query->font_style.computed << std::endl;
7371 std::cout << " GUI: text_anchor.computed: " << query->text_anchor.computed << std::endl;
7372 std::cout << " GUI: text_align.computed: " << query->text_align.computed << std::endl;
7373 std::cout << " GUI: line_height.computed: " << query->line_height.computed
7374 << " line_height.value: " << query->line_height.value
7375 << " line_height.unit: " << query->line_height.unit << std::endl;
7376 std::cout << " GUI: word_spacing.computed: " << query->word_spacing.computed
7377 << " word_spacing.value: " << query->word_spacing.value
7378 << " word_spacing.unit: " << query->word_spacing.unit << std::endl;
7379 std::cout << " GUI: letter_spacing.computed: " << query->letter_spacing.computed
7380 << " letter_spacing.value: " << query->letter_spacing.value
7381 << " letter_spacing.unit: " << query->letter_spacing.unit << std::endl;
7382 std::cout << " GUI: writing_mode.computed: " << query->writing_mode.computed << std::endl;
7383 #endif
7385 sp_style_unref(query);
7387 // Kerning (xshift), yshift, rotation. NB: These are not CSS attributes.
7388 if( SP_IS_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context) ) {
7389 SPTextContext *const tc = SP_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context);
7390 if( tc ) {
7391 unsigned char_index = -1;
7392 TextTagAttributes *attributes =
7393 text_tag_attributes_at_position( tc->text, std::min(tc->text_sel_start, tc->text_sel_end), &char_index );
7394 if( attributes ) {
7396 // Dx
7397 double dx = attributes->getDx( char_index );
7398 GtkAction* dxAction = GTK_ACTION( g_object_get_data( tbl, "TextDxAction" ));
7399 GtkAdjustment *dxAdjustment =
7400 ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( dxAction ));
7401 gtk_adjustment_set_value( dxAdjustment, dx );
7403 // Dy
7404 double dy = attributes->getDy( char_index );
7405 GtkAction* dyAction = GTK_ACTION( g_object_get_data( tbl, "TextDyAction" ));
7406 GtkAdjustment *dyAdjustment =
7407 ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( dyAction ));
7408 gtk_adjustment_set_value( dyAdjustment, dy );
7410 // Rotation
7411 double rotation = attributes->getRotate( char_index );
7412 /* SVG value is between 0 and 360 but we're using -180 to 180 in widget */
7413 if( rotation > 180.0 ) rotation -= 360.0;
7414 GtkAction* rotationAction = GTK_ACTION( g_object_get_data( tbl, "TextRotationAction" ));
7415 GtkAdjustment *rotationAdjustment =
7416 ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( rotationAction ));
7417 gtk_adjustment_set_value( rotationAdjustment, rotation );
7419 #ifdef DEBUG_TEXT
7420 std::cout << " GUI: Dx: " << dx << std::endl;
7421 std::cout << " GUI: Dy: " << dy << std::endl;
7422 std::cout << " GUI: Rotation: " << rotation << std::endl;
7423 #endif
7424 }
7425 }
7426 }
7428 {
7429 // Set these here as we don't always have kerning/rotating attributes
7430 GtkAction* dxAction = GTK_ACTION( g_object_get_data( tbl, "TextDxAction" ));
7431 gtk_action_set_sensitive( GTK_ACTION(dxAction), !isFlow );
7433 GtkAction* dyAction = GTK_ACTION( g_object_get_data( tbl, "TextDyAction" ));
7434 gtk_action_set_sensitive( GTK_ACTION(dyAction), !isFlow );
7436 GtkAction* rotationAction = GTK_ACTION( g_object_get_data( tbl, "TextRotationAction" ));
7437 gtk_action_set_sensitive( GTK_ACTION(rotationAction), !isFlow );
7438 }
7440 #ifdef DEBUG_TEXT
7441 std::cout << "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" << std::endl;
7442 std::cout << std::endl;
7443 #endif
7445 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
7447 }
7449 static void sp_text_toolbox_selection_modified(Inkscape::Selection *selection, guint /*flags*/, GObject *tbl)
7450 {
7451 sp_text_toolbox_selection_changed (selection, tbl);
7452 }
7454 void
7455 sp_text_toolbox_subselection_changed (gpointer /*tc*/, GObject *tbl)
7456 {
7457 sp_text_toolbox_selection_changed (NULL, tbl);
7458 }
7460 // Define all the "widgets" in the toolbar.
7461 static void sp_text_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
7462 {
7463 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
7464 Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
7466 // Is this used?
7467 UnitTracker* tracker = new UnitTracker( SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE );
7468 tracker->setActiveUnit( sp_desktop_namedview(desktop)->doc_units );
7469 g_object_set_data( holder, "tracker", tracker );
7471 /* Font family */
7472 {
7473 // Font list
7474 Glib::RefPtr<Gtk::ListStore> store = Inkscape::FontLister::get_instance()->get_font_list();
7475 GtkListStore* model = store->gobj();
7477 Ink_ComboBoxEntry_Action* act = ink_comboboxentry_action_new( "TextFontFamilyAction",
7478 _("Font Family"),
7479 _("Select Font Family (Alt-X to access)"),
7480 NULL,
7481 GTK_TREE_MODEL(model),
7482 -1, // Entry width
7483 50, // Extra list width
7484 (gpointer)cell_data_func ); // Cell layout
7485 ink_comboboxentry_action_popup_enable( act ); // Enable entry completion
7486 gchar *const warning = _("Font not found on system");
7487 ink_comboboxentry_action_set_warning( act, warning ); // Show icon with tooltip if missing font
7488 ink_comboboxentry_action_set_altx_name( act, "altx-text" ); // Set Alt-X keyboard shortcut
7489 g_signal_connect( G_OBJECT(act), "changed", G_CALLBACK(sp_text_fontfamily_value_changed), holder );
7490 gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
7491 g_object_set_data( holder, "TextFontFamilyAction", act );
7493 // Change style of drop-down from menu to list
7494 gtk_rc_parse_string (
7495 "style \"dropdown-as-list-style\"\n"
7496 "{\n"
7497 " GtkComboBox::appears-as-list = 1\n"
7498 "}\n"
7499 "widget \"*.TextFontFamilyAction_combobox\" style \"dropdown-as-list-style\"");
7500 }
7502 /* Font size */
7503 {
7504 // List of font sizes for drop-down menu
7505 GtkListStore* model_size = gtk_list_store_new( 1, G_TYPE_STRING );
7506 gchar const *const sizes[] = {
7507 "4", "6", "8", "9", "10", "11", "12", "13", "14", "16",
7508 "18", "20", "22", "24", "28", "32", "36", "40", "48", "56",
7509 "64", "72", "144"
7510 };
7511 for( unsigned int i = 0; i < G_N_ELEMENTS(sizes); ++i ) {
7512 GtkTreeIter iter;
7513 gtk_list_store_append( model_size, &iter );
7514 gtk_list_store_set( model_size, &iter, 0, sizes[i], -1 );
7515 }
7517 Ink_ComboBoxEntry_Action* act = ink_comboboxentry_action_new( "TextFontSizeAction",
7518 _("Font Size"),
7519 _("Font size (px)"),
7520 NULL,
7521 GTK_TREE_MODEL(model_size),
7522 4 ); // Width in characters
7523 g_signal_connect( G_OBJECT(act), "changed", G_CALLBACK(sp_text_fontsize_value_changed), holder );
7524 gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
7525 g_object_set_data( holder, "TextFontSizeAction", act );
7526 }
7528 /* Style - Bold */
7529 {
7530 InkToggleAction* act = ink_toggle_action_new( "TextBoldAction", // Name
7531 _("Toggle Bold"), // Label
7532 _("Toggle bold or normal weight"), // Tooltip
7533 GTK_STOCK_BOLD, // Icon (inkId)
7534 secondarySize ); // Icon size
7535 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
7536 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_text_style_changed), holder );
7537 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/text/bold", false) );
7538 g_object_set_data( holder, "TextBoldAction", act );
7539 }
7541 /* Style - Italic/Oblique */
7542 {
7543 InkToggleAction* act = ink_toggle_action_new( "TextItalicAction", // Name
7544 _("Toggle Italic/Oblique"), // Label
7545 _("Toggle italic/oblique style"),// Tooltip
7546 GTK_STOCK_ITALIC, // Icon (inkId)
7547 secondarySize ); // Icon size
7548 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
7549 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_text_style_changed), holder );
7550 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/text/italic", false) );
7551 g_object_set_data( holder, "TextItalicAction", act );
7552 }
7554 /* Style - Superscript */
7555 {
7556 InkToggleAction* act = ink_toggle_action_new( "TextSuperscriptAction", // Name
7557 _("Toggle Superscript"), // Label
7558 _("Toggle superscript"), // Tooltip
7559 GTK_STOCK_ITALIC, // Icon (inkId)
7560 secondarySize ); // Icon size
7561 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
7562 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_text_script_changed), holder );
7563 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/text/super", false) );
7564 g_object_set_data( holder, "TextSuperscriptAction", act );
7565 }
7567 /* Style - Subscript */
7568 {
7569 InkToggleAction* act = ink_toggle_action_new( "TextSubscriptAction", // Name
7570 _("Toggle Subscript"), // Label
7571 _("Toggle subscript"), // Tooltip
7572 GTK_STOCK_ITALIC, // Icon (inkId)
7573 secondarySize ); // Icon size
7574 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
7575 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_text_script_changed), holder );
7576 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/text/sub", false) );
7577 g_object_set_data( holder, "TextSubscriptAction", act );
7578 }
7580 /* Alignment */
7581 {
7582 GtkListStore* model = gtk_list_store_new( 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN );
7584 GtkTreeIter iter;
7586 gtk_list_store_append( model, &iter );
7587 gtk_list_store_set( model, &iter,
7588 0, _("Align left"),
7589 1, _("Align left"),
7590 2, GTK_STOCK_JUSTIFY_LEFT,
7591 3, true,
7592 -1 );
7594 gtk_list_store_append( model, &iter );
7595 gtk_list_store_set( model, &iter,
7596 0, _("Align center"),
7597 1, _("Align center"),
7598 2, GTK_STOCK_JUSTIFY_CENTER,
7599 3, true,
7600 -1 );
7602 gtk_list_store_append( model, &iter );
7603 gtk_list_store_set( model, &iter,
7604 0, _("Align right"),
7605 1, _("Align right"),
7606 2, GTK_STOCK_JUSTIFY_RIGHT,
7607 3, true,
7608 -1 );
7610 gtk_list_store_append( model, &iter );
7611 gtk_list_store_set( model, &iter,
7612 0, _("Justify"),
7613 1, _("Justify (only flowed text)"),
7614 2, GTK_STOCK_JUSTIFY_FILL,
7615 3, false,
7616 -1 );
7618 EgeSelectOneAction* act = ege_select_one_action_new( "TextAlignAction", // Name
7619 _("Alignment"), // Label
7620 _("Text alignment"), // Tooltip
7621 NULL, // StockID
7622 GTK_TREE_MODEL(model) ); // Model
7623 g_object_set( act, "short_label", "NotUsed", NULL );
7624 gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
7625 g_object_set_data( holder, "TextAlignAction", act );
7627 ege_select_one_action_set_appearance( act, "full" );
7628 ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
7629 g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
7630 ege_select_one_action_set_icon_column( act, 2 );
7631 ege_select_one_action_set_icon_size( act, secondarySize );
7632 ege_select_one_action_set_tooltip_column( act, 1 );
7633 ege_select_one_action_set_sensitive_column( act, 3 );
7634 gint mode = prefs->getInt("/tools/text/align_mode", 0);
7635 ege_select_one_action_set_active( act, mode );
7636 g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_text_align_mode_changed), holder );
7637 }
7639 /* Orientation (Left to Right, Top to Bottom */
7640 {
7641 GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
7643 GtkTreeIter iter;
7645 gtk_list_store_append( model, &iter );
7646 gtk_list_store_set( model, &iter,
7647 0, _("Horizontal"),
7648 1, _("Horizontal text"),
7649 2, INKSCAPE_ICON_FORMAT_TEXT_DIRECTION_HORIZONTAL,
7650 -1 );
7652 gtk_list_store_append( model, &iter );
7653 gtk_list_store_set( model, &iter,
7654 0, _("Vertical"),
7655 1, _("Vertical text"),
7656 2, INKSCAPE_ICON_FORMAT_TEXT_DIRECTION_VERTICAL,
7657 -1 );
7659 EgeSelectOneAction* act = ege_select_one_action_new( "TextOrientationAction", // Name
7660 _("Orientation"), // Label
7661 _("Text orientation"), // Tooltip
7662 NULL, // StockID
7663 GTK_TREE_MODEL(model) ); // Model
7665 g_object_set( act, "short_label", "NotUsed", NULL );
7666 gtk_action_group_add_action( mainActions, GTK_ACTION(act) );
7667 g_object_set_data( holder, "TextOrientationAction", act );
7669 ege_select_one_action_set_appearance( act, "full" );
7670 ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE );
7671 g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL );
7672 ege_select_one_action_set_icon_column( act, 2 );
7673 ege_select_one_action_set_icon_size( act, secondarySize );
7674 ege_select_one_action_set_tooltip_column( act, 1 );
7676 gint mode = prefs->getInt("/tools/text/orientation", 0);
7677 ege_select_one_action_set_active( act, mode );
7678 g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_text_orientation_mode_changed), holder );
7679 }
7681 /* Line height */
7682 {
7683 // Drop down menu
7684 gchar const* labels[] = {_("Smaller spacing"), 0, 0, 0, 0, _("Normal"), 0, 0, 0, 0, 0, _("Larger spacing")};
7685 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};
7687 EgeAdjustmentAction *eact = create_adjustment_action(
7688 "TextLineHeightAction", /* name */
7689 _("Line Height"), /* label */
7690 _("Line:"), /* short label */
7691 _("Spacing between lines (times font size)"), /* tooltip */
7692 "/tools/text/lineheight", /* preferences path */
7693 0.0, /* default */
7694 GTK_WIDGET(desktop->canvas), /* focusTarget */
7695 NULL, /* unit selector */
7696 holder, /* dataKludge */
7697 FALSE, /* set alt-x keyboard shortcut? */
7698 NULL, /* altx_mark */
7699 0.0, 10.0, 0.01, 0.10, /* lower, upper, step (arrow up/down), page up/down */
7700 labels, values, G_N_ELEMENTS(labels), /* drop down menu */
7701 sp_text_lineheight_value_changed, /* callback */
7702 0.1, /* step (used?) */
7703 2, /* digits to show */
7704 1.0 /* factor (multiplies default) */
7705 );
7706 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
7707 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
7708 g_object_set_data( holder, "TextLineHeightAction", eact );
7709 g_object_set( G_OBJECT(eact), "iconId", "text_line_spacing", NULL );
7710 }
7712 /* Word spacing */
7713 {
7714 // Drop down menu
7715 gchar const* labels[] = {_("Negative spacing"), 0, 0, 0, _("Normal"), 0, 0, 0, 0, 0, 0, 0, _("Positive spacing")};
7716 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};
7718 EgeAdjustmentAction *eact = create_adjustment_action(
7719 "TextWordSpacingAction", /* name */
7720 _("Word spacing"), /* label */
7721 _("Word:"), /* short label */
7722 _("Spacing between words (px)"), /* tooltip */
7723 "/tools/text/wordspacing", /* preferences path */
7724 0.0, /* default */
7725 GTK_WIDGET(desktop->canvas), /* focusTarget */
7726 NULL, /* unit selector */
7727 holder, /* dataKludge */
7728 FALSE, /* set alt-x keyboard shortcut? */
7729 NULL, /* altx_mark */
7730 -100.0, 100.0, 0.01, 0.10, /* lower, upper, step (arrow up/down), page up/down */
7731 labels, values, G_N_ELEMENTS(labels), /* drop down menu */
7732 sp_text_wordspacing_value_changed, /* callback */
7733 0.1, /* step (used?) */
7734 2, /* digits to show */
7735 1.0 /* factor (multiplies default) */
7736 );
7737 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
7738 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
7739 g_object_set_data( holder, "TextWordSpacingAction", eact );
7740 g_object_set( G_OBJECT(eact), "iconId", "text_word_spacing", NULL );
7741 }
7743 /* Letter spacing */
7744 {
7745 // Drop down menu
7746 gchar const* labels[] = {_("Negative spacing"), 0, 0, 0, _("Normal"), 0, 0, 0, 0, 0, 0, 0, _("Positive spacing")};
7747 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};
7749 EgeAdjustmentAction *eact = create_adjustment_action(
7750 "TextLetterSpacingAction", /* name */
7751 _("Letter spacing"), /* label */
7752 _("Letter:"), /* short label */
7753 _("Spacing between letters (px)"), /* tooltip */
7754 "/tools/text/letterspacing", /* preferences path */
7755 0.0, /* default */
7756 GTK_WIDGET(desktop->canvas), /* focusTarget */
7757 NULL, /* unit selector */
7758 holder, /* dataKludge */
7759 FALSE, /* set alt-x keyboard shortcut? */
7760 NULL, /* altx_mark */
7761 -100.0, 100.0, 0.01, 0.10, /* lower, upper, step (arrow up/down), page up/down */
7762 labels, values, G_N_ELEMENTS(labels), /* drop down menu */
7763 sp_text_letterspacing_value_changed, /* callback */
7764 0.1, /* step (used?) */
7765 2, /* digits to show */
7766 1.0 /* factor (multiplies default) */
7767 );
7768 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
7769 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
7770 g_object_set_data( holder, "TextLetterSpacingAction", eact );
7771 g_object_set( G_OBJECT(eact), "iconId", "text_letter_spacing", NULL );
7772 }
7774 /* Character kerning (horizontal shift) */
7775 {
7776 // Drop down menu
7777 gchar const* labels[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
7778 gdouble values[] = { -2.0, -1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5, 2.0, 2.5 };
7780 EgeAdjustmentAction *eact = create_adjustment_action(
7781 "TextDxAction", /* name */
7782 _("Kerning"), /* label */
7783 _("Kern:"), /* short label */
7784 _("Horizontal kerning (px)"), /* tooltip */
7785 "/tools/text/dx", /* preferences path */
7786 0.0, /* default */
7787 GTK_WIDGET(desktop->canvas), /* focusTarget */
7788 NULL, /* unit selector */
7789 holder, /* dataKludge */
7790 FALSE, /* set alt-x keyboard shortcut? */
7791 NULL, /* altx_mark */
7792 -100.0, 100.0, 0.01, 0.1, /* lower, upper, step (arrow up/down), page up/down */
7793 labels, values, G_N_ELEMENTS(labels), /* drop down menu */
7794 sp_text_dx_value_changed, /* callback */
7795 0.1, /* step (used?) */
7796 2, /* digits to show */
7797 1.0 /* factor (multiplies default) */
7798 );
7799 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
7800 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
7801 g_object_set_data( holder, "TextDxAction", eact );
7802 g_object_set( G_OBJECT(eact), "iconId", "text_horz_kern", NULL );
7803 }
7805 /* Character vertical shift */
7806 {
7807 // Drop down menu
7808 gchar const* labels[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
7809 gdouble values[] = { -2.0, -1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5, 2.0, 2.5 };
7811 EgeAdjustmentAction *eact = create_adjustment_action(
7812 "TextDyAction", /* name */
7813 _("Vertical Shift"), /* label */
7814 _("Vert:"), /* short label */
7815 _("Vertical shift (px)"), /* tooltip */
7816 "/tools/text/dy", /* preferences path */
7817 0.0, /* default */
7818 GTK_WIDGET(desktop->canvas), /* focusTarget */
7819 NULL, /* unit selector */
7820 holder, /* dataKludge */
7821 FALSE, /* set alt-x keyboard shortcut? */
7822 NULL, /* altx_mark */
7823 -100.0, 100.0, 0.01, 0.1, /* lower, upper, step (arrow up/down), page up/down */
7824 labels, values, G_N_ELEMENTS(labels), /* drop down menu */
7825 sp_text_dy_value_changed, /* callback */
7826 0.1, /* step (used?) */
7827 2, /* digits to show */
7828 1.0 /* factor (multiplies default) */
7829 );
7830 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
7831 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
7832 g_object_set_data( holder, "TextDyAction", eact );
7833 g_object_set( G_OBJECT(eact), "iconId", "text_vert_kern", NULL );
7834 }
7836 /* Character rotation */
7837 {
7838 // Drop down menu
7839 gchar const* labels[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
7840 gdouble values[] = { -90, -45, -30, -15, 0, 15, 30, 45, 90, 180 };
7842 EgeAdjustmentAction *eact = create_adjustment_action(
7843 "TextRotationAction", /* name */
7844 _("Letter rotation"), /* label */
7845 _("Rot:"), /* short label */
7846 _("Character rotation (degrees)"),/* tooltip */
7847 "/tools/text/rotation", /* preferences path */
7848 0.0, /* default */
7849 GTK_WIDGET(desktop->canvas), /* focusTarget */
7850 NULL, /* unit selector */
7851 holder, /* dataKludge */
7852 FALSE, /* set alt-x keyboard shortcut? */
7853 NULL, /* altx_mark */
7854 -180.0, 180.0, 0.1, 1.0, /* lower, upper, step (arrow up/down), page up/down */
7855 labels, values, G_N_ELEMENTS(labels), /* drop down menu */
7856 sp_text_rotation_value_changed, /* callback */
7857 0.1, /* step (used?) */
7858 2, /* digits to show */
7859 1.0 /* factor (multiplies default) */
7860 );
7861 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
7862 gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
7863 g_object_set_data( holder, "TextRotationAction", eact );
7864 g_object_set( G_OBJECT(eact), "iconId", "text_rotation", NULL );
7865 }
7867 // Is this necessary to call? Shouldn't hurt.
7868 sp_text_toolbox_selection_changed(sp_desktop_selection(desktop), holder);
7870 // Watch selection
7871 Inkscape::ConnectionPool* pool = Inkscape::ConnectionPool::new_connection_pool ("ISTextToolboxGTK");
7873 sigc::connection *c_selection_changed =
7874 new sigc::connection (sp_desktop_selection (desktop)->connectChanged
7875 (sigc::bind (sigc::ptr_fun (sp_text_toolbox_selection_changed), (GObject*)holder)));
7876 pool->add_connection ("selection-changed", c_selection_changed);
7878 sigc::connection *c_selection_modified =
7879 new sigc::connection (sp_desktop_selection (desktop)->connectModified
7880 (sigc::bind (sigc::ptr_fun (sp_text_toolbox_selection_modified), (GObject*)holder)));
7881 pool->add_connection ("selection-modified", c_selection_modified);
7883 sigc::connection *c_subselection_changed =
7884 new sigc::connection (desktop->connectToolSubselectionChanged
7885 (sigc::bind (sigc::ptr_fun (sp_text_toolbox_subselection_changed), (GObject*)holder)));
7886 pool->add_connection ("tool-subselection-changed", c_subselection_changed);
7888 Inkscape::ConnectionPool::connect_destroy (G_OBJECT (holder), pool);
7890 g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder );
7892 }
7895 //#########################
7896 //## Connector ##
7897 //#########################
7899 static void sp_connector_mode_toggled( GtkToggleAction* act, GtkObject * /*tbl*/ )
7900 {
7901 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
7902 prefs->setBool("/tools/connector/mode",
7903 gtk_toggle_action_get_active( act ));
7904 }
7906 static void sp_connector_path_set_avoid(void)
7907 {
7908 cc_selection_set_avoid(true);
7909 }
7912 static void sp_connector_path_set_ignore(void)
7913 {
7914 cc_selection_set_avoid(false);
7915 }
7917 static void sp_connector_orthogonal_toggled( GtkToggleAction* act, GObject *tbl )
7918 {
7919 SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
7920 Inkscape::Selection * selection = sp_desktop_selection(desktop);
7921 SPDocument *doc = sp_desktop_document(desktop);
7923 if (!sp_document_get_undo_sensitive(doc)) {
7924 return;
7925 }
7928 // quit if run by the _changed callbacks
7929 if (g_object_get_data( tbl, "freeze" )) {
7930 return;
7931 }
7933 // in turn, prevent callbacks from responding
7934 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
7936 bool is_orthog = gtk_toggle_action_get_active( act );
7937 gchar orthog_str[] = "orthogonal";
7938 gchar polyline_str[] = "polyline";
7939 gchar *value = is_orthog ? orthog_str : polyline_str ;
7941 bool modmade = false;
7942 GSList *l = (GSList *) selection->itemList();
7943 while (l) {
7944 SPItem *item = (SPItem *) l->data;
7946 if (cc_item_is_connector(item)) {
7947 sp_object_setAttribute(item, "inkscape:connector-type",
7948 value, false);
7949 item->avoidRef->handleSettingChange();
7950 modmade = true;
7951 }
7952 l = l->next;
7953 }
7955 if (!modmade) {
7956 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
7957 prefs->setBool("/tools/connector/orthogonal", is_orthog);
7958 }
7960 sp_document_done(doc, SP_VERB_CONTEXT_CONNECTOR,
7961 is_orthog ? _("Set connector type: orthogonal"): _("Set connector type: polyline"));
7963 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
7964 }
7966 static void connector_curvature_changed(GtkAdjustment *adj, GObject* tbl)
7967 {
7968 SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
7969 Inkscape::Selection * selection = sp_desktop_selection(desktop);
7970 SPDocument *doc = sp_desktop_document(desktop);
7972 if (!sp_document_get_undo_sensitive(doc)) {
7973 return;
7974 }
7977 // quit if run by the _changed callbacks
7978 if (g_object_get_data( tbl, "freeze" )) {
7979 return;
7980 }
7982 // in turn, prevent callbacks from responding
7983 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) );
7985 gdouble newValue = gtk_adjustment_get_value(adj);
7986 gchar value[G_ASCII_DTOSTR_BUF_SIZE];
7987 g_ascii_dtostr(value, G_ASCII_DTOSTR_BUF_SIZE, newValue);
7989 bool modmade = false;
7990 GSList *l = (GSList *) selection->itemList();
7991 while (l) {
7992 SPItem *item = (SPItem *) l->data;
7994 if (cc_item_is_connector(item)) {
7995 sp_object_setAttribute(item, "inkscape:connector-curvature",
7996 value, false);
7997 item->avoidRef->handleSettingChange();
7998 modmade = true;
7999 }
8000 l = l->next;
8001 }
8003 if (!modmade) {
8004 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
8005 prefs->setDouble(Glib::ustring("/tools/connector/curvature"), newValue);
8006 }
8008 sp_document_done(doc, SP_VERB_CONTEXT_CONNECTOR,
8009 _("Change connector curvature"));
8011 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
8012 }
8015 static void connector_spacing_changed(GtkAdjustment *adj, GObject* tbl)
8016 {
8017 SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
8018 SPDocument *doc = sp_desktop_document(desktop);
8020 if (!sp_document_get_undo_sensitive(doc)) {
8021 return;
8022 }
8024 Inkscape::XML::Node *repr = SP_OBJECT_REPR(desktop->namedview);
8026 if ( !repr->attribute("inkscape:connector-spacing") &&
8027 ( adj->value == defaultConnSpacing )) {
8028 // Don't need to update the repr if the attribute doesn't
8029 // exist and it is being set to the default value -- as will
8030 // happen at startup.
8031 return;
8032 }
8034 // quit if run by the attr_changed listener
8035 if (g_object_get_data( tbl, "freeze" )) {
8036 return;
8037 }
8039 // in turn, prevent listener from responding
8040 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE));
8042 sp_repr_set_css_double(repr, "inkscape:connector-spacing", adj->value);
8043 SP_OBJECT(desktop->namedview)->updateRepr();
8045 GSList *items = get_avoided_items(NULL, desktop->currentRoot(), desktop);
8046 for ( GSList const *iter = items ; iter != NULL ; iter = iter->next ) {
8047 SPItem *item = reinterpret_cast<SPItem *>(iter->data);
8048 Geom::Matrix m = Geom::identity();
8049 avoid_item_move(&m, item);
8050 }
8052 if (items) {
8053 g_slist_free(items);
8054 }
8056 sp_document_done(doc, SP_VERB_CONTEXT_CONNECTOR,
8057 _("Change connector spacing"));
8059 g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
8060 }
8062 static void sp_connector_graph_layout(void)
8063 {
8064 if (!SP_ACTIVE_DESKTOP) {
8065 return;
8066 }
8067 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
8069 // hack for clones, see comment in align-and-distribute.cpp
8070 int saved_compensation = prefs->getInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_UNMOVED);
8071 prefs->setInt("/options/clonecompensation/value", SP_CLONE_COMPENSATION_UNMOVED);
8073 graphlayout(sp_desktop_selection(SP_ACTIVE_DESKTOP)->itemList());
8075 prefs->setInt("/options/clonecompensation/value", saved_compensation);
8077 sp_document_done(sp_desktop_document(SP_ACTIVE_DESKTOP), SP_VERB_DIALOG_ALIGN_DISTRIBUTE, _("Arrange connector network"));
8078 }
8080 static void sp_directed_graph_layout_toggled( GtkToggleAction* act, GtkObject * /*tbl*/ )
8081 {
8082 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
8083 prefs->setBool("/tools/connector/directedlayout",
8084 gtk_toggle_action_get_active( act ));
8085 }
8087 static void sp_nooverlaps_graph_layout_toggled( GtkToggleAction* act, GtkObject * /*tbl*/ )
8088 {
8089 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
8090 prefs->setBool("/tools/connector/avoidoverlaplayout",
8091 gtk_toggle_action_get_active( act ));
8092 }
8095 static void connector_length_changed(GtkAdjustment *adj, GObject* /*tbl*/)
8096 {
8097 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
8098 prefs->setDouble("/tools/connector/length", adj->value);
8099 }
8101 static void connector_tb_event_attr_changed(Inkscape::XML::Node *repr,
8102 gchar const *name, gchar const * /*old_value*/, gchar const * /*new_value*/,
8103 bool /*is_interactive*/, gpointer data)
8104 {
8105 GtkWidget *tbl = GTK_WIDGET(data);
8107 if (g_object_get_data(G_OBJECT(tbl), "freeze")) {
8108 return;
8109 }
8110 if (strcmp(name, "inkscape:connector-spacing") == 0)
8111 {
8112 GtkAdjustment *adj = (GtkAdjustment*)
8113 gtk_object_get_data(GTK_OBJECT(tbl), "spacing");
8114 gdouble spacing = defaultConnSpacing;
8115 sp_repr_get_double(repr, "inkscape:connector-spacing", &spacing);
8117 gtk_adjustment_set_value(adj, spacing);
8118 gtk_adjustment_value_changed(adj);
8119 }
8121 spinbutton_defocus(GTK_OBJECT(tbl));
8122 }
8124 static void sp_connector_new_connection_point(GtkWidget *, GObject *tbl)
8125 {
8126 SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
8127 SPConnectorContext* cc = SP_CONNECTOR_CONTEXT(desktop->event_context);
8129 if (cc->mode == SP_CONNECTOR_CONTEXT_EDITING_MODE) {
8130 cc_create_connection_point(cc);
8131 }
8132 }
8134 static void sp_connector_remove_connection_point(GtkWidget *, GObject *tbl)
8135 {
8136 SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" );
8137 SPConnectorContext* cc = SP_CONNECTOR_CONTEXT(desktop->event_context);
8139 if (cc->mode == SP_CONNECTOR_CONTEXT_EDITING_MODE) {
8140 cc_remove_connection_point(cc);
8141 }
8142 }
8144 static Inkscape::XML::NodeEventVector connector_tb_repr_events = {
8145 NULL, /* child_added */
8146 NULL, /* child_removed */
8147 connector_tb_event_attr_changed,
8148 NULL, /* content_changed */
8149 NULL /* order_changed */
8150 };
8152 static void sp_connector_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl)
8153 {
8154 GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "curvature" ) );
8155 GtkToggleAction *act = GTK_TOGGLE_ACTION( g_object_get_data( tbl, "orthogonal" ) );
8156 SPItem *item = selection->singleItem();
8157 if (SP_IS_PATH(item))
8158 {
8159 gdouble curvature = SP_PATH(item)->connEndPair.getCurvature();
8160 bool is_orthog = SP_PATH(item)->connEndPair.isOrthogonal();
8161 gtk_toggle_action_set_active(act, is_orthog);
8162 gtk_adjustment_set_value(adj, curvature);
8163 }
8165 }
8167 static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder )
8168 {
8169 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
8170 Inkscape::IconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1);
8172 // Editing mode toggle button
8173 {
8174 InkToggleAction* act = ink_toggle_action_new( "ConnectorEditModeAction",
8175 _("EditMode"),
8176 _("Switch between connection point editing and connector drawing mode"),
8177 INKSCAPE_ICON_CONNECTOR_EDIT,
8178 Inkscape::ICON_SIZE_DECORATION );
8179 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
8181 bool tbuttonstate = prefs->getBool("/tools/connector/mode");
8182 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act), ( tbuttonstate ? TRUE : FALSE ));
8183 g_object_set_data( holder, "mode", act );
8184 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_connector_mode_toggled), holder );
8185 }
8188 {
8189 InkAction* inky = ink_action_new( "ConnectorAvoidAction",
8190 _("Avoid"),
8191 _("Make connectors avoid selected objects"),
8192 INKSCAPE_ICON_CONNECTOR_AVOID,
8193 secondarySize );
8194 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_path_set_avoid), holder );
8195 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
8196 }
8198 {
8199 InkAction* inky = ink_action_new( "ConnectorIgnoreAction",
8200 _("Ignore"),
8201 _("Make connectors ignore selected objects"),
8202 INKSCAPE_ICON_CONNECTOR_IGNORE,
8203 secondarySize );
8204 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_path_set_ignore), holder );
8205 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
8206 }
8208 // Orthogonal connectors toggle button
8209 {
8210 InkToggleAction* act = ink_toggle_action_new( "ConnectorOrthogonalAction",
8211 _("Orthogonal"),
8212 _("Make connector orthogonal or polyline"),
8213 INKSCAPE_ICON_CONNECTOR_ORTHOGONAL,
8214 Inkscape::ICON_SIZE_DECORATION );
8215 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
8217 bool tbuttonstate = prefs->getBool("/tools/connector/orthogonal");
8218 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act), ( tbuttonstate ? TRUE : FALSE ));
8219 g_object_set_data( holder, "orthogonal", act );
8220 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_connector_orthogonal_toggled), holder );
8221 }
8223 EgeAdjustmentAction* eact = 0;
8224 // Curvature spinbox
8225 eact = create_adjustment_action( "ConnectorCurvatureAction",
8226 _("Connector Curvature"), _("Curvature:"),
8227 _("The amount of connectors curvature"),
8228 "/tools/connector/curvature", defaultConnCurvature,
8229 GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "inkscape:connector-curvature",
8230 0, 100, 1.0, 10.0,
8231 0, 0, 0,
8232 connector_curvature_changed, 1, 0 );
8233 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
8235 // Spacing spinbox
8236 eact = create_adjustment_action( "ConnectorSpacingAction",
8237 _("Connector Spacing"), _("Spacing:"),
8238 _("The amount of space left around objects by auto-routing connectors"),
8239 "/tools/connector/spacing", defaultConnSpacing,
8240 GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "inkscape:connector-spacing",
8241 0, 100, 1.0, 10.0,
8242 0, 0, 0,
8243 connector_spacing_changed, 1, 0 );
8244 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
8246 // Graph (connector network) layout
8247 {
8248 InkAction* inky = ink_action_new( "ConnectorGraphAction",
8249 _("Graph"),
8250 _("Nicely arrange selected connector network"),
8251 INKSCAPE_ICON_DISTRIBUTE_GRAPH,
8252 secondarySize );
8253 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_graph_layout), holder );
8254 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
8255 }
8257 // Default connector length spinbox
8258 eact = create_adjustment_action( "ConnectorLengthAction",
8259 _("Connector Length"), _("Length:"),
8260 _("Ideal length for connectors when layout is applied"),
8261 "/tools/connector/length", 100,
8262 GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "inkscape:connector-length",
8263 10, 1000, 10.0, 100.0,
8264 0, 0, 0,
8265 connector_length_changed, 1, 0 );
8266 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
8269 // Directed edges toggle button
8270 {
8271 InkToggleAction* act = ink_toggle_action_new( "ConnectorDirectedAction",
8272 _("Downwards"),
8273 _("Make connectors with end-markers (arrows) point downwards"),
8274 INKSCAPE_ICON_DISTRIBUTE_GRAPH_DIRECTED,
8275 Inkscape::ICON_SIZE_DECORATION );
8276 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
8278 bool tbuttonstate = prefs->getBool("/tools/connector/directedlayout");
8279 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act), ( tbuttonstate ? TRUE : FALSE ));
8281 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_directed_graph_layout_toggled), holder );
8282 sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_connector_toolbox_selection_changed), (GObject *)holder));
8283 }
8285 // Avoid overlaps toggle button
8286 {
8287 InkToggleAction* act = ink_toggle_action_new( "ConnectorOverlapAction",
8288 _("Remove overlaps"),
8289 _("Do not allow overlapping shapes"),
8290 INKSCAPE_ICON_DISTRIBUTE_REMOVE_OVERLAPS,
8291 Inkscape::ICON_SIZE_DECORATION );
8292 gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
8294 bool tbuttonstate = prefs->getBool("/tools/connector/avoidoverlaplayout");
8295 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act), (tbuttonstate ? TRUE : FALSE ));
8297 g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_nooverlaps_graph_layout_toggled), holder );
8298 }
8301 // New connection point button
8302 {
8303 InkAction* inky = ink_action_new( "ConnectorNewConnPointAction",
8304 _("New connection point"),
8305 _("Add a new connection point to the currently selected item"),
8306 INKSCAPE_ICON_CONNECTOR_NEW_CONNPOINT,
8307 secondarySize );
8308 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_new_connection_point), holder );
8309 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
8310 }
8312 // Remove selected connection point button
8314 {
8315 InkAction* inky = ink_action_new( "ConnectorRemoveConnPointAction",
8316 _("Remove connection point"),
8317 _("Remove the currently selected connection point"),
8318 INKSCAPE_ICON_CONNECTOR_REMOVE_CONNPOINT,
8319 secondarySize );
8320 g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_remove_connection_point), holder );
8321 gtk_action_group_add_action( mainActions, GTK_ACTION(inky) );
8322 }
8325 // Code to watch for changes to the connector-spacing attribute in
8326 // the XML.
8327 Inkscape::XML::Node *repr = SP_OBJECT_REPR(desktop->namedview);
8328 g_assert(repr != NULL);
8330 purge_repr_listener( holder, holder );
8332 if (repr) {
8333 g_object_set_data( holder, "repr", repr );
8334 Inkscape::GC::anchor(repr);
8335 sp_repr_add_listener( repr, &connector_tb_repr_events, holder );
8336 sp_repr_synthesize_events( repr, &connector_tb_repr_events, holder );
8337 }
8338 } // end of sp_connector_toolbox_prep()
8341 //#########################
8342 //## Paintbucket ##
8343 //#########################
8345 static void paintbucket_channels_changed(EgeSelectOneAction* act, GObject* /*tbl*/)
8346 {
8347 gint channels = ege_select_one_action_get_active( act );
8348 flood_channels_set_channels( channels );
8349 }
8351 static void paintbucket_threshold_changed(GtkAdjustment *adj, GObject * /*tbl*/)
8352 {
8353 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
8354 prefs->setInt("/tools/paintbucket/threshold", (gint)adj->value);
8355 }
8357 static void paintbucket_autogap_changed(EgeSelectOneAction* act, GObject * /*tbl*/)
8358 {
8359 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
8360 prefs->setBool("/tools/paintbucket/autogap", ege_select_one_action_get_active( act ));
8361 }
8363 static void paintbucket_offset_changed(GtkAdjustment *adj, GObject *tbl)
8364 {
8365 UnitTracker* tracker = static_cast<UnitTracker*>(g_object_get_data( tbl, "tracker" ));
8366 SPUnit const *unit = tracker->getActiveUnit();
8367 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
8369 prefs->setDouble("/tools/paintbucket/offset", (gdouble)sp_units_get_pixels(adj->value, *unit));
8370 prefs->setString("/tools/paintbucket/offsetunits", sp_unit_get_abbreviation(unit));
8371 }
8373 static void paintbucket_defaults(GtkWidget *, GObject *tbl)
8374 {
8375 // FIXME: make defaults settable via Inkscape Options
8376 struct KeyValue {
8377 char const *key;
8378 double value;
8379 } const key_values[] = {
8380 {"threshold", 15},
8381 {"offset", 0.0}
8382 };
8384 for (unsigned i = 0; i < G_N_ELEMENTS(key_values); ++i) {
8385 KeyValue const &kv = key_values[i];
8386 GtkAdjustment* adj = static_cast<GtkAdjustment *>(g_object_get_data(tbl, kv.key));
8387 if ( adj ) {
8388 gtk_adjustment_set_value(adj, kv.value);
8389 }
8390 }
8392 EgeSelectOneAction* channels_action = EGE_SELECT_ONE_ACTION( g_object_get_data (tbl, "channels_action" ) );
8393 ege_select_one_action_set_active( channels_action, FLOOD_CHANNELS_RGB );
8394 EgeSelectOneAction* autogap_action = EGE_SELECT_ONE_ACTION( g_object_get_data (tbl, "autogap_action" ) );
8395 ege_select_one_action_set_active( autogap_action, 0 );
8396 }
8398 static void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
8399 {
8400 EgeAdjustmentAction* eact = 0;
8401 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
8403 {
8404 GtkListStore* model = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_INT );
8406 GList* items = 0;
8407 gint count = 0;
8408 for ( items = flood_channels_dropdown_items_list(); items ; items = g_list_next(items) )
8409 {
8410 GtkTreeIter iter;
8411 gtk_list_store_append( model, &iter );
8412 gtk_list_store_set( model, &iter, 0, reinterpret_cast<gchar*>(items->data), 1, count, -1 );
8413 count++;
8414 }
8415 g_list_free( items );
8416 items = 0;
8417 EgeSelectOneAction* act1 = ege_select_one_action_new( "ChannelsAction", _("Fill by"), (""), NULL, GTK_TREE_MODEL(model) );
8418 g_object_set( act1, "short_label", _("Fill by:"), NULL );
8419 ege_select_one_action_set_appearance( act1, "compact" );
8420 ege_select_one_action_set_active( act1, prefs->getInt("/tools/paintbucket/channels", 0) );
8421 g_signal_connect( G_OBJECT(act1), "changed", G_CALLBACK(paintbucket_channels_changed), holder );
8422 gtk_action_group_add_action( mainActions, GTK_ACTION(act1) );
8423 g_object_set_data( holder, "channels_action", act1 );
8424 }
8426 // Spacing spinbox
8427 {
8428 eact = create_adjustment_action(
8429 "ThresholdAction",
8430 _("Fill Threshold"), _("Threshold:"),
8431 _("The maximum allowed difference between the clicked pixel and the neighboring pixels to be counted in the fill"),
8432 "/tools/paintbucket/threshold", 5, GTK_WIDGET(desktop->canvas), NULL, holder, TRUE,
8433 "inkscape:paintbucket-threshold", 0, 100.0, 1.0, 10.0,
8434 0, 0, 0,
8435 paintbucket_threshold_changed, 1, 0 );
8437 ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
8438 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
8439 }
8441 // Create the units menu.
8442 UnitTracker* tracker = new UnitTracker( SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE );
8443 Glib::ustring stored_unit = prefs->getString("/tools/paintbucket/offsetunits");
8444 if (!stored_unit.empty()) {
8445 tracker->setActiveUnit(sp_unit_get_by_abbreviation(stored_unit.data()));
8446 }
8447 g_object_set_data( holder, "tracker", tracker );
8448 {
8449 GtkAction* act = tracker->createAction( "PaintbucketUnitsAction", _("Units"), ("") );
8450 gtk_action_group_add_action( mainActions, act );
8451 }
8453 // Offset spinbox
8454 {
8455 eact = create_adjustment_action(
8456 "OffsetAction",
8457 _("Grow/shrink by"), _("Grow/shrink by:"),
8458 _("The amount to grow (positive) or shrink (negative) the created fill path"),
8459 "/tools/paintbucket/offset", 0, GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, TRUE,
8460 "inkscape:paintbucket-offset", -1e6, 1e6, 0.1, 0.5,
8461 0, 0, 0,
8462 paintbucket_offset_changed, 1, 2);
8463 tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );
8465 gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
8466 }
8468 /* Auto Gap */
8469 {
8470 GtkListStore* model = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_INT );
8472 GList* items = 0;
8473 gint count = 0;
8474 for ( items = flood_autogap_dropdown_items_list(); items ; items = g_list_next(items) )
8475 {
8476 GtkTreeIter iter;
8477 gtk_list_store_append( model, &iter );
8478 gtk_list_store_set( model, &iter, 0, reinterpret_cast<gchar*>(items->data), 1, count, -1 );
8479 count++;
8480 }
8481 g_list_free( items );
8482 items = 0;
8483 EgeSelectOneAction* act2 = ege_select_one_action_new( "AutoGapAction", _("Close gaps"), (""), NULL, GTK_TREE_MODEL(model) );
8484 g_object_set( act2, "short_label", _("Close gaps:"), NULL );
8485 ege_select_one_action_set_appearance( act2, "compact" );
8486 ege_select_one_action_set_active( act2, prefs->getBool("/tools/paintbucket/autogap") );
8487 g_signal_connect( G_OBJECT(act2), "changed", G_CALLBACK(paintbucket_autogap_changed), holder );
8488 gtk_action_group_add_action( mainActions, GTK_ACTION(act2) );
8489 g_object_set_data( holder, "autogap_action", act2 );
8490 }
8492 /* Reset */
8493 {
8494 GtkAction* act = gtk_action_new( "PaintbucketResetAction",
8495 _("Defaults"),
8496 _("Reset paint bucket parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
8497 GTK_STOCK_CLEAR );
8498 g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(paintbucket_defaults), holder );
8499 gtk_action_group_add_action( mainActions, act );
8500 gtk_action_set_sensitive( act, TRUE );
8501 }
8503 }
8505 /*
8506 Local Variables:
8507 mode:c++
8508 c-file-style:"stroustrup"
8509 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
8510 indent-tabs-mode:nil
8511 fill-column:99
8512 End:
8513 */
8514 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :