![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
diff --git a/src/display/curve.cpp b/src/display/curve.cpp
index 489553dacf7f40205dcb621d0a900cdd9d28afe6..c229ec28a533ebc5b9b2ff28c7a4b366d50bead3 100644 (file)
--- a/src/display/curve.cpp
+++ b/src/display/curve.cpp
#define __CURVE_C__
/** \file
- * Routines for SPCurve and for NArtBpath arrays in general.
+ * Routines for SPCurve and for NArtBpath arrays / Geom::PathVector in general.
*/
/*
- * Author:
+ * Authors:
* Lauris Kaplinski <lauris@kaplinski.com>
+ * Johan Engelen
*
* Copyright (C) 2000 Lauris Kaplinski
* Copyright (C) 2000-2001 Ximian, Inc.
#include <libnr/n-art-bpath.h>
#include <libnr/nr-point-matrix-ops.h>
#include <libnr/nr-translate-ops.h>
+#include <libnr/n-art-bpath-2geom.h>
+#include <libnr/nr-convert2geom.h>
#include <cstring>
#include <string>
+#include <2geom/pathvector.h>
+#include <2geom/sbasis-geometric.h>
+#include <2geom/sbasis-to-bezier.h>
+#include "svg/svg.h"
+#include <2geom/point.h>
static unsigned sp_bpath_length(NArtBpath const bpath[]);
static bool sp_bpath_closed(NArtBpath const bpath[]);
* The returned curve's state is as if SPCurve::reset has just been called on it.
* \param length Initial number of NArtBpath elements allocated for bpath (including NR_END
* element).
+ * 2GEOMproof
*/
SPCurve::SPCurve(guint length)
: _refcount(1),
_bpath(NULL),
+ _pathv(),
_end(0),
_length(length),
_substart(0),
_bpath = g_new(NArtBpath, length);
_bpath->code = NR_END;
+
+ _pathv.clear();
}
+SPCurve::SPCurve(Geom::PathVector const& pathv)
+ : _refcount(1),
+ _bpath(NULL),
+ _pathv(pathv),
+ _end(0),
+ _length(0),
+ _substart(0),
+ _hascpt(false),
+ _posSet(false),
+ _moving(false),
+ _closed(false)
+{
+ // temporary code to convert to _bpath as well:
+ _bpath = BPath_from_2GeomPath(_pathv);
+ unsigned const len = sp_bpath_length(_bpath);
+ _length = len;
+ _end = _length - 1;
+ gint i = _end;
+ for (; i > 0; i--)
+ if ((_bpath[i].code == NR_MOVETO) ||
+ (_bpath[i].code == NR_MOVETO_OPEN))
+ break;
+ _substart = i;
+ _closed = sp_bpath_closed(_bpath);
+}
+
+// * 2GEOMproof
SPCurve *
SPCurve::new_from_foreign_bpath(NArtBpath const *bpath)
{
curve->_substart = i;
curve->_closed = sp_bpath_closed(new_bpath);
+ curve->_pathv = BPath_to_2GeomPath(curve->_bpath);
+
return curve;
}
* Convert NArtBpath object to SPCurve object.
*
* \return new SPCurve, or NULL if the curve was not created for some reason.
+ * 2GEOMproof
*/
SPCurve *
SPCurve::new_from_bpath(NArtBpath *bpath)
SPCurve *curve = SPCurve::new_from_foreign_bpath(bpath);
g_free(bpath);
+
return curve;
}
+// * 2GEOMproof
SPCurve *
-SPCurve::new_from_rect(NR::Maybe<NR::Rect> const &rect)
+SPCurve::new_from_rect(Geom::Rect const &rect)
{
- g_return_val_if_fail(rect, NULL);
-
SPCurve *c = new SPCurve();
- NR::Point p = rect->corner(0);
+ NR::Point p = rect.corner(0);
c->moveto(p);
for (int i=3; i>=0; i--) {
- c->lineto(rect->corner(i));
+ c->lineto(rect.corner(i));
}
c->closepath_current();
return c;
}
+// * 2GEOMproof
SPCurve::~SPCurve()
{
if (_bpath) {
/* Methods */
-/**
- * Frees old path and sets new path
- * This does not copy the bpath, so the new_bpath should not be deleted by caller
- */
void
-SPCurve::set_bpath(NArtBpath * new_bpath)
+SPCurve::set_pathvector(Geom::PathVector const & new_pathv)
{
- if (new_bpath && new_bpath != _bpath) { // FIXME, add function to SPCurve to change bpath? or a copy function?
- if (_bpath) {
- g_free(_bpath); //delete old bpath
- }
- _bpath = new_bpath;
+ _pathv = new_pathv;
+
+ _hascpt = false;
+ _posSet = false;
+ _moving = false;
+
+ // temporary code to convert to _bpath as well:
+ if (_bpath) {
+ g_free(_bpath);
+ _bpath = NULL;
}
+ _bpath = BPath_from_2GeomPath(_pathv);
+ unsigned const len = sp_bpath_length(_bpath);
+ _length = len;
+ _end = _length - 1;
+ gint i = _end;
+ for (; i > 0; i--)
+ if ((_bpath[i].code == NR_MOVETO) ||
+ (_bpath[i].code == NR_MOVETO_OPEN))
+ break;
+ _substart = i;
+ _closed = sp_bpath_closed(_bpath);
}
/**
{
return _bpath;
};
+
+Geom::PathVector const &
+SPCurve::get_pathvector() const
+{
+ return _pathv;
+}
+
+/**
+ *Returns index in bpath[] of NR_END element.
+ * remove for 2geom
+ */
+guint
+SPCurve::get_length() const
+{
+// g_message("SPCurve::get_length must be removed");
+
+ return _end;
+}
+
/*
-NArtBpath *
-SPCurve::get_bpath()
+ * Returns the number of segments of all paths summed
+ */
+guint
+SPCurve::get_segment_count() const
{
- return _bpath;
-};
-*/
+ guint nr = 0;
+ for(Geom::PathVector::const_iterator it = _pathv.begin(); it != _pathv.end(); ++it) {
+ nr += (*it).size();
+
+ if (it->closed()) nr += 1;
+ }
+ return nr;
+}
/**
* Increase _refcount of curve.
SPCurve *
SPCurve::ref()
{
- g_return_val_if_fail(this != NULL, NULL);
-
_refcount += 1;
return this;
SPCurve *
SPCurve::unref()
{
- g_return_val_if_fail(this != NULL, NULL);
-
_refcount -= 1;
if (_refcount < 1) {
- if (_bpath) {
- g_free(_bpath);
- _bpath = NULL;
- }
delete this;
}
/**
* Add space for more paths in curve.
+ * This function has no meaning for 2geom representation, other than maybe for optimization issues (enlargening the vector for what is to come)
+ * 2GEOMproof
*/
void
SPCurve::ensure_space(guint space)
/**
* Create new curve from its own bpath array.
+ * 2GEOMproof
*/
SPCurve *
SPCurve::copy() const
{
- g_return_val_if_fail(this != NULL, NULL);
-
return SPCurve::new_from_foreign_bpath(_bpath);
}
/**
* Return new curve that is the concatenation of all curves in list.
+ * 2GEOMified
*/
SPCurve *
SPCurve::concat(GSList const *list)
{
- g_return_val_if_fail(list != NULL, NULL);
-
gint length = 0;
for (GSList const *l = list; l != NULL; l = l->next) {
new_curve->_substart = i;
+ for (GSList const *l = list; l != NULL; l = l->next) {
+ SPCurve *c = (SPCurve *) l->data;
+ new_curve->_pathv.insert( new_curve->_pathv.end(), c->get_pathvector().begin(), c->get_pathvector().end() );
+ }
+
return new_curve;
}
/**
* Returns a list of new curves corresponding to the subpaths in \a curve.
+ * 2geomified
*/
GSList *
SPCurve::split() const
{
- g_return_val_if_fail(this != NULL, NULL);
-
guint p = 0;
GSList *l = NULL;
+ gint pathnr = 0;
while (p < _end) {
gint i = 1;
while ((_bpath[p + i].code == NR_LINETO) ||
new_curve->_substart = 0;
new_curve->_closed = (new_curve->_bpath->code == NR_MOVETO);
new_curve->_hascpt = (new_curve->_bpath->code == NR_MOVETO_OPEN);
+ new_curve->_pathv = Geom::PathVector(1, _pathv[pathnr]);
l = g_slist_prepend(l, new_curve);
p += i;
+ pathnr++;
}
return l;
*/
template<class M>
static void
-tmpl_curve_transform(SPCurve *const curve, M const &m)
+tmpl_curve_transform(SPCurve * curve, M const &m)
{
g_return_if_fail(curve != NULL);
}
}
-/**
- * Transform all paths in curve using matrix.
- */
+
void
SPCurve::transform(NR::Matrix const &m)
{
- tmpl_curve_transform<NR::Matrix>(this, m);
-}
+ transform(to_2geom(m));
+};
+
/**
- * Transform all paths in curve using NR::translate.
+ * Transform all paths in curve using matrix.
*/
void
-SPCurve::transform(NR::translate const &m)
+SPCurve::transform(Geom::Matrix const &m)
{
- tmpl_curve_transform<NR::translate>(this, m);
+ tmpl_curve_transform<NR::Matrix>(this, from_2geom(m));
+
+ _pathv = _pathv * m;
}
/**
* Set curve to empty curve.
+ * 2GEOMified
*/
void
SPCurve::reset()
{
- g_return_if_fail(this != NULL);
-
_bpath->code = NR_END;
_end = 0;
_substart = 0;
_posSet = false;
_moving = false;
_closed = false;
+
+ _pathv.clear();
}
/* Several consecutive movetos are ALLOWED */
{
moveto(NR::Point(x, y));
}
-
+/**
+ * Calls SPCurve::moveto() with point made of given coordinates.
+ */
+void
+SPCurve::moveto(Geom::Point const &p)
+{
+ moveto(from_2geom(p));
+}
/**
* Perform a moveto to a point, thus starting a new subpath.
+ * 2GEOMified
*/
void
SPCurve::moveto(NR::Point const &p)
{
- g_return_if_fail(this != NULL);
g_return_if_fail(!_moving);
_substart = _end;
_hascpt = true;
_posSet = true;
_movePos = p;
+ _pathv.push_back( Geom::Path() ); // for some reason Geom::Path(p) does not work...
+ _pathv.back().start(to_2geom(p));
}
+/**
+ * Calls SPCurve::lineto() with a point's coordinates.
+ */
+void
+SPCurve::lineto(Geom::Point const &p)
+{
+ lineto(p[Geom::X], p[Geom::Y]);
+}
/**
* Calls SPCurve::lineto() with a point's coordinates.
*/
{
lineto(p[NR::X], p[NR::Y]);
}
-
/**
* Adds a line to the current subpath.
+ * 2GEOMified
*/
void
SPCurve::lineto(gdouble x, gdouble y)
{
- g_return_if_fail(this != NULL);
g_return_if_fail(_hascpt);
if (_moving) {
bp->x3 = x;
bp->y3 = y;
_moving = false;
- return;
- }
- if (_posSet) {
+ Geom::Path::iterator it = _pathv.back().end();
+ if ( Geom::LineSegment const *last_line_segment = dynamic_cast<Geom::LineSegment const *>( &(*it) )) {
+ Geom::LineSegment new_seg( *last_line_segment );
+ new_seg.setFinal( Geom::Point(x,y) );
+ _pathv.back().replace(it, new_seg);
+ }
+ } else if (_posSet) {
/* start a new segment */
ensure_space(2);
NArtBpath *bp = _bpath + _end;
_end += 2;
_posSet = false;
_closed = false;
- return;
- }
-
- /* add line */
-
- g_return_if_fail(_end > 1);
- ensure_space(1);
- NArtBpath *bp = _bpath + _end;
- bp->code = NR_LINETO;
- bp->x3 = x;
- bp->y3 = y;
- bp++;
- bp->code = NR_END;
- _end++;
-}
-
-/// Unused
-void
-SPCurve::lineto_moving(gdouble x, gdouble y)
-{
- g_return_if_fail(this != NULL);
- g_return_if_fail(_hascpt);
- if (_moving) {
- /* change endpoint */
- g_return_if_fail(!_posSet);
- g_return_if_fail(_end > 1);
- NArtBpath *bp = _bpath + _end - 1;
- g_return_if_fail(bp->code == NR_LINETO);
- bp->x3 = x;
- bp->y3 = y;
+ _pathv.back().appendNew<Geom::LineSegment>( Geom::Point(x,y) );
return;
- }
+ } else {
+ /* add line */
- if (_posSet) {
- /* start a new segment */
- ensure_space(2);
+ g_return_if_fail(_end > 1);
+ ensure_space(1);
NArtBpath *bp = _bpath + _end;
- bp->code = NR_MOVETO_OPEN;
- bp->setC(3, _movePos);
- bp++;
bp->code = NR_LINETO;
bp->x3 = x;
bp->y3 = y;
bp++;
bp->code = NR_END;
- _end += 2;
- _posSet = false;
- _moving = true;
- _closed = false;
- return;
+ _end++;
+ _pathv.back().appendNew<Geom::LineSegment>( Geom::Point(x,y) );
}
-
- /* add line */
-
- g_return_if_fail(_end > 1);
- ensure_space(1);
- NArtBpath *bp = _bpath + _end;
- bp->code = NR_LINETO;
- bp->x3 = x;
- bp->y3 = y;
- bp++;
- bp->code = NR_END;
- _end++;
- _moving = true;
}
+/**
+ * Calls SPCurve::curveto() with coordinates of three points.
+ */
+void
+SPCurve::curveto(Geom::Point const &p0, Geom::Point const &p1, Geom::Point const &p2)
+{
+ using Geom::X;
+ using Geom::Y;
+ curveto( p0[X], p0[Y],
+ p1[X], p1[Y],
+ p2[X], p2[Y] );
+}
/**
* Calls SPCurve::curveto() with coordinates of three points.
*/
@@ -512,14 +578,13 @@ SPCurve::curveto(NR::Point const &p0, NR::Point const &p1, NR::Point const &p2)
p1[X], p1[Y],
p2[X], p2[Y] );
}
-
/**
* Adds a bezier segment to the current subpath.
+ * 2GEOMified
*/
void
SPCurve::curveto(gdouble x0, gdouble y0, gdouble x1, gdouble y1, gdouble x2, gdouble y2)
{
- g_return_if_fail(this != NULL);
g_return_if_fail(_hascpt);
g_return_if_fail(!_moving);
@@ -542,33 +607,35 @@ SPCurve::curveto(gdouble x0, gdouble y0, gdouble x1, gdouble y1, gdouble x2, gdo
_end += 2;
_posSet = false;
_closed = false;
- return;
- }
+ _pathv.back().appendNew<Geom::CubicBezier>( Geom::Point(x0,y0), Geom::Point(x1,y1), Geom::Point(x2,y2) );
+ } else {
+ /* add curve */
- /* add curve */
-
- g_return_if_fail(_end > 1);
- ensure_space(1);
- NArtBpath *bp = _bpath + _end;
- bp->code = NR_CURVETO;
- bp->x1 = x0;
- bp->y1 = y0;
- bp->x2 = x1;
- bp->y2 = y1;
- bp->x3 = x2;
- bp->y3 = y2;
- bp++;
- bp->code = NR_END;
- _end++;
+ g_return_if_fail(_end > 1);
+ ensure_space(1);
+ NArtBpath *bp = _bpath + _end;
+ bp->code = NR_CURVETO;
+ bp->x1 = x0;
+ bp->y1 = y0;
+ bp->x2 = x1;
+ bp->y2 = y1;
+ bp->x3 = x2;
+ bp->y3 = y2;
+ bp++;
+ bp->code = NR_END;
+ _end++;
+ if (_pathv.empty()) g_message("leeg");
+ else _pathv.back().appendNew<Geom::CubicBezier>( Geom::Point(x0,y0), Geom::Point(x1,y1), Geom::Point(x2,y2) );
+ }
}
/**
* Close current subpath by possibly adding a line between start and end.
+ * 2GEOMified
*/
void
SPCurve::closepath()
{
- g_return_if_fail(this != NULL);
g_return_if_fail(_hascpt);
g_return_if_fail(!_posSet);
g_return_if_fail(!_moving);
bs->code = NR_MOVETO;
}
+ // Inkscape always manually adds the closing line segment to SPCurve with a lineto.
+ // This lineto is removed in the writing function for NArtBpath,
+ // so when path is closed and the last segment is a lineto, the closing line segment must really be removed first!
+ // TODO: fix behavior in Inkscape!
+ if ( /*Geom::LineSegment const *line_segment = */ dynamic_cast<Geom::LineSegment const *>(&_pathv.back().back())) {
+ _pathv.back().erase_last();
+ }
+ _pathv.back().close(true);
_closed = true;
+ for (Geom::PathVector::const_iterator it = _pathv.begin(); it != _pathv.end(); it++) {
+ if ( ! it->closed() ) {
+ _closed = false;
+ break;
+ }
+ }
+
for (NArtBpath const *bp = _bpath; bp->code != NR_END; bp++) {
/** \todo
* effic: Maintain a count of NR_MOVETO_OPEN's (e.g. instead of
command to the subpath start point instead of adding a new lineto.
Used for freehand drawing when the user draws back to the start point.
+
+ 2GEOMified
**/
void
SPCurve::closepath_current()
{
- g_return_if_fail(this != NULL);
g_return_if_fail(_hascpt);
g_return_if_fail(!_posSet);
g_return_if_fail(!_closed);
bs->code = NR_MOVETO;
}
+ // Inkscape always manually adds the closing line segment to SPCurve with a lineto.
+ // This lineto is removed in the writing function for NArtBpath,
+ // so when path is closed and the last segment is a lineto, the closing line segment must really be removed first!
+ // TODO: fix behavior in Inkscape!
+ if ( /*Geom::LineSegment const *line_segment = */ dynamic_cast<Geom::LineSegment const *>(&_pathv.back().back())) {
+ _pathv.back().erase_last();
+ }
+ _pathv.back().close(true);
_closed = true;
+ for (Geom::PathVector::const_iterator it = _pathv.begin(); it != _pathv.end(); it++) {
+ if ( ! it->closed() ) {
+ _closed = false;
+ break;
+ }
+ }
+
for (NArtBpath const *bp = _bpath; bp->code != NR_END; bp++) {
/** \todo
* effic: Maintain a count of NR_MOVETO_OPEN's (e.g. instead of
}
/**
- * True if no paths are in curve.
+ * True if no paths are in curve. If it only contains a path with only a moveto, the path is considered NON-empty
*/
bool
SPCurve::is_empty() const
{
- g_return_val_if_fail(this != NULL, TRUE);
+ bool empty = _pathv.empty();
- return (_bpath->code == NR_END);
+ return empty;
}
/**
bool
SPCurve::is_closed() const
{
- return _closed;
+ bool closed = true;
+ for (Geom::PathVector::const_iterator it = _pathv.begin(); it != _pathv.end(); it++) {
+ if ( ! it->closed() ) {
+ closed = false;
+ break;
+ }
+ }
+
+ return closed;
}
/**
* Return last subpath or NULL.
*/
-NArtBpath *
+NArtBpath const *
SPCurve::last_bpath() const
{
- g_return_val_if_fail(this != NULL, NULL);
-
if (_end == 0) {
return NULL;
}
}
/**
- * Return first subpath or NULL.
+ * Return last pathsegment (possibly the closing path segment) of the last path in PathVector or NULL.
+ * If the last path is empty (contains only a moveto), the function returns NULL
*/
-NArtBpath *
-SPCurve::first_bpath() const
+Geom::Curve const *
+SPCurve::last_segment() const
{
- g_return_val_if_fail(this != NULL, NULL);
+ if (is_empty()) {
+ return NULL;
+ }
+ if (_pathv.back().empty()) {
+ return NULL;
+ }
- if (_end == 0) {
+ return &_pathv.back().back_default();
+}
+
+/**
+ * Return last path in PathVector or NULL.
+ */
+Geom::Path const *
+SPCurve::last_path() const
+{
+ if (is_empty()) {
return NULL;
}
- return _bpath;
+ return &_pathv.back();
}
/**
- * Return first point of first subpath or (0,0).
+ * Return first pathsegment in PathVector or NULL.
+ * equal in functionality to SPCurve::first_bpath()
+ */
+Geom::Curve const *
+SPCurve::first_segment() const
+{
+ if (is_empty()) {
+ return NULL;
+ }
+ if (_pathv.front().empty()) {
+ return NULL;
+ }
+
+ return &_pathv.front().front();
+}
+
+/**
+ * Return first path in PathVector or NULL.
+ */
+Geom::Path const *
+SPCurve::first_path() const
+{
+ if (is_empty()) {
+ return NULL;
+ }
+
+ return &_pathv.front();
+}
+
+/**
+ * Return first point of first subpath or (0,0). TODO: shouldn't this be (NR_HUGE, NR_HUGE) to be able to tell it apart from normal (0,0) ?
*/
NR::Point
SPCurve::first_point() const
{
- NArtBpath *const bpath = first_bpath();
- g_return_val_if_fail(bpath != NULL, NR::Point(0, 0));
- return bpath->c(3);
+ if (is_empty())
+ return NR::Point(0, 0);
+
+ return from_2geom( _pathv.front().initialPoint() );
}
/**
* Return the second point of first subpath or _movePos if curve too short.
+ * If the pathvector is empty, this returns (0,0). If the first path is only a moveto, this method
+ * returns the first point of the second path, if it exists. If there is no 2nd path, it returns the
+ * first point of the first path.
+ *
+ * FIXME: for empty paths shouldn't this return (NR_HUGE,NR_HUGE)
*/
NR::Point
SPCurve::second_point() const
{
- g_return_val_if_fail(this != NULL, NR::Point(0, 0));
-
- if (_end < 1) {
- return _movePos;
+ if (is_empty()) {
+ return NR::Point(0,0);
}
-
- NArtBpath *bpath = NULL;
- if (_end < 2) {
- bpath = _bpath;
- } else {
- bpath = _bpath + 1;
+ else if (_pathv.front().empty()) {
+ // first path is only a moveto
+ // check if there is second path
+ if (_pathv.size() > 1) {
+ return _pathv[1].initialPoint();
+ } else {
+ return _pathv[0].initialPoint();
+ }
}
- g_return_val_if_fail(bpath != NULL, NR::Point(0, 0));
- return bpath->c(3);
+ else
+ return _pathv.front()[0].finalPoint();
}
/**
NR::Point
SPCurve::penultimate_point() const
{
- g_return_val_if_fail(this != NULL, NR::Point(0, 0));
-
if (_end < 2) {
return _movePos;
}
NArtBpath *const bpath = _bpath + _end - 2;
g_return_val_if_fail(bpath != NULL, NR::Point(0, 0));
- return bpath->c(3);
+
+
+ Geom::Curve const& back = _pathv.back().back_default();
+ Geom::Point p = back.initialPoint();
+ return from_2geom(p);
}
/**
- * Return last point of last subpath or (0,0).
+ * Return last point of last subpath or (0,0). TODO: shouldn't this be (NR_HUGE, NR_HUGE) to be able to tell it apart from normal (0,0) ?
+ * If the last path is only a moveto, then return that point.
*/
NR::Point
SPCurve::last_point() const
{
- NArtBpath *const bpath = last_bpath();
- g_return_val_if_fail(bpath != NULL, NR::Point(0, 0));
- return bpath->c(3);
+ if (is_empty())
+ return NR::Point(0, 0);
+
+ return from_2geom( _pathv.back().finalPoint() );
}
inline static bool
* Returns a *new* \a curve but drawn in the opposite direction.
* Should result in the same shape, but
* with all its markers drawn facing the other direction.
+ * Reverses the order of subpaths as well
+ * 2GEOMified
**/
SPCurve *
SPCurve::create_reverse() const
g_assert_not_reached();
}
}
+
+ new_curve->_pathv = Geom::reverse_paths_and_order(_pathv);
}
/**
- * Append \a curve2 to \a curve.
+ * Append \a curve2 to \a this.
+ * If \a use_lineto is false, simply add all paths in \a curve2 to \a this;
+ * if \a use_lineto is true, combine \a this's last path and \a curve2's first path and add the rest of the paths in \a curve2 to \a this.
+ * 2GEOMified
*/
void
SPCurve::append(SPCurve const *curve2,
bool use_lineto)
{
- g_return_if_fail(this != NULL);
g_return_if_fail(curve2 != NULL);
+ if (curve2->is_empty())
+ return;
if (curve2->_end < 1)
return;
case NR_MOVETO_OPEN:
if (use_lineto && _hascpt) {
lineto(bp->x3, bp->y3);
- use_lineto = FALSE;
+ use_lineto = false;
} else {
- if (closed) closepath();
+ if (closed && _hascpt) closepath();
moveto(bp->x3, bp->y3);
}
closed = false;
lineto(bp->x3, bp->y3);
use_lineto = FALSE;
} else {
- if (closed) closepath();
+ if (closed && _hascpt) closepath();
moveto(bp->x3, bp->y3);
}
closed = true;
if (closed) {
closepath();
}
+
+ /* 2GEOM code when code above is removed:
+ if (use_lineto) {
+ Geom::PathVector::const_iterator it = curve2->_pathv.begin();
+ if ( ! _pathv.empty() ) {
+ Geom::Path & lastpath = _pathv.back();
+ lastpath.appendNew<Geom::LineSegment>( (*it).initialPoint() );
+ lastpath.append( (*it) );
+ } else {
+ _pathv.push_back( (*it) );
+ }
+
+ for (it++; it != curve2->_pathv.end(); it++) {
+ _pathv.push_back( (*it) );
+ }
+ } else {
+ for (Geom::PathVector::const_iterator it = curve2->_pathv.begin(); it != curve2->_pathv.end(); it++) {
+ _pathv.push_back( (*it) );
+ }
+ }
+ */
}
/**
* Append \a c1 to \a this with possible fusing of close endpoints.
+ * 2GEOMproof. Needs to be recoded when NArtBpath is no longer there. Right now, it applies the same changes to bpath and pathv depending on bpath
*/
SPCurve *
SPCurve::append_continuous(SPCurve const *c1, gdouble tolerance)
{
- g_return_val_if_fail(this != NULL, NULL);
g_return_val_if_fail(c1 != NULL, NULL);
g_return_val_if_fail(!_closed, NULL);
g_return_val_if_fail(!c1->_closed, NULL);
return this;
}
- NArtBpath *be = last_bpath();
+ NArtBpath const *be = last_bpath();
if (be) {
- NArtBpath const *bs = c1->first_bpath();
+ NArtBpath const *bs = c1->get_bpath();
if ( bs
&& ( fabs( bs->x3 - be->x3 ) <= tolerance )
&& ( fabs( bs->y3 - be->y3 ) <= tolerance ) )
/**
* Remove last segment of curve.
+ * (Only used once in /src/pen-context.cpp)
+ * 2GEOMified
*/
void
SPCurve::backspace()
{
- g_return_if_fail(this != NULL);
+ if ( is_empty() )
+ return;
if (_end > 0) {
_end -= 1;
}
_bpath[_end].code = NR_END;
}
+
+ if ( !_pathv.back().empty() ) {
+ _pathv.back().erase_last();
+ _pathv.back().close(false);
+ }
}
/* Private methods */
@@ -1045,7 +1241,7 @@ sp_curve_distance_including_space(SPCurve const *const curve, double seg2len[])
}
NR::Point prev(curve->_bpath->c(3));
- for (gint i = 1; i < curve->_end; ++i) {
+ for (guint i = 1; i < curve->_end; ++i) {
NArtBpath &p = curve->_bpath[i];
double seg_len = 0;
switch (p.code) {
@@ -1089,6 +1285,9 @@ sp_curve_nonzero_distance_including_space(SPCurve const *const curve, double seg
}
}
+/**
+ * 2GEOMified
+ */
void
SPCurve::stretch_endpoints(NR::Point const &new_p0, NR::Point const &new_p1)
{
/* Explicit set for better numerical properties. */
_bpath[nSegs].setC(3, new_p1);
delete [] seg2len;
+
+ Geom::Piecewise<Geom::D2<Geom::SBasis> > pwd2 = _pathv.front().toPwSb();
+ Geom::Piecewise<Geom::SBasis> arclength = Geom::arcLengthSb(pwd2);
+ if ( arclength.lastValue() <= 0 ) {
+ g_error("SPCurve::stretch_endpoints - arclength <= 0");
+ throw;
+ }
+ arclength *= 1./arclength.lastValue();
+ Geom::Point const A( to_2geom(offset0) );
+ Geom::Point const B( to_2geom(offset1) );
+ Geom::Piecewise<Geom::SBasis> offsetx = (arclength*-1.+1)*A[0] + arclength*B[0];
+ Geom::Piecewise<Geom::SBasis> offsety = (arclength*-1.+1)*A[1] + arclength*B[1];
+ Geom::Piecewise<Geom::D2<Geom::SBasis> > offsetpath = Geom::sectionize( Geom::D2<Geom::Piecewise<Geom::SBasis> >(offsetx, offsety) );
+ pwd2 += offsetpath;
+ _pathv = Geom::path_from_piecewise( pwd2, 0.001 );
}
+/**
+ * sets start of first path to new_p0, and end of first path to new_p1
+ * 2GEOMified
+ */
void
SPCurve::move_endpoints(NR::Point const &new_p0, NR::Point const &new_p1)
{
_bpath->setC(3, new_p0);
_bpath[nSegs].setC(3, new_p1);
+
+ _pathv.front().setInitial(to_2geom(new_p0));
+ _pathv.front().setFinal(to_2geom(new_p1));
+}
+
+/**
+ * returns the number of nodes in a path, used for statusbar text when selecting an spcurve.
+ * 2GEOMified
+ */
+guint
+SPCurve::nodes_in_path() const
+{
+ gint r = _end;
+ gint i = _length - 1;
+ if (i > r) i = r; // sometimes after switching from node editor length is wrong, e.g. f6 - draw - f2 - tab - f1, this fixes it
+ for (; i >= 0; i --)
+ if (_bpath[i].code == NR_MOVETO)
+ r --;
+
+ guint nr = 0;
+ for(Geom::PathVector::const_iterator it = _pathv.begin(); it != _pathv.end(); ++it) {
+ nr += (*it).size();
+
+ nr++; // count last node (this works also for closed paths because although they don't have a 'last node', they do have an extra segment
+ }
+
+ return r;
}
+/**
+ * Adds p to the last point (and last handle if present) of the last path
+ * 2GEOMified
+ */
+void
+SPCurve::last_point_additive_move(Geom::Point const & p)
+{
+ if (is_empty()) {
+ return;
+ }
+ if (_end == 0) {
+ return;
+ }
+ NArtBpath * path = _bpath + _end - 1;
+
+ if (path->code == NR_CURVETO) {
+ path->x2 += p[Geom::X];
+ path->y2 += p[Geom::Y];
+ }
+ path->x3 += p[Geom::X];
+ path->y3 += p[Geom::Y];
+
+ _pathv.back().setFinal( _pathv.back().finalPoint() + p );
+
+ // Move handle as well when the last segment is a cubic bezier segment:
+ // TODO: what to do for quadratic beziers?
+ if ( Geom::CubicBezier const *lastcube = dynamic_cast<Geom::CubicBezier const *>(&_pathv.back().back()) ) {
+ Geom::CubicBezier newcube( *lastcube );
+ newcube.setPoint(2, newcube[2] + p);
+ _pathv.back().replace( --_pathv.back().end(), newcube );
+ }
+}
/*
Local Variables: