Renaming of files in preparation for code style tools.

Signed-off-by: Michele Calgaro <[email protected]>
(cherry picked from commit 8b78a8791bc539bcffe7159f9d9714d577cb3d7d)

1 files changed, 1153 insertions, 0 deletions

diff --git a/karbon/core/vpath.cpp b/karbon/core/vpath.cpp
new file mode 100644
index 00000000..ea05fc76
--- /dev/null
+++ b/karbon/core/vpath.cpp
@@ -0,0 +1,1153 @@
+/* This file is part of the KDE project
+   Copyright (C) 2002, The Karbon Developers
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+*/
+
+
+#include <math.h>
+
+#include <tqdom.h>
+#include <tqvaluelist.h>
+#include <tqwmatrix.h>
+
+#include "vpath.h"
+#include "vsegment.h"
+#include "vvisitor.h"
+
+#include <kdebug.h>
+
+
+class VSubpathIteratorList
+{
+public:
+	VSubpathIteratorList()
+			: m_list( 0L ), m_iterator( 0L )
+	{}
+
+	~VSubpathIteratorList()
+	{
+		notifyClear( true );
+		delete m_list;
+	}
+
+	void add( VSubpathIterator* itr )
+	{
+		if( !m_iterator )
+			m_iterator = itr;
+		else if( m_list )
+			m_list->push_front( itr );
+		else
+		{
+			m_list = new TQValueList<VSubpathIterator*>;
+			m_list->push_front( itr );
+		}
+	}
+
+	void remove( VSubpathIterator* itr )
+	{
+		if( m_iterator == itr )
+			m_iterator = 0L;
+		else if( m_list )
+		{
+			m_list->remove( itr );
+
+			if( m_list->isEmpty() )
+			{
+				delete m_list;
+				m_list = 0L;
+			}
+		}
+	}
+
+	void notifyClear( bool zeroList )
+	{
+		if( m_iterator )
+		{
+			if( zeroList )
+				m_iterator->m_list = 0L;
+
+			m_iterator->m_current = 0L;
+		}
+
+		if( m_list )
+		{
+			for(
+				TQValueList<VSubpathIterator*>::Iterator itr = m_list->begin();
+				itr != m_list->end();
+				++itr )
+			{
+				if( zeroList )
+					( *itr )->m_list = 0L;
+
+				( *itr )->m_current = 0L;
+			}
+		}
+	}
+
+	void notifyRemove( VSegment* segment, VSegment* current )
+	{
+		if( m_iterator )
+		{
+			if( m_iterator->m_current == segment )
+				m_iterator->m_current = current;
+		}
+
+		if( m_list )
+		{
+			for(
+				TQValueList<VSubpathIterator*>::Iterator itr = m_list->begin();
+				itr != m_list->end();
+				++itr )
+			{
+				if( ( *itr )->m_current == segment )
+					( *itr )->m_current = current;
+			}
+		}
+	}
+
+private:
+	TQValueList<VSubpathIterator*>* m_list;
+	VSubpathIterator* m_iterator;
+};
+
+
+VSubpath::VSubpath( VObject* parent )
+		: VObject( parent )
+{
+	m_isClosed = false;
+
+	m_first = m_last = m_current = 0L;
+	m_number = 0;
+	m_currentIndex = -1;
+	m_iteratorList = 0L;
+
+	// Add an initial segment.
+	append( new VSegment( 1 ) );
+}
+
+VSubpath::VSubpath( const VSubpath& list )
+		: VObject( list )
+{
+	m_isClosed = list.isClosed();
+
+	m_first = m_last = m_current = 0L;
+	m_number = 0;
+	m_currentIndex = -1;
+	m_iteratorList = 0L;
+
+	VSegment* segment = list.m_first;
+
+	while( segment )
+	{
+		append( segment->clone() );
+		segment = segment->m_next;
+	}
+}
+
+VSubpath::VSubpath( const VSegment& segment )
+		: VObject( 0L )
+{
+	m_isClosed = false;
+
+	m_first = m_last = m_current = 0L;
+	m_number = 0;
+	m_currentIndex = -1;
+	m_iteratorList = 0L;
+
+	// The segment is not a "begin" segment.
+	if( segment.prev() )
+	{
+		// Add an initial segment.
+		append( new VSegment( 1 ) );
+
+		// Move the "begin" segment to the new segment's previous knot.
+		moveTo( segment.prev()->knot() );
+	}
+
+	// Append a copy of the segment.
+	append( segment.clone() );
+}
+
+VSubpath::~VSubpath()
+{
+	clear();
+	delete m_iteratorList;
+}
+
+const KoPoint&
+VSubpath::currentPoint() const
+{
+	return getLast()->knot();
+}
+
+bool
+VSubpath::moveTo( const KoPoint& p )
+{
+	// Move "begin" segment if path is still empty.
+	if( isEmpty() )
+	{
+		getLast()->setKnot( p );
+		return true;
+	}
+
+	return false;
+}
+
+bool
+VSubpath::lineTo( const KoPoint& p )
+{
+	if( isClosed() )
+		return false;
+
+	VSegment* s = new VSegment( 1 );
+
+	s->setDegree( 1 );
+	s->setKnot( p );
+
+	append( s );
+
+	return true;
+}
+
+bool
+VSubpath::curveTo(
+	const KoPoint& p1, const KoPoint& p2, const KoPoint& p3 )
+{
+	if( isClosed() )
+		return false;
+
+	VSegment* s = new VSegment();
+
+	s->setDegree( 3 );
+	s->setPoint( 0, p1 );
+	s->setPoint( 1, p2 );
+	s->setPoint( 2, p3 );
+
+	append( s );
+
+
+	return true;
+}
+
+bool
+VSubpath::curve1To( const KoPoint& p2, const KoPoint& p3 )
+{
+	if( isClosed() )
+		return false;
+
+	VSegment* s = new VSegment();
+
+	s->setDegree( 3 );
+	s->setPoint( 0, currentPoint() );
+	s->setPoint( 1, p2 );
+	s->setPoint( 2, p3 );
+
+	append( s );
+
+
+	return true;
+}
+
+bool
+VSubpath::curve2To( const KoPoint& p1, const KoPoint& p3 )
+{
+	if( isClosed() )
+		return false;
+
+	VSegment* s = new VSegment();
+
+	s->setDegree( 3 );
+	s->setPoint( 0, p1 );
+	s->setPoint( 1, p3 );
+	s->setPoint( 2, p3 );
+
+	append( s );
+
+
+	return true;
+}
+
+bool
+VSubpath::arcTo(
+	const KoPoint& p1, const KoPoint& p2, const double r )
+{
+	/* This routine is inspired by code in GNU ghostscript.
+	 *
+	 *           |- P1B3 -|
+	 *
+	 *          |- - - T12- - -|
+	 *
+	 *  -   - P1 x....__--o.....x P2
+	 *  |   |    :  _/    B3
+	 * P1B0      : /
+	 *      |    :/
+	 *  |        |
+	 *  -  T10   o B0
+	 *           |
+	 *      |    |
+	 *           |
+	 *      |    |
+	 *      -    x P0
+	 */
+
+	if( isClosed() || r < 0.0 )
+		return false;
+
+
+	// We need to calculate the tangent points. Therefore calculate tangents
+	// T10=P1P0 and T12=P1P2 first.
+	double dx0 = currentPoint().x() - p1.x();
+	double dy0 = currentPoint().y() - p1.y();
+	double dx2 = p2.x() - p1.x();
+	double dy2 = p2.y() - p1.y();
+
+	// Calculate distance squares.
+	double dsqT10 = dx0 * dx0 + dy0 * dy0;
+	double dsqT12 = dx2 * dx2 + dy2 * dy2;
+
+	// We now calculate tan(a/2) where a is the angle between T10 and T12.
+	// We benefit from the facts T10*T12 = |T10|*|T12|*cos(a),
+	// |T10xT12| = |T10|*|T12|*sin(a) (cross product) and tan(a/2) = sin(a)/[1-cos(a)].
+	double num = dy0 * dx2 - dy2 * dx0;
+
+	double denom = sqrt( dsqT10 * dsqT12 ) - ( dx0 * dx2 + dy0 * dy2 );
+
+	// The points are colinear.
+	if( 1.0 + denom == 1.0 )
+	{
+		// Just add a line.
+		lineTo( p1 );
+	}
+	else
+	{
+		// |P1B0| = |P1B3| = r * tan(a/2).
+		double dP1B0 = fabs( r * num / denom );
+
+		// B0 = P1 + |P1B0| * T10/|T10|.
+		KoPoint b0 = p1 + KoPoint( dx0, dy0 ) * ( dP1B0 / sqrt( dsqT10 ) );
+
+		// If B0 deviates from current point P0, add a line to it.
+		if( !b0.isNear( currentPoint(), VGlobal::isNearRange ) )
+			lineTo( b0 );
+
+		// B3 = P1 + |P1B3| * T12/|T12|.
+		KoPoint b3 = p1 + KoPoint( dx2, dy2 ) * ( dP1B0 / sqrt( dsqT12 ) );
+
+
+		// The two bezier-control points are located on the tangents at a fraction
+		// of the distance[ tangent points <-> tangent intersection ].
+		const KoPoint d = p1 - b0;
+
+		double distsq = d * d;
+
+		double rsq = r * r;
+
+		double fract;
+
+		// r is very small.
+		if( distsq >= rsq * VGlobal::veryBigNumber )
+		{
+			// Assume dist = r = 0.
+			fract = 0.0;
+		}
+		else
+		{
+			fract = ( 4.0 / 3.0 ) / ( 1.0 + sqrt( 1.0 + distsq / rsq ) );
+		}
+
+		KoPoint b1 = b0 + ( p1 - b0 ) * fract;
+		KoPoint b2 = b3 + ( p1 - b3 ) * fract;
+
+		// Finally add the bezier-segment.
+		curveTo( b1, b2, b3 );
+	}
+
+	return true;
+}
+
+void
+VSubpath::close()
+{
+	// In the case the list is 100% empty (which should actually never happen),
+	// append a "begin" first, to avoid a crash.
+	if( count() == 0 )
+		append( new VSegment( 1 ) );
+
+	// Move last segment if we are already closed.
+	if( isClosed() )
+	{
+		getLast()->setKnot( getFirst()->knot() );
+	}
+	// Append a line, if necessary.
+	else
+	{
+		if(
+			getLast()->knot().isNear(
+				getFirst()->knot(), VGlobal::isNearRange ) )
+		{
+			// Move last knot.
+			getLast()->setKnot( getFirst()->knot() );
+		}
+		else
+		{
+			// Add a line.
+			lineTo( getFirst()->knot() );
+		}
+
+		m_isClosed = true;
+	}
+}
+
+bool
+VSubpath::pointIsInside( const KoPoint& p ) const
+{
+	// If the point is not inside the boundingbox, it cannot be inside the path either.
+	if( !boundingBox().contains( p ) )
+		return false;
+
+	// First check if the point is inside the knot polygon (beziers are treated
+	// as lines).
+
+	/* This algorithm is taken from "Fast Winding Number Inclusion of a Point
+	 * in a Polygon" by Dan Sunday, geometryalgorithms.com.
+	 */
+
+	/*
+	int windingNumber = 0;
+
+	// Ommit first segment.
+	VSegment* segment = getFirst()->next();
+
+	while( segment )
+	{
+		if( segment->prev()->knot().y() <= p.y() )
+		{
+			// Upward crossing.
+			if( segment->knot().y() > p.y() )
+			{
+				// Point is left.
+				if( segment->pointIsLeft( p ) > 0 )
+				{
+					// Valid up intersection.
+					++windingNumber;
+				}
+			}
+		}
+		else
+		{
+			// Downward crossing.
+			if( segment->knot().y() <= p.y() )
+			{
+				// Point is right.
+				if( segment->pointIsLeft( p ) < 0 )
+				{
+					// Valid down intersection.
+					--windingNumber;
+				}
+			}
+		}
+
+		segment = segment->next();
+	}
+
+	if( static_cast<bool>( windingNumber ) )
+		return true;
+	*/
+	
+	// Then check if the point is located in between the knot polygon
+	// and the bezier curves.
+
+	/* We rotate each segment in order to make their chord (the line between
+	 * the previous knot and the knot ) parallel to the x-axis. Then we
+	 * calculate y(xp) on the segment for the rotated input point (xp,yp)
+	 * and compare y(xp) with yp.
+	 */
+// TODO
+	
+	// cache the closed evaluation
+	bool closed = isClosed() || getLast()->knot() == getFirst()->knot();
+
+	TQValueList<double> rparams;
+
+	VSegment* segment = getFirst()->next();
+
+	// move all segements so that p is the origin 
+	// and compute their intersections with the x-axis
+	while( segment )
+	{
+		VSubpath tmpCurve( 0L );
+		tmpCurve.append( new VSegment( segment->degree() ) );
+	
+		for( int i = 0; i <= segment->degree(); ++i )
+			tmpCurve.current()->setP(i, segment->p(i)-p );
+		
+		tmpCurve.current()->rootParams( rparams );
+
+		segment = segment->next();
+	}
+	
+	// if the path is not closed, compute the intersection of
+	// the line through the first and last knot and the x-axis too
+	if( ! closed )
+	{
+		KoPoint prevKnot = getLast()->knot() - p;
+		KoPoint nextKnot = getFirst()->knot() - p;
+
+		double dx = nextKnot.x() - prevKnot.x();
+		double dy = nextKnot.y() - prevKnot.y();
+		if( dx == 0.0 )
+		{
+			rparams.append( nextKnot.x() );
+		}
+		else if( dy != 0.0 )
+		{
+			if( ( prevKnot.y() < 0.0 && nextKnot.y() > 0.0 ) || ( prevKnot.y() > 0.0 && nextKnot.y() < 0.0 ) )
+			{
+				double n = prevKnot.y() - dy / dx * prevKnot.x();
+				rparams.append( -n * dx / dy );
+			}
+		}
+	}
+	
+	kdDebug(38000) << "intersection count: " << rparams.count() << endl;
+
+	// sort all intersections
+	qHeapSort( rparams );
+
+	TQValueList<double>::iterator itr, etr = rparams.end();
+	
+	for( itr = rparams.begin(); itr != etr; ++itr )
+		kdDebug(38000) << "intersection: " << *itr << endl;
+
+	if( closed )
+	{
+		// pair the intersections and check if the origin is within a pair
+		for( itr = rparams.begin(); itr != etr; ++itr )
+		{
+			if( *itr > 0.0 ) 
+				return false;
+	
+			if( ++itr == etr )
+				return false;
+			
+			if( *itr > 0.0 )
+				return true;
+		}
+	}
+	else
+	{
+		// only check if point is between first and last intersection if we have an open path
+		if ( rparams.front() < 0.0 && rparams.back() > 0.0 )
+			return true;
+	}
+
+	return false;
+}
+
+bool
+VSubpath::intersects( const VSegment& s ) const
+{
+	// Check if path is empty and if boundingboxes intersect.
+	if(
+		isEmpty() ||
+		!boundingBox().intersects( s.boundingBox() ) )
+	{
+		return false;
+	}
+
+
+	// Ommit first segment.
+	VSegment* segment = getFirst()->next();
+
+	while( segment )
+	{
+		if( segment->intersects( s ) )
+		{
+			return true;
+		}
+
+		segment = segment->next();
+	}
+
+	return false;
+}
+
+bool
+VSubpath::counterClockwise() const
+{
+	/* This algorithm is taken from the FAQ of comp.graphics.algorithms:
+	 * "Find the lowest vertex (or, if there is more than one vertex with the
+	 * same lowest coordinate, the rightmost of those vertices) and then take
+	 * the cross product of the edges fore and aft of it."
+	 */
+
+	// A non closed path does not have a winding.
+	if( !isClosed() )
+	{
+		return false;
+	}
+
+
+	VSegment* segment = getFirst();
+
+	// We save the segment not the knot itself. Initialize it with the
+	// first segment:
+	const VSegment* bottomRight = getFirst();
+
+	while( segment )
+	{
+		if( segment->knot().y() < bottomRight->knot().y() )
+			bottomRight = segment;
+		else if( segment->knot().y() - bottomRight->knot().y()
+				  < VGlobal::isNearRange )
+		{
+			if( segment->knot().x() > bottomRight->knot().x() )
+				bottomRight = segment;
+		}
+
+		segment = segment->next();
+	}
+
+
+	// Catch boundary case (bottomRight is first or last segment):
+	const VSegment* current;
+	const VSegment* next;
+
+	if( bottomRight == getFirst() )
+		current = getLast();
+	else
+		current = bottomRight;
+
+	if( bottomRight == getLast() )
+		next = getFirst()->next();
+	else
+		next = bottomRight->next();
+
+	// Check "z-component" of cross product:
+	return
+		( next->knot().x() - next->prev()->knot().x() ) *
+		( current->knot().y() - current->prev()->knot().y() )
+		-
+		( next->knot().y() - next->prev()->knot().y() ) *
+		( current->knot().x() - current->prev()->knot().x() ) < 0.0;
+}
+
+void
+VSubpath::revert()
+{
+	// Catch case where the list is "empty".
+	if( isEmpty() )
+		return;
+
+
+	VSubpath list( parent() );
+	list.moveTo( getLast()->knot() );
+
+	VSegment* segment = getLast();
+
+	while( segment->prev() )
+	{
+		list.append( segment->revert() );
+		segment = segment->prev();
+	}
+
+	list.m_isClosed = isClosed();
+
+	*this = list;
+}
+
+const KoRect&
+VSubpath::boundingBox() const
+{
+	if( m_boundingBoxIsInvalid )
+	{
+		// Reset the boundingbox.
+		m_boundingBox = KoRect();
+
+		VSegment* segment = m_first;
+
+		while( segment )
+		{
+			if( segment->state() != VSegment::deleted )
+				m_boundingBox |= segment->boundingBox();
+
+			segment = segment->m_next;
+		}
+
+		m_boundingBoxIsInvalid = false;
+	}
+
+	return m_boundingBox;
+}
+
+VSubpath*
+VSubpath::clone() const
+{
+	return new VSubpath( *this );
+}
+
+void
+VSubpath::saveSvgPath( TQString &d ) const
+{
+	// Save segments.
+	VSegment* segment = getFirst();
+
+	while( segment )
+	{
+		if( segment->state() == VSegment::normal )
+		{
+			if( segment->degree() <= 2 )
+			{
+				// Line.
+				if( segment->prev() )
+				{
+					d += TQString( "L%1 %2" ).
+							arg( segment->knot().x() ).arg( segment->knot().y() );
+				}
+				// Moveto.
+				else
+				{
+					d += TQString( "M%1 %2" ).
+							arg( segment->knot().x() ).arg( segment->knot().y() );
+				}
+			}
+			// Bezier ( degree >= 3 ).
+			else
+			{
+				// We currently treat all beziers as cubic beziers.
+				d += TQString( "C%1 %2 %3 %4 %5 %6" ).
+							arg( segment->point( segment->degree() - 3 ).x() ).
+							arg( segment->point( segment->degree() - 3 ).y() ).
+							arg( segment->point( segment->degree() - 2 ).x() ).
+							arg( segment->point( segment->degree() - 2 ).y() ).
+							arg( segment->knot().x() ).
+							arg( segment->knot().y() );
+			}
+		}
+
+		segment = segment->m_next;
+	}
+
+	if( isClosed() )
+		d += "Z";
+}
+
+// TODO: remove this backward compatibility function after koffice 1.3.x
+void
+VSubpath::load( const TQDomElement& element )
+{
+	// We might have a "begin" segment.
+	clear();
+
+	TQDomNodeList list = element.childNodes();
+
+	for( uint i = 0; i < list.count(); ++i )
+	{
+		if( list.item( i ).isElement() )
+		{
+			TQDomElement segment = list.item( i ).toElement();
+
+			VSegment* s = new VSegment();
+			s->load( segment );
+			append( s );
+		}
+	}
+
+	if( element.attribute( "isClosed" ) == 0 ? false : true )
+		close();
+}
+
+void
+VSubpath::accept( VVisitor& visitor )
+{
+	visitor.visitVSubpath( *this );
+}
+
+
+VSubpath&
+VSubpath::operator=( const VSubpath& list )
+{
+	if( this == &list )
+		return *this;
+
+	m_isClosed = list.isClosed();
+
+	clear();
+
+	VSegment* segment = list.m_first;
+
+	while( segment )
+	{
+		append( segment->clone() );
+		segment = segment->m_next;
+	}
+
+	m_current = m_first;
+	m_currentIndex = 0;
+
+	return *this;
+}
+
+bool
+VSubpath::insert( const VSegment* segment )
+{
+	if( m_currentIndex == -1 )
+		return false;
+
+	VSegment* s = const_cast<VSegment*>( segment );
+
+	VSegment* prev = m_current->m_prev;
+
+	m_current->m_prev = s;
+	prev->m_next = s;
+	s->m_prev = prev;
+	s->m_next = m_current;
+
+	m_current = s;
+	++m_number;
+
+	invalidateBoundingBox();
+
+	return true;
+}
+
+bool
+VSubpath::insert( uint index, const VSegment* segment )
+{
+	VSegment* s = const_cast<VSegment*>( segment );
+
+	if( index == 0 )
+	{
+		prepend( s );
+		return true;
+	}
+	else if( index == m_number )
+	{
+		append( s );
+		return true;
+	}
+
+	VSegment* next = locate( index );
+
+	if( !next )
+		return false;
+
+	VSegment* prev = next->m_prev;
+
+	next->m_prev = s;
+	prev->m_next = s;
+	s->m_prev = prev;
+	s->m_next = next;
+
+	m_current = s;
+	++m_number;
+
+	invalidateBoundingBox();
+
+	return true;
+}
+
+void
+VSubpath::prepend( const VSegment* segment )
+{
+	VSegment* s = const_cast<VSegment*>( segment );
+
+	s->m_prev = 0L;
+
+	if( ( s->m_next = m_first ) )
+		m_first->m_prev = s;
+	else
+		m_last = s;
+
+	m_first = m_current = s;
+
+	++m_number;
+	m_currentIndex = 0;
+
+	invalidateBoundingBox();
+}
+
+void
+VSubpath::append( const VSegment* segment )
+{
+	VSegment* s = const_cast<VSegment*>( segment );
+
+	s->m_next = 0L;
+
+	if( ( s->m_prev = m_last ) )
+		m_last->m_next = s;
+	else
+		m_first = s;
+
+	m_last = m_current = s;
+
+	m_currentIndex = m_number;
+	++m_number;
+
+	invalidateBoundingBox();
+}
+
+void
+VSubpath::clear()
+{
+	VSegment* segment = m_first;
+
+	m_first = m_last = m_current = 0L;
+	m_number = 0;
+	m_currentIndex = -1;
+
+	if( m_iteratorList )
+		m_iteratorList->notifyClear( false );
+
+	VSegment* prev;
+
+	while( segment )
+	{
+		prev = segment;
+		segment = segment->m_next;
+		delete prev;
+	}
+
+	m_isClosed = false;
+
+	invalidateBoundingBox();
+}
+
+VSegment*
+VSubpath::first()
+{
+	if( m_first )
+	{
+		m_currentIndex = 0;
+		return m_current = m_first;
+	}
+
+	return 0L;
+}
+
+VSegment*
+VSubpath::last()
+{
+	if( m_last )
+	{
+		m_currentIndex = m_number - 1;
+		return m_current = m_last;
+	}
+
+	return 0L;
+}
+
+VSegment*
+VSubpath::prev()
+{
+	if( m_current )
+	{
+		if( m_current->m_prev )
+		{
+			--m_currentIndex;
+			return m_current = m_current->m_prev;
+		}
+
+		m_currentIndex = -1;
+		m_current = 0L;
+	}
+
+	return 0L;
+}
+
+VSegment*
+VSubpath::next()
+{
+	if( m_current )
+	{
+		if( m_current->m_next )
+		{
+			++m_currentIndex;
+			return m_current = m_current->m_next;
+		}
+
+		m_currentIndex = -1;
+		m_current = 0L;
+	}
+
+	return 0L;
+}
+
+VSegment*
+VSubpath::locate( uint index )
+{
+	if( index == static_cast<uint>( m_currentIndex ) )
+		return m_current;
+
+	if( !m_current && m_first )
+	{
+		m_current = m_first;
+		m_currentIndex = 0;
+	}
+
+	VSegment* segment;
+	int distance = index - m_currentIndex;
+	bool forward;
+
+	if( index >= m_number )
+		return 0L;
+
+	if( distance < 0 )
+		distance = -distance;
+
+	if(
+		static_cast<uint>( distance ) < index &&
+		static_cast<uint>( distance ) < m_number - index )
+	{
+		segment = m_current;
+		forward = index > static_cast<uint>( m_currentIndex );
+	}
+	else if( index < m_number - index )
+	{
+		segment = m_first;
+		distance = index;
+		forward = true;
+	}
+	else
+	{
+		segment = m_last;
+		distance = m_number - index - 1;
+		if( distance < 0 )
+			distance = 0;
+		forward = false;
+	}
+
+	if( forward )
+	{
+		while( distance-- )
+			segment = segment->m_next;
+	}
+	else
+	{
+		while( distance-- )
+			segment = segment->m_prev;
+	}
+
+	m_currentIndex = index;
+	return m_current = segment;
+}
+
+
+VSubpathIterator::VSubpathIterator( const VSubpath& list )
+{
+	m_list = const_cast<VSubpath*>( &list );
+	m_current = m_list->m_first;
+
+	if( !m_list->m_iteratorList )
+		m_list->m_iteratorList = new VSubpathIteratorList();
+
+	m_list->m_iteratorList->add( this );
+}
+
+VSubpathIterator::VSubpathIterator( const VSubpathIterator& itr )
+{
+	m_list = itr.m_list;
+	m_current = itr.m_current;
+
+	if( m_list )
+		m_list->m_iteratorList->add( this );
+}
+
+VSubpathIterator::~VSubpathIterator()
+{
+	if( m_list )
+		m_list->m_iteratorList->remove( this );
+}
+
+VSubpathIterator&
+VSubpathIterator::operator=( const VSubpathIterator& itr )
+{
+	if( m_list )
+		m_list->m_iteratorList->remove( this );
+
+	m_list = itr.m_list;
+	m_current = itr.m_current;
+
+	if( m_list )
+		m_list->m_iteratorList->add( this );
+
+	return *this;
+}
+
+VSegment*
+VSubpathIterator::current() const
+{
+	// If m_current points to a deleted segment, find the next not
+	// deleted segment.
+	if(
+		m_current &&
+		m_current->state() == VSegment::deleted )
+	{
+		return m_current->next();
+	}
+
+	return m_current;
+}
+
+VSegment*
+VSubpathIterator::operator()()
+{
+	if( VSegment* const old = current() )
+	{
+		m_current = current()->next();
+		return old;
+	}
+
+	return 0L;
+}
+
+VSegment*
+VSubpathIterator::operator++()
+{
+	if( current() )
+		return m_current = current()->next();
+
+	return 0L;
+}
+
+VSegment*
+VSubpathIterator::operator+=( uint i )
+{
+	while( current() && i-- )
+		m_current = current()->next();
+
+	return current();
+}
+
+VSegment*
+VSubpathIterator::operator--()
+{
+	if( current() )
+		return m_current = current()->prev();
+
+	return 0L;
+}
+
+VSegment*
+VSubpathIterator::operator-=( uint i )
+{
+	while( current() && i-- )
+		m_current = current()->prev();
+
+	return current();
+}
+