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