src/sp-tref.cpp

   1 #define __SP_TREF_CPP__
   2
   3 /** \file
   4  * SVG <tref> implementation - All character data within the referenced
   5  * element, including character data enclosed within additional markup,
   6  * will be rendered.
   7  *
   8  * This file was created based on skeleton.cpp
   9  */
  10 /*
  11  * Authors:
  12  *   Gail Banaszkiewicz <Gail.Banaszkiewicz@gmail.com>
  13  *
  14  * Copyright (C) 2007 Gail Banaszkiewicz
  15  *
  16  * Released under GNU GPL, read the file 'COPYING' for more information
  17  */
  18
  19 #ifdef HAVE_CONFIG_H
  20 # include "config.h"
  21 #endif
  22
  23 #include <glibmm/i18n.h>
  24
  25 #include "attributes.h"
  26 #include "document.h"
  27 #include "sp-object-repr.h"
  28 #include "sp-text.h"
  29 #include "sp-tspan.h"
  30 #include "sp-tref.h"
  31 #include "style.h"
  32 #include "text-editing.h"
  33 #include "uri.h"
  34
  35 #include "display/nr-arena-group.h"
  36 #include "libnr/nr-matrix-fns.h"
  37 #include "xml/node.h"
  38 #include "xml/repr.h"
  39
  40
  41 //#define DEBUG_TREF
  42 #ifdef DEBUG_TREF
  43 # define debug(f, a...) { g_message("%s(%d) %s:", \
  44                                   __FILE__,__LINE__,__FUNCTION__); \
  45                           g_message(f, ## a); \
  46                           g_message("\n"); \
  47                         }
  48 #else
  49 # define debug(f, a...) /**/
  50 #endif
  51
  52
  53 static void build_string_from_root(Inkscape::XML::Node *root, Glib::ustring *retString);
  54
  55 /* TRef base class */
  56
  57 static void sp_tref_class_init(SPTRefClass *tref_class);
  58 static void sp_tref_init(SPTRef *tref);
  59 static void sp_tref_finalize(GObject *obj);
  60
  61 static void sp_tref_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
  62 static void sp_tref_release(SPObject *object);
  63 static void sp_tref_set(SPObject *object, unsigned int key, gchar const *value);
  64 static void sp_tref_update(SPObject *object, SPCtx *ctx, guint flags);
  65 static void sp_tref_modified(SPObject *object, guint flags);
  66 static Inkscape::XML::Node *sp_tref_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags);
  67
  68 static void sp_tref_bbox(SPItem const *item, NRRect *bbox, Geom::Matrix const &transform, unsigned const flags);
  69 static gchar *sp_tref_description(SPItem *item);
  70
  71 static void sp_tref_href_changed(SPObject *old_ref, SPObject *ref, SPTRef *tref);
  72 static void sp_tref_delete_self(SPObject *deleted, SPTRef *self);
  73
  74 static SPObjectClass *tref_parent_class;
  75
  76 GType
  77 sp_tref_get_type()
  78 {
  79     static GType tref_type = 0;
  80
  81     if (!tref_type) {
  82         GTypeInfo tref_info = {
  83             sizeof(SPTRefClass),
  84             NULL, NULL,
  85             (GClassInitFunc) sp_tref_class_init,
  86             NULL, NULL,
  87             sizeof(SPTRef),
  88             16,
  89             (GInstanceInitFunc) sp_tref_init,
  90             NULL,    /* value_table */
  91         };
  92         tref_type = g_type_register_static(SP_TYPE_ITEM, "SPTRef", &tref_info, (GTypeFlags)0);
  93     }
  94     return tref_type;
  95 }
  96
  97 static void
  98 sp_tref_class_init(SPTRefClass *tref_class)
  99 {
 100     GObjectClass *gobject_class = (GObjectClass *) tref_class;
 101     SPObjectClass *sp_object_class = (SPObjectClass *)tref_class;
 102
 103     tref_parent_class = (SPObjectClass*)g_type_class_peek_parent(tref_class);
 104
 105     sp_object_class->build = sp_tref_build;
 106     sp_object_class->release = sp_tref_release;
 107     sp_object_class->write = sp_tref_write;
 108     sp_object_class->set = sp_tref_set;
 109     sp_object_class->update = sp_tref_update;
 110     sp_object_class->modified = sp_tref_modified;
 111
 112     gobject_class->finalize = sp_tref_finalize;
 113
 114     SPItemClass *item_class = (SPItemClass *) tref_class;
 115
 116     item_class->bbox = sp_tref_bbox;
 117     item_class->description = sp_tref_description;
 118 }
 119
 120 static void
 121 sp_tref_init(SPTRef *tref)
 122 {
 123     new (&tref->attributes) TextTagAttributes;
 124
 125     tref->href = NULL;
 126     tref->uriOriginalRef = new SPTRefReference(SP_OBJECT(tref));
 127     new (&tref->_delete_connection) sigc::connection();
 128     new (&tref->_changed_connection) sigc::connection();
 129
 130     tref->_changed_connection =
 131         tref->uriOriginalRef->changedSignal().connect(sigc::bind(sigc::ptr_fun(sp_tref_href_changed), tref));
 132 }
 133
 134
 135 static void
 136 sp_tref_finalize(GObject *obj)
 137 {
 138     SPTRef *tref = (SPTRef *) obj;
 139
 140     delete tref->uriOriginalRef;
 141
 142     tref->_delete_connection.~connection();
 143     tref->_changed_connection.~connection();
 144 }
 145
 146
 147 /**
 148  * Reads the Inkscape::XML::Node, and initializes SPTRef variables.
 149  */
 150 static void
 151 sp_tref_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
 152 {
 153     if (((SPObjectClass *) tref_parent_class)->build) {
 154         ((SPObjectClass *) tref_parent_class)->build(object, document, repr);
 155     }
 156
 157     sp_object_read_attr(object, "xlink:href");
 158     sp_object_read_attr(object, "x");
 159     sp_object_read_attr(object, "y");
 160     sp_object_read_attr(object, "dx");
 161     sp_object_read_attr(object, "dy");
 162     sp_object_read_attr(object, "rotate");
 163 }
 164
 165 /**
 166  * Drops any allocated memory.
 167  */
 168 static void
 169 sp_tref_release(SPObject *object)
 170 {
 171     SPTRef *tref = SP_TREF(object);
 172
 173     tref->attributes.~TextTagAttributes();
 174
 175     tref->_delete_connection.disconnect();
 176     tref->_changed_connection.disconnect();
 177
 178     g_free(tref->href);
 179     tref->href = NULL;
 180
 181     tref->uriOriginalRef->detach();
 182
 183     if (((SPObjectClass *) tref_parent_class)->release)
 184         ((SPObjectClass *) tref_parent_class)->release(object);
 185 }
 186
 187 /**
 188  * Sets a specific value in the SPTRef.
 189  */
 190 static void
 191 sp_tref_set(SPObject *object, unsigned int key, gchar const *value)
 192 {
 193     debug("0x%p %s(%u): '%s'",object,
 194             sp_attribute_name(key),key,value ? value : "<no value>");
 195
 196     SPTRef *tref = SP_TREF(object);
 197
 198     if (tref->attributes.readSingleAttribute(key, value)) { // x, y, dx, dy, rotate
 199         object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
 200     } else if (key == SP_ATTR_XLINK_HREF) { // xlink:href
 201         if ( !value ) {
 202             // No value
 203             g_free(tref->href);
 204             tref->href = NULL;
 205             tref->uriOriginalRef->detach();
 206         } else if ((tref->href && strcmp(value, tref->href) != 0) || (!tref->href)) {
 207
 208             // Value has changed
 209
 210             if ( tref->href ) {
 211                 g_free(tref->href);
 212                 tref->href = NULL;
 213             }
 214
 215             tref->href = g_strdup(value);
 216
 217             try {
 218                 tref->uriOriginalRef->attach(Inkscape::URI(value));
 219                 tref->uriOriginalRef->updateObserver();
 220             } catch ( Inkscape::BadURIException &e ) {
 221                 g_warning("%s", e.what());
 222                 tref->uriOriginalRef->detach();
 223             }
 224
 225             // No matter what happened, an update should be in order
 226             SP_OBJECT(tref)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
 227         }
 228
 229     } else { // default
 230         if (((SPObjectClass *) tref_parent_class)->set) {
 231             ((SPObjectClass *) tref_parent_class)->set(object, key, value);
 232         }
 233     }
 234
 235
 236 }
 237
 238 /**
 239  * Receives update notifications.  Code based on sp_use_update and sp_tspan_update.
 240  */
 241 static void
 242 sp_tref_update(SPObject *object, SPCtx *ctx, guint flags)
 243 {
 244     debug("0x%p",object);
 245
 246     SPTRef *tref = SP_TREF(object);
 247
 248     if (((SPObjectClass *) tref_parent_class)->update) {
 249         ((SPObjectClass *) tref_parent_class)->update(object, ctx, flags);
 250     }
 251
 252     if (flags & SP_OBJECT_MODIFIED_FLAG) {
 253         flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
 254     }
 255
 256     flags &= SP_OBJECT_MODIFIED_CASCADE;
 257
 258     SPObject *child = tref->stringChild;
 259     if (child) {
 260         if ( flags || ( child->uflags & SP_OBJECT_MODIFIED_FLAG )) {
 261             child->updateDisplay(ctx, flags);
 262         }
 263     }
 264
 265
 266 }
 267
 268 static void
 269 sp_tref_modified(SPObject *object, guint flags)
 270 {
 271     SPTRef *tref_obj = SP_TREF(object);
 272
 273     if (flags & SP_OBJECT_MODIFIED_FLAG) {
 274         flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
 275     }
 276
 277     flags &= SP_OBJECT_MODIFIED_CASCADE;
 278
 279     SPObject *child = tref_obj->stringChild;
 280     if (child) {
 281         g_object_ref(G_OBJECT(child));
 282         if (flags || (child->mflags & SP_OBJECT_MODIFIED_FLAG)) {
 283             child->emitModified(flags);
 284         }
 285         g_object_unref(G_OBJECT(child));
 286     }
 287 }
 288
 289 /**
 290  * Writes its settings to an incoming repr object, if any.
 291  */
 292 static Inkscape::XML::Node *
 293 sp_tref_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
 294 {
 295     debug("0x%p",object);
 296
 297     SPTRef *tref = SP_TREF(object);
 298
 299     if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
 300         repr = xml_doc->createElement("svg:tref");
 301     }
 302
 303     tref->attributes.writeTo(repr);
 304
 305     if (tref->uriOriginalRef->getURI()) {
 306         gchar *uri_string = tref->uriOriginalRef->getURI()->toString();
 307         debug("uri_string=%s", uri_string);
 308         repr->setAttribute("xlink:href", uri_string);
 309         g_free(uri_string);
 310     }
 311
 312     if (((SPObjectClass *) tref_parent_class)->write) {
 313         ((SPObjectClass *) tref_parent_class)->write(object, xml_doc, repr, flags);
 314     }
 315
 316     return repr;
 317 }
 318
 319 /**
 320  *  The code for this function is swiped from the tspan bbox code, since tref should work pretty much the same way
 321  */
 322 static void
 323 sp_tref_bbox(SPItem const *item, NRRect *bbox, Geom::Matrix const &transform, unsigned const /*flags*/)
 324 {
 325     // find out the ancestor text which holds our layout
 326     SPObject *parent_text = SP_OBJECT(item);
 327     for (; parent_text != NULL && !SP_IS_TEXT(parent_text); parent_text = SP_OBJECT_PARENT (parent_text));
 328     if (parent_text == NULL) return;
 329
 330     // get the bbox of our portion of the layout
 331     SP_TEXT(parent_text)->layout.getBoundingBox(
 332         bbox, transform, sp_text_get_length_upto(parent_text, item), sp_text_get_length_upto(item, NULL) - 1);
 333
 334     // Add stroke width
 335     SPStyle* style=SP_OBJECT_STYLE (item);
 336     if (!style->stroke.isNone()) {
 337         double const scale = transform.descrim();
 338         if ( fabs(style->stroke_width.computed * scale) > 0.01 ) { // sinon c'est 0=oon veut pas de bord
 339             double const width = MAX(0.125, style->stroke_width.computed * scale);
 340             if ( fabs(bbox->x1 - bbox->x0) > -0.00001 && fabs(bbox->y1 - bbox->y0) > -0.00001 ) {
 341                 bbox->x0-=0.5*width;
 342                 bbox->x1+=0.5*width;
 343                 bbox->y0-=0.5*width;
 344                 bbox->y1+=0.5*width;
 345             }
 346         }
 347     }
 348 }
 349
 350
 351 static gchar *
 352 sp_tref_description(SPItem *item)
 353 {
 354     SPTRef *tref = SP_TREF(item);
 355
 356     SPObject *referred = tref->getObjectReferredTo();
 357
 358     if (tref && tref->getObjectReferredTo()) {
 359         char *child_desc;
 360
 361         if (SP_IS_ITEM(referred)) {
 362             child_desc = sp_item_description(SP_ITEM(referred));
 363         } else {
 364             child_desc = g_strdup("");
 365         }
 366
 367         char *ret = g_strdup_printf(
 368                 _("<b>Cloned character data</b>%s%s"),
 369                 (SP_IS_ITEM(referred) ? _(" from ") : ""),
 370                 child_desc);
 371         g_free(child_desc);
 372         return ret;
 373     } else {
 374         return g_strdup(_("<b>Orphaned cloned character data</b>"));
 375     }
 376 }
 377
 378
 379 /* For the sigc::connection changes (i.e. when the object being refered to changes) */
 380 static void
 381 sp_tref_href_changed(SPObject */*old_ref*/, SPObject */*ref*/, SPTRef *tref)
 382 {
 383     if (tref)
 384     {
 385         // Save a pointer to the original object being referred to
 386         SPObject *refRoot = tref->getObjectReferredTo();
 387
 388         tref->_delete_connection.disconnect();
 389
 390         if (tref->stringChild) {
 391             sp_object_detach(SP_OBJECT(tref), tref->stringChild);
 392             tref->stringChild = NULL;
 393         }
 394
 395         // Ensure that we are referring to a legitimate object
 396         if (tref->href && refRoot && sp_tref_reference_allowed(tref, refRoot)) {
 397
 398             // Update the text being referred to (will create a new string child)
 399             sp_tref_update_text(tref);
 400
 401             // Restore the delete connection now that we're done messing with stuff
 402             tref->_delete_connection = SP_OBJECT(refRoot)->connectDelete(sigc::bind(sigc::ptr_fun(&sp_tref_delete_self), tref));
 403         }
 404
 405     }
 406 }
 407
 408
 409 /**
 410  * Delete the tref object
 411  */
 412 static void
 413 sp_tref_delete_self(SPObject */*deleted*/, SPTRef *self)
 414 {
 415     SP_OBJECT(self)->deleteObject();
 416 }
 417
 418 /**
 419  * Return the object referred to via the URI reference
 420  */
 421 SPObject * SPTRef::getObjectReferredTo(void)
 422 {
 423     SPObject *referredObject = NULL;
 424
 425     if (uriOriginalRef) {
 426         referredObject = SP_OBJECT(uriOriginalRef->getObject());
 427     }
 428
 429     return referredObject;
 430 }
 431
 432
 433 /**
 434  * Returns true when the given tref is allowed to refer to a particular object
 435  */
 436 bool
 437 sp_tref_reference_allowed(SPTRef *tref, SPObject *possible_ref)
 438 {
 439     bool allowed = false;
 440
 441     if (tref && possible_ref) {
 442         if (tref != possible_ref) {
 443             bool ancestor = false;
 444             for (SPObject *obj = tref; obj; obj = SP_OBJECT_PARENT(obj)) {
 445                 if (possible_ref == obj) {
 446                     ancestor = true;
 447                     break;
 448                 }
 449             }
 450             allowed = !ancestor;
 451         }
 452     }
 453
 454     return allowed;
 455 }
 456
 457
 458 /**
 459  * Returns true if a tref is fully contained in the confines of the given
 460  * iterators and layout (or if there is no tref).
 461  */
 462 bool
 463 sp_tref_fully_contained(SPObject *start_item, Glib::ustring::iterator &start,
 464                              SPObject *end_item, Glib::ustring::iterator &end)
 465 {
 466     bool fully_contained = false;
 467
 468     if (start_item && end_item) {
 469
 470         // If neither the beginning or the end is a tref then we return true (whether there
 471         // is a tref in the innards or not, because if there is one then it must be totally
 472         // contained)
 473         if (!(SP_IS_STRING(start_item) && SP_IS_TREF(SP_OBJECT_PARENT(start_item)))
 474                 && !(SP_IS_STRING(end_item) && SP_IS_TREF(SP_OBJECT_PARENT(end_item)))) {
 475             fully_contained = true;
 476         }
 477
 478         // Both the beginning and end are trefs; but in this case, the string iterators
 479         // must be at the right places
 480         else if ((SP_IS_STRING(start_item) && SP_IS_TREF(SP_OBJECT_PARENT(start_item)))
 481                 && (SP_IS_STRING(end_item) && SP_IS_TREF(SP_OBJECT_PARENT(end_item)))) {
 482             if (start == SP_STRING(start_item)->string.begin()
 483                     && end == SP_STRING(start_item)->string.end()) {
 484                 fully_contained = true;
 485             }
 486         }
 487
 488         // If the beginning is a string that is a child of a tref, the iterator has to be
 489         // at the beginning of the item
 490         else if ((SP_IS_STRING(start_item) && SP_IS_TREF(SP_OBJECT_PARENT(start_item)))
 491                     && !(SP_IS_STRING(end_item) && SP_IS_TREF(SP_OBJECT_PARENT(end_item)))) {
 492             if (start == SP_STRING(start_item)->string.begin()) {
 493                 fully_contained = true;
 494             }
 495         }
 496
 497         // Same, but the for the end
 498         else if (!(SP_IS_STRING(start_item) && SP_IS_TREF(SP_OBJECT_PARENT(start_item)))
 499                     && (SP_IS_STRING(end_item) && SP_IS_TREF(SP_OBJECT_PARENT(end_item)))) {
 500             if (end == SP_STRING(start_item)->string.end()) {
 501                 fully_contained = true;
 502             }
 503         }
 504     }
 505
 506     return fully_contained;
 507 }
 508
 509
 510 void
 511 sp_tref_update_text(SPTRef *tref)
 512 {
 513     if (tref) {
 514         // Get the character data that will be used with this tref
 515         Glib::ustring charData = "";
 516         build_string_from_root(SP_OBJECT_REPR(tref->getObjectReferredTo()), &charData);
 517
 518         if (tref->stringChild) {
 519             sp_object_detach(SP_OBJECT(tref), tref->stringChild);
 520             tref->stringChild = NULL;
 521         }
 522
 523         // Create the node and SPString to be the tref's child
 524         Inkscape::XML::Document *xml_doc = sp_document_repr_doc(SP_OBJECT_DOCUMENT(tref));
 525
 526         Inkscape::XML::Node *newStringRepr = xml_doc->createTextNode(charData.c_str());
 527         tref->stringChild = SP_OBJECT(g_object_new(sp_repr_type_lookup(newStringRepr), NULL));
 528
 529         // Add this SPString as a child of the tref
 530         sp_object_attach(SP_OBJECT(tref), tref->stringChild, tref->lastChild());
 531         sp_object_unref(tref->stringChild, NULL);
 532         sp_object_invoke_build(tref->stringChild, SP_OBJECT(tref)->document, newStringRepr, TRUE);
 533
 534         Inkscape::GC::release(newStringRepr);
 535     }
 536 }
 537
 538
 539
 540 /**
 541  * Using depth-first search, build up a string by concatenating all SPStrings
 542  * found in the tree starting at the root
 543  */
 544 static void
 545 build_string_from_root(Inkscape::XML::Node *root, Glib::ustring *retString)
 546 {
 547     if (root && retString) {
 548
 549         // Stop and concatenate when a SPString is found
 550         if (root->type() == Inkscape::XML::TEXT_NODE) {
 551             *retString += (root->content());
 552
 553             debug("%s", retString->c_str());
 554
 555         // Otherwise, continue searching down the tree (with the assumption that no children nodes
 556         // of a SPString are actually legal)
 557         } else {
 558             Inkscape::XML::Node *childNode;
 559             for (childNode = root->firstChild(); childNode; childNode = childNode->next()) {
 560                 build_string_from_root(childNode, retString);
 561             }
 562         }
 563     }
 564 }
 565
 566 /**
 567  * This function will create a new tspan element with the same attributes as
 568  * the tref had and add the same text as a child.  The tref is replaced in the
 569  * tree with the new tspan.
 570  * The code is based partially on sp_use_unlink
 571  */
 572 SPObject *
 573 sp_tref_convert_to_tspan(SPObject *obj)
 574 {
 575     SPObject * new_tspan = NULL;
 576
 577     ////////////////////
 578     // BASE CASE
 579     ////////////////////
 580     if (SP_IS_TREF(obj)) {
 581
 582         SPTRef *tref = SP_TREF(obj);
 583
 584         if (tref && tref->stringChild) {
 585             Inkscape::XML::Node *tref_repr = SP_OBJECT_REPR(tref);
 586             Inkscape::XML::Node *tref_parent = sp_repr_parent(tref_repr);
 587
 588             SPDocument *document = SP_OBJECT(tref)->document;
 589             Inkscape::XML::Document *xml_doc = sp_document_repr_doc(document);
 590
 591             Inkscape::XML::Node *new_tspan_repr = xml_doc->createElement("svg:tspan");
 592
 593             // Add the new tspan element just after the current tref
 594             tref_parent->addChild(new_tspan_repr, tref_repr);
 595             Inkscape::GC::release(new_tspan_repr);
 596
 597             new_tspan = document->getObjectByRepr(new_tspan_repr);
 598
 599             // Create a new string child for the tspan
 600             Inkscape::XML::Node *new_string_repr = SP_OBJECT_REPR(tref->stringChild)->duplicate(xml_doc);
 601             new_tspan_repr->addChild(new_string_repr, NULL);
 602
 603             //SPObject * new_string_child = document->getObjectByRepr(new_string_repr);
 604
 605             // Merge style from the tref
 606             SPStyle *new_tspan_sty = SP_OBJECT_STYLE(new_tspan);
 607             SPStyle const *tref_sty = SP_OBJECT_STYLE(tref);
 608             sp_style_merge_from_dying_parent(new_tspan_sty, tref_sty);
 609             sp_style_merge_from_parent(new_tspan_sty, new_tspan->parent->style);
 610
 611
 612             SP_OBJECT(new_tspan)->updateRepr();
 613
 614             // Hold onto our SPObject and repr for now.
 615             sp_object_ref(SP_OBJECT(tref), NULL);
 616             Inkscape::GC::anchor(tref_repr);
 617
 618             // Remove ourselves, not propagating delete events to avoid a
 619             // chain-reaction with other elements that might reference us.
 620             SP_OBJECT(tref)->deleteObject(false);
 621
 622             // Give the copy our old id and let go of our old repr.
 623             new_tspan_repr->setAttribute("id", tref_repr->attribute("id"));
 624             Inkscape::GC::release(tref_repr);
 625
 626             // Establish the succession and let go of our object.
 627             SP_OBJECT(tref)->setSuccessor(new_tspan);
 628             sp_object_unref(SP_OBJECT(tref), NULL);
 629         }
 630     }
 631     ////////////////////
 632     // RECURSIVE CASE
 633     ////////////////////
 634     else {
 635         GSList *l = NULL;
 636         for (SPObject *child = sp_object_first_child(obj) ; child != NULL ; child = SP_OBJECT_NEXT(child) ) {
 637             sp_object_ref (SP_OBJECT (child), obj);
 638             l = g_slist_prepend (l, child);
 639         }
 640         l = g_slist_reverse (l);
 641         while (l) {
 642             SPObject *child = SP_OBJECT (l->data);
 643             l = g_slist_remove (l, child);
 644
 645             // Note that there may be more than one conversion happening here, so if it's not a
 646             // tref being passed into this function, the returned value can't be specifically known
 647             new_tspan = sp_tref_convert_to_tspan(child);
 648
 649             sp_object_unref (SP_OBJECT (child), obj);
 650         }
 651     }
 652
 653     return new_tspan;
 654 }
 655
 656
 657 /*
 658   Local Variables:
 659   mode:c++
 660   c-file-style:"stroustrup"
 661   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 662   indent-tabs-mode:nil
 663   fill-column:99
 664   End:
 665 */
 666 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :