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