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