Combined some classes.

(bzr r11608.1.75)

1 files changed, 114 insertions, 136 deletions

diff --git a/src/sp-path.cpp b/src/sp-path.cpp
index 394b815fb..06167e6dd 100644
--- a/src/sp-path.cpp
+++ b/src/sp-path.cpp
@@ -66,24 +66,26 @@ gint SPPath::nodesInPath() const
     return _curve ? _curve->nodes_in_path() : 0;
 }
 
-gchar* CPath::description() {
-	SPPath* item = this->sppath;
-
-    int count = SP_PATH(item)->nodesInPath();
-    if (SP_IS_LPE_ITEM(item) && sp_lpe_item_has_path_effect(SP_LPE_ITEM(item))) {
-
+gchar* SPPath::description() {
+    int count = this->nodesInPath();
+    
+    if (sp_lpe_item_has_path_effect(this)) {
         Glib::ustring s;
-
-        PathEffectList effect_list =  sp_lpe_item_get_effect_list(SP_LPE_ITEM(item));
+        PathEffectList effect_list =  sp_lpe_item_get_effect_list(this);
+        
         for (PathEffectList::iterator it = effect_list.begin(); it != effect_list.end(); ++it)
         {
             LivePathEffectObject *lpeobj = (*it)->lpeobject;
-            if (!lpeobj || !lpeobj->get_lpe())
+            
+            if (!lpeobj || !lpeobj->get_lpe()) {
                 break;
-            if (s.empty())
+            }
+            
+            if (s.empty()) {
                 s = lpeobj->get_lpe()->getName();
-            else
+            } else {
                 s = s + ", " + lpeobj->get_lpe()->getName();
+            }
         }
 
         return g_strdup_printf(ngettext("<b>Path</b> (%i node, path effect: %s)",
@@ -94,19 +96,16 @@ gchar* CPath::description() {
     }
 }
 
-void CPath::convert_to_guides() {
-	SPPath* item = this->sppath;
-    SPPath *path = item;
-
-    if (!path->_curve) {
+void SPPath::convert_to_guides() {
+    if (!this->_curve) {
         return;
     }
 
     std::list<std::pair<Geom::Point, Geom::Point> > pts;
 
-    Geom::Affine const i2dt(path->i2dt_affine());
-
-    Geom::PathVector const & pv = path->_curve->get_pathvector();
+    Geom::Affine const i2dt(this->i2dt_affine());
+    Geom::PathVector const & pv = this->_curve->get_pathvector();
+    
     for(Geom::PathVector::const_iterator pit = pv.begin(); pit != pv.end(); ++pit) {
         for(Geom::Path::const_iterator cit = pit->begin(); cit != pit->end_default(); ++cit) {
             // only add curves for straight line segments
@@ -117,121 +116,106 @@ void CPath::convert_to_guides() {
         }
     }
 
-    sp_guide_pt_pairs_to_guides(item->document, pts);
+    sp_guide_pt_pairs_to_guides(this->document, pts);
 }
 
-CPath::CPath(SPPath* path) : CShape(path) {
-	this->sppath = path;
-}
-
-CPath::~CPath() {
-}
-
-SPPath::SPPath() : SPShape(), connEndPair(this) {
-	SPPath* path = this;
-
-	path->cpath = new CPath(path);
-	path->typeHierarchy.insert(typeid(SPPath));
-
-	delete path->cshape;
-	path->cshape = path->cpath;
-	path->clpeitem = path->cpath;
-	path->citem = path->cpath;
-	path->cobject = path->cpath;
+SPPath::SPPath() : SPShape(), CShape(this), connEndPair(this) {
+	delete this->cshape;
+	this->cshape = this;
+	this->clpeitem = this;
+	this->citem = this;
+	this->cobject = this;
 }
 
 SPPath::~SPPath() {
 }
 
-void CPath::build(SPDocument *document, Inkscape::XML::Node *repr) {
-	SPPath* object = this->sppath;
-
+void SPPath::build(SPDocument *document, Inkscape::XML::Node *repr) {
     /* Are these calls actually necessary? */
-    object->readAttr( "marker" );
-    object->readAttr( "marker-start" );
-    object->readAttr( "marker-mid" );
-    object->readAttr( "marker-end" );
+    this->readAttr( "marker" );
+    this->readAttr( "marker-start" );
+    this->readAttr( "marker-mid" );
+    this->readAttr( "marker-end" );
 
-    sp_conn_end_pair_build(object);
+    sp_conn_end_pair_build(this);
 
     CShape::build(document, repr);
 
-    object->readAttr( "inkscape:original-d" );
-    object->readAttr( "d" );
+    this->readAttr( "inkscape:original-d" );
+    this->readAttr( "d" );
 
     /* d is a required attribute */
-    gchar const *d = object->getAttribute("d", NULL);
+    gchar const *d = this->getAttribute("d", NULL);
+
     if (d == NULL) {
-        object->setKeyValue( sp_attribute_lookup("d"), "");
+        this->setKeyValue( sp_attribute_lookup("d"), "");
     }
 }
 
-void CPath::release() {
-	SPPath* object = this->sppath;
-    SPPath *path = object;
-
-    path->connEndPair.release();
+void SPPath::release() {
+    this->connEndPair.release();
 
     CShape::release();
 }
 
-
-void CPath::set(unsigned int key, const gchar* value) {
-	SPPath* object = this->sppath;
-    SPPath *path = (SPPath *) object;
-
+void SPPath::set(unsigned int key, const gchar* value) {
     switch (key) {
         case SP_ATTR_INKSCAPE_ORIGINAL_D:
-                if (value) {
-                    Geom::PathVector pv = sp_svg_read_pathv(value);
-                    SPCurve *curve = new SPCurve(pv);
-                    if (curve) {
-                        path->set_original_curve(curve, TRUE, true);
-                        curve->unref();
-                    }
-                } else {
-                    path->set_original_curve(NULL, TRUE, true);
-                }
-                object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+			if (value) {
+				Geom::PathVector pv = sp_svg_read_pathv(value);
+				SPCurve *curve = new SPCurve(pv);
+
+				if (curve) {
+					this->set_original_curve(curve, TRUE, true);
+					curve->unref();
+				}
+			} else {
+				this->set_original_curve(NULL, TRUE, true);
+			}
+
+			this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
             break;
+
        case SP_ATTR_D:
-                if (value) {
-                    Geom::PathVector pv = sp_svg_read_pathv(value);
-                    SPCurve *curve = new SPCurve(pv);
-                    if (curve) {
-                        ((SPShape *) path)->setCurve(curve, TRUE);
-                        curve->unref();
-                    }
-                } else {
-                    ((SPShape *) path)->setCurve(NULL, TRUE);
-                }
-                object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+			if (value) {
+				Geom::PathVector pv = sp_svg_read_pathv(value);
+				SPCurve *curve = new SPCurve(pv);
+
+				if (curve) {
+					this->setCurve(curve, TRUE);
+					curve->unref();
+				}
+			} else {
+				this->setCurve(NULL, TRUE);
+			}
+
+			this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
             break;
+
         case SP_PROP_MARKER:
         case SP_PROP_MARKER_START:
         case SP_PROP_MARKER_MID:
         case SP_PROP_MARKER_END:
-            sp_shape_set_marker(object, key, value);
-            object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+            sp_shape_set_marker(this, key, value);
+            this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
             break;
+
         case SP_ATTR_CONNECTOR_TYPE:
         case SP_ATTR_CONNECTOR_CURVATURE:
         case SP_ATTR_CONNECTION_START:
         case SP_ATTR_CONNECTION_END:
         case SP_ATTR_CONNECTION_START_POINT:
         case SP_ATTR_CONNECTION_END_POINT:
-            path->connEndPair.setAttr(key, value);
+            this->connEndPair.setAttr(key, value);
             break;
+
         default:
             CShape::set(key, value);
             break;
     }
 }
 
-Inkscape::XML::Node* CPath::write(Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags) {
-	SPPath* object = this->sppath;
-	SPShape *shape = (SPShape *) object;
-
+Inkscape::XML::Node* SPPath::write(Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags) {
     if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
         repr = xml_doc->createElement("svg:path");
     }
@@ -239,8 +223,9 @@ Inkscape::XML::Node* CPath::write(Inkscape::XML::Document *xml_doc, Inkscape::XM
 #ifdef PATH_VERBOSE
 g_message("sp_path_write writes 'd' attribute");
 #endif
-    if ( shape->_curve != NULL ) {
-        gchar *str = sp_svg_write_path(shape->_curve->get_pathvector());
+
+    if ( this->_curve != NULL ) {
+        gchar *str = sp_svg_write_path(this->_curve->get_pathvector());
         repr->setAttribute("d", str);
         g_free(str);
     } else {
@@ -248,8 +233,8 @@ g_message("sp_path_write writes 'd' attribute");
     }
 
     if (flags & SP_OBJECT_WRITE_EXT) {
-        if ( shape->_curve_before_lpe != NULL ) {
-            gchar *str = sp_svg_write_path(shape->_curve_before_lpe->get_pathvector());
+        if ( this->_curve_before_lpe != NULL ) {
+            gchar *str = sp_svg_write_path(this->_curve_before_lpe->get_pathvector());
             repr->setAttribute("inkscape:original-d", str);
             g_free(str);
         } else {
@@ -257,94 +242,82 @@ g_message("sp_path_write writes 'd' attribute");
         }
     }
 
-    SP_PATH(shape)->connEndPair.writeRepr(repr);
+    this->connEndPair.writeRepr(repr);
 
     CShape::write(xml_doc, repr, flags);
 
     return repr;
 }
 
-void CPath::update(SPCtx *ctx, guint flags) {
-	SPPath* object = this->sppath;
-
+void SPPath::update(SPCtx *ctx, guint flags) {
 	if (flags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG | SP_OBJECT_VIEWPORT_MODIFIED_FLAG)) {
-	        flags &= ~SP_OBJECT_USER_MODIFIED_FLAG_B; // since we change the description, it's not a "just translation" anymore
-	    }
+		flags &= ~SP_OBJECT_USER_MODIFIED_FLAG_B; // since we change the description, it's not a "just translation" anymore
+	}
 
-	    CShape::update(ctx, flags);
+	CShape::update(ctx, flags);
 
-	    SPPath *path = SP_PATH(object);
-	    path->connEndPair.update();
+	this->connEndPair.update();
 }
 
-
-Geom::Affine CPath::set_transform(Geom::Affine const &transform) {
-	SPPath* item = this->sppath;
-
-    if (!SP_IS_PATH(item)) {
+Geom::Affine SPPath::set_transform(Geom::Affine const &transform) {
+    if (!this->_curve) { // 0 nodes, nothing to transform
         return Geom::identity();
     }
-    SPPath *path = SP_PATH(item);
 
-    if (!path->_curve) { // 0 nodes, nothing to transform
-        return Geom::identity();
-    }
-
-    // Transform the original-d path if this is a valid LPE item, other else the (ordinary) path
-    if (path->_curve_before_lpe && sp_lpe_item_has_path_effect_recursive(SP_LPE_ITEM(item))) {
-        if (sp_lpe_item_has_path_effect_of_type(SP_LPE_ITEM(item), Inkscape::LivePathEffect::CLONE_ORIGINAL)) {
+    // Transform the original-d path if this is a valid LPE this, other else the (ordinary) path
+    if (this->_curve_before_lpe && sp_lpe_item_has_path_effect_recursive(this)) {
+        if (sp_lpe_item_has_path_effect_of_type(this, Inkscape::LivePathEffect::CLONE_ORIGINAL)) {
             // if path has the CLONE_ORIGINAL LPE applied, don't write the transform to the pathdata, but write it 'unoptimized'
             return transform;
         } else {
-            path->_curve_before_lpe->transform(transform);
+        	this->_curve_before_lpe->transform(transform);
         }
     } else {
-        path->_curve->transform(transform);
+    	this->_curve->transform(transform);
     }
 
     // Adjust stroke
-    item->adjust_stroke(transform.descrim());
+    this->adjust_stroke(transform.descrim());
 
     // Adjust pattern fill
-    item->adjust_pattern(transform);
+    this->adjust_pattern(transform);
 
     // Adjust gradient fill
-    item->adjust_gradient(transform);
+    this->adjust_gradient(transform);
 
     // Adjust LPE
-    item->adjust_livepatheffect(transform);
+    this->adjust_livepatheffect(transform);
 
-    item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
+    this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
 
     // nothing remains - we've written all of the transform, so return identity
     return Geom::identity();
 }
 
 
-void CPath::update_patheffect(bool write) {
-	SPPath* lpeitem = this->sppath;
-    SPShape * const shape = (SPShape *) lpeitem;
-
-    Inkscape::XML::Node *repr = shape->getRepr();
+void SPPath::update_patheffect(bool write) {
+    Inkscape::XML::Node *repr = this->getRepr();
 
 #ifdef PATH_VERBOSE
 g_message("sp_path_update_patheffect");
 #endif
 
-    if (shape->_curve_before_lpe && sp_lpe_item_has_path_effect_recursive(lpeitem)) {
-        SPCurve *curve = shape->_curve_before_lpe->copy();
+    if (this->_curve_before_lpe && sp_lpe_item_has_path_effect_recursive(this)) {
+        SPCurve *curve = this->_curve_before_lpe->copy();
         /* if a path has an lpeitem applied, then reset the curve to the _curve_before_lpe.
          * This is very important for LPEs to work properly! (the bbox might be recalculated depending on the curve in shape)*/
-        shape->setCurveInsync(curve, TRUE);
+        this->setCurveInsync(curve, TRUE);
+
+        bool success = sp_lpe_item_perform_path_effect(this, curve);
 
-        bool success = sp_lpe_item_perform_path_effect(SP_LPE_ITEM(shape), curve);
         if (success && write) {
-            // could also do shape->getRepr()->updateRepr();  but only the d attribute needs updating.
+            // could also do this->getRepr()->updateRepr();  but only the d attribute needs updating.
 #ifdef PATH_VERBOSE
 g_message("sp_path_update_patheffect writes 'd' attribute");
 #endif
-            if ( shape->_curve != NULL ) {
-                gchar *str = sp_svg_write_path(shape->_curve->get_pathvector());
+
+            if ( this->_curve != NULL ) {
+                gchar *str = sp_svg_write_path(this->_curve->get_pathvector());
                 repr->setAttribute("d", str);
                 g_free(str);
             } else {
@@ -355,13 +328,15 @@ g_message("sp_path_update_patheffect writes 'd' attribute");
             if (gchar const * value = repr->attribute("d")) {
                 Geom::PathVector pv = sp_svg_read_pathv(value);
                 SPCurve *oldcurve = new SPCurve(pv);
+
                 if (oldcurve) {
-                    shape->setCurve(oldcurve, TRUE);
+                    this->setCurve(oldcurve, TRUE);
                     oldcurve->unref();
                 }
             }
         }
-        shape->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+
+        this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
         curve->unref();
     }
 }
@@ -380,6 +355,7 @@ void SPPath::set_original_curve (SPCurve *new_curve, unsigned int owner, bool wr
     if (_curve_before_lpe) {
         _curve_before_lpe = _curve_before_lpe->unref();
     }
+
     if (new_curve) {
         if (owner) {
             _curve_before_lpe = new_curve->ref();
@@ -387,6 +363,7 @@ void SPPath::set_original_curve (SPCurve *new_curve, unsigned int owner, bool wr
             _curve_before_lpe = new_curve->copy();
         }
     }
+
     sp_lpe_item_update_patheffect(this, true, write);
     requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
 }
@@ -399,6 +376,7 @@ SPCurve * SPPath::get_original_curve () const
     if (_curve_before_lpe) {
         return _curve_before_lpe->copy();
     }
+
     return NULL;
 }