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