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