1 #define __SP_NAMEDVIEW_C__
3 /*
4 * <sodipodi:namedview> implementation
5 *
6 * Authors:
7 * Lauris Kaplinski <lauris@kaplinski.com>
8 * bulia byak <buliabyak@users.sf.net>
9 *
10 * Copyright (C) 2006 Johan Engelen <johan@shouraizou.nl>
11 * Copyright (C) 1999-2008 Authors
12 * Copyright (C) 2000-2001 Ximian, Inc.
13 *
14 * Released under GNU GPL, read the file 'COPYING' for more information
15 */
17 #include "config.h"
18 #include <cstring>
19 #include <string>
21 #include "display/canvas-grid.h"
22 #include "helper/units.h"
23 #include "svg/svg-color.h"
24 #include "xml/repr.h"
25 #include "attributes.h"
26 #include "document.h"
27 #include "desktop-events.h"
28 #include "desktop-handles.h"
29 #include "event-log.h"
30 #include "sp-guide.h"
31 #include "sp-item-group.h"
32 #include "sp-namedview.h"
33 #include "preferences.h"
34 #include "desktop.h"
35 #include "conn-avoid-ref.h" // for defaultConnSpacing.
37 #define DEFAULTGRIDCOLOR 0x3f3fff25
38 #define DEFAULTGRIDEMPCOLOR 0x3f3fff60
39 #define DEFAULTGRIDEMPSPACING 5
40 #define DEFAULTGUIDECOLOR 0x0000ff7f
41 #define DEFAULTGUIDEHICOLOR 0xff00007f
42 #define DEFAULTBORDERCOLOR 0x000000ff
43 #define DEFAULTPAGECOLOR 0xffffff00
45 static void sp_namedview_class_init(SPNamedViewClass *klass);
46 static void sp_namedview_init(SPNamedView *namedview);
48 static void sp_namedview_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
49 static void sp_namedview_release(SPObject *object);
50 static void sp_namedview_set(SPObject *object, unsigned int key, const gchar *value);
51 static void sp_namedview_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref);
52 static void sp_namedview_remove_child(SPObject *object, Inkscape::XML::Node *child);
53 static Inkscape::XML::Node *sp_namedview_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags);
55 static void sp_namedview_setup_guides(SPNamedView * nv);
57 static gboolean sp_str_to_bool(const gchar *str);
58 static gboolean sp_nv_read_opacity(const gchar *str, guint32 *color);
60 static SPObjectGroupClass * parent_class;
62 GType
63 sp_namedview_get_type()
64 {
65 static GType namedview_type = 0;
66 if (!namedview_type) {
67 GTypeInfo namedview_info = {
68 sizeof(SPNamedViewClass),
69 NULL, /* base_init */
70 NULL, /* base_finalize */
71 (GClassInitFunc) sp_namedview_class_init,
72 NULL, /* class_finalize */
73 NULL, /* class_data */
74 sizeof(SPNamedView),
75 16, /* n_preallocs */
76 (GInstanceInitFunc) sp_namedview_init,
77 NULL, /* value_table */
78 };
79 namedview_type = g_type_register_static(SP_TYPE_OBJECTGROUP, "SPNamedView", &namedview_info, (GTypeFlags)0);
80 }
81 return namedview_type;
82 }
84 static void sp_namedview_class_init(SPNamedViewClass * klass)
85 {
86 GObjectClass * gobject_class;
87 SPObjectClass * sp_object_class;
89 gobject_class = (GObjectClass *) klass;
90 sp_object_class = (SPObjectClass *) klass;
92 parent_class = (SPObjectGroupClass*) g_type_class_ref(SP_TYPE_OBJECTGROUP);
94 sp_object_class->build = sp_namedview_build;
95 sp_object_class->release = sp_namedview_release;
96 sp_object_class->set = sp_namedview_set;
97 sp_object_class->child_added = sp_namedview_child_added;
98 sp_object_class->remove_child = sp_namedview_remove_child;
99 sp_object_class->write = sp_namedview_write;
100 }
102 static void sp_namedview_init(SPNamedView *nv)
103 {
104 nv->editable = TRUE;
105 nv->showguides = TRUE;
106 nv->grids_visible = false;
107 nv->showborder = TRUE;
108 nv->showpageshadow = TRUE;
110 nv->guides = NULL;
111 nv->viewcount = 0;
112 nv->grids = NULL;
114 nv->default_layer_id = 0;
116 nv->connector_spacing = defaultConnSpacing;
118 new (&nv->snap_manager) SnapManager(nv);
119 }
121 static void sp_namedview_generate_old_grid(SPNamedView * /*nv*/, SPDocument *document, Inkscape::XML::Node *repr) {
122 bool old_grid_settings_present = false;
124 // set old settings
125 const char* gridspacingx = "1px";
126 const char* gridspacingy = "1px";
127 const char* gridoriginy = "0px";
128 const char* gridoriginx = "0px";
129 const char* gridempspacing = "5";
130 const char* gridcolor = "#0000ff";
131 const char* gridempcolor = "#0000ff";
132 const char* gridopacity = "0.2";
133 const char* gridempopacity = "0.4";
135 const char* value = NULL;
136 if ((value = repr->attribute("gridoriginx"))) {
137 gridspacingx = value;
138 old_grid_settings_present = true;
139 }
140 if ((value = repr->attribute("gridoriginy"))) {
141 gridoriginy = value;
142 old_grid_settings_present = true;
143 }
144 if ((value = repr->attribute("gridspacingx"))) {
145 gridspacingx = value;
146 old_grid_settings_present = true;
147 }
148 if ((value = repr->attribute("gridspacingy"))) {
149 gridspacingy = value;
150 old_grid_settings_present = true;
151 }
152 if ((value = repr->attribute("gridcolor"))) {
153 gridcolor = value;
154 old_grid_settings_present = true;
155 }
156 if ((value = repr->attribute("gridempcolor"))) {
157 gridempcolor = value;
158 old_grid_settings_present = true;
159 }
160 if ((value = repr->attribute("gridempspacing"))) {
161 gridempspacing = value;
162 old_grid_settings_present = true;
163 }
164 if ((value = repr->attribute("gridopacity"))) {
165 gridopacity = value;
166 old_grid_settings_present = true;
167 }
168 if ((value = repr->attribute("gridempopacity"))) {
169 gridempopacity = value;
170 old_grid_settings_present = true;
171 }
173 if (old_grid_settings_present) {
174 // generate new xy grid with the correct settings
175 // first create the child xml node, then hook it to repr. This order is important, to not set off listeners to repr before the new node is complete.
177 Inkscape::XML::Document *xml_doc = sp_document_repr_doc(document);
178 Inkscape::XML::Node *newnode = xml_doc->createElement("inkscape:grid");
179 newnode->setAttribute("id", "GridFromPre046Settings");
180 newnode->setAttribute("type", Inkscape::CanvasGrid::getSVGName(Inkscape::GRID_RECTANGULAR));
181 newnode->setAttribute("originx", gridoriginx);
182 newnode->setAttribute("originy", gridoriginy);
183 newnode->setAttribute("spacingx", gridspacingx);
184 newnode->setAttribute("spacingy", gridspacingy);
185 newnode->setAttribute("color", gridcolor);
186 newnode->setAttribute("empcolor", gridempcolor);
187 newnode->setAttribute("opacity", gridopacity);
188 newnode->setAttribute("empopacity", gridempopacity);
189 newnode->setAttribute("empspacing", gridempspacing);
191 repr->appendChild(newnode);
192 Inkscape::GC::release(newnode);
194 // remove all old settings
195 repr->setAttribute("gridoriginx", NULL);
196 repr->setAttribute("gridoriginy", NULL);
197 repr->setAttribute("gridspacingx", NULL);
198 repr->setAttribute("gridspacingy", NULL);
199 repr->setAttribute("gridcolor", NULL);
200 repr->setAttribute("gridempcolor", NULL);
201 repr->setAttribute("gridopacity", NULL);
202 repr->setAttribute("gridempopacity", NULL);
203 repr->setAttribute("gridempspacing", NULL);
205 // sp_document_done(doc, SP_VERB_DIALOG_NAMEDVIEW, _("Create new grid from pre0.46 grid settings"));
206 }
207 }
209 static void sp_namedview_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
210 {
211 SPNamedView *nv = (SPNamedView *) object;
212 SPObjectGroup *og = (SPObjectGroup *) object;
214 if (((SPObjectClass *) (parent_class))->build) {
215 (* ((SPObjectClass *) (parent_class))->build)(object, document, repr);
216 }
218 sp_object_read_attr(object, "inkscape:document-units");
219 sp_object_read_attr(object, "viewonly");
220 sp_object_read_attr(object, "showguides");
221 sp_object_read_attr(object, "showgrid");
222 sp_object_read_attr(object, "gridtolerance");
223 sp_object_read_attr(object, "guidetolerance");
224 sp_object_read_attr(object, "objecttolerance");
225 sp_object_read_attr(object, "guidecolor");
226 sp_object_read_attr(object, "guideopacity");
227 sp_object_read_attr(object, "guidehicolor");
228 sp_object_read_attr(object, "guidehiopacity");
229 sp_object_read_attr(object, "showborder");
230 sp_object_read_attr(object, "inkscape:showpageshadow");
231 sp_object_read_attr(object, "borderlayer");
232 sp_object_read_attr(object, "bordercolor");
233 sp_object_read_attr(object, "borderopacity");
234 sp_object_read_attr(object, "pagecolor");
235 sp_object_read_attr(object, "inkscape:pageopacity");
236 sp_object_read_attr(object, "inkscape:pageshadow");
237 sp_object_read_attr(object, "inkscape:zoom");
238 sp_object_read_attr(object, "inkscape:cx");
239 sp_object_read_attr(object, "inkscape:cy");
240 sp_object_read_attr(object, "inkscape:window-width");
241 sp_object_read_attr(object, "inkscape:window-height");
242 sp_object_read_attr(object, "inkscape:window-x");
243 sp_object_read_attr(object, "inkscape:window-y");
244 sp_object_read_attr(object, "inkscape:snap-global");
245 sp_object_read_attr(object, "inkscape:snap-bbox");
246 sp_object_read_attr(object, "inkscape:snap-nodes");
247 sp_object_read_attr(object, "inkscape:snap-from-guide");
248 sp_object_read_attr(object, "inkscape:snap-center");
249 sp_object_read_attr(object, "inkscape:snap-smooth-nodes");
250 sp_object_read_attr(object, "inkscape:snap-midpoints");
251 sp_object_read_attr(object, "inkscape:snap-object-midpoints");
252 sp_object_read_attr(object, "inkscape:snap-bbox-edge-midpoints");
253 sp_object_read_attr(object, "inkscape:snap-bbox-midpoints");
254 sp_object_read_attr(object, "inkscape:snap-to-guides");
255 sp_object_read_attr(object, "inkscape:snap-grids");
256 sp_object_read_attr(object, "inkscape:snap-intersection-paths");
257 sp_object_read_attr(object, "inkscape:object-paths");
258 sp_object_read_attr(object, "inkscape:object-nodes");
259 sp_object_read_attr(object, "inkscape:bbox-paths");
260 sp_object_read_attr(object, "inkscape:bbox-nodes");
261 sp_object_read_attr(object, "inkscape:snap-page");
262 sp_object_read_attr(object, "inkscape:current-layer");
263 sp_object_read_attr(object, "inkscape:connector-spacing");
265 /* Construct guideline list */
266 for (SPObject *o = sp_object_first_child(SP_OBJECT(og)) ; o != NULL; o = SP_OBJECT_NEXT(o) ) {
267 if (SP_IS_GUIDE(o)) {
268 SPGuide * g = SP_GUIDE(o);
269 nv->guides = g_slist_prepend(nv->guides, g);
270 g_object_set(G_OBJECT(g), "color", nv->guidecolor, "hicolor", nv->guidehicolor, NULL);
271 }
272 }
274 // backwards compatibility with grid settings (pre 0.46)
275 sp_namedview_generate_old_grid(nv, document, repr);
276 }
278 static void sp_namedview_release(SPObject *object)
279 {
280 SPNamedView *namedview = (SPNamedView *) object;
282 if (namedview->guides) {
283 g_slist_free(namedview->guides);
284 namedview->guides = NULL;
285 }
287 // delete grids:
288 while ( namedview->grids ) {
289 Inkscape::CanvasGrid *gr = (Inkscape::CanvasGrid *)namedview->grids->data; // get first entry
290 delete gr;
291 namedview->grids = g_slist_remove_link(namedview->grids, namedview->grids); // deletes first entry
292 }
294 if (((SPObjectClass *) parent_class)->release) {
295 ((SPObjectClass *) parent_class)->release(object);
296 }
298 namedview->snap_manager.~SnapManager();
299 }
301 static void sp_namedview_set(SPObject *object, unsigned int key, const gchar *value)
302 {
303 SPNamedView *nv = SP_NAMEDVIEW(object);
304 SPUnit const &px = sp_unit_get_by_id(SP_UNIT_PX);
306 switch (key) {
307 case SP_ATTR_VIEWONLY:
308 nv->editable = (!value);
309 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
310 break;
311 case SP_ATTR_SHOWGUIDES:
312 if (!value) { // show guides if not specified, for backwards compatibility
313 nv->showguides = TRUE;
314 } else {
315 nv->showguides = sp_str_to_bool(value);
316 }
317 sp_namedview_setup_guides(nv);
318 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
319 break;
320 case SP_ATTR_SHOWGRIDS:
321 if (!value) { // don't show grids if not specified, for backwards compatibility
322 nv->grids_visible = false;
323 } else {
324 nv->grids_visible = sp_str_to_bool(value);
325 }
326 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
327 break;
328 case SP_ATTR_GRIDTOLERANCE:
329 nv->snap_manager.snapprefs.setGridTolerance(value ? g_ascii_strtod(value, NULL) : 10000);
330 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
331 break;
332 case SP_ATTR_GUIDETOLERANCE:
333 nv->snap_manager.snapprefs.setGuideTolerance(value ? g_ascii_strtod(value, NULL) : 20);
334 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
335 break;
336 case SP_ATTR_OBJECTTOLERANCE:
337 nv->snap_manager.snapprefs.setObjectTolerance(value ? g_ascii_strtod(value, NULL) : 20);
338 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
339 break;
340 case SP_ATTR_GUIDECOLOR:
341 nv->guidecolor = (nv->guidecolor & 0xff) | (DEFAULTGUIDECOLOR & 0xffffff00);
342 if (value) {
343 nv->guidecolor = (nv->guidecolor & 0xff) | sp_svg_read_color(value, nv->guidecolor);
344 }
345 for (GSList *l = nv->guides; l != NULL; l = l->next) {
346 g_object_set(G_OBJECT(l->data), "color", nv->guidecolor, NULL);
347 }
348 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
349 break;
350 case SP_ATTR_GUIDEOPACITY:
351 nv->guidecolor = (nv->guidecolor & 0xffffff00) | (DEFAULTGUIDECOLOR & 0xff);
352 sp_nv_read_opacity(value, &nv->guidecolor);
353 for (GSList *l = nv->guides; l != NULL; l = l->next) {
354 g_object_set(G_OBJECT(l->data), "color", nv->guidecolor, NULL);
355 }
356 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
357 break;
358 case SP_ATTR_GUIDEHICOLOR:
359 nv->guidehicolor = (nv->guidehicolor & 0xff) | (DEFAULTGUIDEHICOLOR & 0xffffff00);
360 if (value) {
361 nv->guidehicolor = (nv->guidehicolor & 0xff) | sp_svg_read_color(value, nv->guidehicolor);
362 }
363 for (GSList *l = nv->guides; l != NULL; l = l->next) {
364 g_object_set(G_OBJECT(l->data), "hicolor", nv->guidehicolor, NULL);
365 }
366 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
367 break;
368 case SP_ATTR_GUIDEHIOPACITY:
369 nv->guidehicolor = (nv->guidehicolor & 0xffffff00) | (DEFAULTGUIDEHICOLOR & 0xff);
370 sp_nv_read_opacity(value, &nv->guidehicolor);
371 for (GSList *l = nv->guides; l != NULL; l = l->next) {
372 g_object_set(G_OBJECT(l->data), "hicolor", nv->guidehicolor, NULL);
373 }
374 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
375 break;
376 case SP_ATTR_SHOWBORDER:
377 nv->showborder = (value) ? sp_str_to_bool (value) : TRUE;
378 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
379 break;
380 case SP_ATTR_BORDERLAYER:
381 nv->borderlayer = SP_BORDER_LAYER_BOTTOM;
382 if (value && !strcasecmp(value, "true")) nv->borderlayer = SP_BORDER_LAYER_TOP;
383 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
384 break;
385 case SP_ATTR_BORDERCOLOR:
386 nv->bordercolor = (nv->bordercolor & 0xff) | (DEFAULTBORDERCOLOR & 0xffffff00);
387 if (value) {
388 nv->bordercolor = (nv->bordercolor & 0xff) | sp_svg_read_color (value, nv->bordercolor);
389 }
390 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
391 break;
392 case SP_ATTR_BORDEROPACITY:
393 nv->bordercolor = (nv->bordercolor & 0xffffff00) | (DEFAULTBORDERCOLOR & 0xff);
394 sp_nv_read_opacity(value, &nv->bordercolor);
395 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
396 break;
397 case SP_ATTR_PAGECOLOR:
398 nv->pagecolor = (nv->pagecolor & 0xff) | (DEFAULTPAGECOLOR & 0xffffff00);
399 if (value) {
400 nv->pagecolor = (nv->pagecolor & 0xff) | sp_svg_read_color(value, nv->pagecolor);
401 }
402 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
403 break;
404 case SP_ATTR_INKSCAPE_PAGEOPACITY:
405 nv->pagecolor = (nv->pagecolor & 0xffffff00) | (DEFAULTPAGECOLOR & 0xff);
406 sp_nv_read_opacity(value, &nv->pagecolor);
407 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
408 break;
409 case SP_ATTR_INKSCAPE_PAGESHADOW:
410 nv->pageshadow = value? atoi(value) : 2; // 2 is the default
411 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
412 break;
413 case SP_ATTR_SHOWPAGESHADOW:
414 nv->showpageshadow = (value) ? sp_str_to_bool(value) : TRUE;
415 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
416 break;
417 case SP_ATTR_INKSCAPE_ZOOM:
418 nv->zoom = value ? g_ascii_strtod(value, NULL) : 0; // zero means not set
419 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
420 break;
421 case SP_ATTR_INKSCAPE_CX:
422 nv->cx = value ? g_ascii_strtod(value, NULL) : HUGE_VAL; // HUGE_VAL means not set
423 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
424 break;
425 case SP_ATTR_INKSCAPE_CY:
426 nv->cy = value ? g_ascii_strtod(value, NULL) : HUGE_VAL; // HUGE_VAL means not set
427 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
428 break;
429 case SP_ATTR_INKSCAPE_WINDOW_WIDTH:
430 nv->window_width = value? atoi(value) : -1; // -1 means not set
431 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
432 break;
433 case SP_ATTR_INKSCAPE_WINDOW_HEIGHT:
434 nv->window_height = value ? atoi(value) : -1; // -1 means not set
435 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
436 break;
437 case SP_ATTR_INKSCAPE_WINDOW_X:
438 nv->window_x = value ? atoi(value) : -1; // -1 means not set
439 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
440 break;
441 case SP_ATTR_INKSCAPE_WINDOW_Y:
442 nv->window_y = value ? atoi(value) : -1; // -1 means not set
443 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
444 break;
445 case SP_ATTR_INKSCAPE_SNAP_GLOBAL:
446 nv->snap_manager.snapprefs.setSnapEnabledGlobally(value ? sp_str_to_bool(value) : TRUE);
447 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
448 break;
449 case SP_ATTR_INKSCAPE_SNAP_BBOX:
450 nv->snap_manager.snapprefs.setSnapModeBBox(value ? sp_str_to_bool(value) : FALSE);
451 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
452 break;
453 case SP_ATTR_INKSCAPE_SNAP_NODES:
454 nv->snap_manager.snapprefs.setSnapModeNode(value ? sp_str_to_bool(value) : TRUE);
455 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
456 break;
457 case SP_ATTR_INKSCAPE_SNAP_CENTER:
458 nv->snap_manager.snapprefs.setIncludeItemCenter(value ? sp_str_to_bool(value) : FALSE);
459 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
460 break;
461 case SP_ATTR_INKSCAPE_SNAP_GRIDS:
462 nv->snap_manager.snapprefs.setSnapToGrids(value ? sp_str_to_bool(value) : TRUE);
463 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
464 break;
465 case SP_ATTR_INKSCAPE_SNAP_TO_GUIDES:
466 nv->snap_manager.snapprefs.setSnapToGuides(value ? sp_str_to_bool(value) : TRUE);
467 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
468 break;
469 case SP_ATTR_INKSCAPE_SNAP_SMOOTH_NODES:
470 nv->snap_manager.snapprefs.setSnapSmoothNodes(value ? sp_str_to_bool(value) : FALSE);
471 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
472 break;
473 case SP_ATTR_INKSCAPE_SNAP_LINE_MIDPOINTS:
474 nv->snap_manager.snapprefs.setSnapLineMidpoints(value ? sp_str_to_bool(value) : FALSE);
475 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
476 break;
477 case SP_ATTR_INKSCAPE_SNAP_OBJECT_MIDPOINTS:
478 nv->snap_manager.snapprefs.setSnapObjectMidpoints(value ? sp_str_to_bool(value) : FALSE);
479 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
480 break;
481 case SP_ATTR_INKSCAPE_SNAP_BBOX_EDGE_MIDPOINTS:
482 nv->snap_manager.snapprefs.setSnapBBoxEdgeMidpoints(value ? sp_str_to_bool(value) : FALSE);
483 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
484 break;
485 case SP_ATTR_INKSCAPE_SNAP_BBOX_MIDPOINTS:
486 nv->snap_manager.snapprefs.setSnapBBoxMidpoints(value ? sp_str_to_bool(value) : FALSE);
487 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
488 break;
489 case SP_ATTR_INKSCAPE_SNAP_FROM_GUIDE:
490 nv->snap_manager.snapprefs.setSnapModeGuide(value ? sp_str_to_bool(value) : TRUE);
491 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
492 break;
493 case SP_ATTR_INKSCAPE_SNAP_INTERS_PATHS:
494 nv->snap_manager.snapprefs.setSnapIntersectionCS(value ? sp_str_to_bool(value) : FALSE);
495 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
496 break;
497 case SP_ATTR_INKSCAPE_OBJECT_PATHS:
498 nv->snap_manager.snapprefs.setSnapToItemPath(value ? sp_str_to_bool(value) : FALSE);
499 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
500 break;
501 case SP_ATTR_INKSCAPE_OBJECT_NODES:
502 nv->snap_manager.snapprefs.setSnapToItemNode(value ? sp_str_to_bool(value) : FALSE);
503 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
504 break;
505 case SP_ATTR_INKSCAPE_BBOX_PATHS:
506 nv->snap_manager.snapprefs.setSnapToBBoxPath(value ? sp_str_to_bool(value) : FALSE);
507 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
508 break;
509 case SP_ATTR_INKSCAPE_BBOX_NODES:
510 nv->snap_manager.snapprefs.setSnapToBBoxNode(value ? sp_str_to_bool(value) : FALSE);
511 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
512 break;
513 case SP_ATTR_INKSCAPE_SNAP_PAGE:
514 nv->snap_manager.snapprefs.setSnapToPageBorder(value ? sp_str_to_bool(value) : FALSE);
515 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
516 break;
517 case SP_ATTR_INKSCAPE_CURRENT_LAYER:
518 nv->default_layer_id = value ? g_quark_from_string(value) : 0;
519 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
520 break;
521 case SP_ATTR_INKSCAPE_CONNECTOR_SPACING:
522 nv->connector_spacing = value ? g_ascii_strtod(value, NULL) :
523 defaultConnSpacing;
524 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
525 break;
526 case SP_ATTR_INKSCAPE_DOCUMENT_UNITS: {
527 /* The default unit if the document doesn't override this: e.g. for files saved as
528 * `plain SVG', or non-inkscape files, or files created by an inkscape 0.40 &
529 * earlier.
530 *
531 * Here we choose `px': useful for screen-destined SVGs, and fewer bug reports
532 * about "not the same numbers as what's in the SVG file" (at least for documents
533 * without a viewBox attribute on the root <svg> element). Similarly, it's also
534 * the most reliable unit (i.e. least likely to be wrong in different viewing
535 * conditions) for viewBox-less SVG files given that it's the unit that inkscape
536 * uses for all coordinates.
537 *
538 * For documents that do have a viewBox attribute on the root <svg> element, it
539 * might be better if we used either viewBox coordinates or if we used the unit of
540 * say the width attribute of the root <svg> element. However, these pose problems
541 * in that they aren't in general absolute units as currently required by
542 * doc_units.
543 */
544 SPUnit const *new_unit = &sp_unit_get_by_id(SP_UNIT_PX);
546 if (value) {
547 SPUnit const *const req_unit = sp_unit_get_by_abbreviation(value);
548 if ( req_unit == NULL ) {
549 g_warning("Unrecognized unit `%s'", value);
550 /* fixme: Document errors should be reported in the status bar or
551 * the like (e.g. as per
552 * http://www.w3.org/TR/SVG11/implnote.html#ErrorProcessing); g_log
553 * should be only for programmer errors. */
554 } else if ( req_unit->base == SP_UNIT_ABSOLUTE ||
555 req_unit->base == SP_UNIT_DEVICE ) {
556 new_unit = req_unit;
557 } else {
558 g_warning("Document units must be absolute like `mm', `pt' or `px', but found `%s'",
559 value);
560 /* fixme: Don't use g_log (see above). */
561 }
562 }
563 nv->doc_units = new_unit;
564 object->requestModified(SP_OBJECT_MODIFIED_FLAG);
565 break;
566 }
567 default:
568 if (((SPObjectClass *) (parent_class))->set) {
569 ((SPObjectClass *) (parent_class))->set(object, key, value);
570 }
571 break;
572 }
573 }
575 /**
576 * add a grid item from SVG-repr. Check if this namedview already has a gridobject for this one! If desktop=null, add grid-canvasitem to all desktops of this namedview,
577 * otherwise only add it to the specified desktop.
578 */
579 static Inkscape::CanvasGrid*
580 sp_namedview_add_grid(SPNamedView *nv, Inkscape::XML::Node *repr, SPDesktop *desktop) {
581 Inkscape::CanvasGrid* grid = NULL;
582 //check if namedview already has an object for this grid
583 for (GSList *l = nv->grids; l != NULL; l = l->next) {
584 Inkscape::CanvasGrid* g = (Inkscape::CanvasGrid*) l->data;
585 if (repr == g->repr) {
586 grid = g;
587 break;
588 }
589 }
591 if (!grid) {
592 //create grid object
593 Inkscape::GridType gridtype = Inkscape::CanvasGrid::getGridTypeFromSVGName(repr->attribute("type"));
594 if (!nv->document) {
595 g_warning("sp_namedview_add_grid - how come doc is null here?!");
596 return NULL;
597 }
598 grid = Inkscape::CanvasGrid::NewGrid(nv, repr, nv->document, gridtype);
599 nv->grids = g_slist_append(nv->grids, grid);
600 }
602 if (!desktop) {
603 //add canvasitem to all desktops
604 for (GSList *l = nv->views; l != NULL; l = l->next) {
605 SPDesktop *dt = static_cast<SPDesktop*>(l->data);
606 grid->createCanvasItem(dt);
607 }
608 } else {
609 //add canvasitem only for specified desktop
610 grid->createCanvasItem(desktop);
611 }
613 return grid;
614 }
616 static void sp_namedview_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
617 {
618 SPNamedView *nv = (SPNamedView *) object;
620 if (((SPObjectClass *) (parent_class))->child_added) {
621 (* ((SPObjectClass *) (parent_class))->child_added)(object, child, ref);
622 }
624 if (!strcmp(child->name(), "inkscape:grid")) {
625 sp_namedview_add_grid(nv, child, NULL);
626 } else {
627 SPObject *no = object->document->getObjectByRepr(child);
628 if ( !SP_IS_OBJECT(no) )
629 return;
631 if (SP_IS_GUIDE(no)) {
632 SPGuide *g = (SPGuide *) no;
633 nv->guides = g_slist_prepend(nv->guides, g);
634 g_object_set(G_OBJECT(g), "color", nv->guidecolor, "hicolor", nv->guidehicolor, NULL);
635 if (nv->editable) {
636 for (GSList *l = nv->views; l != NULL; l = l->next) {
637 sp_guide_show(g, static_cast<SPDesktop*>(l->data)->guides, (GCallback) sp_dt_guide_event);
638 if (static_cast<SPDesktop*>(l->data)->guides_active)
639 sp_guide_sensitize(g,
640 sp_desktop_canvas(static_cast<SPDesktop*> (l->data)),
641 TRUE);
642 if (nv->showguides) {
643 for (GSList *v = SP_GUIDE(g)->views; v != NULL; v = v->next) {
644 sp_canvas_item_show(SP_CANVAS_ITEM(v->data));
645 }
646 } else {
647 for (GSList *v = SP_GUIDE(g)->views; v != NULL; v = v->next) {
648 sp_canvas_item_hide(SP_CANVAS_ITEM(v->data));
649 }
650 }
651 }
652 }
653 }
654 }
655 }
657 static void sp_namedview_remove_child(SPObject *object, Inkscape::XML::Node *child)
658 {
659 SPNamedView *nv = (SPNamedView *) object;
661 if (!strcmp(child->name(), "inkscape:grid")) {
662 for ( GSList *iter = nv->grids ; iter ; iter = iter->next ) {
663 Inkscape::CanvasGrid *gr = (Inkscape::CanvasGrid *)iter->data;
664 if ( gr->repr == child ) {
665 delete gr;
666 nv->grids = g_slist_remove_link(nv->grids, iter);
667 break;
668 }
669 }
670 } else {
671 GSList **ref = &nv->guides;
672 for ( GSList *iter = nv->guides ; iter ; iter = iter->next ) {
673 if ( SP_OBJECT_REPR((SPObject *)iter->data) == child ) {
674 *ref = iter->next;
675 iter->next = NULL;
676 g_slist_free_1(iter);
677 break;
678 }
679 ref = &iter->next;
680 }
681 }
683 if (((SPObjectClass *) (parent_class))->remove_child) {
684 (* ((SPObjectClass *) (parent_class))->remove_child)(object, child);
685 }
686 }
688 static Inkscape::XML::Node *sp_namedview_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags)
689 {
690 if ( ( flags & SP_OBJECT_WRITE_EXT ) &&
691 repr != SP_OBJECT_REPR(object) )
692 {
693 if (repr) {
694 repr->mergeFrom(SP_OBJECT_REPR(object), "id");
695 } else {
696 repr = SP_OBJECT_REPR(object)->duplicate(doc);
697 }
698 }
700 return repr;
701 }
703 void SPNamedView::show(SPDesktop *desktop)
704 {
705 for (GSList *l = guides; l != NULL; l = l->next) {
706 sp_guide_show(SP_GUIDE(l->data), desktop->guides, (GCallback) sp_dt_guide_event);
707 if (desktop->guides_active) {
708 sp_guide_sensitize(SP_GUIDE(l->data), sp_desktop_canvas(desktop), TRUE);
709 }
710 if (showguides) {
711 for (GSList *v = SP_GUIDE(l->data)->views; v != NULL; v = v->next) {
712 sp_canvas_item_show(SP_CANVAS_ITEM(v->data));
713 }
714 } else {
715 for (GSList *v = SP_GUIDE(l->data)->views; v != NULL; v = v->next) {
716 sp_canvas_item_hide(SP_CANVAS_ITEM(v->data));
717 }
718 }
719 }
721 views = g_slist_prepend(views, desktop);
723 // generate grids specified in SVG:
724 Inkscape::XML::Node *repr = SP_OBJECT_REPR(this);
725 if (repr) {
726 for (Inkscape::XML::Node * child = repr->firstChild() ; child != NULL; child = child->next() ) {
727 if (!strcmp(child->name(), "inkscape:grid")) {
728 sp_namedview_add_grid(this, child, desktop);
729 }
730 }
731 }
733 desktop->showGrids(grids_visible, false);
734 }
736 #define MIN_ONSCREEN_DISTANCE 50
738 /*
739 * Restores window geometry from the document settings or defaults in prefs
740 */
741 void sp_namedview_window_from_document(SPDesktop *desktop)
742 {
743 SPNamedView *nv = desktop->namedview;
744 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
745 bool geometry_from_file = prefs->getBool("/options/savewindowgeometry/value");
747 // restore window size and position stored with the document
748 if (geometry_from_file) {
749 gint w = MIN(gdk_screen_width(), nv->window_width);
750 gint h = MIN(gdk_screen_height(), nv->window_height);
751 gint x = MIN(gdk_screen_width() - MIN_ONSCREEN_DISTANCE, nv->window_x);
752 gint y = MIN(gdk_screen_height() - MIN_ONSCREEN_DISTANCE, nv->window_y);
753 if (w>0 && h>0 && x>0 && y>0) {
754 x = MIN(gdk_screen_width() - w, x);
755 y = MIN(gdk_screen_height() - h, y);
756 }
757 if (w>0 && h>0) {
758 desktop->setWindowSize(w, h);
759 }
760 if (x>0 && y>0) {
761 desktop->setWindowPosition(Geom::Point(x, y));
762 }
763 }
765 // restore zoom and view
766 if (nv->zoom != 0 && nv->zoom != HUGE_VAL && !IS_NAN(nv->zoom)
767 && nv->cx != HUGE_VAL && !IS_NAN(nv->cx)
768 && nv->cy != HUGE_VAL && !IS_NAN(nv->cy)) {
769 desktop->zoom_absolute(nv->cx, nv->cy, nv->zoom);
770 } else if (sp_desktop_document(desktop)) { // document without saved zoom, zoom to its page
771 desktop->zoom_page();
772 }
774 // cancel any history of zooms up to this point
775 if (desktop->zooms_past) {
776 g_list_free(desktop->zooms_past);
777 desktop->zooms_past = NULL;
778 }
779 }
781 void sp_namedview_update_layers_from_document (SPDesktop *desktop)
782 {
783 SPObject *layer = NULL;
784 SPDocument *document = desktop->doc();
785 SPNamedView *nv = desktop->namedview;
786 if ( nv->default_layer_id != 0 ) {
787 layer = document->getObjectById(g_quark_to_string(nv->default_layer_id));
788 }
789 // don't use that object if it's not at least group
790 if ( !layer || !SP_IS_GROUP(layer) ) {
791 layer = NULL;
792 }
793 // if that didn't work out, look for the topmost layer
794 if (!layer) {
795 SPObject *iter = sp_object_first_child(SP_DOCUMENT_ROOT(document));
796 for ( ; iter ; iter = SP_OBJECT_NEXT(iter) ) {
797 if (desktop->isLayer(iter)) {
798 layer = iter;
799 }
800 }
801 }
802 if (layer) {
803 desktop->setCurrentLayer(layer);
804 }
806 // FIXME: find a better place to do this
807 desktop->event_log->updateUndoVerbs();
808 }
810 void sp_namedview_document_from_window(SPDesktop *desktop)
811 {
812 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
813 bool save_geometry_in_file = prefs->getBool("/options/savewindowgeometry/value", 0);
814 Inkscape::XML::Node *view = SP_OBJECT_REPR(desktop->namedview);
815 Geom::Rect const r = desktop->get_display_area();
817 // saving window geometry is not undoable
818 bool saved = sp_document_get_undo_sensitive(sp_desktop_document(desktop));
819 sp_document_set_undo_sensitive(sp_desktop_document(desktop), false);
821 sp_repr_set_svg_double(view, "inkscape:zoom", desktop->current_zoom());
822 sp_repr_set_svg_double(view, "inkscape:cx", r.midpoint()[Geom::X]);
823 sp_repr_set_svg_double(view, "inkscape:cy", r.midpoint()[Geom::Y]);
825 if (save_geometry_in_file) {
826 gint w, h, x, y;
827 desktop->getWindowGeometry(x, y, w, h);
828 sp_repr_set_int(view, "inkscape:window-width", w);
829 sp_repr_set_int(view, "inkscape:window-height", h);
830 sp_repr_set_int(view, "inkscape:window-x", x);
831 sp_repr_set_int(view, "inkscape:window-y", y);
832 }
834 view->setAttribute("inkscape:current-layer", SP_OBJECT_ID(desktop->currentLayer()));
836 // restore undoability
837 sp_document_set_undo_sensitive(sp_desktop_document(desktop), saved);
838 }
840 void SPNamedView::hide(SPDesktop const *desktop)
841 {
842 g_assert(desktop != NULL);
843 g_assert(g_slist_find(views, desktop));
845 for (GSList *l = guides; l != NULL; l = l->next) {
846 sp_guide_hide(SP_GUIDE(l->data), sp_desktop_canvas(desktop));
847 }
849 views = g_slist_remove(views, desktop);
850 }
852 void SPNamedView::activateGuides(gpointer desktop, gboolean active)
853 {
854 g_assert(desktop != NULL);
855 g_assert(g_slist_find(views, desktop));
857 SPDesktop *dt = static_cast<SPDesktop*>(desktop);
859 for (GSList *l = guides; l != NULL; l = l->next) {
860 sp_guide_sensitize(SP_GUIDE(l->data), sp_desktop_canvas(dt), active);
861 }
862 }
864 static void sp_namedview_setup_guides(SPNamedView *nv)
865 {
866 for (GSList *l = nv->guides; l != NULL; l = l->next) {
867 if (nv->showguides) {
868 for (GSList *v = SP_GUIDE(l->data)->views; v != NULL; v = v->next) {
869 sp_canvas_item_show(SP_CANVAS_ITEM(v->data));
870 }
871 } else {
872 for (GSList *v = SP_GUIDE(l->data)->views; v != NULL; v = v->next) {
873 sp_canvas_item_hide(SP_CANVAS_ITEM(v->data));
874 }
875 }
876 }
877 }
879 void sp_namedview_toggle_guides(SPDocument *doc, Inkscape::XML::Node *repr)
880 {
881 unsigned int v;
882 unsigned int set = sp_repr_get_boolean(repr, "showguides", &v);
883 if (!set) { // hide guides if not specified, for backwards compatibility
884 v = FALSE;
885 } else {
886 v = !v;
887 }
889 bool saved = sp_document_get_undo_sensitive(doc);
890 sp_document_set_undo_sensitive(doc, false);
891 sp_repr_set_boolean(repr, "showguides", v);
892 sp_document_set_undo_sensitive(doc, saved);
894 doc->setModifiedSinceSave();
895 }
897 void sp_namedview_show_grids(SPNamedView * namedview, bool show, bool dirty_document)
898 {
899 namedview->grids_visible = show;
901 SPDocument *doc = SP_OBJECT_DOCUMENT (namedview);
902 Inkscape::XML::Node *repr = SP_OBJECT_REPR(namedview);
904 bool saved = sp_document_get_undo_sensitive(doc);
905 sp_document_set_undo_sensitive(doc, false);
906 sp_repr_set_boolean(repr, "showgrid", namedview->grids_visible);
907 sp_document_set_undo_sensitive(doc, saved);
909 /* we don't want the document to get dirty on startup; that's when
910 we call this function with dirty_document = false */
911 if (dirty_document) {
912 doc->setModifiedSinceSave();
913 }
914 }
916 gchar const *SPNamedView::getName() const
917 {
918 SPException ex;
919 SP_EXCEPTION_INIT(&ex);
920 return sp_object_getAttribute(SP_OBJECT(this), "id", &ex);
921 }
923 guint SPNamedView::getViewCount()
924 {
925 return ++viewcount;
926 }
928 GSList const *SPNamedView::getViewList() const
929 {
930 return views;
931 }
933 /* This should be moved somewhere */
935 static gboolean sp_str_to_bool(const gchar *str)
936 {
937 if (str) {
938 if (!g_strcasecmp(str, "true") ||
939 !g_strcasecmp(str, "yes") ||
940 !g_strcasecmp(str, "y") ||
941 (atoi(str) != 0)) {
942 return TRUE;
943 }
944 }
946 return FALSE;
947 }
949 static gboolean sp_nv_read_opacity(const gchar *str, guint32 *color)
950 {
951 if (!str) {
952 return FALSE;
953 }
955 gchar *u;
956 gdouble v = g_ascii_strtod(str, &u);
957 if (!u) {
958 return FALSE;
959 }
960 v = CLAMP(v, 0.0, 1.0);
962 *color = (*color & 0xffffff00) | (guint32) floor(v * 255.9999);
964 return TRUE;
965 }
967 SPNamedView *sp_document_namedview(SPDocument *document, const gchar *id)
968 {
969 g_return_val_if_fail(document != NULL, NULL);
971 SPObject *nv = sp_item_group_get_child_by_name((SPGroup *) document->root, NULL, "sodipodi:namedview");
972 g_assert(nv != NULL);
974 if (id == NULL) {
975 return (SPNamedView *) nv;
976 }
978 while (nv && strcmp(nv->id, id)) {
979 nv = sp_item_group_get_child_by_name((SPGroup *) document->root, nv, "sodipodi:namedview");
980 }
982 return (SPNamedView *) nv;
983 }
985 /**
986 * Returns namedview's default metric.
987 */
988 SPMetric SPNamedView::getDefaultMetric() const
989 {
990 if (doc_units) {
991 return sp_unit_get_metric(doc_units);
992 } else {
993 return SP_PT;
994 }
995 }
997 /**
998 * Returns the first grid it could find that isEnabled(). Returns NULL, if none is enabled
999 */
1000 Inkscape::CanvasGrid * sp_namedview_get_first_enabled_grid(SPNamedView *namedview)
1001 {
1002 for (GSList const * l = namedview->grids; l != NULL; l = l->next) {
1003 Inkscape::CanvasGrid * grid = (Inkscape::CanvasGrid*) l->data;
1004 if (grid->isEnabled())
1005 return grid;
1006 }
1008 return NULL;
1009 }
1011 void SPNamedView::translateGuides(Geom::Translate const &tr) {
1012 for (GSList *l = guides; l != NULL; l = l->next) {
1013 SPGuide &guide = *SP_GUIDE(l->data);
1014 Geom::Point point_on_line = guide.point_on_line;
1015 point_on_line[0] += tr[0];
1016 point_on_line[1] += tr[1];
1017 sp_guide_moveto(guide, point_on_line, true);
1018 }
1019 }
1021 void SPNamedView::scrollAllDesktops(double dx, double dy, bool is_scrolling) {
1022 for(GSList *l = views; l; l = l->next) {
1023 SPDesktop *desktop = static_cast<SPDesktop *>(l->data);
1024 desktop->scroll_world_in_svg_coords(dx, dy, is_scrolling);
1025 }
1026 }
1029 /*
1030 Local Variables:
1031 mode:c++
1032 c-file-style:"stroustrup"
1033 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1034 indent-tabs-mode:nil
1035 fill-column:99
1036 End:
1037 */
1038 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :