trunk/src/sp-namedview.cpp

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