src/sp-object.cpp

   1 #define __SP_OBJECT_C__
   2 /** \file
   3  * SPObject implementation.
   4  *
   5  * Authors:
   6  *   Lauris Kaplinski <lauris@kaplinski.com>
   7  *   bulia byak <buliabyak@users.sf.net>
   8  *
   9  * Copyright (C) 1999-2005 authors
  10  * Copyright (C) 2001-2002 Ximian, Inc.
  11  *
  12  * Released under GNU GPL, read the file 'COPYING' for more information
  13  */
  14
  15 /** \class SPObject
  16  *
  17  * SPObject is an abstract base class of all of the document nodes at the
  18  * SVG document level. Each SPObject subclass implements a certain SVG
  19  * element node type, or is an abstract base class for different node
  20  * types.  The SPObject layer is bound to the SPRepr layer, closely
  21  * following the SPRepr mutations via callbacks.  During creation,
  22  * SPObject parses and interprets all textual attributes and CSS style
  23  * strings of the SPRepr, and later updates the internal state whenever
  24  * it receives a signal about a change. The opposite is not true - there
  25  * are methods manipulating SPObjects directly and such changes do not
  26  * propagate to the SPRepr layer. This is important for implementation of
  27  * the undo stack, animations and other features.
  28  *
  29  * SPObjects are bound to the higher-level container SPDocument, which
  30  * provides document level functionality such as the undo stack,
  31  * dictionary and so on. Source: doc/architecture.txt
  32  */
  33
  34
  35 #include "helper/sp-marshal.h"
  36 #include "xml/node-event-vector.h"
  37 #include "attributes.h"
  38 #include "document.h"
  39 #include "style.h"
  40 #include "sp-object-repr.h"
  41 #include "sp-root.h"
  42 #include "streq.h"
  43 #include "strneq.h"
  44 #include "xml/repr.h"
  45 #include "xml/node-fns.h"
  46 #include "debug/event-tracker.h"
  47 #include "debug/simple-event.h"
  48 #include "debug/demangle.h"
  49 #include "util/share.h"
  50 #include "util/format.h"
  51
  52 #include "algorithms/longest-common-suffix.h"
  53 using std::memcpy;
  54 using std::strchr;
  55 using std::strcmp;
  56 using std::strlen;
  57 using std::strstr;
  58
  59 #define noSP_OBJECT_DEBUG_CASCADE
  60
  61 #define noSP_OBJECT_DEBUG
  62
  63 #ifdef SP_OBJECT_DEBUG
  64 # define debug(f, a...) { g_print("%s(%d) %s:", \
  65                                   __FILE__,__LINE__,__FUNCTION__); \
  66                           g_print(f, ## a); \
  67                           g_print("\n"); \
  68                         }
  69 #else
  70 # define debug(f, a...) /**/
  71 #endif
  72
  73 static void sp_object_class_init(SPObjectClass *klass);
  74 static void sp_object_init(SPObject *object);
  75 static void sp_object_finalize(GObject *object);
  76
  77 static void sp_object_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref);
  78 static void sp_object_remove_child(SPObject *object, Inkscape::XML::Node *child);
  79 static void sp_object_order_changed(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *old_ref, Inkscape::XML::Node *new_ref);
  80
  81 static void sp_object_release(SPObject *object);
  82 static void sp_object_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
  83
  84 static void sp_object_private_set(SPObject *object, unsigned int key, gchar const *value);
  85 static Inkscape::XML::Node *sp_object_private_write(SPObject *object, Inkscape::XML::Node *repr, guint flags);
  86
  87 /* Real handlers of repr signals */
  88
  89 static void sp_object_repr_attr_changed(Inkscape::XML::Node *repr, gchar const *key, gchar const *oldval, gchar const *newval, bool is_interactive, gpointer data);
  90
  91 static void sp_object_repr_content_changed(Inkscape::XML::Node *repr, gchar const *oldcontent, gchar const *newcontent, gpointer data);
  92
  93 static void sp_object_repr_child_added(Inkscape::XML::Node *repr, Inkscape::XML::Node *child, Inkscape::XML::Node *ref, gpointer data);
  94 static void sp_object_repr_child_removed(Inkscape::XML::Node *repr, Inkscape::XML::Node *child, Inkscape::XML::Node *ref, void *data);
  95
  96 static void sp_object_repr_order_changed(Inkscape::XML::Node *repr, Inkscape::XML::Node *child, Inkscape::XML::Node *old, Inkscape::XML::Node *newer, gpointer data);
  97
  98 static gchar *sp_object_get_unique_id(SPObject *object, gchar const *defid);
  99
 100 guint update_in_progress = 0; // guard against update-during-update
 101
 102 Inkscape::XML::NodeEventVector object_event_vector = {
 103     sp_object_repr_child_added,
 104     sp_object_repr_child_removed,
 105     sp_object_repr_attr_changed,
 106     sp_object_repr_content_changed,
 107     sp_object_repr_order_changed
 108 };
 109
 110 static GObjectClass *parent_class;
 111
 112 /**
 113  * Registers the SPObject class with Gdk and returns its type number.
 114  */
 115 GType
 116 sp_object_get_type(void)
 117 {
 118     static GType type = 0;
 119     if (!type) {
 120         GTypeInfo info = {
 121             sizeof(SPObjectClass),
 122             NULL, NULL,
 123             (GClassInitFunc) sp_object_class_init,
 124             NULL, NULL,
 125             sizeof(SPObject),
 126             16,
 127             (GInstanceInitFunc) sp_object_init,
 128             NULL
 129         };
 130         type = g_type_register_static(G_TYPE_OBJECT, "SPObject", &info, (GTypeFlags)0);
 131     }
 132     return type;
 133 }
 134
 135 /**
 136  * Initializes the SPObject vtable.
 137  */
 138 static void
 139 sp_object_class_init(SPObjectClass *klass)
 140 {
 141     GObjectClass *object_class;
 142
 143     object_class = (GObjectClass *) klass;
 144
 145     parent_class = (GObjectClass *) g_type_class_ref(G_TYPE_OBJECT);
 146
 147     object_class->finalize = sp_object_finalize;
 148
 149     klass->child_added = sp_object_child_added;
 150     klass->remove_child = sp_object_remove_child;
 151     klass->order_changed = sp_object_order_changed;
 152
 153     klass->release = sp_object_release;
 154
 155     klass->build = sp_object_build;
 156
 157     klass->set = sp_object_private_set;
 158     klass->write = sp_object_private_write;
 159 }
 160
 161 /**
 162  * Callback to initialize the SPObject object.
 163  */
 164 static void
 165 sp_object_init(SPObject *object)
 166 {
 167     debug("id=%x, typename=%s",object, g_type_name_from_instance((GTypeInstance*)object));
 168
 169     object->hrefcount = 0;
 170     object->_total_hrefcount = 0;
 171     object->document = NULL;
 172     object->children = object->_last_child = NULL;
 173     object->parent = object->next = NULL;
 174     object->repr = NULL;
 175     object->id = NULL;
 176     object->style = NULL;
 177
 178     object->_collection_policy = SPObject::COLLECT_WITH_PARENT;
 179
 180     new (&object->_release_signal) sigc::signal<void, SPObject *>();
 181     new (&object->_modified_signal) sigc::signal<void, SPObject *, unsigned int>();
 182     new (&object->_delete_signal) sigc::signal<void, SPObject *>();
 183     new (&object->_position_changed_signal) sigc::signal<void, SPObject *>();
 184     object->_successor = NULL;
 185
 186     object->_label = NULL;
 187     object->_default_label = NULL;
 188 }
 189
 190 /**
 191  * Callback to destroy all members and connections of object and itself.
 192  */
 193 static void
 194 sp_object_finalize(GObject *object)
 195 {
 196     SPObject *spobject = (SPObject *)object;
 197
 198     g_free(spobject->_label);
 199     g_free(spobject->_default_label);
 200     spobject->_label = NULL;
 201     spobject->_default_label = NULL;
 202
 203     if (spobject->_successor) {
 204         sp_object_unref(spobject->_successor, NULL);
 205         spobject->_successor = NULL;
 206     }
 207
 208     if (((GObjectClass *) (parent_class))->finalize) {
 209         (* ((GObjectClass *) (parent_class))->finalize)(object);
 210     }
 211
 212     spobject->_release_signal.~signal();
 213     spobject->_modified_signal.~signal();
 214     spobject->_delete_signal.~signal();
 215     spobject->_position_changed_signal.~signal();
 216 }
 217
 218 namespace {
 219
 220 namespace Debug = Inkscape::Debug;
 221 namespace Util = Inkscape::Util;
 222
 223 typedef Debug::SimpleEvent<Debug::Event::REFCOUNT> BaseRefCountEvent;
 224
 225 class RefCountEvent : public BaseRefCountEvent {
 226 public:
 227     RefCountEvent(SPObject *object, int bias, Util::ptr_shared<char> name)
 228     : BaseRefCountEvent(name)
 229     {
 230         _addProperty("object", Util::format("%p", object));
 231         _addProperty("class", Debug::demangle(g_type_name(G_TYPE_FROM_INSTANCE(object))));
 232         _addProperty("new-refcount", Util::format("%d", G_OBJECT(object)->ref_count + bias));
 233     }
 234 };
 235
 236 class RefEvent : public RefCountEvent {
 237 public:
 238     RefEvent(SPObject *object)
 239     : RefCountEvent(object, 1, Util::share_static_string("sp-object-ref"))
 240     {}
 241 };
 242
 243 class UnrefEvent : public RefCountEvent {
 244 public:
 245     UnrefEvent(SPObject *object)
 246     : RefCountEvent(object, -1, Util::share_static_string("sp-object-unref"))
 247     {}
 248 };
 249
 250 }
 251
 252 /**
 253  * Increase reference count of object, with possible debugging.
 254  *
 255  * \param owner If non-NULL, make debug log entry.
 256  * \return object, NULL is error.
 257  * \pre object points to real object
 258  */
 259 SPObject *
 260 sp_object_ref(SPObject *object, SPObject *owner)
 261 {
 262     g_return_val_if_fail(object != NULL, NULL);
 263     g_return_val_if_fail(SP_IS_OBJECT(object), NULL);
 264     g_return_val_if_fail(!owner || SP_IS_OBJECT(owner), NULL);
 265
 266     Inkscape::Debug::EventTracker<RefEvent> tracker(object);
 267     g_object_ref(G_OBJECT(object));
 268     return object;
 269 }
 270
 271 /**
 272  * Decrease reference count of object, with possible debugging and
 273  * finalization.
 274  *
 275  * \param owner If non-NULL, make debug log entry.
 276  * \return always NULL
 277  * \pre object points to real object
 278  */
 279 SPObject *
 280 sp_object_unref(SPObject *object, SPObject *owner)
 281 {
 282     g_return_val_if_fail(object != NULL, NULL);
 283     g_return_val_if_fail(SP_IS_OBJECT(object), NULL);
 284     g_return_val_if_fail(!owner || SP_IS_OBJECT(owner), NULL);
 285
 286     Inkscape::Debug::EventTracker<UnrefEvent> tracker(object);
 287     g_object_unref(G_OBJECT(object));
 288     return NULL;
 289 }
 290
 291 /**
 292  * Increase weak refcount.
 293  *
 294  * Hrefcount is used for weak references, for example, to
 295  * determine whether any graphical element references a certain gradient
 296  * node.
 297  * \param owner Ignored.
 298  * \return object, NULL is error
 299  * \pre object points to real object
 300  */
 301 SPObject *
 302 sp_object_href(SPObject *object, gpointer owner)
 303 {
 304     g_return_val_if_fail(object != NULL, NULL);
 305     g_return_val_if_fail(SP_IS_OBJECT(object), NULL);
 306
 307     object->hrefcount++;
 308     object->_updateTotalHRefCount(1);
 309
 310     return object;
 311 }
 312
 313 /**
 314  * Decrease weak refcount.
 315  *
 316  * Hrefcount is used for weak references, for example, to determine whether
 317  * any graphical element references a certain gradient node.
 318  * \param owner Ignored.
 319  * \return always NULL
 320  * \pre object points to real object and hrefcount>0
 321  */
 322 SPObject *
 323 sp_object_hunref(SPObject *object, gpointer owner)
 324 {
 325     g_return_val_if_fail(object != NULL, NULL);
 326     g_return_val_if_fail(SP_IS_OBJECT(object), NULL);
 327     g_return_val_if_fail(object->hrefcount > 0, NULL);
 328
 329     object->hrefcount--;
 330     object->_updateTotalHRefCount(-1);
 331
 332     return NULL;
 333 }
 334
 335 /**
 336  * Adds increment to _total_hrefcount of object and its parents.
 337  */
 338 void
 339 SPObject::_updateTotalHRefCount(int increment) {
 340     SPObject *topmost_collectable = NULL;
 341     for ( SPObject *iter = this ; iter ; iter = SP_OBJECT_PARENT(iter) ) {
 342         iter->_total_hrefcount += increment;
 343         if ( iter->_total_hrefcount < iter->hrefcount ) {
 344             g_critical("HRefs overcounted");
 345         }
 346         if ( iter->_total_hrefcount == 0 &&
 347              iter->_collection_policy != COLLECT_WITH_PARENT )
 348         {
 349             topmost_collectable = iter;
 350         }
 351     }
 352     if (topmost_collectable) {
 353         topmost_collectable->requestOrphanCollection();
 354     }
 355 }
 356
 357 /**
 358  * True if object is non-NULL and this is some in/direct parent of object.
 359  */
 360 bool
 361 SPObject::isAncestorOf(SPObject const *object) const {
 362     g_return_val_if_fail(object != NULL, false);
 363     object = SP_OBJECT_PARENT(object);
 364     while (object) {
 365         if ( object == this ) {
 366             return true;
 367         }
 368         object = SP_OBJECT_PARENT(object);
 369     }
 370     return false;
 371 }
 372
 373 namespace {
 374
 375 bool same_objects(SPObject const &a, SPObject const &b) {
 376     return &a == &b;
 377 }
 378
 379 }
 380
 381 /**
 382  * Returns youngest object being parent to this and object.
 383  */
 384 SPObject const *
 385 SPObject::nearestCommonAncestor(SPObject const *object) const {
 386     g_return_val_if_fail(object != NULL, NULL);
 387
 388     using Inkscape::Algorithms::longest_common_suffix;
 389     return longest_common_suffix<SPObject::ConstParentIterator>(this, object, NULL, &same_objects);
 390 }
 391
 392 SPObject const *AncestorSon(SPObject const *obj, SPObject const *ancestor) {
 393     if (obj == NULL || ancestor == NULL)
 394         return NULL;
 395     if (SP_OBJECT_PARENT(obj) == ancestor)
 396         return obj;
 397     return AncestorSon(SP_OBJECT_PARENT(obj), ancestor);
 398 }
 399
 400 /**
 401  * Compares height of objects in tree.
 402  *
 403  * Works for different-parent objects, so long as they have a common ancestor.
 404  * \return \verbatim
 405  *    0    positions are equivalent
 406  *    1    first object's position is greater than the second
 407  *   -1    first object's position is less than the second   \endverbatim
 408  */
 409 int
 410 sp_object_compare_position(SPObject const *first, SPObject const *second)
 411 {
 412     if (first == second) return 0;
 413
 414     SPObject const *ancestor = first->nearestCommonAncestor(second);
 415     if (ancestor == NULL) return 0; // cannot compare, no common ancestor!
 416
 417     // we have an object and its ancestor (should not happen when sorting selection)
 418     if (ancestor == first)
 419         return 1;
 420     if (ancestor == second)
 421         return -1;
 422
 423     SPObject const *to_first = AncestorSon(first, ancestor);
 424     SPObject const *to_second = AncestorSon(second, ancestor);
 425
 426     g_assert(SP_OBJECT_PARENT(to_second) == SP_OBJECT_PARENT(to_first));
 427
 428     return sp_repr_compare_position(SP_OBJECT_REPR(to_first), SP_OBJECT_REPR(to_second));
 429 }
 430
 431
 432 /**
 433  * Append repr as child of this object.
 434  * \pre this is not a cloned object
 435  */
 436 SPObject *
 437 SPObject::appendChildRepr(Inkscape::XML::Node *repr) {
 438     if (!SP_OBJECT_IS_CLONED(this)) {
 439         SP_OBJECT_REPR(this)->appendChild(repr);
 440         return SP_OBJECT_DOCUMENT(this)->getObjectByRepr(repr);
 441     } else {
 442         g_critical("Attempt to append repr as child of cloned object");
 443         return NULL;
 444     }
 445 }
 446
 447 /**
 448  * Retrieves the children as a GSList object, optionally ref'ing the children
 449  * in the process, if add_ref is specified.
 450  */
 451 GSList *SPObject::childList(bool add_ref, Action) {
 452     GSList *l = NULL;
 453     for (SPObject *child = sp_object_first_child(this) ; child != NULL; child = SP_OBJECT_NEXT(child) ) {
 454         if (add_ref)
 455             g_object_ref (G_OBJECT (child));
 456
 457         l = g_slist_prepend (l, child);
 458     }
 459     return l;
 460
 461 }
 462
 463 /** Gets the label property for the object or a default if no label
 464  *  is defined.
 465  */
 466 gchar const *
 467 SPObject::label() const {
 468     return _label;
 469 }
 470
 471 /** Returns a default label property for the object. */
 472 gchar const *
 473 SPObject::defaultLabel() const {
 474     if (_label) {
 475         return _label;
 476     } else {
 477         if (!_default_label) {
 478             gchar const *id=SP_OBJECT_ID(this);
 479             if (id) {
 480                 _default_label = g_strdup_printf("#%s", id);
 481             } else {
 482                 _default_label = g_strdup_printf("<%s>", SP_OBJECT_REPR(this)->name());
 483             }
 484         }
 485         return _default_label;
 486     }
 487 }
 488
 489 /** Sets the label property for the object */
 490 void
 491 SPObject::setLabel(gchar const *label) {
 492     SP_OBJECT_REPR(this)->setAttribute("inkscape:label", label, false);
 493 }
 494
 495
 496 /** Queues the object for orphan collection */
 497 void
 498 SPObject::requestOrphanCollection() {
 499     g_return_if_fail(document != NULL);
 500     document->queueForOrphanCollection(this);
 501
 502     /** \todo
 503      * This is a temporary hack added to make fill&stroke rebuild its
 504      * gradient list when the defs are vacuumed.  gradient-vector.cpp
 505      * listens to the modified signal on defs, and now we give it that
 506      * signal.  Mental says that this should be made automatic by
 507      * merging SPObjectGroup with SPObject; SPObjectGroup would issue
 508      * this signal automatically. Or maybe just derive SPDefs from
 509      * SPObjectGroup?
 510      */
 511
 512     this->requestModified(SP_OBJECT_CHILD_MODIFIED_FLAG);
 513 }
 514
 515 /** Sends the delete signal to all children of this object recursively */
 516 void
 517 SPObject::_sendDeleteSignalRecursive() {
 518     for (SPObject *child = sp_object_first_child(this); child; child = SP_OBJECT_NEXT(child)) {
 519         child->_delete_signal.emit(child);
 520         child->_sendDeleteSignalRecursive();
 521     }
 522 }
 523
 524 /**
 525  * Deletes the object reference, unparenting it from its parent.
 526  *
 527  * If the \a propagate parameter is set to true, it emits a delete
 528  * signal.  If the \a propagate_descendants parameter is true, it
 529  * recursively sends the delete signal to children.
 530  */
 531 void
 532 SPObject::deleteObject(bool propagate, bool propagate_descendants)
 533 {
 534     sp_object_ref(this, NULL);
 535     if (propagate) {
 536         _delete_signal.emit(this);
 537     }
 538     if (propagate_descendants) {
 539         this->_sendDeleteSignalRecursive();
 540     }
 541
 542     Inkscape::XML::Node *repr=SP_OBJECT_REPR(this);
 543     if (repr && sp_repr_parent(repr)) {
 544         sp_repr_unparent(repr);
 545     }
 546
 547     if (_successor) {
 548         _successor->deleteObject(propagate, propagate_descendants);
 549     }
 550     sp_object_unref(this, NULL);
 551 }
 552
 553 /**
 554  * Put object into object tree, under parent, and behind prev;
 555  * also update object's XML space.
 556  */
 557 void
 558 sp_object_attach(SPObject *parent, SPObject *object, SPObject *prev)
 559 {
 560     g_return_if_fail(parent != NULL);
 561     g_return_if_fail(SP_IS_OBJECT(parent));
 562     g_return_if_fail(object != NULL);
 563     g_return_if_fail(SP_IS_OBJECT(object));
 564     g_return_if_fail(!prev || SP_IS_OBJECT(prev));
 565     g_return_if_fail(!prev || prev->parent == parent);
 566     g_return_if_fail(!object->parent);
 567
 568     sp_object_ref(object, parent);
 569     object->parent = parent;
 570     parent->_updateTotalHRefCount(object->_total_hrefcount);
 571
 572     SPObject *next;
 573     if (prev) {
 574         next = prev->next;
 575         prev->next = object;
 576     } else {
 577         next = parent->children;
 578         parent->children = object;
 579     }
 580     object->next = next;
 581     if (!next) {
 582         parent->_last_child = object;
 583     }
 584     if (!object->xml_space.set)
 585         object->xml_space.value = parent->xml_space.value;
 586 }
 587
 588 /**
 589  * In list of object's siblings, move object behind prev.
 590  */
 591 void
 592 sp_object_reorder(SPObject *object, SPObject *prev) {
 593     g_return_if_fail(object != NULL);
 594     g_return_if_fail(SP_IS_OBJECT(object));
 595     g_return_if_fail(object->parent != NULL);
 596     g_return_if_fail(object != prev);
 597     g_return_if_fail(!prev || SP_IS_OBJECT(prev));
 598     g_return_if_fail(!prev || prev->parent == object->parent);
 599
 600     SPObject *const parent=object->parent;
 601
 602     SPObject *old_prev=NULL;
 603     for ( SPObject *child = parent->children ; child && child != object ;
 604           child = child->next )
 605     {
 606         old_prev = child;
 607     }
 608
 609     SPObject *next=object->next;
 610     if (old_prev) {
 611         old_prev->next = next;
 612     } else {
 613         parent->children = next;
 614     }
 615     if (!next) {
 616         parent->_last_child = old_prev;
 617     }
 618     if (prev) {
 619         next = prev->next;
 620         prev->next = object;
 621     } else {
 622         next = parent->children;
 623         parent->children = object;
 624     }
 625     object->next = next;
 626     if (!next) {
 627         parent->_last_child = object;
 628     }
 629 }
 630
 631 /**
 632  * Remove object from parent's children, release and unref it.
 633  */
 634 void
 635 sp_object_detach(SPObject *parent, SPObject *object) {
 636     g_return_if_fail(parent != NULL);
 637     g_return_if_fail(SP_IS_OBJECT(parent));
 638     g_return_if_fail(object != NULL);
 639     g_return_if_fail(SP_IS_OBJECT(object));
 640     g_return_if_fail(object->parent == parent);
 641
 642     object->releaseReferences();
 643
 644     SPObject *prev=NULL;
 645     for ( SPObject *child = parent->children ; child && child != object ;
 646           child = child->next )
 647     {
 648         prev = child;
 649     }
 650
 651     SPObject *next=object->next;
 652     if (prev) {
 653         prev->next = next;
 654     } else {
 655         parent->children = next;
 656     }
 657     if (!next) {
 658         parent->_last_child = prev;
 659     }
 660
 661     object->next = NULL;
 662     object->parent = NULL;
 663
 664     parent->_updateTotalHRefCount(-object->_total_hrefcount);
 665     sp_object_unref(object, parent);
 666 }
 667
 668 /**
 669  * Return object's child whose node pointer equals repr.
 670  */
 671 SPObject *
 672 sp_object_get_child_by_repr(SPObject *object, Inkscape::XML::Node *repr)
 673 {
 674     g_return_val_if_fail(object != NULL, NULL);
 675     g_return_val_if_fail(SP_IS_OBJECT(object), NULL);
 676     g_return_val_if_fail(repr != NULL, NULL);
 677
 678     if (object->_last_child && SP_OBJECT_REPR(object->_last_child) == repr)
 679         return object->_last_child;   // optimization for common scenario
 680     for ( SPObject *child = object->children ; child ; child = child->next ) {
 681         if ( SP_OBJECT_REPR(child) == repr ) {
 682             return child;
 683         }
 684     }
 685
 686     return NULL;
 687 }
 688
 689 /**
 690  * Callback for child_added event.
 691  * Invoked whenever the given mutation event happens in the XML tree.
 692  */
 693 static void
 694 sp_object_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
 695 {
 696     GType type = sp_repr_type_lookup(child);
 697     if (!type) {
 698         return;
 699     }
 700     SPObject *ochild = SP_OBJECT(g_object_new(type, 0));
 701     SPObject *prev = ref ? sp_object_get_child_by_repr(object, ref) : NULL;
 702     sp_object_attach(object, ochild, prev);
 703     sp_object_unref(ochild, NULL);
 704
 705     sp_object_invoke_build(ochild, object->document, child, SP_OBJECT_IS_CLONED(object));
 706 }
 707
 708 /**
 709  * Removes, releases and unrefs all children of object.
 710  *
 711  * This is the opposite of build. It has to be invoked as soon as the
 712  * object is removed from the tree, even if it is still alive according
 713  * to reference count. The frontend unregisters the object from the
 714  * document and releases the SPRepr bindings; implementations should free
 715  * state data and release all child objects.  Invoking release on
 716  * SPRoot destroys the whole document tree.
 717  * \see sp_object_build()
 718  */
 719 static void sp_object_release(SPObject *object)
 720 {
 721     debug("id=%x, typename=%s", object, g_type_name_from_instance((GTypeInstance*)object));
 722     while (object->children) {
 723         sp_object_detach(object, object->children);
 724     }
 725 }
 726
 727 /**
 728  * Remove object's child whose node equals repr, release and
 729  * unref it.
 730  *
 731  * Invoked whenever the given mutation event happens in the XML
 732  * tree, BEFORE removal from the XML tree happens, so grouping
 733  * objects can safely release the child data.
 734  */
 735 static void
 736 sp_object_remove_child(SPObject *object, Inkscape::XML::Node *child)
 737 {
 738     debug("id=%x, typename=%s", object, g_type_name_from_instance((GTypeInstance*)object));
 739     SPObject *ochild = sp_object_get_child_by_repr(object, child);
 740     g_return_if_fail (ochild != NULL || !strcmp("comment", child->name())); // comments have no objects
 741     if (ochild)
 742         sp_object_detach(object, ochild);
 743 }
 744
 745 /**
 746  * Move object corresponding to child after sibling object corresponding
 747  * to new_ref.
 748  * Invoked whenever the given mutation event happens in the XML tree.
 749  * \param old_ref Ignored
 750  */
 751 static void sp_object_order_changed(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *old_ref,
 752                                     Inkscape::XML::Node *new_ref)
 753 {
 754     SPObject *ochild = sp_object_get_child_by_repr(object, child);
 755     g_return_if_fail(ochild != NULL);
 756     SPObject *prev = new_ref ? sp_object_get_child_by_repr(object, new_ref) : NULL;
 757     sp_object_reorder(ochild, prev);
 758     ochild->_position_changed_signal.emit(ochild);
 759 }
 760
 761 /**
 762  * Virtual build callback.
 763  *
 764  * This has to be invoked immediately after creation of an SPObject. The
 765  * frontend method ensures that the new object is properly attached to
 766  * the document and repr; implementation then will parse all of the attributes,
 767  * generate the children objects and so on.  Invoking build on the SPRoot
 768  * object results in creation of the whole document tree (this is, what
 769  * SPDocument does after the creation of the XML tree).
 770  * \see sp_object_release()
 771  */
 772 static void
 773 sp_object_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
 774 {
 775     /* Nothing specific here */
 776     debug("id=%x, typename=%s", object, g_type_name_from_instance((GTypeInstance*)object));
 777
 778     sp_object_read_attr(object, "xml:space");
 779     sp_object_read_attr(object, "inkscape:label");
 780     sp_object_read_attr(object, "inkscape:collect");
 781
 782     for (Inkscape::XML::Node *rchild = repr->firstChild() ; rchild != NULL; rchild = rchild->next()) {
 783         GType type = sp_repr_type_lookup(rchild);
 784         if (!type) {
 785             continue;
 786         }
 787         SPObject *child = SP_OBJECT(g_object_new(type, 0));
 788         sp_object_attach(object, child, object->lastChild());
 789         sp_object_unref(child, NULL);
 790         sp_object_invoke_build(child, document, rchild, SP_OBJECT_IS_CLONED(object));
 791     }
 792 }
 793
 794 void
 795 sp_object_invoke_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr, unsigned int cloned)
 796 {
 797     debug("id=%x, typename=%s", object, g_type_name_from_instance((GTypeInstance*)object));
 798
 799     g_assert(object != NULL);
 800     g_assert(SP_IS_OBJECT(object));
 801     g_assert(document != NULL);
 802     g_assert(repr != NULL);
 803
 804     g_assert(object->document == NULL);
 805     g_assert(object->repr == NULL);
 806     g_assert(object->id == NULL);
 807
 808     /* Bookkeeping */
 809
 810     object->document = document;
 811     object->repr = repr;
 812     Inkscape::GC::anchor(repr);
 813     object->cloned = cloned;
 814
 815     if (!SP_OBJECT_IS_CLONED(object)) {
 816         object->document->bindObjectToRepr(object->repr, object);
 817
 818         if (Inkscape::XML::id_permitted(object->repr)) {
 819             /* If we are not cloned, force unique id */
 820             gchar const *id = object->repr->attribute("id");
 821             gchar *realid = sp_object_get_unique_id(object, id);
 822             g_assert(realid != NULL);
 823
 824             object->document->bindObjectToId(realid, object);
 825             object->id = realid;
 826
 827             /* Redefine ID, if required */
 828             if ((id == NULL) || (strcmp(id, realid) != 0)) {
 829                 bool saved = sp_document_get_undo_sensitive(document);
 830                 sp_document_set_undo_sensitive(document, false);
 831                 object->repr->setAttribute("id", realid);
 832                 sp_document_set_undo_sensitive(document, saved);
 833             }
 834         }
 835     } else {
 836         g_assert(object->id == NULL);
 837     }
 838
 839     /* Invoke derived methods, if any */
 840
 841     if (((SPObjectClass *) G_OBJECT_GET_CLASS(object))->build) {
 842         (*((SPObjectClass *) G_OBJECT_GET_CLASS(object))->build)(object, document, repr);
 843     }
 844
 845     /* Signalling (should be connected AFTER processing derived methods */
 846     sp_repr_add_listener(repr, &object_event_vector, object);
 847 }
 848
 849 void SPObject::releaseReferences() {
 850     g_assert(this->document);
 851     g_assert(this->repr);
 852
 853     sp_repr_remove_listener_by_data(this->repr, this);
 854
 855     this->_release_signal.emit(this);
 856     SPObjectClass *klass=(SPObjectClass *)G_OBJECT_GET_CLASS(this);
 857     if (klass->release) {
 858         klass->release(this);
 859     }
 860
 861     /* all hrefs should be released by the "release" handlers */
 862     g_assert(this->hrefcount == 0);
 863
 864     if (!SP_OBJECT_IS_CLONED(this)) {
 865         if (this->id) {
 866             this->document->bindObjectToId(this->id, NULL);
 867         }
 868         g_free(this->id);
 869         this->id = NULL;
 870
 871         g_free(this->_default_label);
 872         this->_default_label = NULL;
 873
 874         this->document->bindObjectToRepr(this->repr, NULL);
 875     } else {
 876         g_assert(!this->id);
 877     }
 878
 879     if (this->style) {
 880         this->style = sp_style_unref(this->style);
 881     }
 882
 883     Inkscape::GC::release(this->repr);
 884
 885     this->document = NULL;
 886     this->repr = NULL;
 887 }
 888
 889 /**
 890  * Callback for child_added node event.
 891  */
 892 static void
 893 sp_object_repr_child_added(Inkscape::XML::Node *repr, Inkscape::XML::Node *child, Inkscape::XML::Node *ref, gpointer data)
 894 {
 895     SPObject *object = SP_OBJECT(data);
 896
 897     if (((SPObjectClass *) G_OBJECT_GET_CLASS(object))->child_added)
 898         (*((SPObjectClass *)G_OBJECT_GET_CLASS(object))->child_added)(object, child, ref);
 899 }
 900
 901 /**
 902  * Callback for remove_child node event.
 903  */
 904 static void
 905 sp_object_repr_child_removed(Inkscape::XML::Node *repr, Inkscape::XML::Node *child, Inkscape::XML::Node *ref, gpointer data)
 906 {
 907     SPObject *object = SP_OBJECT(data);
 908
 909     if (((SPObjectClass *) G_OBJECT_GET_CLASS(object))->remove_child) {
 910         (* ((SPObjectClass *)G_OBJECT_GET_CLASS(object))->remove_child)(object, child);
 911     }
 912 }
 913
 914 /**
 915  * Callback for order_changed node event.
 916  *
 917  * \todo fixme:
 918  */
 919 static void
 920 sp_object_repr_order_changed(Inkscape::XML::Node *repr, Inkscape::XML::Node *child, Inkscape::XML::Node *old, Inkscape::XML::Node *newer, gpointer data)
 921 {
 922     SPObject *object = SP_OBJECT(data);
 923
 924     if (((SPObjectClass *) G_OBJECT_GET_CLASS(object))->order_changed) {
 925         (* ((SPObjectClass *)G_OBJECT_GET_CLASS(object))->order_changed)(object, child, old, newer);
 926     }
 927 }
 928
 929 /**
 930  * Callback for set event.
 931  */
 932 static void
 933 sp_object_private_set(SPObject *object, unsigned int key, gchar const *value)
 934 {
 935     g_assert(key != SP_ATTR_INVALID);
 936
 937     switch (key) {
 938         case SP_ATTR_ID:
 939             if ( !SP_OBJECT_IS_CLONED(object) && object->repr->type() == Inkscape::XML::ELEMENT_NODE ) {
 940                 SPDocument *document=object->document;
 941                 SPObject *conflict=NULL;
 942
 943                 if (value) {
 944                     conflict = document->getObjectById((char const *)value);
 945                 }
 946                 if ( conflict && conflict != object ) {
 947                     sp_object_ref(conflict, NULL);
 948                     // give the conflicting object a new ID
 949                     gchar *new_conflict_id = sp_object_get_unique_id(conflict, NULL);
 950                     SP_OBJECT_REPR(conflict)->setAttribute("id", new_conflict_id);
 951                     g_free(new_conflict_id);
 952                     sp_object_unref(conflict, NULL);
 953                 }
 954
 955                 if (object->id) {
 956                     document->bindObjectToId(object->id, NULL);
 957                     g_free(object->id);
 958                 }
 959
 960                 if (value) {
 961                     object->id = g_strdup((char const*)value);
 962                     document->bindObjectToId(object->id, object);
 963                 } else {
 964                     object->id = NULL;
 965                 }
 966
 967                 g_free(object->_default_label);
 968                 object->_default_label = NULL;
 969             }
 970             break;
 971         case SP_ATTR_INKSCAPE_LABEL:
 972             g_free(object->_label);
 973             if (value) {
 974                 object->_label = g_strdup(value);
 975             } else {
 976                 object->_label = NULL;
 977             }
 978             g_free(object->_default_label);
 979             object->_default_label = NULL;
 980             break;
 981         case SP_ATTR_INKSCAPE_COLLECT:
 982             if ( value && !strcmp(value, "always") ) {
 983                 object->setCollectionPolicy(SPObject::ALWAYS_COLLECT);
 984             } else {
 985                 object->setCollectionPolicy(SPObject::COLLECT_WITH_PARENT);
 986             }
 987             break;
 988         case SP_ATTR_XML_SPACE:
 989             if (value && !strcmp(value, "preserve")) {
 990                 object->xml_space.value = SP_XML_SPACE_PRESERVE;
 991                 object->xml_space.set = TRUE;
 992             } else if (value && !strcmp(value, "default")) {
 993                 object->xml_space.value = SP_XML_SPACE_DEFAULT;
 994                 object->xml_space.set = TRUE;
 995             } else if (object->parent) {
 996                 SPObject *parent;
 997                 parent = object->parent;
 998                 object->xml_space.value = parent->xml_space.value;
 999             }
1000             object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
1001             break;
1002         default:
1003             break;
1004     }
1005 }
1006
1007 /**
1008  * Call virtual set() function of object.
1009  */
1010 void
1011 sp_object_set(SPObject *object, unsigned int key, gchar const *value)
1012 {
1013     g_assert(object != NULL);
1014     g_assert(SP_IS_OBJECT(object));
1015
1016     if (((SPObjectClass *) G_OBJECT_GET_CLASS(object))->set) {
1017         ((SPObjectClass *) G_OBJECT_GET_CLASS(object))->set(object, key, value);
1018     }
1019 }
1020
1021 /**
1022  * Read value of key attribute from XML node into object.
1023  */
1024 void
1025 sp_object_read_attr(SPObject *object, gchar const *key)
1026 {
1027     g_assert(object != NULL);
1028     g_assert(SP_IS_OBJECT(object));
1029     g_assert(key != NULL);
1030
1031     g_assert(object->repr != NULL);
1032
1033     unsigned int keyid = sp_attribute_lookup(key);
1034     if (keyid != SP_ATTR_INVALID) {
1035         /* Retrieve the 'key' attribute from the object's XML representation */
1036         gchar const *value = object->repr->attribute(key);
1037
1038         sp_object_set(object, keyid, value);
1039     }
1040 }
1041
1042 /**
1043  * Callback for attr_changed node event.
1044  */
1045 static void
1046 sp_object_repr_attr_changed(Inkscape::XML::Node *repr, gchar const *key, gchar const *oldval, gchar const *newval, bool is_interactive, gpointer data)
1047 {
1048     SPObject *object = SP_OBJECT(data);
1049
1050     sp_object_read_attr(object, key);
1051
1052     // manual changes to extension attributes require the normal
1053     // attributes, which depend on them, to be updated immediately
1054     if (is_interactive) {
1055         object->updateRepr(repr, 0);
1056     }
1057 }
1058
1059 /**
1060  * Callback for content_changed node event.
1061  */
1062 static void
1063 sp_object_repr_content_changed(Inkscape::XML::Node *repr, gchar const *oldcontent, gchar const *newcontent, gpointer data)
1064 {
1065     SPObject *object = SP_OBJECT(data);
1066
1067     if (((SPObjectClass *) G_OBJECT_GET_CLASS(object))->read_content)
1068         (*((SPObjectClass *) G_OBJECT_GET_CLASS(object))->read_content)(object);
1069 }
1070
1071 /**
1072  * Return string representation of space value.
1073  */
1074 static gchar const*
1075 sp_xml_get_space_string(unsigned int space)
1076 {
1077     switch (space) {
1078         case SP_XML_SPACE_DEFAULT:
1079             return "default";
1080         case SP_XML_SPACE_PRESERVE:
1081             return "preserve";
1082         default:
1083             return NULL;
1084     }
1085 }
1086
1087 /**
1088  * Callback for write event.
1089  */
1090 static Inkscape::XML::Node *
1091 sp_object_private_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
1092 {
1093     if (!repr && (flags & SP_OBJECT_WRITE_BUILD)) {
1094         repr = SP_OBJECT_REPR(object)->duplicate();
1095         if (!( flags & SP_OBJECT_WRITE_EXT )) {
1096             repr->setAttribute("inkscape:collect", NULL);
1097         }
1098     } else {
1099         repr->setAttribute("id", object->id);
1100
1101         if (object->xml_space.set) {
1102             char const *xml_space;
1103             xml_space = sp_xml_get_space_string(object->xml_space.value);
1104             repr->setAttribute("xml:space", xml_space);
1105         }
1106
1107         if ( flags & SP_OBJECT_WRITE_EXT &&
1108              object->collectionPolicy() == SPObject::ALWAYS_COLLECT )
1109         {
1110             repr->setAttribute("inkscape:collect", "always");
1111         } else {
1112             repr->setAttribute("inkscape:collect", NULL);
1113         }
1114     }
1115
1116     return repr;
1117 }
1118
1119 /**
1120  * Update this object's XML node with flags value.
1121  */
1122 Inkscape::XML::Node *
1123 SPObject::updateRepr(unsigned int flags) {
1124     if (!SP_OBJECT_IS_CLONED(this)) {
1125         Inkscape::XML::Node *repr=SP_OBJECT_REPR(this);
1126         if (repr) {
1127             return updateRepr(repr, flags);
1128         } else {
1129             g_critical("Attempt to update non-existent repr");
1130             return NULL;
1131         }
1132     } else {
1133         /* cloned objects have no repr */
1134         return NULL;
1135     }
1136 }
1137
1138 Inkscape::XML::Node *
1139 SPObject::updateRepr(Inkscape::XML::Node *repr, unsigned int flags) {
1140     if (SP_OBJECT_IS_CLONED(this)) {
1141         /* cloned objects have no repr */
1142         return NULL;
1143     }
1144     if (((SPObjectClass *) G_OBJECT_GET_CLASS(this))->write) {
1145         if (!(flags & SP_OBJECT_WRITE_BUILD) && !repr) {
1146             repr = SP_OBJECT_REPR(this);
1147         }
1148         return ((SPObjectClass *) G_OBJECT_GET_CLASS(this))->write(this, repr, flags);
1149     } else {
1150         g_warning("Class %s does not implement ::write", G_OBJECT_TYPE_NAME(this));
1151         if (!repr) {
1152             if (flags & SP_OBJECT_WRITE_BUILD) {
1153                 repr = SP_OBJECT_REPR(this)->duplicate();
1154             }
1155             /// \todo fixme: else probably error (Lauris) */
1156         } else {
1157             repr->mergeFrom(SP_OBJECT_REPR(this), "id");
1158         }
1159         return repr;
1160     }
1161 }
1162
1163 /* Modification */
1164
1165 /**
1166  * Add \a flags to \a object's as dirtiness flags, and
1167  * recursively add CHILD_MODIFIED flag to
1168  * parent and ancestors (as far up as necessary).
1169  */
1170 void
1171 SPObject::requestDisplayUpdate(unsigned int flags)
1172 {
1173     g_return_if_fail( this->document != NULL );
1174
1175     if (update_in_progress) {
1176         g_print("WARNING: Requested update while update in progress, counter = %d\n", update_in_progress);
1177     }
1178
1179     /* requestModified must be used only to set one of SP_OBJECT_MODIFIED_FLAG or
1180      * SP_OBJECT_CHILD_MODIFIED_FLAG */
1181     g_return_if_fail(!(flags & SP_OBJECT_PARENT_MODIFIED_FLAG));
1182     g_return_if_fail((flags & SP_OBJECT_MODIFIED_FLAG) || (flags & SP_OBJECT_CHILD_MODIFIED_FLAG));
1183     g_return_if_fail(!((flags & SP_OBJECT_MODIFIED_FLAG) && (flags & SP_OBJECT_CHILD_MODIFIED_FLAG)));
1184
1185     bool already_propagated = (!(this->uflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG)));
1186
1187     this->uflags |= flags;
1188
1189     /* If requestModified has already been called on this object or one of its children, then we
1190      * don't need to set CHILD_MODIFIED on our ancestors because it's already been done.
1191      */
1192     if (already_propagated) {
1193         SPObject *parent = SP_OBJECT_PARENT(this);
1194         if (parent) {
1195             parent->requestDisplayUpdate(SP_OBJECT_CHILD_MODIFIED_FLAG);
1196         } else {
1197             sp_document_request_modified(SP_OBJECT_DOCUMENT(this));
1198         }
1199     }
1200 }
1201
1202 /**
1203  * Update views
1204  */
1205 void
1206 SPObject::updateDisplay(SPCtx *ctx, unsigned int flags)
1207 {
1208     g_return_if_fail(!(flags & ~SP_OBJECT_MODIFIED_CASCADE));
1209
1210     update_in_progress ++;
1211
1212 #ifdef SP_OBJECT_DEBUG_CASCADE
1213     g_print("Update %s:%s %x %x %x\n", g_type_name_from_instance((GTypeInstance *) this), SP_OBJECT_ID(this), flags, this->uflags, this->mflags);
1214 #endif
1215
1216     /* Get this flags */
1217     flags |= this->uflags;
1218     /* Copy flags to modified cascade for later processing */
1219     this->mflags |= this->uflags;
1220     /* We have to clear flags here to allow rescheduling update */
1221     this->uflags = 0;
1222
1223     // Merge style if we have good reasons to think that parent style is changed */
1224     /** \todo
1225      * I am not sure whether we should check only propagated
1226      * flag. We are currently assuming that style parsing is
1227      * done immediately. I think this is correct (Lauris).
1228      */
1229     if ((flags & SP_OBJECT_STYLE_MODIFIED_FLAG) && (flags & SP_OBJECT_PARENT_MODIFIED_FLAG)) {
1230         if (this->style && this->parent) {
1231             sp_style_merge_from_parent(this->style, this->parent->style);
1232         }
1233     }
1234
1235     if (((SPObjectClass *) G_OBJECT_GET_CLASS(this))->update)
1236         ((SPObjectClass *) G_OBJECT_GET_CLASS(this))->update(this, ctx, flags);
1237
1238     update_in_progress --;
1239 }
1240
1241 /**
1242  * Request modified always bubbles *up* the tree, as opposed to
1243  * request display update, which trickles down and relies on the
1244  * flags set during this pass...
1245  */
1246 void
1247 SPObject::requestModified(unsigned int flags)
1248 {
1249     g_return_if_fail( this->document != NULL );
1250
1251     /* requestModified must be used only to set one of SP_OBJECT_MODIFIED_FLAG or
1252      * SP_OBJECT_CHILD_MODIFIED_FLAG */
1253     g_return_if_fail(!(flags & SP_OBJECT_PARENT_MODIFIED_FLAG));
1254     g_return_if_fail((flags & SP_OBJECT_MODIFIED_FLAG) || (flags & SP_OBJECT_CHILD_MODIFIED_FLAG));
1255     g_return_if_fail(!((flags & SP_OBJECT_MODIFIED_FLAG) && (flags & SP_OBJECT_CHILD_MODIFIED_FLAG)));
1256
1257     bool already_propagated = (!(this->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG)));
1258
1259     this->mflags |= flags;
1260
1261     /* If requestModified has already been called on this object or one of its children, then we
1262      * don't need to set CHILD_MODIFIED on our ancestors because it's already been done.
1263      */
1264     if (already_propagated) {
1265         SPObject *parent=SP_OBJECT_PARENT(this);
1266         if (parent) {
1267             parent->requestModified(SP_OBJECT_CHILD_MODIFIED_FLAG);
1268         } else {
1269             sp_document_request_modified(SP_OBJECT_DOCUMENT(this));
1270         }
1271     }
1272 }
1273
1274 /**
1275  *  Emits the MODIFIED signal with the object's flags.
1276  *  The object's mflags are the original set aside during the update pass for
1277  *  later delivery here.  Once emitModified() is called, those flags don't
1278  *  need to be stored any longer.
1279  */
1280 void
1281 SPObject::emitModified(unsigned int flags)
1282 {
1283     /* only the MODIFIED_CASCADE flag is legal here */
1284     g_return_if_fail(!(flags & ~SP_OBJECT_MODIFIED_CASCADE));
1285
1286 #ifdef SP_OBJECT_DEBUG_CASCADE
1287     g_print("Modified %s:%s %x %x %x\n", g_type_name_from_instance((GTypeInstance *) this), SP_OBJECT_ID(this), flags, this->uflags, this->mflags);
1288 #endif
1289
1290     flags |= this->mflags;
1291     /* We have to clear mflags beforehand, as signal handlers may
1292      * make changes and therefore queue new modification notifications
1293      * themselves. */
1294     this->mflags = 0;
1295
1296     g_object_ref(G_OBJECT(this));
1297     SPObjectClass *klass=(SPObjectClass *)G_OBJECT_GET_CLASS(this);
1298     if (klass->modified) {
1299         klass->modified(this, flags);
1300     }
1301     _modified_signal.emit(this, flags);
1302     g_object_unref(G_OBJECT(this));
1303 }
1304
1305 /*
1306  * Get and set descriptive parameters
1307  *
1308  * These are inefficent, so they are not intended to be used interactively
1309  */
1310
1311 gchar const *
1312 sp_object_title_get(SPObject *object)
1313 {
1314     return NULL;
1315 }
1316
1317 gchar const *
1318 sp_object_description_get(SPObject *object)
1319 {
1320     return NULL;
1321 }
1322
1323 unsigned int
1324 sp_object_title_set(SPObject *object, gchar const *title)
1325 {
1326     return FALSE;
1327 }
1328
1329 unsigned int
1330 sp_object_description_set(SPObject *object, gchar const *desc)
1331 {
1332     return FALSE;
1333 }
1334
1335 gchar const *
1336 sp_object_tagName_get(SPObject const *object, SPException *ex)
1337 {
1338     /* If exception is not clear, return */
1339     if (!SP_EXCEPTION_IS_OK(ex)) {
1340         return NULL;
1341     }
1342
1343     /// \todo fixme: Exception if object is NULL? */
1344     return object->repr->name();
1345 }
1346
1347 gchar const *
1348 sp_object_getAttribute(SPObject const *object, gchar const *key, SPException *ex)
1349 {
1350     /* If exception is not clear, return */
1351     if (!SP_EXCEPTION_IS_OK(ex)) {
1352         return NULL;
1353     }
1354
1355     /// \todo fixme: Exception if object is NULL? */
1356     return (gchar const *) object->repr->attribute(key);
1357 }
1358
1359 void
1360 sp_object_setAttribute(SPObject *object, gchar const *key, gchar const *value, SPException *ex)
1361 {
1362     /* If exception is not clear, return */
1363     g_return_if_fail(SP_EXCEPTION_IS_OK(ex));
1364
1365     /// \todo fixme: Exception if object is NULL? */
1366     if (!sp_repr_set_attr(object->repr, key, value)) {
1367         ex->code = SP_NO_MODIFICATION_ALLOWED_ERR;
1368     }
1369 }
1370
1371 void
1372 sp_object_removeAttribute(SPObject *object, gchar const *key, SPException *ex)
1373 {
1374     /* If exception is not clear, return */
1375     g_return_if_fail(SP_EXCEPTION_IS_OK(ex));
1376
1377     /// \todo fixme: Exception if object is NULL? */
1378     if (!sp_repr_set_attr(object->repr, key, NULL)) {
1379         ex->code = SP_NO_MODIFICATION_ALLOWED_ERR;
1380     }
1381 }
1382
1383 /* Helper */
1384
1385 static gchar *
1386 sp_object_get_unique_id(SPObject *object, gchar const *id)
1387 {
1388     static unsigned long count = 0;
1389
1390     g_assert(SP_IS_OBJECT(object));
1391
1392     count++;
1393
1394     gchar const *name = object->repr->name();
1395     g_assert(name != NULL);
1396
1397     gchar const *local = strchr(name, ':');
1398     if (local) {
1399         name = local + 1;
1400     }
1401
1402     if (id != NULL) {
1403         if (object->document->getObjectById(id) == NULL) {
1404             return g_strdup(id);
1405         }
1406     }
1407
1408     size_t const name_len = strlen(name);
1409     size_t const buflen = name_len + (sizeof(count) * 10 / 4) + 1;
1410     gchar *const buf = (gchar *) g_malloc(buflen);
1411     memcpy(buf, name, name_len);
1412     gchar *const count_buf = buf + name_len;
1413     size_t const count_buflen = buflen - name_len;
1414     do {
1415         ++count;
1416         g_snprintf(count_buf, count_buflen, "%lu", count);
1417     } while ( object->document->getObjectById(buf) != NULL );
1418     return buf;
1419 }
1420
1421 /* Style */
1422
1423 /**
1424  * Returns an object style property.
1425  *
1426  * \todo
1427  * fixme: Use proper CSS parsing.  The current version is buggy
1428  * in a number of situations where key is a substring of the
1429  * style string other than as a property name (including
1430  * where key is a substring of a property name), and is also
1431  * buggy in its handling of inheritance for properties that
1432  * aren't inherited by default.  It also doesn't allow for
1433  * the case where the property is specified but with an invalid
1434  * value (in which case I believe the CSS2 error-handling
1435  * behaviour applies, viz. behave as if the property hadn't
1436  * been specified).  Also, the current code doesn't use CRSelEng
1437  * stuff to take a value from stylesheets.  Also, we aren't
1438  * setting any hooks to force an update for changes in any of
1439  * the inputs (i.e., in any of the elements that this function
1440  * queries).
1441  *
1442  * \par
1443  * Given that the default value for a property depends on what
1444  * property it is (e.g., whether to inherit or not), and given
1445  * the above comment about ignoring invalid values, and that the
1446  * repr parent isn't necessarily the right element to inherit
1447  * from (e.g., maybe we need to inherit from the referencing
1448  * <use> element instead), we should probably make the caller
1449  * responsible for ascending the repr tree as necessary.
1450  */
1451 gchar const *
1452 sp_object_get_style_property(SPObject const *object, gchar const *key, gchar const *def)
1453 {
1454     g_return_val_if_fail(object != NULL, NULL);
1455     g_return_val_if_fail(SP_IS_OBJECT(object), NULL);
1456     g_return_val_if_fail(key != NULL, NULL);
1457
1458     gchar const *style = object->repr->attribute("style");
1459     if (style) {
1460         size_t const len = strlen(key);
1461         char const *p;
1462         while ( (p = strstr(style, key))
1463                 != NULL )
1464         {
1465             p += len;
1466             while ((*p <= ' ') && *p) p++;
1467             if (*p++ != ':') break;
1468             while ((*p <= ' ') && *p) p++;
1469             size_t const inherit_len = sizeof("inherit") - 1;
1470             if (*p
1471                 && !(strneq(p, "inherit", inherit_len)
1472                      && (p[inherit_len] == '\0'
1473                          || p[inherit_len] == ';'
1474                          || g_ascii_isspace(p[inherit_len])))) {
1475                 return p;
1476             }
1477         }
1478     }
1479     gchar const *val = object->repr->attribute(key);
1480     if (val && !streq(val, "inherit")) {
1481         return val;
1482     }
1483     if (object->parent) {
1484         return sp_object_get_style_property(object->parent, key, def);
1485     }
1486
1487     return def;
1488 }
1489
1490 /**
1491  * Lifts SVG version of all root objects to version.
1492  */
1493 void
1494 SPObject::_requireSVGVersion(Inkscape::Version version) {
1495     for ( SPObject::ParentIterator iter=this ; iter ; ++iter ) {
1496         SPObject *object=iter;
1497         if (SP_IS_ROOT(object)) {
1498             SPRoot *root=SP_ROOT(object);
1499             if ( root->version.svg < version ) {
1500                 root->version.svg = version;
1501             }
1502         }
1503     }
1504 }
1505
1506 /**
1507  * Return sodipodi version of first root ancestor or (0,0).
1508  */
1509 Inkscape::Version
1510 sp_object_get_sodipodi_version(SPObject *object)
1511 {
1512     static Inkscape::Version const zero_version(0, 0);
1513
1514     while (object) {
1515         if (SP_IS_ROOT(object)) {
1516             return SP_ROOT(object)->version.sodipodi;
1517         }
1518         object = SP_OBJECT_PARENT(object);
1519     }
1520
1521     return zero_version;
1522 }
1523
1524 /**
1525  * Returns previous object in sibling list or NULL.
1526  */
1527 SPObject *
1528 sp_object_prev(SPObject *child)
1529 {
1530     SPObject *parent = SP_OBJECT_PARENT(child);
1531     for ( SPObject *i = sp_object_first_child(parent); i; i = SP_OBJECT_NEXT(i) ) {
1532         if (SP_OBJECT_NEXT(i) == child)
1533             return i;
1534     }
1535     return NULL;
1536 }
1537
1538
1539 /*
1540   Local Variables:
1541   mode:c++
1542   c-file-style:"stroustrup"
1543   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1544   indent-tabs-mode:nil
1545   fill-column:99
1546   End:
1547 */
1548 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :