From: johanengelen Date: Mon, 5 May 2008 19:00:20 +0000 (+0000) Subject: struct SPCurve => class SPCurve X-Git-Url: https://git.tokkee.org/?a=commitdiff_plain;h=ff10ef00a3847886fff81e690d2f329f5eba2253;p=inkscape.git struct SPCurve => class SPCurve change all sp_curve_methods functions to SPCurve::methods. --- diff --git a/src/box3d-side.cpp b/src/box3d-side.cpp index 632a697af..2fff9f7b5 100644 --- a/src/box3d-side.cpp +++ b/src/box3d-side.cpp @@ -221,7 +221,7 @@ box3d_side_set_shape (SPShape *shape) return; } - SPCurve *c = sp_curve_new (); + SPCurve *c = new SPCurve(); // TODO: Draw the correct quadrangle here // To do this, determine the perspective of the box, the orientation of the side (e.g., XY-FRONT) // compute the coordinates of the corners in P^3, project them onto the canvas, and draw the @@ -230,15 +230,15 @@ box3d_side_set_shape (SPShape *shape) unsigned int corners[4]; box3d_side_compute_corner_ids(side, corners); - sp_curve_moveto (c, box3d_get_corner_screen(box, corners[0])); - sp_curve_lineto (c, box3d_get_corner_screen(box, corners[1])); - sp_curve_lineto (c, box3d_get_corner_screen(box, corners[2])); - sp_curve_lineto (c, box3d_get_corner_screen(box, corners[3])); + c->moveto(box3d_get_corner_screen(box, corners[0])); + c->lineto(box3d_get_corner_screen(box, corners[1])); + c->lineto(box3d_get_corner_screen(box, corners[2])); + c->lineto(box3d_get_corner_screen(box, corners[3])); - sp_curve_closepath (c); + c->closepath(); sp_lpe_item_perform_path_effect(SP_LPE_ITEM (side), c); sp_shape_set_curve_insync (SP_SHAPE (side), c, TRUE); - sp_curve_unref (c); + c->unref(); } void diff --git a/src/connector-context.cpp b/src/connector-context.cpp index d311cfabd..07e512e06 100644 --- a/src/connector-context.cpp +++ b/src/connector-context.cpp @@ -275,10 +275,10 @@ sp_connector_context_setup(SPEventContext *ec) sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(cc->red_bpath), 0x00000000, SP_WIND_RULE_NONZERO); /* Create red curve */ - cc->red_curve = sp_curve_new_sized(4); + cc->red_curve = new SPCurve(4); /* Create green curve */ - cc->green_curve = sp_curve_new_sized(64); + cc->green_curve = new SPCurve(64); // Notice the initial selection. cc_selection_changed(cc->selection, (gpointer) cc); @@ -638,17 +638,17 @@ connector_handle_motion_notify(SPConnectorContext *const cc, GdkEventMotion cons SPCurve *curve = (SP_SHAPE(path))->curve; if (cc->clickedhandle == cc->endpt_handle[0]) { NR::Point o = cc->endpt_handle[1]->pos; - sp_curve_stretch_endpoints(curve, p * d2i, o * d2i); + curve->stretch_endpoints(p * d2i, o * d2i); } else { NR::Point o = cc->endpt_handle[0]->pos; - sp_curve_stretch_endpoints(curve, o * d2i, p * d2i); + curve->stretch_endpoints(o * d2i, p * d2i); } sp_conn_adjust_path(path); // Copy this to the temporary visible path - cc->red_curve = sp_curve_copy(SP_SHAPE(path)->curve); - sp_curve_transform(cc->red_curve, i2d); + cc->red_curve = SP_SHAPE(path)->curve->copy(); + cc->red_curve->transform(i2d); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(cc->red_bpath), cc->red_curve); ret = TRUE; @@ -772,7 +772,7 @@ cc_connector_rerouting_finish(SPConnectorContext *const cc, NR::Point *const p) SPDocument *doc = sp_desktop_document(desktop); // Clear the temporary path: - sp_curve_reset(cc->red_curve); + cc->red_curve->reset(); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(cc->red_bpath), NULL); if (p != NULL) @@ -805,10 +805,10 @@ static void spcc_reset_colors(SPConnectorContext *cc) { /* Red */ - sp_curve_reset(cc->red_curve); + cc->red_curve->reset(); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(cc->red_bpath), NULL); - sp_curve_reset(cc->green_curve); + cc->green_curve->reset(); cc->npoints = 0; } @@ -849,15 +849,15 @@ spcc_connector_set_subsequent_point(SPConnectorContext *const cc, NR::Point cons Avoid::PolyLine route = cc->newConnRef->route(); cc->newConnRef->calcRouteDist(); - sp_curve_reset(cc->red_curve); + cc->red_curve->reset(); NR::Point pt(route.ps[0].x, route.ps[0].y); - sp_curve_moveto(cc->red_curve, pt); + cc->red_curve->moveto(pt); for (int i = 1; i < route.pn; ++i) { NR::Point p(route.ps[i].x, route.ps[i].y); - sp_curve_lineto(cc->red_curve, p); + cc->red_curve->lineto(p); } - sp_curve_transform(cc->red_curve, dt->doc2dt()); + cc->red_curve->transform(dt->doc2dt()); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(cc->red_bpath), cc->red_curve); } @@ -871,19 +871,19 @@ static void spcc_concat_colors_and_flush(SPConnectorContext *cc) { SPCurve *c = cc->green_curve; - cc->green_curve = sp_curve_new_sized(64); + cc->green_curve = new SPCurve(64); - sp_curve_reset(cc->red_curve); + cc->red_curve->reset(); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(cc->red_bpath), NULL); - if (sp_curve_empty(c)) { - sp_curve_unref(c); + if (c->is_empty()) { + c->unref(); return; } spcc_flush_white(cc, c); - sp_curve_unref(c); + c->unref(); } @@ -902,20 +902,19 @@ spcc_flush_white(SPConnectorContext *cc, SPCurve *gc) if (gc) { c = gc; - sp_curve_ref(c); + c->ref(); } else { return; } /* Now we have to go back to item coordinates at last */ - sp_curve_transform(c, - sp_desktop_dt2root_affine(SP_EVENT_CONTEXT_DESKTOP(cc))); + c->transform(sp_desktop_dt2root_affine(SP_EVENT_CONTEXT_DESKTOP(cc))); SPDesktop *desktop = SP_EVENT_CONTEXT_DESKTOP(cc); SPDocument *doc = sp_desktop_document(desktop); Inkscape::XML::Document *xml_doc = sp_document_repr_doc(doc); - if ( c && !sp_curve_empty(c) ) { + if ( c && !c->is_empty() ) { /* We actually have something to write */ Inkscape::XML::Node *repr = xml_doc->createElement("svg:path"); @@ -958,7 +957,7 @@ spcc_flush_white(SPConnectorContext *cc, SPCurve *gc) cc->newconn->updateRepr(); } - sp_curve_unref(c); + c->unref(); /* Flush pending updates */ sp_document_done(doc, SP_VERB_CONTEXT_CONNECTOR, _("Create connector")); @@ -969,14 +968,14 @@ spcc_flush_white(SPConnectorContext *cc, SPCurve *gc) static void spcc_connector_finish_segment(SPConnectorContext *const cc, NR::Point const /*p*/) { - if (!sp_curve_empty(cc->red_curve)) { - sp_curve_append_continuous(cc->green_curve, cc->red_curve, 0.0625); + if (!cc->red_curve->is_empty()) { + cc->green_curve->append_continuous(cc->red_curve, 0.0625); cc->p[0] = cc->p[3]; cc->p[1] = cc->p[4]; cc->npoints = 2; - sp_curve_reset(cc->red_curve); + cc->red_curve->reset(); } } @@ -987,7 +986,7 @@ spcc_connector_finish(SPConnectorContext *const cc) SPDesktop *const desktop = cc->desktop; desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Finishing connector")); - sp_curve_reset(cc->red_curve); + cc->red_curve->reset(); spcc_concat_colors_and_flush(cc); cc->npoints = 0; @@ -1078,11 +1077,10 @@ endpt_handler(SPKnot */*knot*/, GdkEvent *event, SPConnectorContext *cc) } // Show the red path for dragging. - cc->red_curve = sp_curve_copy(SP_PATH(cc->clickeditem)->curve); + cc->red_curve = SP_PATH(cc->clickeditem)->curve->copy(); NR::Matrix i2d = sp_item_i2d_affine(cc->clickeditem); - sp_curve_transform(cc->red_curve, i2d); - sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(cc->red_bpath), - cc->red_curve); + cc->red_curve->transform(i2d); + sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(cc->red_bpath), cc->red_curve); cc->clickeditem->setHidden(true); @@ -1172,10 +1170,10 @@ cc_set_active_conn(SPConnectorContext *cc, SPItem *item) if (cc->active_conn == item) { // Just adjust handle positions. - NR::Point startpt = sp_curve_first_point(curve) * i2d; + NR::Point startpt = curve->first_point() * i2d; sp_knot_set_position(cc->endpt_handle[0], &startpt, 0); - NR::Point endpt = sp_curve_last_point(curve) * i2d; + NR::Point endpt = curve->last_point() * i2d; sp_knot_set_position(cc->endpt_handle[1], &endpt, 0); return; @@ -1239,10 +1237,10 @@ cc_set_active_conn(SPConnectorContext *cc, SPItem *item) G_CALLBACK(endpt_handler), cc); } - NR::Point startpt = sp_curve_first_point(curve) * i2d; + NR::Point startpt = curve->first_point() * i2d; sp_knot_set_position(cc->endpt_handle[0], &startpt, 0); - NR::Point endpt = sp_curve_last_point(curve) * i2d; + NR::Point endpt = curve->last_point() * i2d; sp_knot_set_position(cc->endpt_handle[1], &endpt, 0); sp_knot_show(cc->endpt_handle[0]); diff --git a/src/display/canvas-bpath.cpp b/src/display/canvas-bpath.cpp index ed317722c..6aa413623 100644 --- a/src/display/canvas-bpath.cpp +++ b/src/display/canvas-bpath.cpp @@ -103,7 +103,7 @@ sp_canvas_bpath_destroy (GtkObject *object) cbp->stroke_shp = NULL; } if (cbp->curve) { - cbp->curve = sp_curve_unref (cbp->curve); + cbp->curve = cbp->curve->unref(); } if (GTK_OBJECT_CLASS (parent_class)->destroy) @@ -272,11 +272,11 @@ sp_canvas_bpath_set_bpath (SPCanvasBPath *cbp, SPCurve *curve) g_return_if_fail (SP_IS_CANVAS_BPATH (cbp)); if (cbp->curve) { - cbp->curve = sp_curve_unref (cbp->curve); + cbp->curve = cbp->curve->unref(); } if (curve) { - cbp->curve = sp_curve_ref (curve); + cbp->curve = curve->ref(); } sp_canvas_item_request_update (SP_CANVAS_ITEM (cbp)); diff --git a/src/display/curve.cpp b/src/display/curve.cpp index 8868107bc..e97b09744 100644 --- a/src/display/curve.cpp +++ b/src/display/curve.cpp @@ -11,85 +11,55 @@ * Copyright (C) 2000 Lauris Kaplinski * Copyright (C) 2000-2001 Ximian, Inc. * Copyright (C) 2002 Lauris Kaplinski + * Copyright (C) 2008 Johan Engelen * * Released under GNU GPL */ +#include + #include #include -#include +#include "libnr/nr-point.h" +#include "libnr/nr-rect.h" #include #include #include #include #include -#define SP_CURVE_LENSTEP 32 - static unsigned sp_bpath_length(NArtBpath const bpath[]); static bool sp_bpath_closed(NArtBpath const bpath[]); /* Constructors */ /** - * The returned curve's state is as if sp_curve_reset has just been called on it. - */ -SPCurve * -sp_curve_new() -{ - return sp_curve_new_sized(SP_CURVE_LENSTEP); -} - -/** - * Like sp_curve_new, but overriding the default initial capacity. - * - * The returned curve's state is as if sp_curve_reset has just been called on it. - * + * 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). */ -SPCurve * -sp_curve_new_sized(gint length) +SPCurve::SPCurve(gint length) + : refcount(1), + _bpath(NULL), + end(0), + length(length), + substart(0), + hascpt(false), + posSet(false), + moving(false), + closed(false) { - g_return_val_if_fail(length > 0, NULL); - - SPCurve *curve = g_new(SPCurve, 1); - - curve->refcount = 1; - curve->_bpath = g_new(NArtBpath, length); - curve->_bpath->code = NR_END; - curve->end = 0; - curve->length = length; - curve->substart = 0; - curve->hascpt = false; - curve->posSet = false; - curve->moving = false; - curve->closed = false; + if (length <= 0) { + g_error("SPCurve::SPCurve called with invalid length parameter"); + throw; + } - return curve; + _bpath = g_new(NArtBpath, length); + _bpath->code = NR_END; } -/** - * Convert NArtBpath object to SPCurve object. - * - * \return new SPCurve, or NULL if the curve was not created for some reason. - */ SPCurve * -sp_curve_new_from_bpath(NArtBpath *bpath) -{ - g_return_val_if_fail(bpath != NULL, NULL); - - SPCurve *curve = sp_curve_new_from_foreign_bpath(bpath); - g_free(bpath); - return curve; -} - -/** - * Convert const NArtBpath array to SPCurve. - * - * \return new SPCurve, or NULL if the curve was not created for some reason. - */ -SPCurve *sp_curve_new_from_foreign_bpath(NArtBpath const bpath[]) +SPCurve::new_from_foreign_bpath(NArtBpath const *bpath) { g_return_val_if_fail(bpath != NULL, NULL); @@ -98,9 +68,8 @@ SPCurve *sp_curve_new_from_foreign_bpath(NArtBpath const bpath[]) new_bpath = g_new(NArtBpath, len); memcpy(new_bpath, bpath, len * sizeof(NArtBpath)); - SPCurve *curve = g_new(SPCurve, 1); + SPCurve *curve = new SPCurve(); - curve->refcount = 1; curve->_bpath = new_bpath; curve->length = len; curve->end = curve->length - 1; @@ -110,44 +79,67 @@ SPCurve *sp_curve_new_from_foreign_bpath(NArtBpath const bpath[]) (curve->_bpath[i].code == NR_MOVETO_OPEN)) break; curve->substart = i; - curve->hascpt = false; - curve->posSet = false; - curve->moving = false; curve->closed = sp_bpath_closed(new_bpath); return curve; } -SPCurve *sp_curve_new_from_rect(NR::Maybe const &rect) +/** + * Convert NArtBpath object to SPCurve object. + * + * \return new SPCurve, or NULL if the curve was not created for some reason. + */ +SPCurve * +SPCurve::new_from_bpath(NArtBpath *bpath) +{ + g_return_val_if_fail(bpath != NULL, NULL); + + SPCurve *curve = SPCurve::new_from_foreign_bpath(bpath); + g_free(bpath); + return curve; +} + +SPCurve * +SPCurve::new_from_rect(NR::Maybe const &rect) { g_return_val_if_fail(rect, NULL); - SPCurve *c = sp_curve_new(); + SPCurve *c = new SPCurve(); NR::Point p = rect->corner(0); - sp_curve_moveto(c, p); + c->moveto(p); for (int i=3; i>=0; i--) { - sp_curve_lineto(c, rect->corner(i)); + c->lineto(rect->corner(i)); } - sp_curve_closepath_current(c); + c->closepath_current(); return c; } +SPCurve::~SPCurve() +{ + if (_bpath) { + g_free(_bpath); + _bpath = NULL; + } +} + +/* Methods */ + /** * Increase refcount of curve. * * \todo should this be shared with other refcounting code? */ SPCurve * -sp_curve_ref(SPCurve *curve) +SPCurve::ref() { - g_return_val_if_fail(curve != NULL, NULL); + g_return_val_if_fail(this != NULL, NULL); - curve->refcount += 1; + refcount += 1; - return curve; + return this; } /** @@ -156,17 +148,18 @@ sp_curve_ref(SPCurve *curve) * \todo should this be shared with other refcounting code? */ SPCurve * -sp_curve_unref(SPCurve *curve) +SPCurve::unref() { - g_return_val_if_fail(curve != NULL, NULL); + g_return_val_if_fail(this != NULL, NULL); - curve->refcount -= 1; + refcount -= 1; - if (curve->refcount < 1) { - if (curve->_bpath) { - g_free(curve->_bpath); + if (refcount < 1) { + if (_bpath) { + g_free(_bpath); + _bpath = NULL; } - g_free(curve); + delete this; } return NULL; @@ -196,18 +189,18 @@ sp_curve_ensure_space(SPCurve *curve, gint space) * Create new curve from its own bpath array. */ SPCurve * -sp_curve_copy(SPCurve *curve) +SPCurve::copy() const { - g_return_val_if_fail(curve != NULL, NULL); + g_return_val_if_fail(this != NULL, NULL); - return sp_curve_new_from_foreign_bpath(curve->_bpath); + return SPCurve::new_from_foreign_bpath(_bpath); } /** * Return new curve that is the concatenation of all curves in list. */ SPCurve * -sp_curve_concat(GSList const *list) +SPCurve::concat(GSList const *list) { g_return_val_if_fail(list != NULL, NULL); @@ -218,7 +211,7 @@ sp_curve_concat(GSList const *list) length += c->end; } - SPCurve *new_curve = sp_curve_new_sized(length + 1); + SPCurve *new_curve = new SPCurve(length + 1); NArtBpath *bp = new_curve->_bpath; @@ -247,20 +240,20 @@ sp_curve_concat(GSList const *list) * Returns a list of new curves corresponding to the subpaths in \a curve. */ GSList * -sp_curve_split(SPCurve const *curve) +SPCurve::split() const { - g_return_val_if_fail(curve != NULL, NULL); + g_return_val_if_fail(this != NULL, NULL); gint p = 0; GSList *l = NULL; - while (p < curve->end) { + while (p < end) { gint i = 1; - while ((curve->_bpath[p + i].code == NR_LINETO) || - (curve->_bpath[p + i].code == NR_CURVETO)) + while ((_bpath[p + i].code == NR_LINETO) || + (_bpath[p + i].code == NR_CURVETO)) i++; - SPCurve *new_curve = sp_curve_new_sized(i + 1); - memcpy(new_curve->_bpath, curve->_bpath + p, i * sizeof(NArtBpath)); + SPCurve *new_curve = new SPCurve(i + 1); + memcpy(new_curve->_bpath, _bpath + p, i * sizeof(NArtBpath)); new_curve->end = i; new_curve->_bpath[i].code = NR_END; new_curve->substart = 0; @@ -307,208 +300,204 @@ tmpl_curve_transform(SPCurve *const curve, M const &m) * Transform all paths in curve using matrix. */ void -sp_curve_transform(SPCurve *const curve, NR::Matrix const &m) +SPCurve::transform(NR::Matrix const &m) { - tmpl_curve_transform(curve, m); + tmpl_curve_transform(this, m); } /** * Transform all paths in curve using NR::translate. */ void -sp_curve_transform(SPCurve *const curve, NR::translate const &m) +SPCurve::transform(NR::translate const &m) { - tmpl_curve_transform(curve, m); + tmpl_curve_transform(this, m); } - -/* Methods */ - /** * Set curve to empty curve. */ void -sp_curve_reset(SPCurve *curve) +SPCurve::reset() { - g_return_if_fail(curve != NULL); - - curve->_bpath->code = NR_END; - curve->end = 0; - curve->substart = 0; - curve->hascpt = false; - curve->posSet = false; - curve->moving = false; - curve->closed = false; + g_return_if_fail(this != NULL); + + _bpath->code = NR_END; + end = 0; + substart = 0; + hascpt = false; + posSet = false; + moving = false; + closed = false; } /* Several consecutive movetos are ALLOWED */ /** - * Calls sp_curve_moveto() with point made of given coordinates. + * Calls SPCurve::moveto() with point made of given coordinates. */ void -sp_curve_moveto(SPCurve *curve, gdouble x, gdouble y) +SPCurve::moveto(gdouble x, gdouble y) { - sp_curve_moveto(curve, NR::Point(x, y)); + moveto(NR::Point(x, y)); } /** * Perform a moveto to a point, thus starting a new subpath. */ void -sp_curve_moveto(SPCurve *curve, NR::Point const &p) +SPCurve::moveto(NR::Point const &p) { - g_return_if_fail(curve != NULL); - g_return_if_fail(!curve->moving); + g_return_if_fail(this != NULL); + g_return_if_fail(!moving); - curve->substart = curve->end; - curve->hascpt = true; - curve->posSet = true; - curve->movePos = p; + substart = end; + hascpt = true; + posSet = true; + movePos = p; } /** - * Calls sp_curve_lineto() with a point's coordinates. + * Calls SPCurve::lineto() with a point's coordinates. */ void -sp_curve_lineto(SPCurve *curve, NR::Point const &p) +SPCurve::lineto(NR::Point const &p) { - sp_curve_lineto(curve, p[NR::X], p[NR::Y]); + lineto(p[NR::X], p[NR::Y]); } /** * Adds a line to the current subpath. */ void -sp_curve_lineto(SPCurve *curve, gdouble x, gdouble y) +SPCurve::lineto(gdouble x, gdouble y) { - g_return_if_fail(curve != NULL); - g_return_if_fail(curve->hascpt); + g_return_if_fail(this != NULL); + g_return_if_fail(hascpt); - if (curve->moving) { + if (moving) { /* fix endpoint */ - g_return_if_fail(!curve->posSet); - g_return_if_fail(curve->end > 1); - NArtBpath *bp = curve->_bpath + curve->end - 1; + 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; - curve->moving = false; + moving = false; return; } - if (curve->posSet) { + if (posSet) { /* start a new segment */ - sp_curve_ensure_space(curve, 2); - NArtBpath *bp = curve->_bpath + curve->end; + sp_curve_ensure_space(this, 2); + NArtBpath *bp = _bpath + end; bp->code = NR_MOVETO_OPEN; - bp->setC(3, curve->movePos); + bp->setC(3, movePos); bp++; bp->code = NR_LINETO; bp->x3 = x; bp->y3 = y; bp++; bp->code = NR_END; - curve->end += 2; - curve->posSet = false; - curve->closed = false; + end += 2; + posSet = false; + closed = false; return; } /* add line */ - g_return_if_fail(curve->end > 1); - sp_curve_ensure_space(curve, 1); - NArtBpath *bp = curve->_bpath + curve->end; + g_return_if_fail(end > 1); + sp_curve_ensure_space(this, 1); + NArtBpath *bp = _bpath + end; bp->code = NR_LINETO; bp->x3 = x; bp->y3 = y; bp++; bp->code = NR_END; - curve->end++; + end++; } /// Unused void -sp_curve_lineto_moving(SPCurve *curve, gdouble x, gdouble y) +SPCurve::lineto_moving(gdouble x, gdouble y) { - g_return_if_fail(curve != NULL); - g_return_if_fail(curve->hascpt); + g_return_if_fail(this != NULL); + g_return_if_fail(hascpt); - if (curve->moving) { + if (moving) { /* change endpoint */ - g_return_if_fail(!curve->posSet); - g_return_if_fail(curve->end > 1); - NArtBpath *bp = curve->_bpath + curve->end - 1; + 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; return; } - if (curve->posSet) { + if (posSet) { /* start a new segment */ - sp_curve_ensure_space(curve, 2); - NArtBpath *bp = curve->_bpath + curve->end; + sp_curve_ensure_space(this, 2); + NArtBpath *bp = _bpath + end; bp->code = NR_MOVETO_OPEN; - bp->setC(3, curve->movePos); + bp->setC(3, movePos); bp++; bp->code = NR_LINETO; bp->x3 = x; bp->y3 = y; bp++; bp->code = NR_END; - curve->end += 2; - curve->posSet = false; - curve->moving = true; - curve->closed = false; + end += 2; + posSet = false; + moving = true; + closed = false; return; } /* add line */ - g_return_if_fail(curve->end > 1); - sp_curve_ensure_space(curve, 1); - NArtBpath *bp = curve->_bpath + curve->end; + g_return_if_fail(end > 1); + sp_curve_ensure_space(this, 1); + NArtBpath *bp = _bpath + end; bp->code = NR_LINETO; bp->x3 = x; bp->y3 = y; bp++; bp->code = NR_END; - curve->end++; - curve->moving = true; + end++; + moving = true; } /** - * Calls sp_curve_curveto() with coordinates of three points. + * Calls SPCurve::curveto() with coordinates of three points. */ void -sp_curve_curveto(SPCurve *curve, NR::Point const &p0, NR::Point const &p1, NR::Point const &p2) +SPCurve::curveto(NR::Point const &p0, NR::Point const &p1, NR::Point const &p2) { using NR::X; using NR::Y; - sp_curve_curveto(curve, - p0[X], p0[Y], - p1[X], p1[Y], - p2[X], p2[Y]); + curveto( p0[X], p0[Y], + p1[X], p1[Y], + p2[X], p2[Y] ); } /** * Adds a bezier segment to the current subpath. */ void -sp_curve_curveto(SPCurve *curve, gdouble x0, gdouble y0, gdouble x1, gdouble y1, gdouble x2, gdouble y2) +SPCurve::curveto(gdouble x0, gdouble y0, gdouble x1, gdouble y1, gdouble x2, gdouble y2) { - g_return_if_fail(curve != NULL); - g_return_if_fail(curve->hascpt); - g_return_if_fail(!curve->moving); + g_return_if_fail(this != NULL); + g_return_if_fail(hascpt); + g_return_if_fail(!moving); - if (curve->posSet) { + if (posSet) { /* start a new segment */ - sp_curve_ensure_space(curve, 2); - NArtBpath *bp = curve->_bpath + curve->end; + sp_curve_ensure_space(this, 2); + NArtBpath *bp = _bpath + end; bp->code = NR_MOVETO_OPEN; - bp->setC(3, curve->movePos); + bp->setC(3, movePos); bp++; bp->code = NR_CURVETO; bp->x1 = x0; @@ -519,17 +508,17 @@ sp_curve_curveto(SPCurve *curve, gdouble x0, gdouble y0, gdouble x1, gdouble y1, bp->y3 = y2; bp++; bp->code = NR_END; - curve->end += 2; - curve->posSet = false; - curve->closed = false; + end += 2; + posSet = false; + closed = false; return; } /* add curve */ - g_return_if_fail(curve->end > 1); - sp_curve_ensure_space(curve, 1); - NArtBpath *bp = curve->_bpath + curve->end; + g_return_if_fail(end > 1); + sp_curve_ensure_space(this, 1); + NArtBpath *bp = _bpath + end; bp->code = NR_CURVETO; bp->x1 = x0; bp->y1 = y0; @@ -539,178 +528,178 @@ sp_curve_curveto(SPCurve *curve, gdouble x0, gdouble y0, gdouble x1, gdouble y1, bp->y3 = y2; bp++; bp->code = NR_END; - curve->end++; + end++; } /** * Close current subpath by possibly adding a line between start and end. */ void -sp_curve_closepath(SPCurve *curve) +SPCurve::closepath() { - g_return_if_fail(curve != NULL); - g_return_if_fail(curve->hascpt); - g_return_if_fail(!curve->posSet); - g_return_if_fail(!curve->moving); - g_return_if_fail(!curve->closed); + g_return_if_fail(this != NULL); + g_return_if_fail(hascpt); + g_return_if_fail(!posSet); + g_return_if_fail(!moving); + g_return_if_fail(!closed); /* We need at least moveto, curveto, end. */ - g_return_if_fail(curve->end - curve->substart > 1); + g_return_if_fail(end - substart > 1); { - NArtBpath *bs = curve->_bpath + curve->substart; - NArtBpath *be = curve->_bpath + curve->end - 1; + NArtBpath *bs = _bpath + substart; + NArtBpath *be = _bpath + end - 1; if (bs->c(3) != be->c(3)) { - sp_curve_lineto(curve, bs->c(3)); - bs = curve->_bpath + curve->substart; + lineto(bs->c(3)); + bs = _bpath + substart; } bs->code = NR_MOVETO; } - curve->closed = true; + closed = true; - for (NArtBpath const *bp = curve->_bpath; bp->code != NR_END; bp++) { + for (NArtBpath const *bp = _bpath; bp->code != NR_END; bp++) { /** \todo * effic: Maintain a count of NR_MOVETO_OPEN's (e.g. instead of * the closed boolean). */ if (bp->code == NR_MOVETO_OPEN) { - curve->closed = false; + closed = false; break; } } - curve->hascpt = false; + hascpt = false; } -/** Like sp_curve_closepath() but sets the end point of the current +/** Like SPCurve::closepath() but sets the end point of the current 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. **/ void -sp_curve_closepath_current(SPCurve *curve) +SPCurve::closepath_current() { - g_return_if_fail(curve != NULL); - g_return_if_fail(curve->hascpt); - g_return_if_fail(!curve->posSet); - g_return_if_fail(!curve->closed); + g_return_if_fail(this != NULL); + g_return_if_fail(hascpt); + g_return_if_fail(!posSet); + g_return_if_fail(!closed); /* We need at least moveto, curveto, end. */ - g_return_if_fail(curve->end - curve->substart > 1); + g_return_if_fail(end - substart > 1); { - NArtBpath *bs = curve->_bpath + curve->substart; - NArtBpath *be = curve->_bpath + curve->end - 1; + NArtBpath *bs = _bpath + substart; + NArtBpath *be = _bpath + end - 1; be->x3 = bs->x3; be->y3 = bs->y3; bs->code = NR_MOVETO; } - curve->closed = true; + closed = true; - for (NArtBpath const *bp = curve->_bpath; bp->code != NR_END; bp++) { + for (NArtBpath const *bp = _bpath; bp->code != NR_END; bp++) { /** \todo * effic: Maintain a count of NR_MOVETO_OPEN's (e.g. instead of * the closed boolean). */ if (bp->code == NR_MOVETO_OPEN) { - curve->closed = false; + closed = false; break; } } - curve->hascpt = false; - curve->moving = false; + hascpt = false; + moving = false; } /** * True if no paths are in curve. */ bool -sp_curve_empty(SPCurve *curve) +SPCurve::is_empty() const { - g_return_val_if_fail(curve != NULL, TRUE); + g_return_val_if_fail(this != NULL, TRUE); - return (curve->_bpath->code == NR_END); + return (_bpath->code == NR_END); } /** * Return last subpath or NULL. */ NArtBpath * -sp_curve_last_bpath(SPCurve const *curve) +SPCurve::last_bpath() const { - g_return_val_if_fail(curve != NULL, NULL); + g_return_val_if_fail(this != NULL, NULL); - if (curve->end == 0) { + if (end == 0) { return NULL; } - return curve->_bpath + curve->end - 1; + return _bpath + end - 1; } /** * Return first subpath or NULL. */ NArtBpath * -sp_curve_first_bpath(SPCurve const *curve) +SPCurve::first_bpath() const { - g_return_val_if_fail(curve != NULL, NULL); + g_return_val_if_fail(this != NULL, NULL); - if (curve->end == 0) { + if (end == 0) { return NULL; } - return curve->_bpath; + return _bpath; } /** * Return first point of first subpath or (0,0). */ NR::Point -sp_curve_first_point(SPCurve const *const curve) +SPCurve::first_point() const { - NArtBpath *const bpath = sp_curve_first_bpath(curve); + NArtBpath *const bpath = first_bpath(); g_return_val_if_fail(bpath != NULL, NR::Point(0, 0)); return bpath->c(3); } /** - * Return the second point of first subpath or curve->movePos if curve too short. + * Return the second point of first subpath or movePos if curve too short. */ NR::Point -sp_curve_second_point(SPCurve const *const curve) +SPCurve::second_point() const { - g_return_val_if_fail(curve != NULL, NR::Point(0, 0)); + g_return_val_if_fail(this != NULL, NR::Point(0, 0)); - if (curve->end < 1) { - return curve->movePos; + if (end < 1) { + return movePos; } NArtBpath *bpath = NULL; - if (curve->end < 2) { - bpath = curve->_bpath; + if (end < 2) { + bpath = _bpath; } else { - bpath = curve->_bpath + 1; + bpath = _bpath + 1; } g_return_val_if_fail(bpath != NULL, NR::Point(0, 0)); return bpath->c(3); } /** - * Return the second-last point of last subpath or curve->movePos if curve too short. + * Return the second-last point of last subpath or movePos if curve too short. */ NR::Point -sp_curve_penultimate_point(SPCurve const *const curve) +SPCurve::penultimate_point() const { - g_return_val_if_fail(curve != NULL, NR::Point(0, 0)); + g_return_val_if_fail(this != NULL, NR::Point(0, 0)); - if (curve->end < 2) { - return curve->movePos; + if (end < 2) { + return movePos; } - NArtBpath *const bpath = curve->_bpath + curve->end - 2; + NArtBpath *const bpath = _bpath + end - 2; g_return_val_if_fail(bpath != NULL, NR::Point(0, 0)); return bpath->c(3); } @@ -719,9 +708,9 @@ sp_curve_penultimate_point(SPCurve const *const curve) * Return last point of last subpath or (0,0). */ NR::Point -sp_curve_last_point(SPCurve const *const curve) +SPCurve::last_point() const { - NArtBpath *const bpath = sp_curve_last_bpath(curve); + NArtBpath *const bpath = last_bpath(); g_return_val_if_fail(bpath != NULL, NR::Point(0, 0)); return bpath->c(3); } @@ -738,19 +727,19 @@ is_moveto(NRPathcode const c) * with all its markers drawn facing the other direction. **/ SPCurve * -sp_curve_reverse(SPCurve const *curve) +SPCurve::reverse() const { /* We need at least moveto, curveto, end. */ - g_return_val_if_fail(curve->end - curve->substart > 1, NULL); + g_return_val_if_fail(end - substart > 1, NULL); - NArtBpath const *be = curve->_bpath + curve->end - 1; + NArtBpath const *be = _bpath + end - 1; - g_assert(is_moveto(curve->_bpath[curve->substart].code)); - g_assert(is_moveto(curve->_bpath[0].code)); + g_assert(is_moveto(_bpath[substart].code)); + g_assert(is_moveto(_bpath[0].code)); g_assert((be+1)->code == NR_END); - SPCurve *new_curve = sp_curve_new_sized(curve->length); - sp_curve_moveto(new_curve, be->c(3)); + SPCurve *new_curve = new SPCurve(length); + new_curve->moveto(be->c(3)); for (NArtBpath const *bp = be; ; --bp) { switch (bp->code) { @@ -759,18 +748,18 @@ sp_curve_reverse(SPCurve const *curve) new_curve->_bpath[new_curve->substart].code = NR_MOVETO; /* FALL-THROUGH */ case NR_MOVETO_OPEN: - if (bp == curve->_bpath) { + if (bp == _bpath) { return new_curve; } - sp_curve_moveto(new_curve, (bp-1)->c(3)); + new_curve->moveto((bp-1)->c(3)); break; case NR_LINETO: - sp_curve_lineto(new_curve, (bp-1)->c(3)); + new_curve->lineto((bp-1)->c(3)); break; case NR_CURVETO: - sp_curve_curveto(new_curve, bp->c(2), bp->c(1), (bp-1)->c(3)); + new_curve->curveto(bp->c(2), bp->c(1), (bp-1)->c(3)); break; default: @@ -783,11 +772,10 @@ sp_curve_reverse(SPCurve const *curve) * Append \a curve2 to \a curve. */ void -sp_curve_append(SPCurve *curve, - SPCurve const *curve2, +SPCurve::append(SPCurve const *curve2, bool use_lineto) { - g_return_if_fail(curve != NULL); + g_return_if_fail(this != NULL); g_return_if_fail(curve2 != NULL); if (curve2->end < 1) @@ -795,38 +783,38 @@ sp_curve_append(SPCurve *curve, NArtBpath const *bs = curve2->_bpath; - bool closed = curve->closed; + bool _closed = this->closed; for (NArtBpath const *bp = bs; bp->code != NR_END; bp++) { switch (bp->code) { case NR_MOVETO_OPEN: - if (use_lineto && curve->hascpt) { - sp_curve_lineto(curve, bp->x3, bp->y3); + if (use_lineto && hascpt) { + lineto(bp->x3, bp->y3); use_lineto = FALSE; } else { - if (closed) sp_curve_closepath(curve); - sp_curve_moveto(curve, bp->x3, bp->y3); + if (_closed) closepath(); + moveto(bp->x3, bp->y3); } - closed = false; + _closed = false; break; case NR_MOVETO: - if (use_lineto && curve->hascpt) { - sp_curve_lineto(curve, bp->x3, bp->y3); + if (use_lineto && hascpt) { + lineto(bp->x3, bp->y3); use_lineto = FALSE; } else { - if (closed) sp_curve_closepath(curve); - sp_curve_moveto(curve, bp->x3, bp->y3); + if (_closed) closepath(); + moveto(bp->x3, bp->y3); } - closed = true; + _closed = true; break; case NR_LINETO: - sp_curve_lineto(curve, bp->x3, bp->y3); + lineto(bp->x3, bp->y3); break; case NR_CURVETO: - sp_curve_curveto(curve, bp->x1, bp->y1, bp->x2, bp->y2, bp->x3, bp->y3); + curveto(bp->x1, bp->y1, bp->x2, bp->y2, bp->x3, bp->y3); break; case NR_END: @@ -834,29 +822,29 @@ sp_curve_append(SPCurve *curve, } } - if (closed) { - sp_curve_closepath(curve); + if (_closed) { + closepath(); } } /** - * Append \a c1 to \a c0 with possible fusing of close endpoints. + * Append \a c1 to \a this with possible fusing of close endpoints. */ SPCurve * -sp_curve_append_continuous(SPCurve *c0, SPCurve const *c1, gdouble tolerance) +SPCurve::append_continuous(SPCurve const *c1, gdouble tolerance) { - g_return_val_if_fail(c0 != NULL, NULL); + g_return_val_if_fail(this != NULL, NULL); g_return_val_if_fail(c1 != NULL, NULL); - g_return_val_if_fail(!c0->closed, NULL); + g_return_val_if_fail(!closed, NULL); g_return_val_if_fail(!c1->closed, NULL); if (c1->end < 1) { - return c0; + return this; } - NArtBpath *be = sp_curve_last_bpath(c0); + NArtBpath *be = last_bpath(); if (be) { - NArtBpath const *bs = sp_curve_first_bpath(c1); + NArtBpath const *bs = c1->first_bpath(); if ( bs && ( fabs( bs->x3 - be->x3 ) <= tolerance ) && ( fabs( bs->y3 - be->y3 ) <= tolerance ) ) @@ -865,62 +853,62 @@ sp_curve_append_continuous(SPCurve *c0, SPCurve const *c1, gdouble tolerance) * fixme: Strictly we mess in case of multisegment mixed * open/close curves */ - bool closed = false; + bool _closed = false; for (bs = bs + 1; bs->code != NR_END; bs++) { switch (bs->code) { case NR_MOVETO_OPEN: - if (closed) sp_curve_closepath(c0); - sp_curve_moveto(c0, bs->x3, bs->y3); - closed = false; + if (_closed) closepath(); + moveto(bs->x3, bs->y3); + _closed = false; break; case NR_MOVETO: - if (closed) sp_curve_closepath(c0); - sp_curve_moveto(c0, bs->x3, bs->y3); - closed = true; + if (_closed) closepath(); + moveto(bs->x3, bs->y3); + _closed = true; break; case NR_LINETO: - sp_curve_lineto(c0, bs->x3, bs->y3); + lineto(bs->x3, bs->y3); break; case NR_CURVETO: - sp_curve_curveto(c0, bs->x1, bs->y1, bs->x2, bs->y2, bs->x3, bs->y3); + curveto(bs->x1, bs->y1, bs->x2, bs->y2, bs->x3, bs->y3); break; case NR_END: g_assert_not_reached(); } } } else { - sp_curve_append(c0, c1, TRUE); + append(c1, TRUE); } } else { - sp_curve_append(c0, c1, TRUE); + append(c1, TRUE); } - return c0; + return this; } /** * Remove last segment of curve. */ void -sp_curve_backspace(SPCurve *curve) +SPCurve::backspace() { - g_return_if_fail(curve != NULL); + g_return_if_fail(this != NULL); - if (curve->end > 0) { - curve->end -= 1; - if (curve->end > 0) { - NArtBpath *bp = curve->_bpath + curve->end - 1; + if (end > 0) { + end -= 1; + if (end > 0) { + NArtBpath *bp = _bpath + end - 1; if ((bp->code == NR_MOVETO) || (bp->code == NR_MOVETO_OPEN) ) { - curve->hascpt = true; - curve->posSet = true; - curve->closed = false; - curve->movePos = bp->c(3); - curve->end -= 1; + hascpt = true; + posSet = true; + closed = false; + movePos = bp->c(3); + end -= 1; } } - curve->_bpath[curve->end].code = NR_END; + _bpath[end].code = NR_END; } } @@ -1062,23 +1050,23 @@ sp_curve_nonzero_distance_including_space(SPCurve const *const curve, double seg } void -sp_curve_stretch_endpoints(SPCurve *curve, NR::Point const &new_p0, NR::Point const &new_p1) +SPCurve::stretch_endpoints(NR::Point const &new_p0, NR::Point const &new_p1) { - if (sp_curve_empty(curve)) { + if (is_empty()) { return; } - g_assert(unsigned(SP_CURVE_LENGTH(curve)) + 1 == sp_bpath_length(curve->_bpath)); - unsigned const nSegs = SP_CURVE_LENGTH(curve) - 1; + g_assert(unsigned(SP_CURVE_LENGTH(this)) + 1 == sp_bpath_length(_bpath)); + unsigned const nSegs = SP_CURVE_LENGTH(this) - 1; g_assert(nSegs != 0); double *const seg2len = new double[nSegs]; - double const tot_len = sp_curve_nonzero_distance_including_space(curve, seg2len); - NR::Point const offset0( new_p0 - sp_curve_first_point(curve) ); - NR::Point const offset1( new_p1 - sp_curve_last_point(curve) ); - curve->_bpath->setC(3, new_p0); + double const tot_len = sp_curve_nonzero_distance_including_space(this, seg2len); + NR::Point const offset0( new_p0 - first_point() ); + NR::Point const offset1( new_p1 - last_point() ); + _bpath->setC(3, new_p0); double begin_dist = 0.; for (unsigned si = 0; si < nSegs; ++si) { double const end_dist = begin_dist + seg2len[si]; - NArtBpath &p = curve->_bpath[1 + si]; + NArtBpath &p = _bpath[1 + si]; switch (p.code) { case NR_LINETO: case NR_MOVETO: @@ -1098,24 +1086,23 @@ sp_curve_stretch_endpoints(SPCurve *curve, NR::Point const &new_p0, NR::Point co begin_dist = end_dist; } - g_assert(L1(curve->_bpath[nSegs].c(3) - new_p1) < 1.); + g_assert(L1(_bpath[nSegs].c(3) - new_p1) < 1.); /* Explicit set for better numerical properties. */ - curve->_bpath[nSegs].setC(3, new_p1); + _bpath[nSegs].setC(3, new_p1); delete [] seg2len; } void -sp_curve_move_endpoints(SPCurve *curve, NR::Point const &new_p0, - NR::Point const &new_p1) +SPCurve::move_endpoints(NR::Point const &new_p0, NR::Point const &new_p1) { - if (sp_curve_empty(curve)) { + if (is_empty()) { return; } - unsigned const nSegs = SP_CURVE_LENGTH(curve) - 1; + unsigned const nSegs = SP_CURVE_LENGTH(this) - 1; g_assert(nSegs != 0); - curve->_bpath->setC(3, new_p0); - curve->_bpath[nSegs].setC(3, new_p1); + _bpath->setC(3, new_p0); + _bpath[nSegs].setC(3, new_p1); } diff --git a/src/display/curve.h b/src/display/curve.h index 847d09f46..9cbb11529 100644 --- a/src/display/curve.h +++ b/src/display/curve.h @@ -10,6 +10,7 @@ * Copyright (C) 2000 Lauris Kaplinski * Copyright (C) 2000-2001 Ximian, Inc. * Copyright (C) 2002 Lauris Kaplinski + * Copyright (C) 2008 Johan Engelen * * Released under GNU GPL */ @@ -18,11 +19,21 @@ #include #include "libnr/nr-forward.h" -#include "libnr/nr-point.h" #include "libnr/nr-rect.h" +#define SP_CURVE_LENSTEP 32 + /// Wrapper around NArtBpath. -struct SPCurve { +class SPCurve { +public: + /* Constructors */ + SPCurve(gint length = SP_CURVE_LENSTEP); + static SPCurve * new_from_bpath(NArtBpath *bpath); + static SPCurve * new_from_foreign_bpath(NArtBpath const *bpath); + static SPCurve * new_from_rect(NR::Maybe const &rect); + + virtual ~SPCurve(); + gint refcount; NArtBpath *_bpath; @@ -59,62 +70,56 @@ struct SPCurve { /// True iff all subpaths are closed. bool closed : 1; + + SPCurve * ref(); + SPCurve * unref(); + + SPCurve * copy() const; + + GSList * split() const; + void transform(NR::Matrix const &); + void transform(NR::translate const &); + void stretch_endpoints(NR::Point const &, NR::Point const &); + void move_endpoints(NR::Point const &, NR::Point const &); + + void reset(); + + void moveto(NR::Point const &p); + void moveto(gdouble x, gdouble y); + void lineto(NR::Point const &p); + void lineto(gdouble x, gdouble y); + void lineto_moving(gdouble x, gdouble y); + void curveto(NR::Point const &p0, NR::Point const &p1, NR::Point const &p2); + void curveto(gdouble x0, gdouble y0, gdouble x1, gdouble y1, gdouble x2, gdouble y2); + void closepath(); + void closepath_current(); + + SPCurve * append_continuous(SPCurve const *c1, gdouble tolerance); + + bool is_empty() const; + NArtBpath * last_bpath() const; + NArtBpath * first_bpath() const; + NR::Point first_point() const; + NR::Point last_point() const; + NR::Point second_point() const; + NR::Point penultimate_point() const; + + void append(SPCurve const *curve2, bool use_lineto); + SPCurve * reverse() const; + void backspace(); + + static SPCurve * concat(GSList const *list); + +private: + // Don't implement these: + SPCurve(const SPCurve&); + SPCurve& operator=(const SPCurve&); }; #define SP_CURVE_LENGTH(c) (((SPCurve const *)(c))->end) #define SP_CURVE_BPATH(c) (((SPCurve const *)(c))->_bpath) #define SP_CURVE_SEGMENT(c,i) (((SPCurve const *)(c))->_bpath + (i)) -/* Constructors */ - -SPCurve *sp_curve_new(); -SPCurve *sp_curve_new_sized(gint length); -SPCurve *sp_curve_new_from_bpath(NArtBpath *bpath); -SPCurve *sp_curve_new_from_foreign_bpath(NArtBpath const bpath[]); -SPCurve *sp_curve_new_from_rect(NR::Maybe const &rect); - -SPCurve *sp_curve_ref(SPCurve *curve); -SPCurve *sp_curve_unref(SPCurve *curve); - -SPCurve *sp_curve_copy(SPCurve *curve); -SPCurve *sp_curve_concat(GSList const *list); -GSList *sp_curve_split(SPCurve const *curve); -void sp_curve_transform(SPCurve *curve, NR::Matrix const &); -void sp_curve_transform(SPCurve *curve, NR::translate const &); -void sp_curve_stretch_endpoints(SPCurve *curve, NR::Point const &, NR::Point const &); -void sp_curve_move_endpoints(SPCurve *curve, NR::Point const &, - NR::Point const &); - -/* Methods */ - -void sp_curve_reset(SPCurve *curve); - -void sp_curve_moveto(SPCurve *curve, NR::Point const &p); -void sp_curve_moveto(SPCurve *curve, gdouble x, gdouble y); -void sp_curve_lineto(SPCurve *curve, NR::Point const &p); -void sp_curve_lineto(SPCurve *curve, gdouble x, gdouble y); -void sp_curve_lineto_moving(SPCurve *curve, gdouble x, gdouble y); -void sp_curve_curveto(SPCurve *curve, NR::Point const &p0, NR::Point const &p1, NR::Point const &p2); -void sp_curve_curveto(SPCurve *curve, gdouble x0, gdouble y0, gdouble x1, gdouble y1, gdouble x2, gdouble y2); -void sp_curve_closepath(SPCurve *curve); -void sp_curve_closepath_current(SPCurve *curve); - -SPCurve *sp_curve_append_continuous(SPCurve *c0, SPCurve const *c1, gdouble tolerance); - -#define sp_curve_is_empty sp_curve_empty -bool sp_curve_empty(SPCurve *curve); -NArtBpath *sp_curve_last_bpath(SPCurve const *curve); -NArtBpath *sp_curve_first_bpath(SPCurve const *curve); -NR::Point sp_curve_first_point(SPCurve const *curve); -NR::Point sp_curve_last_point(SPCurve const *curve); -NR::Point sp_curve_second_point(SPCurve const *curve); -NR::Point sp_curve_penultimate_point(SPCurve const *curve); - -void sp_curve_append(SPCurve *curve, SPCurve const *curve2, bool use_lineto); -SPCurve *sp_curve_reverse(SPCurve const *curve); -void sp_curve_backspace(SPCurve *curve); - - #endif /* !SEEN_DISPLAY_CURVE_H */ /* diff --git a/src/display/nr-arena-shape.cpp b/src/display/nr-arena-shape.cpp index 5676b3ce6..4df93a9a2 100644 --- a/src/display/nr-arena-shape.cpp +++ b/src/display/nr-arena-shape.cpp @@ -142,7 +142,7 @@ nr_arena_shape_finalize(NRObject *object) if (shape->stroke_painter) sp_painter_free(shape->stroke_painter); if (shape->style) sp_style_unref(shape->style); - if (shape->curve) sp_curve_unref(shape->curve); + if (shape->curve) shape->curve->unref(); ((NRObjectClass *) shape_parent_class)->finalize(object); } @@ -333,7 +333,7 @@ nr_arena_shape_update(NRArenaItem *item, NRRectL *area, NRGC *gc, guint state, g if (!shape->curve || !shape->style || - sp_curve_is_empty(shape->curve) || + shape->curve->is_empty() || (( shape->_fill.paint.type() == NRArenaShape::Paint::NONE ) && ( shape->_stroke.paint.type() == NRArenaShape::Paint::NONE && !outline) )) { @@ -1188,13 +1188,13 @@ void nr_arena_shape_set_path(NRArenaShape *shape, SPCurve *curve,bool justTrans) nr_arena_item_request_render(NR_ARENA_ITEM(shape)); if (shape->curve) { - sp_curve_unref(shape->curve); + shape->curve->unref(); shape->curve = NULL; } if (curve) { shape->curve = curve; - sp_curve_ref(curve); + curve->ref(); } nr_arena_item_request_update(NR_ARENA_ITEM(shape), NR_ARENA_ITEM_STATE_ALL, FALSE); diff --git a/src/draw-context.cpp b/src/draw-context.cpp index 05045e969..b48b34ed0 100644 --- a/src/draw-context.cpp +++ b/src/draw-context.cpp @@ -164,16 +164,16 @@ sp_draw_context_setup(SPEventContext *ec) dc->red_bpath = sp_canvas_bpath_new(sp_desktop_sketch(ec->desktop), NULL); sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(dc->red_bpath), dc->red_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); /* Create red curve */ - dc->red_curve = sp_curve_new_sized(4); + dc->red_curve = new SPCurve(4); /* Create blue bpath */ dc->blue_bpath = sp_canvas_bpath_new(sp_desktop_sketch(ec->desktop), NULL); sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(dc->blue_bpath), dc->blue_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); /* Create blue curve */ - dc->blue_curve = sp_curve_new_sized(8); + dc->blue_curve = new SPCurve(8); /* Create green curve */ - dc->green_curve = sp_curve_new_sized(64); + dc->green_curve = new SPCurve(64); /* No green anchor by default */ dc->green_anchor = NULL; dc->green_closed = FALSE; @@ -280,10 +280,10 @@ spdc_attach_selection(SPDrawContext *dc, Inkscape::Selection */*sel*/) /* Curve list */ /* We keep it in desktop coordinates to eliminate calculation errors */ SPCurve *norm = sp_path_get_curve_for_edit (SP_PATH(item)); - sp_curve_transform(norm, sp_item_i2d_affine(dc->white_item)); + norm->transform(sp_item_i2d_affine(dc->white_item)); g_return_if_fail( norm != NULL ); - dc->white_curves = g_slist_reverse(sp_curve_split(norm)); - sp_curve_unref(norm); + dc->white_curves = g_slist_reverse(norm->split()); + norm->unref(); /* Anchor list */ for (GSList *l = dc->white_curves; l != NULL; l = l->next) { SPCurve *c; @@ -292,8 +292,8 @@ spdc_attach_selection(SPDrawContext *dc, Inkscape::Selection */*sel*/) if ( SP_CURVE_BPATH(c)->code == NR_MOVETO_OPEN ) { NArtBpath *s, *e; SPDrawAnchor *a; - s = sp_curve_first_bpath(c); - e = sp_curve_last_bpath(c); + s = c->first_bpath(); + e = c->last_bpath(); a = sp_draw_anchor_new(dc, c, TRUE, NR::Point(s->x3, s->y3)); dc->white_anchors = g_slist_prepend(dc->white_anchors, a); a = sp_draw_anchor_new(dc, c, FALSE, NR::Point(e->x3, e->y3)); @@ -378,8 +378,8 @@ void spdc_endpoint_snap_free(SPEventContext const * const ec, NR::Point& p, guin static SPCurve * reverse_then_unref(SPCurve *orig) { - SPCurve *ret = sp_curve_reverse(orig); - sp_curve_unref(orig); + SPCurve *ret = orig->reverse(); + orig->unref(); return ret; } @@ -395,24 +395,24 @@ spdc_concat_colors_and_flush(SPDrawContext *dc, gboolean forceclosed) SPCurve *c = dc->green_curve; /* Green */ - dc->green_curve = sp_curve_new_sized(64); + dc->green_curve = new SPCurve(64); while (dc->green_bpaths) { gtk_object_destroy(GTK_OBJECT(dc->green_bpaths->data)); dc->green_bpaths = g_slist_remove(dc->green_bpaths, dc->green_bpaths->data); } /* Blue */ - sp_curve_append_continuous(c, dc->blue_curve, 0.0625); - sp_curve_reset(dc->blue_curve); + c->append_continuous(dc->blue_curve, 0.0625); + dc->blue_curve->reset(); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(dc->blue_bpath), NULL); /* Red */ if (dc->red_curve_is_valid) { - sp_curve_append_continuous(c, dc->red_curve, 0.0625); + c->append_continuous(dc->red_curve, 0.0625); } - sp_curve_reset(dc->red_curve); + dc->red_curve->reset(); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(dc->red_bpath), NULL); - if (sp_curve_empty(c)) { - sp_curve_unref(c); + if (c->is_empty()) { + c->unref(); return; } @@ -420,10 +420,10 @@ spdc_concat_colors_and_flush(SPDrawContext *dc, gboolean forceclosed) if ( forceclosed || ( dc->green_anchor && dc->green_anchor->active ) ) { // We hit green anchor, closing Green-Blue-Red SP_EVENT_CONTEXT_DESKTOP(dc)->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Path is closed.")); - sp_curve_closepath_current(c); + c->closepath_current(); /* Closed path, just flush */ spdc_flush_white(dc, c); - sp_curve_unref(c); + c->unref(); return; } @@ -438,9 +438,9 @@ spdc_concat_colors_and_flush(SPDrawContext *dc, gboolean forceclosed) if (dc->sa->start && !(dc->sa->curve->closed) ) { c = reverse_then_unref(c); } - sp_curve_append_continuous(dc->sa->curve, c, 0.0625); - sp_curve_unref(c); - sp_curve_closepath_current(dc->sa->curve); + dc->sa->curve->append_continuous(c, 0.0625); + c->unref(); + dc->sa->curve->closepath_current(); spdc_flush_white(dc, NULL); return; } @@ -452,8 +452,8 @@ spdc_concat_colors_and_flush(SPDrawContext *dc, gboolean forceclosed) if (dc->sa->start) { s = reverse_then_unref(s); } - sp_curve_append_continuous(s, c, 0.0625); - sp_curve_unref(c); + s->append_continuous(c, 0.0625); + c->unref(); c = s; } else /* Step D - test end */ if (dc->ea) { SPCurve *e = dc->ea->curve; @@ -461,14 +461,14 @@ spdc_concat_colors_and_flush(SPDrawContext *dc, gboolean forceclosed) if (!dc->ea->start) { e = reverse_then_unref(e); } - sp_curve_append_continuous(c, e, 0.0625); - sp_curve_unref(e); + c->append_continuous(e, 0.0625); + e->unref(); } spdc_flush_white(dc, c); - sp_curve_unref(c); + c->unref(); } static char const * @@ -494,21 +494,21 @@ spdc_flush_white(SPDrawContext *dc, SPCurve *gc) if (dc->white_curves) { g_assert(dc->white_item); - c = sp_curve_concat(dc->white_curves); + c = SPCurve::concat(dc->white_curves); g_slist_free(dc->white_curves); dc->white_curves = NULL; if (gc) { - sp_curve_append(c, gc, FALSE); + c->append(gc, FALSE); } } else if (gc) { c = gc; - sp_curve_ref(c); + c->ref(); } else { return; } /* Now we have to go back to item coordinates at last */ - sp_curve_transform(c, ( dc->white_item + c->transform(( dc->white_item ? sp_item_dt2i_affine(dc->white_item) : sp_desktop_dt2root_affine(SP_EVENT_CONTEXT_DESKTOP(dc)) )); @@ -516,7 +516,7 @@ spdc_flush_white(SPDrawContext *dc, SPCurve *gc) SPDocument *doc = sp_desktop_document(desktop); Inkscape::XML::Document *xml_doc = sp_document_repr_doc(doc); - if ( c && !sp_curve_empty(c) ) { + if ( c && !c->is_empty() ) { /* We actually have something to write */ bool has_lpe = false; @@ -558,7 +558,7 @@ spdc_flush_white(SPDrawContext *dc, SPCurve *gc) spdc_selection_modified(sp_desktop_selection(desktop), 0, dc); } - sp_curve_unref(c); + c->unref(); /* Flush pending updates */ sp_document_ensure_up_to_date(doc); @@ -595,7 +595,7 @@ spdc_reset_white(SPDrawContext *dc) dc->white_item = NULL; } while (dc->white_curves) { - sp_curve_unref((SPCurve *) dc->white_curves->data); + reinterpret_cast(dc->white_curves->data)->unref(); dc->white_curves = g_slist_remove(dc->white_curves, dc->white_curves->data); } while (dc->white_anchors) { @@ -613,7 +613,7 @@ spdc_free_colors(SPDrawContext *dc) dc->red_bpath = NULL; } if (dc->red_curve) { - dc->red_curve = sp_curve_unref(dc->red_curve); + dc->red_curve = dc->red_curve->unref(); } /* Blue */ if (dc->blue_bpath) { @@ -621,7 +621,7 @@ spdc_free_colors(SPDrawContext *dc) dc->blue_bpath = NULL; } if (dc->blue_curve) { - dc->blue_curve = sp_curve_unref(dc->blue_curve); + dc->blue_curve = dc->blue_curve->unref(); } /* Green */ while (dc->green_bpaths) { @@ -629,7 +629,7 @@ spdc_free_colors(SPDrawContext *dc) dc->green_bpaths = g_slist_remove(dc->green_bpaths, dc->green_bpaths->data); } if (dc->green_curve) { - dc->green_curve = sp_curve_unref(dc->green_curve); + dc->green_curve = dc->green_curve->unref(); } if (dc->green_anchor) { dc->green_anchor = sp_draw_anchor_destroy(dc->green_anchor); @@ -640,7 +640,7 @@ spdc_free_colors(SPDrawContext *dc) dc->white_item = NULL; } while (dc->white_curves) { - sp_curve_unref((SPCurve *) dc->white_curves->data); + reinterpret_cast(dc->white_curves->data)->unref(); dc->white_curves = g_slist_remove(dc->white_curves, dc->white_curves->data); } while (dc->white_anchors) { diff --git a/src/dropper-context.cpp b/src/dropper-context.cpp index 5a1178040..81814fc01 100644 --- a/src/dropper-context.cpp +++ b/src/dropper-context.cpp @@ -111,9 +111,9 @@ static void sp_dropper_context_setup(SPEventContext *ec) ((SPEventContextClass *) parent_class)->setup(ec); } - SPCurve *c = sp_curve_new_from_foreign_bpath(spdc_circle); + SPCurve *c = SPCurve::new_from_foreign_bpath(spdc_circle); dc->area = sp_canvas_bpath_new(sp_desktop_controls(ec->desktop), c); - sp_curve_unref(c); + c->unref(); sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(dc->area), 0x00000000,(SPWindRule)0); sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(dc->area), 0x0000007f, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); sp_canvas_item_hide(dc->area); diff --git a/src/dyna-draw-context.cpp b/src/dyna-draw-context.cpp index 666ea4d2d..4de36d0d7 100644 --- a/src/dyna-draw-context.cpp +++ b/src/dyna-draw-context.cpp @@ -223,7 +223,7 @@ sp_dyna_draw_context_dispose(GObject *object) } if (ddc->accumulated) { - ddc->accumulated = sp_curve_unref(ddc->accumulated); + ddc->accumulated = ddc->accumulated->unref(); } while (ddc->segments) { @@ -231,9 +231,9 @@ sp_dyna_draw_context_dispose(GObject *object) ddc->segments = g_slist_remove(ddc->segments, ddc->segments->data); } - if (ddc->currentcurve) ddc->currentcurve = sp_curve_unref(ddc->currentcurve); - if (ddc->cal1) ddc->cal1 = sp_curve_unref(ddc->cal1); - if (ddc->cal2) ddc->cal2 = sp_curve_unref(ddc->cal2); + if (ddc->currentcurve) ddc->currentcurve = ddc->currentcurve->unref(); + if (ddc->cal1) ddc->cal1 = ddc->cal1->unref(); + if (ddc->cal2) ddc->cal2 = ddc->cal2->unref(); if (ddc->currentshape) { gtk_object_destroy(GTK_OBJECT(ddc->currentshape)); @@ -258,11 +258,11 @@ sp_dyna_draw_context_setup(SPEventContext *ec) if (((SPEventContextClass *) parent_class)->setup) ((SPEventContextClass *) parent_class)->setup(ec); - ddc->accumulated = sp_curve_new_sized(32); - ddc->currentcurve = sp_curve_new_sized(4); + ddc->accumulated = new SPCurve(32); + ddc->currentcurve = new SPCurve(4); - ddc->cal1 = sp_curve_new_sized(32); - ddc->cal2 = sp_curve_new_sized(32); + ddc->cal1 = new SPCurve(32); + ddc->cal2 = new SPCurve(32); ddc->currentshape = sp_canvas_item_new(sp_desktop_sketch(ec->desktop), SP_TYPE_CANVAS_BPATH, NULL); sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(ddc->currentshape), DDC_RED_RGBA, SP_WIND_RULE_EVENODD); @@ -271,9 +271,9 @@ sp_dyna_draw_context_setup(SPEventContext *ec) g_signal_connect(G_OBJECT(ddc->currentshape), "event", G_CALLBACK(sp_desktop_root_handler), ec->desktop); { - SPCurve *c = sp_curve_new_from_foreign_bpath(hatch_area_circle); + SPCurve *c = SPCurve::new_from_foreign_bpath(hatch_area_circle); ddc->hatch_area = sp_canvas_bpath_new(sp_desktop_controls(ec->desktop), c); - sp_curve_unref(c); + c->unref(); sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(ddc->hatch_area), 0x00000000,(SPWindRule)0); sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(ddc->hatch_area), 0x0000007f, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); sp_canvas_item_hide(ddc->hatch_area); @@ -598,7 +598,7 @@ calligraphic_cancel(SPDynaDrawContext *dc) dc->segments = g_slist_remove(dc->segments, dc->segments->data); } /* reset accumulated curve */ - sp_curve_reset(dc->accumulated); + dc->accumulated->reset(); clear_current(dc); if (dc->repr) { dc->repr = NULL; @@ -631,7 +631,7 @@ sp_dyna_draw_context_root_handler(SPEventContext *event_context, sp_dyna_draw_reset(dc, button_dt); sp_dyna_draw_extinput(dc, event); sp_dyna_draw_apply(dc, button_dt); - sp_curve_reset(dc->accumulated); + dc->accumulated->reset(); if (dc->repr) { dc->repr = NULL; } @@ -891,7 +891,7 @@ sp_dyna_draw_context_root_handler(SPEventContext *event_context, set_to_accumulated(dc, event->button.state & GDK_SHIFT_MASK); // performs document_done /* reset accumulated curve */ - sp_curve_reset(dc->accumulated); + dc->accumulated->reset(); clear_current(dc); if (dc->repr) { @@ -1034,9 +1034,9 @@ clear_current(SPDynaDrawContext *dc) /* reset bpath */ sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(dc->currentshape), NULL); /* reset curve */ - sp_curve_reset(dc->currentcurve); - sp_curve_reset(dc->cal1); - sp_curve_reset(dc->cal2); + dc->currentcurve->reset(); + dc->cal1->reset(); + dc->cal2->reset(); /* reset points */ dc->npoints = 0; } @@ -1046,7 +1046,7 @@ set_to_accumulated(SPDynaDrawContext *dc, bool unionize) { SPDesktop *desktop = SP_EVENT_CONTEXT(dc)->desktop; - if (!sp_curve_empty(dc->accumulated)) { + if (!dc->accumulated->is_empty()) { NArtBpath *abp; gchar *str; @@ -1065,7 +1065,7 @@ set_to_accumulated(SPDynaDrawContext *dc, bool unionize) item->transform = SP_ITEM(desktop->currentRoot())->getRelativeTransform(desktop->currentLayer()); item->updateRepr(); } - abp = nr_artpath_affine(sp_curve_first_bpath(dc->accumulated), sp_desktop_dt2root_affine(desktop)); + abp = nr_artpath_affine(dc->accumulated->first_bpath(), sp_desktop_dt2root_affine(desktop)); str = sp_svg_write_path(abp); g_assert( str != NULL ); g_free(abp); @@ -1118,16 +1118,16 @@ add_cap(SPCurve *curve, } if ( NR::L2(v_in) > DYNA_EPSILON || NR::L2(v_out) > DYNA_EPSILON ) { - sp_curve_curveto(curve, from + v_in, to + v_out, to); + curve->curveto(from + v_in, to + v_out, to); } } static void accumulate_calligraphic(SPDynaDrawContext *dc) { - if ( !sp_curve_empty(dc->cal1) && !sp_curve_empty(dc->cal2) ) { - sp_curve_reset(dc->accumulated); /* Is this required ?? */ - SPCurve *rev_cal2 = sp_curve_reverse(dc->cal2); + if ( !dc->cal1->is_empty() && !dc->cal2->is_empty() ) { + dc->accumulated->reset(); /* Is this required ?? */ + SPCurve *rev_cal2 = dc->cal2->reverse(); g_assert(dc->cal1->end > 1); g_assert(rev_cal2->end > 1); @@ -1138,20 +1138,20 @@ accumulate_calligraphic(SPDynaDrawContext *dc) g_assert(SP_CURVE_SEGMENT(dc->cal1, dc->cal1->end-1)->code == NR_CURVETO); g_assert(SP_CURVE_SEGMENT(rev_cal2, rev_cal2->end-1)->code == NR_CURVETO); - sp_curve_append(dc->accumulated, dc->cal1, FALSE); + dc->accumulated->append(dc->cal1, FALSE); add_cap(dc->accumulated, SP_CURVE_SEGMENT(dc->cal1, dc->cal1->end-1)->c(2), SP_CURVE_SEGMENT(dc->cal1, dc->cal1->end-1)->c(3), SP_CURVE_SEGMENT(rev_cal2, 0)->c(3), SP_CURVE_SEGMENT(rev_cal2, 1)->c(1), dc->cap_rounding); - sp_curve_append(dc->accumulated, rev_cal2, TRUE); + dc->accumulated->append(rev_cal2, TRUE); add_cap(dc->accumulated, SP_CURVE_SEGMENT(rev_cal2, rev_cal2->end-1)->c(2), SP_CURVE_SEGMENT(rev_cal2, rev_cal2->end-1)->c(3), SP_CURVE_SEGMENT(dc->cal1, 0)->c(3), SP_CURVE_SEGMENT(dc->cal1, 1)->c(1), dc->cap_rounding); - sp_curve_closepath(dc->accumulated); + dc->accumulated->closepath(); - sp_curve_unref(rev_cal2); + rev_cal2->unref(); - sp_curve_reset(dc->cal1); - sp_curve_reset(dc->cal2); + dc->cal1->reset(); + dc->cal2->reset(); } } @@ -1186,11 +1186,11 @@ fit_and_split(SPDynaDrawContext *dc, gboolean release) if ( dc->cal1->end == 0 || dc->cal2->end == 0 ) { /* dc->npoints > 0 */ /* g_print("calligraphics(1|2) reset\n"); */ - sp_curve_reset(dc->cal1); - sp_curve_reset(dc->cal2); + dc->cal1->reset(); + dc->cal2->reset(); - sp_curve_moveto(dc->cal1, dc->point1[0]); - sp_curve_moveto(dc->cal2, dc->point2[0]); + dc->cal1->moveto(dc->point1[0]); + dc->cal2->moveto(dc->point2[0]); } NR::Point b1[BEZIER_MAX_LENGTH]; @@ -1210,31 +1210,30 @@ fit_and_split(SPDynaDrawContext *dc, gboolean release) #endif /* CanvasShape */ if (! release) { - sp_curve_reset(dc->currentcurve); - sp_curve_moveto(dc->currentcurve, b1[0]); + dc->currentcurve->reset(); + dc->currentcurve->moveto(b1[0]); for (NR::Point *bp1 = b1; bp1 < b1 + BEZIER_SIZE * nb1; bp1 += BEZIER_SIZE) { - sp_curve_curveto(dc->currentcurve, bp1[1], + dc->currentcurve->curveto(bp1[1], bp1[2], bp1[3]); } - sp_curve_lineto(dc->currentcurve, - b2[BEZIER_SIZE*(nb2-1) + 3]); + dc->currentcurve->lineto(b2[BEZIER_SIZE*(nb2-1) + 3]); for (NR::Point *bp2 = b2 + BEZIER_SIZE * ( nb2 - 1 ); bp2 >= b2; bp2 -= BEZIER_SIZE) { - sp_curve_curveto(dc->currentcurve, bp2[2], bp2[1], bp2[0]); + dc->currentcurve->curveto(bp2[2], bp2[1], bp2[0]); } // FIXME: dc->segments is always NULL at this point?? if (!dc->segments) { // first segment add_cap(dc->currentcurve, b2[1], b2[0], b1[0], b1[1], dc->cap_rounding); } - sp_curve_closepath(dc->currentcurve); + dc->currentcurve->closepath(); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(dc->currentshape), dc->currentcurve); } /* Current calligraphic */ for (NR::Point *bp1 = b1; bp1 < b1 + BEZIER_SIZE * nb1; bp1 += BEZIER_SIZE) { - sp_curve_curveto(dc->cal1, bp1[1], bp1[2], bp1[3]); + dc->cal1->curveto(bp1[1], bp1[2], bp1[3]); } for (NR::Point *bp2 = b2; bp2 < b2 + BEZIER_SIZE * nb2; bp2 += BEZIER_SIZE) { - sp_curve_curveto(dc->cal2, bp2[1], bp2[2], bp2[3]); + dc->cal2->curveto(bp2[1], bp2[2], bp2[3]); } } else { /* fixme: ??? */ @@ -1244,10 +1243,10 @@ fit_and_split(SPDynaDrawContext *dc, gboolean release) draw_temporary_box(dc); for (gint i = 1; i < dc->npoints; i++) { - sp_curve_lineto(dc->cal1, dc->point1[i]); + dc->cal1->lineto(dc->point1[i]); } for (gint i = 1; i < dc->npoints; i++) { - sp_curve_lineto(dc->cal2, dc->point2[i]); + dc->cal2->lineto(dc->point2[i]); } } @@ -1256,14 +1255,14 @@ fit_and_split(SPDynaDrawContext *dc, gboolean release) g_print("[%d]Yup\n", dc->npoints); #endif if (!release) { - g_assert(!sp_curve_empty(dc->currentcurve)); + g_assert(!dc->currentcurve->is_empty()); SPCanvasItem *cbp = sp_canvas_item_new(sp_desktop_sketch(SP_EVENT_CONTEXT(dc)->desktop), SP_TYPE_CANVAS_BPATH, NULL); - SPCurve *curve = sp_curve_copy(dc->currentcurve); + SPCurve *curve = dc->currentcurve->copy(); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH (cbp), curve); - sp_curve_unref(curve); + curve->unref(); guint32 fillColor = sp_desktop_get_color_tool (SP_ACTIVE_DESKTOP, "tools.calligraphic", true); //guint32 strokeColor = sp_desktop_get_color_tool (SP_ACTIVE_DESKTOP, "tools.calligraphic", false); @@ -1291,20 +1290,20 @@ fit_and_split(SPDynaDrawContext *dc, gboolean release) static void draw_temporary_box(SPDynaDrawContext *dc) { - sp_curve_reset(dc->currentcurve); + dc->currentcurve->reset(); - sp_curve_moveto(dc->currentcurve, dc->point1[dc->npoints-1]); + dc->currentcurve->moveto(dc->point1[dc->npoints-1]); for (gint i = dc->npoints-2; i >= 0; i--) { - sp_curve_lineto(dc->currentcurve, dc->point1[i]); + dc->currentcurve->lineto(dc->point1[i]); } for (gint i = 0; i < dc->npoints; i++) { - sp_curve_lineto(dc->currentcurve, dc->point2[i]); + dc->currentcurve->lineto(dc->point2[i]); } if (dc->npoints >= 2) { add_cap(dc->currentcurve, dc->point2[dc->npoints-2], dc->point2[dc->npoints-1], dc->point1[dc->npoints-1], dc->point1[dc->npoints-2], dc->cap_rounding); } - sp_curve_closepath(dc->currentcurve); + dc->currentcurve->closepath(); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(dc->currentshape), dc->currentcurve); } diff --git a/src/eraser-context.cpp b/src/eraser-context.cpp index 3ee75eb85..295e75e87 100644 --- a/src/eraser-context.cpp +++ b/src/eraser-context.cpp @@ -190,7 +190,7 @@ sp_eraser_context_dispose(GObject *object) SPEraserContext *erc = SP_ERASER_CONTEXT(object); if (erc->accumulated) { - erc->accumulated = sp_curve_unref(erc->accumulated); + erc->accumulated = erc->accumulated->unref(); } while (erc->segments) { @@ -198,9 +198,9 @@ sp_eraser_context_dispose(GObject *object) erc->segments = g_slist_remove(erc->segments, erc->segments->data); } - if (erc->currentcurve) erc->currentcurve = sp_curve_unref(erc->currentcurve); - if (erc->cal1) erc->cal1 = sp_curve_unref(erc->cal1); - if (erc->cal2) erc->cal2 = sp_curve_unref(erc->cal2); + if (erc->currentcurve) erc->currentcurve = erc->currentcurve->unref(); + if (erc->cal1) erc->cal1 = erc->cal1->unref(); + if (erc->cal2) erc->cal2 = erc->cal2->unref(); if (erc->currentshape) { gtk_object_destroy(GTK_OBJECT(erc->currentshape)); @@ -223,11 +223,11 @@ sp_eraser_context_setup(SPEventContext *ec) if (((SPEventContextClass *) parent_class)->setup) ((SPEventContextClass *) parent_class)->setup(ec); - erc->accumulated = sp_curve_new_sized(32); - erc->currentcurve = sp_curve_new_sized(4); + erc->accumulated = new SPCurve(32); + erc->currentcurve = new SPCurve(4); - erc->cal1 = sp_curve_new_sized(32); - erc->cal2 = sp_curve_new_sized(32); + erc->cal1 = new SPCurve(32); + erc->cal2 = new SPCurve(32); erc->currentshape = sp_canvas_item_new(sp_desktop_sketch(ec->desktop), SP_TYPE_CANVAS_BPATH, NULL); sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(erc->currentshape), ERC_RED_RGBA, SP_WIND_RULE_EVENODD); @@ -546,7 +546,7 @@ eraser_cancel(SPEraserContext *dc) dc->segments = g_slist_remove(dc->segments, dc->segments->data); } /* reset accumulated curve */ - sp_curve_reset(dc->accumulated); + dc->accumulated->reset(); clear_current(dc); if (dc->repr) { dc->repr = NULL; @@ -579,7 +579,7 @@ sp_eraser_context_root_handler(SPEventContext *event_context, sp_eraser_reset(dc, button_dt); sp_eraser_extinput(dc, event); sp_eraser_apply(dc, button_dt); - sp_curve_reset(dc->accumulated); + dc->accumulated->reset(); if (dc->repr) { dc->repr = NULL; } @@ -663,7 +663,7 @@ sp_eraser_context_root_handler(SPEventContext *event_context, set_to_accumulated(dc); // performs document_done /* reset accumulated curve */ - sp_curve_reset(dc->accumulated); + dc->accumulated->reset(); clear_current(dc); if (dc->repr) { @@ -790,9 +790,9 @@ clear_current(SPEraserContext *dc) sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(dc->currentshape), NULL); // reset curve - sp_curve_reset(dc->currentcurve); - sp_curve_reset(dc->cal1); - sp_curve_reset(dc->cal2); + dc->currentcurve->reset(); + dc->cal1->reset(); + dc->cal2->reset(); // reset points dc->npoints = 0; @@ -804,7 +804,7 @@ set_to_accumulated(SPEraserContext *dc) SPDesktop *desktop = SP_EVENT_CONTEXT(dc)->desktop; bool workDone = false; - if (!sp_curve_empty(dc->accumulated)) { + if (!dc->accumulated->is_empty()) { NArtBpath *abp; gchar *str; @@ -823,7 +823,7 @@ set_to_accumulated(SPEraserContext *dc) item->transform = SP_ITEM(desktop->currentRoot())->getRelativeTransform(desktop->currentLayer()); item->updateRepr(); } - abp = nr_artpath_affine(sp_curve_first_bpath(dc->accumulated), sp_desktop_dt2root_affine(desktop)); + abp = nr_artpath_affine(dc->accumulated->first_bpath(), sp_desktop_dt2root_affine(desktop)); str = sp_svg_write_path(abp); g_assert( str != NULL ); g_free(abp); @@ -955,16 +955,16 @@ add_cap(SPCurve *curve, } if ( NR::L2(v_in) > ERASER_EPSILON || NR::L2(v_out) > ERASER_EPSILON ) { - sp_curve_curveto(curve, from + v_in, to + v_out, to); + curve->curveto(from + v_in, to + v_out, to); } } static void accumulate_eraser(SPEraserContext *dc) { - if ( !sp_curve_empty(dc->cal1) && !sp_curve_empty(dc->cal2) ) { - sp_curve_reset(dc->accumulated); // Is this required ?? - SPCurve *rev_cal2 = sp_curve_reverse(dc->cal2); + if ( !dc->cal1->is_empty() && !dc->cal2->is_empty() ) { + dc->accumulated->reset(); /* Is this required ?? */ + SPCurve *rev_cal2 = dc->cal2->reverse(); g_assert(dc->cal1->end > 1); g_assert(rev_cal2->end > 1); @@ -975,20 +975,20 @@ accumulate_eraser(SPEraserContext *dc) g_assert(SP_CURVE_SEGMENT(dc->cal1, dc->cal1->end-1)->code == NR_CURVETO); g_assert(SP_CURVE_SEGMENT(rev_cal2, rev_cal2->end-1)->code == NR_CURVETO); - sp_curve_append(dc->accumulated, dc->cal1, FALSE); + dc->accumulated->append(dc->cal1, FALSE); add_cap(dc->accumulated, SP_CURVE_SEGMENT(dc->cal1, dc->cal1->end-1)->c(2), SP_CURVE_SEGMENT(dc->cal1, dc->cal1->end-1)->c(3), SP_CURVE_SEGMENT(rev_cal2, 0)->c(3), SP_CURVE_SEGMENT(rev_cal2, 1)->c(1), dc->cap_rounding); - sp_curve_append(dc->accumulated, rev_cal2, TRUE); + dc->accumulated->append(rev_cal2, TRUE); add_cap(dc->accumulated, SP_CURVE_SEGMENT(rev_cal2, rev_cal2->end-1)->c(2), SP_CURVE_SEGMENT(rev_cal2, rev_cal2->end-1)->c(3), SP_CURVE_SEGMENT(dc->cal1, 0)->c(3), SP_CURVE_SEGMENT(dc->cal1, 1)->c(1), dc->cap_rounding); - sp_curve_closepath(dc->accumulated); + dc->accumulated->closepath(); - sp_curve_unref(rev_cal2); + rev_cal2->unref(); - sp_curve_reset(dc->cal1); - sp_curve_reset(dc->cal2); + dc->cal1->reset(); + dc->cal2->reset(); } } @@ -1023,11 +1023,11 @@ fit_and_split(SPEraserContext *dc, gboolean release) if ( dc->cal1->end == 0 || dc->cal2->end == 0 ) { /* dc->npoints > 0 */ /* g_print("erasers(1|2) reset\n"); */ - sp_curve_reset(dc->cal1); - sp_curve_reset(dc->cal2); + dc->cal1->reset(); + dc->cal2->reset(); - sp_curve_moveto(dc->cal1, dc->point1[0]); - sp_curve_moveto(dc->cal2, dc->point2[0]); + dc->cal1->moveto(dc->point1[0]); + dc->cal2->moveto(dc->point2[0]); } NR::Point b1[BEZIER_MAX_LENGTH]; @@ -1047,31 +1047,30 @@ fit_and_split(SPEraserContext *dc, gboolean release) #endif /* CanvasShape */ if (! release) { - sp_curve_reset(dc->currentcurve); - sp_curve_moveto(dc->currentcurve, b1[0]); + dc->currentcurve->reset(); + dc->currentcurve->moveto(b1[0]); for (NR::Point *bp1 = b1; bp1 < b1 + BEZIER_SIZE * nb1; bp1 += BEZIER_SIZE) { - sp_curve_curveto(dc->currentcurve, bp1[1], + dc->currentcurve->curveto(bp1[1], bp1[2], bp1[3]); } - sp_curve_lineto(dc->currentcurve, - b2[BEZIER_SIZE*(nb2-1) + 3]); + dc->currentcurve->lineto(b2[BEZIER_SIZE*(nb2-1) + 3]); for (NR::Point *bp2 = b2 + BEZIER_SIZE * ( nb2 - 1 ); bp2 >= b2; bp2 -= BEZIER_SIZE) { - sp_curve_curveto(dc->currentcurve, bp2[2], bp2[1], bp2[0]); + dc->currentcurve->curveto(bp2[2], bp2[1], bp2[0]); } // FIXME: dc->segments is always NULL at this point?? if (!dc->segments) { // first segment add_cap(dc->currentcurve, b2[1], b2[0], b1[0], b1[1], dc->cap_rounding); } - sp_curve_closepath(dc->currentcurve); + dc->currentcurve->closepath(); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(dc->currentshape), dc->currentcurve); } /* Current eraser */ for (NR::Point *bp1 = b1; bp1 < b1 + BEZIER_SIZE * nb1; bp1 += BEZIER_SIZE) { - sp_curve_curveto(dc->cal1, bp1[1], bp1[2], bp1[3]); + dc->cal1->curveto(bp1[1], bp1[2], bp1[3]); } for (NR::Point *bp2 = b2; bp2 < b2 + BEZIER_SIZE * nb2; bp2 += BEZIER_SIZE) { - sp_curve_curveto(dc->cal2, bp2[1], bp2[2], bp2[3]); + dc->cal2->curveto(bp2[1], bp2[2], bp2[3]); } } else { /* fixme: ??? */ @@ -1081,10 +1080,10 @@ fit_and_split(SPEraserContext *dc, gboolean release) draw_temporary_box(dc); for (gint i = 1; i < dc->npoints; i++) { - sp_curve_lineto(dc->cal1, dc->point1[i]); + dc->cal1->lineto(dc->point1[i]); } for (gint i = 1; i < dc->npoints; i++) { - sp_curve_lineto(dc->cal2, dc->point2[i]); + dc->cal2->lineto(dc->point2[i]); } } @@ -1094,14 +1093,14 @@ fit_and_split(SPEraserContext *dc, gboolean release) #endif if (!release) { gint eraserMode = (prefs_get_int_attribute("tools.eraser", "mode", 0) != 0) ? 1 : 0; - g_assert(!sp_curve_empty(dc->currentcurve)); + g_assert(!dc->currentcurve->is_empty()); SPCanvasItem *cbp = sp_canvas_item_new(sp_desktop_sketch(SP_EVENT_CONTEXT(dc)->desktop), SP_TYPE_CANVAS_BPATH, NULL); - SPCurve *curve = sp_curve_copy(dc->currentcurve); + SPCurve *curve = dc->currentcurve->copy(); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH (cbp), curve); - sp_curve_unref(curve); + curve->unref(); guint32 fillColor = sp_desktop_get_color_tool (SP_ACTIVE_DESKTOP, "tools.eraser", true); //guint32 strokeColor = sp_desktop_get_color_tool (SP_ACTIVE_DESKTOP, "tools.eraser", false); @@ -1134,20 +1133,20 @@ fit_and_split(SPEraserContext *dc, gboolean release) static void draw_temporary_box(SPEraserContext *dc) { - sp_curve_reset(dc->currentcurve); + dc->currentcurve->reset(); - sp_curve_moveto(dc->currentcurve, dc->point1[dc->npoints-1]); + dc->currentcurve->moveto(dc->point1[dc->npoints-1]); for (gint i = dc->npoints-2; i >= 0; i--) { - sp_curve_lineto(dc->currentcurve, dc->point1[i]); + dc->currentcurve->lineto(dc->point1[i]); } for (gint i = 0; i < dc->npoints; i++) { - sp_curve_lineto(dc->currentcurve, dc->point2[i]); + dc->currentcurve->lineto(dc->point2[i]); } if (dc->npoints >= 2) { add_cap(dc->currentcurve, dc->point2[dc->npoints-2], dc->point2[dc->npoints-1], dc->point1[dc->npoints-1], dc->point1[dc->npoints-2], dc->cap_rounding); } - sp_curve_closepath(dc->currentcurve); + dc->currentcurve->closepath(); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(dc->currentshape), dc->currentcurve); } diff --git a/src/extension/internal/odf.cpp b/src/extension/internal/odf.cpp index 3123faebb..dd2bcb42c 100644 --- a/src/extension/internal/odf.cpp +++ b/src/extension/internal/odf.cpp @@ -2060,7 +2060,7 @@ bool OdfOutput::writeTree(Writer &couts, Writer &souts, couts.printf("\n\n"); - sp_curve_unref(curve); + curve->unref(); } return true; diff --git a/src/extension/internal/pov-out.cpp b/src/extension/internal/pov-out.cpp index dbfb52676..0f04c6a1a 100644 --- a/src/extension/internal/pov-out.cpp +++ b/src/extension/internal/pov-out.cpp @@ -294,7 +294,7 @@ void PovOutput::doCurves(SPDocument *doc) SPShape *shape = SP_SHAPE(reprobj); SPCurve *curve = shape->curve; - if (sp_curve_empty(curve)) + if (curve->is_empty()) continue; nrShapes++; diff --git a/src/libnrtype/Layout-TNG-Output.cpp b/src/libnrtype/Layout-TNG-Output.cpp index 9ff953c47..5fa20c81c 100755 --- a/src/libnrtype/Layout-TNG-Output.cpp +++ b/src/libnrtype/Layout-TNG-Output.cpp @@ -552,7 +552,7 @@ SPCurve *Layout::convertToCurves(iterator const &from_glyph, iterator const &to_ bpath.path = (NArtBpath*)span.font->ArtBPath(_glyphs[glyph_index].glyph); if (bpath.path) { NArtBpath *abp = nr_artpath_affine(bpath.path, glyph_matrix); - SPCurve *c = sp_curve_new_from_bpath(abp); + SPCurve *c = SPCurve::new_from_bpath(abp); if (c) cc = g_slist_prepend(cc, c); } } @@ -560,14 +560,14 @@ SPCurve *Layout::convertToCurves(iterator const &from_glyph, iterator const &to_ SPCurve *curve; if ( cc ) { - curve = sp_curve_concat(cc); + curve = SPCurve::concat(cc); } else { - curve = sp_curve_new(); + curve = new SPCurve(); } while (cc) { /* fixme: This is dangerous, as we are mixing art_alloc and g_new */ - sp_curve_unref((SPCurve *) cc->data); + reinterpret_cast(cc->data)->unref(); cc = g_slist_remove(cc, cc->data); } diff --git a/src/live_effects/lpe-spiro.cpp b/src/live_effects/lpe-spiro.cpp index 8708d091c..7bbeef7d2 100644 --- a/src/live_effects/lpe-spiro.cpp +++ b/src/live_effects/lpe-spiro.cpp @@ -22,13 +22,13 @@ typedef struct { void bezctx_ink_moveto(bezctx *bc, double x, double y, int /*is_open*/) { bezctx_ink *bi = (bezctx_ink *) bc; - sp_curve_moveto(bi->curve, x, y); + bi->curve->moveto(x, y); } void bezctx_ink_lineto(bezctx *bc, double x, double y) { bezctx_ink *bi = (bezctx_ink *) bc; - sp_curve_lineto(bi->curve, x, y); + bi->curve->lineto(x, y); } void bezctx_ink_quadto(bezctx *bc, double xm, double ym, double x3, double y3) @@ -39,7 +39,7 @@ void bezctx_ink_quadto(bezctx *bc, double xm, double ym, double x3, double y3) double x1, y1; double x2, y2; - NR::Point last = sp_curve_last_point(bi->curve); + NR::Point last = bi->curve->last_point(); x0 = last[NR::X]; y0 = last[NR::Y]; x1 = xm + (1./3) * (x0 - xm); @@ -47,14 +47,14 @@ void bezctx_ink_quadto(bezctx *bc, double xm, double ym, double x3, double y3) x2 = xm + (1./3) * (x3 - xm); y2 = ym + (1./3) * (y3 - ym); - sp_curve_curveto(bi->curve, x1, y1, x2, y2, x3, y3); + bi->curve->curveto(x1, y1, x2, y2, x3, y3); } void bezctx_ink_curveto(bezctx *bc, double x1, double y1, double x2, double y2, double x3, double y3) { bezctx_ink *bi = (bezctx_ink *) bc; - sp_curve_curveto(bi->curve, x1, y1, x2, y2, x3, y3); + bi->curve->curveto(x1, y1, x2, y2, x3, y3); } bezctx * @@ -94,8 +94,8 @@ LPESpiro::setup_nodepath(Inkscape::NodePath::Path *np) void LPESpiro::doEffect(SPCurve * curve) { - SPCurve *csrc = sp_curve_copy(curve); - sp_curve_reset(curve); + SPCurve *csrc = curve->copy(); + curve->reset(); bezctx *bc = new_bezctx_ink(curve); int len = SP_CURVE_LENGTH(csrc); spiro_cp *path = g_new (spiro_cp, len + 1); diff --git a/src/live_effects/parameter/path.cpp b/src/live_effects/parameter/path.cpp index 429cf82d1..9e7be732e 100644 --- a/src/live_effects/parameter/path.cpp +++ b/src/live_effects/parameter/path.cpp @@ -327,7 +327,7 @@ PathParam::linked_modified(SPObject *linked_obj, guint /*flags*/) _pathvector = SVGD_to_2GeomPath(defvalue); } else { _pathvector = BPath_to_2GeomPath(SP_CURVE_BPATH(curve)); - sp_curve_unref(curve); + curve->unref(); } must_recalculate_pwd2 = true; diff --git a/src/node-context.cpp b/src/node-context.cpp index 82d0ab670..c3523e3c5 100644 --- a/src/node-context.cpp +++ b/src/node-context.cpp @@ -218,8 +218,8 @@ sp_node_context_item_handler(SPEventContext *event_context, SPItem *item, GdkEve if (SP_IS_PATH(item)) { // This should be put somewhere else under the name of "generate helperpath" or something. Because basically this is copied of code from nodepath... SPCurve *curve_new = sp_path_get_curve_for_edit(SP_PATH(item)); - SPCurve *flash_curve = sp_curve_copy(curve_new); - sp_curve_transform(flash_curve, sp_item_i2d_affine(item) ); + SPCurve *flash_curve = curve_new->copy(); + flash_curve->transform(sp_item_i2d_affine(item) ); SPCanvasItem * canvasitem = sp_canvas_bpath_new(sp_desktop_tempgroup(desktop), flash_curve); // would be nice if its color could be XORed or something, now it is invisible for red stroked objects... // unless we also flash the nodes... @@ -227,7 +227,7 @@ sp_node_context_item_handler(SPEventContext *event_context, SPItem *item, GdkEve sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvasitem), color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(canvasitem), 0, SP_WIND_RULE_NONZERO); sp_canvas_item_show(canvasitem); - sp_curve_unref(flash_curve); + flash_curve->unref(); guint timeout = prefs_get_int_attribute("tools.nodes", "pathflash_timeout", 500); nc->flash_tempitem = desktop->add_temporary_canvasitem (canvasitem, timeout); } diff --git a/src/nodepath.cpp b/src/nodepath.cpp index 6b1c54057..8e2cd8e82 100644 --- a/src/nodepath.cpp +++ b/src/nodepath.cpp @@ -180,17 +180,17 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object, if (curve == NULL) return NULL; - NArtBpath *bpath = sp_curve_first_bpath(curve); + NArtBpath *bpath = curve->first_bpath(); gint length = curve->end; if (length == 0) { - sp_curve_unref(curve); + curve->unref(); return NULL; // prevent crash for one-node paths } //Create new nodepath Inkscape::NodePath::Path *np = g_new(Inkscape::NodePath::Path, 1); if (!np) { - sp_curve_unref(curve); + curve->unref(); return NULL; } @@ -206,7 +206,7 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object, np->helper_path = NULL; np->helperpath_rgba = prefs_get_int_attribute("tools.nodes", "highlight_color", 0xff0000ff); np->helperpath_width = 1.0; - np->curve = sp_curve_copy(curve); + np->curve = curve->copy(); np->show_helperpath = prefs_get_int_attribute ("tools.nodes", "show_helperpath", 0) == 1; np->straight_path = false; if (IS_LIVEPATHEFFECT(object) && item) { @@ -258,21 +258,21 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object, np->subpaths = g_list_reverse(np->subpaths); g_free(typestr); - sp_curve_unref(curve); + curve->unref(); // create the livarot representation from the same item sp_nodepath_ensure_livarot_path(np); // Draw helper curve if (np->show_helperpath) { - SPCurve *helper_curve = sp_curve_copy(np->curve); - sp_curve_transform(helper_curve, np->i2d ); + SPCurve *helper_curve = np->curve->copy(); + helper_curve->transform(np->i2d ); np->helper_path = sp_canvas_bpath_new(sp_desktop_controls(desktop), helper_curve); sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(np->helper_path), np->helperpath_rgba, np->helperpath_width, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(np->helper_path), 0, SP_WIND_RULE_NONZERO); sp_canvas_item_move_to_z(np->helper_path, 0); sp_canvas_item_show(np->helper_path); - sp_curve_unref(helper_curve); + helper_curve->unref(); } return np; @@ -307,7 +307,7 @@ void sp_nodepath_destroy(Inkscape::NodePath::Path *np) { gtk_object_destroy(temp); } if (np->curve) { - sp_curve_unref(np->curve); + np->curve->unref(); np->curve = NULL; } @@ -336,7 +336,7 @@ void sp_nodepath_ensure_livarot_path(Inkscape::NodePath::Path *np) if (np->livarot_path) np->livarot_path->ConvertWithBackData(0.01); - sp_curve_unref(curve); + curve->unref(); } } @@ -533,16 +533,16 @@ static void update_object(Inkscape::NodePath::Path *np) { g_assert(np); - sp_curve_unref(np->curve); + np->curve->unref(); np->curve = create_curve(np); sp_nodepath_set_curve(np, np->curve); if (np->show_helperpath) { - SPCurve * helper_curve = sp_curve_copy(np->curve); - sp_curve_transform(helper_curve, np->i2d ); + SPCurve * helper_curve = np->curve->copy(); + helper_curve->transform(np->i2d ); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(np->helper_path), helper_curve); - sp_curve_unref(helper_curve); + helper_curve->unref(); } } @@ -555,7 +555,7 @@ static void update_repr_internal(Inkscape::NodePath::Path *np) Inkscape::XML::Node *repr = np->object->repr; - sp_curve_unref(np->curve); + np->curve->unref(); np->curve = create_curve(np); gchar *typestr = create_typestr(np); @@ -576,10 +576,10 @@ static void update_repr_internal(Inkscape::NodePath::Path *np) g_free(typestr); if (np->show_helperpath) { - SPCurve * helper_curve = sp_curve_copy(np->curve); - sp_curve_transform(helper_curve, np->i2d ); + SPCurve * helper_curve = np->curve->copy(); + helper_curve->transform(np->i2d ); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(np->helper_path), helper_curve); - sp_curve_unref(helper_curve); + helper_curve->unref(); } } @@ -652,7 +652,7 @@ static void stamp_repr(Inkscape::NodePath::Path *np) Inkscape::GC::release(new_repr); g_free(svgpath); g_free(typestr); - sp_curve_unref(curve); + curve->unref(); } /** @@ -660,22 +660,20 @@ static void stamp_repr(Inkscape::NodePath::Path *np) */ static SPCurve *create_curve(Inkscape::NodePath::Path *np) { - SPCurve *curve = sp_curve_new(); + SPCurve *curve = new SPCurve(); for (GList *spl = np->subpaths; spl != NULL; spl = spl->next) { Inkscape::NodePath::SubPath *sp = (Inkscape::NodePath::SubPath *) spl->data; - sp_curve_moveto(curve, - sp->first->pos * np->d2i); + curve->moveto(sp->first->pos * np->d2i); Inkscape::NodePath::Node *n = sp->first->n.other; while (n) { NR::Point const end_pt = n->pos * np->d2i; switch (n->code) { case NR_LINETO: - sp_curve_lineto(curve, end_pt); + curve->lineto(end_pt); break; case NR_CURVETO: - sp_curve_curveto(curve, - n->p.other->n.pos * np->d2i, + curve->curveto(n->p.other->n.pos * np->d2i, n->p.pos * np->d2i, end_pt); break; @@ -690,7 +688,7 @@ static SPCurve *create_curve(Inkscape::NodePath::Path *np) } } if (sp->closed) { - sp_curve_closepath(curve); + curve->closepath(); } } @@ -4673,12 +4671,12 @@ SPCurve* sp_nodepath_object_get_curve(SPObject *object, const gchar *key) { SPCurve *curve = NULL; if (SP_IS_PATH(object)) { SPCurve *curve_new = sp_path_get_curve_for_edit(SP_PATH(object)); - curve = sp_curve_copy(curve_new); + curve = curve_new->copy(); } else if ( IS_LIVEPATHEFFECT(object) && key) { const gchar *svgd = object->repr->attribute(key); if (svgd) { NArtBpath *bpath = sp_svg_read_path(svgd); - SPCurve *curve_new = sp_curve_new_from_bpath(bpath); + SPCurve *curve_new = SPCurve::new_from_bpath(bpath); if (curve_new) { curve = curve_new; // don't do curve_copy because curve_new is already only created for us! } else { @@ -4715,8 +4713,8 @@ void sp_nodepath_show_helperpath(Inkscape::NodePath::Path *np, bool show) { np->show_helperpath = show; if (show) { - SPCurve *helper_curve = sp_curve_copy(np->curve); - sp_curve_transform(helper_curve, np->i2d ); + SPCurve *helper_curve = np->curve->copy(); + helper_curve->transform(np->i2d ); if (!np->helper_path) { np->helper_path = sp_canvas_bpath_new(sp_desktop_controls(np->desktop), helper_curve); sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(np->helper_path), np->helperpath_rgba, np->helperpath_width, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); @@ -4726,7 +4724,7 @@ void sp_nodepath_show_helperpath(Inkscape::NodePath::Path *np, bool show) { } else { sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(np->helper_path), helper_curve); } - sp_curve_unref(helper_curve); + helper_curve->unref(); } else { if (np->helper_path) { GtkObject *temp = np->helper_path; diff --git a/src/object-snapper.cpp b/src/object-snapper.cpp index 915b9eb0b..ea0266d98 100644 --- a/src/object-snapper.cpp +++ b/src/object-snapper.cpp @@ -304,7 +304,7 @@ void Inkscape::ObjectSnapper::_collectPaths(Inkscape::Snapper::PointType const & _bpaths_to_snap_to->push_back(bpath); // Because we set doTransformation to true in bpath_for_curve, we // will get a dupe of the path, which must be freed at some point - sp_curve_unref(curve); + curve->unref(); } } } @@ -359,7 +359,7 @@ void Inkscape::ObjectSnapper::_snapPaths(SnappedConstraints &sc, _bpaths_to_snap_to->push_back(bpath); // Because we set doTransformation to true in bpath_for_curve, we // will get a dupe of the path, which must be freed at some point - sp_curve_unref(curve); + curve->unref(); } } // Convert all bpaths to Paths, because here we really must have Paths @@ -688,7 +688,7 @@ NArtBpath* Inkscape::ObjectSnapper::_getBorderBPath() const { NArtBpath *border_bpath = NULL; NR::Rect const border_rect = NR::Rect(NR::Point(0,0), NR::Point(sp_document_width(_named_view->document),sp_document_height(_named_view->document))); - SPCurve const *border_curve = sp_curve_new_from_rect(border_rect); + SPCurve const *border_curve = SPCurve::new_from_rect(border_rect); if (border_curve) { border_bpath = SP_CURVE_BPATH(border_curve); } diff --git a/src/path-chemistry.cpp b/src/path-chemistry.cpp index 4325918c3..b6567a012 100644 --- a/src/path-chemistry.cpp +++ b/src/path-chemistry.cpp @@ -112,12 +112,12 @@ sp_selected_path_combine(void) // FIXME: merge styles of combined objects instead of using the first one's style style = g_strdup(SP_OBJECT_REPR(first)->attribute("style")); path_effect = g_strdup(SP_OBJECT_REPR(first)->attribute("inkscape:path-effect")); - //sp_curve_transform(c, item->transform); + //c->transform(item->transform); curve = c; } else { - sp_curve_transform(c, item->getRelativeTransform(SP_OBJECT(first))); - sp_curve_append(curve, c, false); - sp_curve_unref(c); + c->transform(item->getRelativeTransform(SP_OBJECT(first))); + curve->append(c, false); + c->unref(); } // unless this is the topmost object, @@ -150,7 +150,7 @@ sp_selected_path_combine(void) // set path data corresponding to new curve gchar *dstring = sp_svg_write_path(SP_CURVE_BPATH(curve)); - sp_curve_unref(curve); + curve->unref(); repr->setAttribute("d", dstring); if (path_effect) repr->setAttribute("inkscape:original-d", dstring); @@ -223,17 +223,17 @@ sp_selected_path_break_apart(void) NArtBpath *abp = nr_artpath_affine(SP_CURVE_BPATH(curve), (SP_ITEM(path))->transform); - sp_curve_unref(curve); + curve->unref(); // it's going to resurrect as one of the pieces, so we delete without advertisement SP_OBJECT(item)->deleteObject(false); - curve = sp_curve_new_from_bpath(abp); + curve = SPCurve::new_from_bpath(abp); g_assert(curve != NULL); - GSList *list = sp_curve_split(curve); + GSList *list = curve->split(); - sp_curve_unref(curve); + curve->unref(); GSList *reprs = NULL; for (GSList *l = list; l != NULL; l = l->next) { @@ -437,7 +437,7 @@ sp_selected_item_to_curved_repr(SPItem *item, guint32 /*text_grouping_policy*/) // otherwise we end up with zomby markup in the SVG file if(curve->end <= 0) { - sp_curve_unref(curve); + curve->unref(); return NULL; } @@ -469,7 +469,7 @@ sp_selected_item_to_curved_repr(SPItem *item, guint32 /*text_grouping_policy*/) gchar *def_str = sp_svg_write_path(SP_CURVE_BPATH(curve)); repr->setAttribute("d", def_str); g_free(def_str); - sp_curve_unref(curve); + curve->unref(); return repr; } @@ -503,7 +503,7 @@ sp_selected_path_reverse() did = true; SPPath *path = SP_PATH(i->data); - SPCurve *rcurve = sp_curve_reverse(sp_path_get_curve_reference(path)); + SPCurve *rcurve = sp_path_get_curve_reference(path)->reverse(); gchar *str = sp_svg_write_path(SP_CURVE_BPATH(rcurve)); if ( sp_lpe_item_has_path_effect_recursive(SP_LPE_ITEM(path)) ) { @@ -513,7 +513,7 @@ sp_selected_path_reverse() } g_free(str); - sp_curve_unref(rcurve); + rcurve->unref(); } desktop->clearWaitingCursor(); diff --git a/src/pen-context.cpp b/src/pen-context.cpp index 2a6c84bc7..270b8148d 100644 --- a/src/pen-context.cpp +++ b/src/pen-context.cpp @@ -790,9 +790,9 @@ pen_redraw_all (SPPenContext *const pc) if (pc->green_anchor) SP_CTRL(pc->green_anchor->ctrl)->moveto(pc->green_anchor->dp); - sp_curve_reset(pc->red_curve); - sp_curve_moveto(pc->red_curve, pc->p[0]); - sp_curve_curveto(pc->red_curve, pc->p[1], pc->p[2], pc->p[3]); + pc->red_curve->reset(); + pc->red_curve->moveto(pc->p[0]); + pc->red_curve->curveto(pc->p[1], pc->p[2], pc->p[3]); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(pc->red_bpath), pc->red_curve); // handles @@ -806,7 +806,7 @@ pen_redraw_all (SPPenContext *const pc) sp_canvas_item_hide (pc->cl1); } - NArtBpath *const bpath = sp_curve_last_bpath(pc->green_curve); + NArtBpath *const bpath = pc->green_curve->last_bpath(); if (bpath) { if (bpath->code == NR_CURVETO && NR::Point(bpath->x2, bpath->y2) != pc->p[0]) { SP_CTRL(pc->c0)->moveto(NR::Point(bpath->x2, bpath->y2)); @@ -827,7 +827,7 @@ pen_lastpoint_move (SPPenContext *const pc, gdouble x, gdouble y) return; // green - NArtBpath *const bpath = sp_curve_last_bpath(pc->green_curve); + NArtBpath *const bpath = pc->green_curve->last_bpath(); if (bpath) { if (bpath->code == NR_CURVETO) { bpath->x2 += x; @@ -861,7 +861,7 @@ pen_lastpoint_tocurve (SPPenContext *const pc) return; // red - NArtBpath *const bpath = sp_curve_last_bpath(pc->green_curve); + NArtBpath *const bpath = pc->green_curve->last_bpath(); if (bpath && bpath->code == NR_CURVETO) { pc->p[1] = pc->p[0] + (NR::Point(bpath->x3, bpath->y3) - NR::Point(bpath->x2, bpath->y2)); } else { @@ -999,8 +999,8 @@ pen_handle_key_press(SPPenContext *const pc, GdkEvent *event) case GDK_BackSpace: case GDK_Delete: case GDK_KP_Delete: - if (sp_curve_is_empty(pc->green_curve)) { - if (!sp_curve_is_empty(pc->red_curve)) { + if (pc->green_curve->is_empty()) { + if (!pc->red_curve->is_empty()) { pen_cancel (pc); ret = TRUE; } else { @@ -1008,7 +1008,7 @@ pen_handle_key_press(SPPenContext *const pc, GdkEvent *event) } } else { /* Reset red curve */ - sp_curve_reset(pc->red_curve); + pc->red_curve->reset(); /* Destroy topmost green bpath */ if (pc->green_bpaths) { if (pc->green_bpaths->data) @@ -1032,7 +1032,7 @@ pen_handle_key_press(SPPenContext *const pc, GdkEvent *event) ? p[e - 1].c(3) : pc->p[3] )); pc->npoints = 2; - sp_curve_backspace(pc->green_curve); + pc->green_curve->backspace(); sp_canvas_item_hide(pc->c0); sp_canvas_item_hide(pc->c1); sp_canvas_item_hide(pc->cl0); @@ -1052,17 +1052,17 @@ static void spdc_reset_colors(SPPenContext *pc) { /* Red */ - sp_curve_reset(pc->red_curve); + pc->red_curve->reset(); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(pc->red_bpath), NULL); /* Blue */ - sp_curve_reset(pc->blue_curve); + pc->blue_curve->reset(); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(pc->blue_bpath), NULL); /* Green */ while (pc->green_bpaths) { gtk_object_destroy(GTK_OBJECT(pc->green_bpaths->data)); pc->green_bpaths = g_slist_remove(pc->green_bpaths, pc->green_bpaths->data); } - sp_curve_reset(pc->green_curve); + pc->green_curve->reset(); if (pc->green_anchor) { pc->green_anchor = sp_draw_anchor_destroy(pc->green_anchor); } @@ -1119,16 +1119,16 @@ spdc_pen_set_subsequent_point(SPPenContext *const pc, NR::Point const p, bool st pc->p[3] = p; pc->p[4] = p; pc->npoints = 5; - sp_curve_reset(pc->red_curve); - sp_curve_moveto(pc->red_curve, pc->p[0]); + pc->red_curve->reset(); + pc->red_curve->moveto(pc->p[0]); bool is_curve; if ( (pc->onlycurves) || ( pc->p[1] != pc->p[0] ) ) { - sp_curve_curveto(pc->red_curve, pc->p[1], p, p); + pc->red_curve->curveto(pc->p[1], p, p); is_curve = true; } else { - sp_curve_lineto(pc->red_curve, p); + pc->red_curve->lineto(p); is_curve = false; } @@ -1172,9 +1172,9 @@ spdc_pen_set_ctrl(SPPenContext *const pc, NR::Point const p, guint const state) NR::Point delta = p - pc->p[3]; pc->p[2] = pc->p[3] - delta; is_symm = true; - sp_curve_reset(pc->red_curve); - sp_curve_moveto(pc->red_curve, pc->p[0]); - sp_curve_curveto(pc->red_curve, pc->p[1], pc->p[2], pc->p[3]); + pc->red_curve->reset(); + pc->red_curve->moveto(pc->p[0]); + pc->red_curve->curveto(pc->p[1], pc->p[2], pc->p[3]); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(pc->red_bpath), pc->red_curve); } SP_CTRL(pc->c0)->moveto(pc->p[2]); @@ -1200,12 +1200,12 @@ spdc_pen_set_ctrl(SPPenContext *const pc, NR::Point const p, guint const state) static void spdc_pen_finish_segment(SPPenContext *const pc, NR::Point const /*p*/, guint const /*state*/) { - if (!sp_curve_empty(pc->red_curve)) { - sp_curve_append_continuous(pc->green_curve, pc->red_curve, 0.0625); - SPCurve *curve = sp_curve_copy(pc->red_curve); + if (!pc->red_curve->is_empty()) { + pc->green_curve->append_continuous(pc->red_curve, 0.0625); + SPCurve *curve = pc->red_curve->copy(); /// \todo fixme: SPCanvasItem *cshape = sp_canvas_bpath_new(sp_desktop_sketch(pc->desktop), curve); - sp_curve_unref(curve); + curve->unref(); sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cshape), pc->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); pc->green_bpaths = g_slist_prepend(pc->green_bpaths, cshape); @@ -1214,7 +1214,7 @@ spdc_pen_finish_segment(SPPenContext *const pc, NR::Point const /*p*/, guint con pc->p[1] = pc->p[4]; pc->npoints = 2; - sp_curve_reset(pc->red_curve); + pc->red_curve->reset(); } } @@ -1227,7 +1227,7 @@ spdc_pen_finish(SPPenContext *const pc, gboolean const closed) pc->_message_context->clear(); desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Drawing finished")); - sp_curve_reset(pc->red_curve); + pc->red_curve->reset(); spdc_concat_colors_and_flush(pc, closed); pc->sa = NULL; pc->ea = NULL; diff --git a/src/pencil-context.cpp b/src/pencil-context.cpp index 3d397b180..0ba44dc33 100644 --- a/src/pencil-context.cpp +++ b/src/pencil-context.cpp @@ -445,13 +445,13 @@ pencil_cancel (SPPencilContext *const pc) pc->state = SP_PENCIL_CONTEXT_IDLE; - sp_curve_reset(pc->red_curve); + pc->red_curve->reset(); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(pc->red_bpath), NULL); while (pc->green_bpaths) { gtk_object_destroy(GTK_OBJECT(pc->green_bpaths->data)); pc->green_bpaths = g_slist_remove(pc->green_bpaths, pc->green_bpaths->data); } - sp_curve_reset(pc->green_curve); + pc->green_curve->reset(); if (pc->green_anchor) { pc->green_anchor = sp_draw_anchor_destroy(pc->green_anchor); } @@ -543,7 +543,7 @@ spdc_set_endpoint(SPPencilContext *const pc, NR::Point const p) } g_return_if_fail( pc->npoints > 0 ); - sp_curve_reset(pc->red_curve); + pc->red_curve->reset(); if ( ( p == pc->p[0] ) || !in_svg_plane(p) ) { @@ -552,8 +552,8 @@ spdc_set_endpoint(SPPencilContext *const pc, NR::Point const p) pc->p[1] = p; pc->npoints = 2; - sp_curve_moveto(pc->red_curve, pc->p[0]); - sp_curve_lineto(pc->red_curve, pc->p[1]); + pc->red_curve->moveto(pc->p[0]); + pc->red_curve->lineto(pc->p[1]); pc->red_curve_is_valid = true; sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(pc->red_bpath), pc->red_curve); @@ -574,7 +574,7 @@ spdc_finish_endpoint(SPPencilContext *const pc) || ( SP_CURVE_SEGMENT(pc->red_curve, 0)->c(3) == SP_CURVE_SEGMENT(pc->red_curve, 1)->c(3) ) ) { - sp_curve_reset(pc->red_curve); + pc->red_curve->reset(); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(pc->red_bpath), NULL); } else { /* Write curves to object. */ @@ -623,19 +623,19 @@ fit_and_split(SPPencilContext *pc) && unsigned(pc->npoints) < G_N_ELEMENTS(pc->p) ) { /* Fit and draw and reset state */ - sp_curve_reset(pc->red_curve); - sp_curve_moveto(pc->red_curve, b[0]); - sp_curve_curveto(pc->red_curve, b[1], b[2], b[3]); + pc->red_curve->reset(); + pc->red_curve->moveto(b[0]); + pc->red_curve->curveto(b[1], b[2], b[3]); sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(pc->red_bpath), pc->red_curve); pc->red_curve_is_valid = true; } else { /* Fit and draw and copy last point */ - g_assert(!sp_curve_empty(pc->red_curve)); + g_assert(!pc->red_curve->is_empty()); /* Set up direction of next curve. */ { - NArtBpath const &last_seg = *sp_curve_last_bpath(pc->red_curve); + NArtBpath const &last_seg = *pc->red_curve->last_bpath(); pc->p[0] = last_seg.c(3); pc->npoints = 1; g_assert( last_seg.code == NR_CURVETO ); @@ -646,12 +646,12 @@ fit_and_split(SPPencilContext *pc) : NR::unit_vector(req_vec) ); } - sp_curve_append_continuous(pc->green_curve, pc->red_curve, 0.0625); - SPCurve *curve = sp_curve_copy(pc->red_curve); + pc->green_curve->append_continuous(pc->red_curve, 0.0625); + SPCurve *curve = pc->red_curve->copy(); /// \todo fixme: SPCanvasItem *cshape = sp_canvas_bpath_new(sp_desktop_sketch(pc->desktop), curve); - sp_curve_unref(curve); + curve->unref(); sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cshape), pc->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); pc->green_bpaths = g_slist_prepend(pc->green_bpaths, cshape); diff --git a/src/rubberband.cpp b/src/rubberband.cpp index 24087b10c..4b7b1c48f 100644 --- a/src/rubberband.cpp +++ b/src/rubberband.cpp @@ -28,7 +28,7 @@ Inkscape::Rubberband::Rubberband() { _points.clear(); _mode = RUBBERBAND_MODE_RECT; - _touchpath_curve = sp_curve_new_sized(2000); + _touchpath_curve = new SPCurve(2000); } void Inkscape::Rubberband::delete_canvas_items() @@ -49,13 +49,13 @@ void Inkscape::Rubberband::delete_canvas_items() void Inkscape::Rubberband::start(SPDesktop *d, NR::Point const &p) { _points.clear(); - sp_curve_reset(_touchpath_curve); + _touchpath_curve->reset(); delete_canvas_items(); _desktop = d; _start = p; _started = true; _points.push_back(_desktop->d2w(p)); - sp_curve_moveto(_touchpath_curve, p); + _touchpath_curve->moveto(p); sp_canvas_force_full_redraw_after_interruptions(_desktop->canvas, 5); } @@ -66,7 +66,7 @@ void Inkscape::Rubberband::stop() _mode = RUBBERBAND_MODE_RECT; // restore the default _points.clear(); - sp_curve_reset(_touchpath_curve); + _touchpath_curve->reset(); delete_canvas_items(); @@ -81,7 +81,7 @@ void Inkscape::Rubberband::move(NR::Point const &p) _end = p; _desktop->scroll_to_point(&p); - sp_curve_lineto (_touchpath_curve, p); + _touchpath_curve->lineto(p); NR::Point next = _desktop->d2w(p); // we want the points to be at most 0.5 screen pixels apart, diff --git a/src/sp-conn-end-pair.cpp b/src/sp-conn-end-pair.cpp index 087069293..04591aaba 100644 --- a/src/sp-conn-end-pair.cpp +++ b/src/sp-conn-end-pair.cpp @@ -178,10 +178,10 @@ SPConnEndPair::getEndpoints(NR::Point endPts[]) const { else { if (h == 0) { - endPts[h] = sp_curve_first_point(curve); + endPts[h] = curve->first_point(); } else { - endPts[h] = sp_curve_last_point(curve); + endPts[h] = curve->last_point(); } } } @@ -302,12 +302,12 @@ SPConnEndPair::reroutePath(void) Avoid::PolyLine route = _connRef->route(); _connRef->calcRouteDist(); - sp_curve_reset(curve); - sp_curve_moveto(curve, endPt[0]); + curve->reset(); + curve->moveto(endPt[0]); for (int i = 1; i < route.pn; ++i) { NR::Point p(route.ps[i].x, route.ps[i].y); - sp_curve_lineto(curve, p); + curve->lineto(p); } } diff --git a/src/sp-conn-end.cpp b/src/sp-conn-end.cpp index 99b908e69..f610a8790 100644 --- a/src/sp-conn-end.cpp +++ b/src/sp-conn-end.cpp @@ -69,8 +69,8 @@ sp_conn_end_move_compensate(NR::Matrix const */*mp*/, SPItem */*moved_item*/, NR::Matrix h2i2anc[2]; NR::Rect h2bbox_icoordsys[2]; NR::Point last_seg_endPt[2] = { - sp_curve_second_point(path->curve), - sp_curve_penultimate_point(path->curve) + path->curve->second_point(), + path->curve->penultimate_point() }; for (unsigned h = 0; h < 2; ++h) { NR::Maybe bbox = h2attItem[h]->getBounds(NR::identity()); @@ -102,13 +102,13 @@ sp_conn_end_move_compensate(NR::Matrix const */*mp*/, SPItem */*moved_item*/, NR::Point other_endpt; NR::Point last_seg_pt; if (h2attItem[0] != NULL) { - other_endpt = sp_curve_last_point(path->curve); - last_seg_pt = sp_curve_second_point(path->curve); + other_endpt = path->curve->last_point(); + last_seg_pt = path->curve->second_point(); ind = 0; } else { - other_endpt = sp_curve_first_point(path->curve); - last_seg_pt = sp_curve_penultimate_point(path->curve); + other_endpt = path->curve->first_point(); + last_seg_pt = path->curve->penultimate_point(); ind = 1; } NR::Point h2endPt_icoordsys[2]; @@ -225,11 +225,11 @@ static void change_endpts(SPCurve *const curve, NR::Point const h2endPt[2]) { #if 0 - sp_curve_reset(curve); - sp_curve_moveto(curve, h2endPt[0]); - sp_curve_lineto(curve, h2endPt[1]); + curve->reset(); + curve->moveto(h2endPt[0]); + curve->lineto(h2endPt[1]); #else - sp_curve_move_endpoints(curve, h2endPt[0], h2endPt[1]); + curve->move_endpoints(h2endPt[0], h2endPt[1]); #endif } diff --git a/src/sp-ellipse.cpp b/src/sp-ellipse.cpp index 9b982d758..e25be12af 100644 --- a/src/sp-ellipse.cpp +++ b/src/sp-ellipse.cpp @@ -167,7 +167,7 @@ sp_genericellipse_update_patheffect(SPLPEItem *lpeitem, bool write) if (write) { Inkscape::XML::Node *repr = SP_OBJECT_REPR(shape); if ( shape->curve != NULL ) { - NArtBpath *abp = sp_curve_first_bpath(shape->curve); + NArtBpath *abp = shape->curve->first_bpath(); if (abp) { gchar *str = sp_svg_write_path(abp); repr->setAttribute("d", str); @@ -273,12 +273,12 @@ static void sp_genericellipse_set_shape(SPShape *shape) } bpath[i].code = NR_END; - SPCurve *c = sp_curve_new_from_bpath(nr_artpath_affine(bpath, aff)); + SPCurve *c = SPCurve::new_from_bpath(nr_artpath_affine(bpath, aff)); g_assert(c != NULL); sp_lpe_item_perform_path_effect(SP_LPE_ITEM (ellipse), c); sp_shape_set_curve_insync((SPShape *) ellipse, c, TRUE); - sp_curve_unref(c); + c->unref(); } static void sp_genericellipse_snappoints(SPItem const *item, SnapPointsIter p) diff --git a/src/sp-flowregion.cpp b/src/sp-flowregion.cpp index 6e8c014f1..b989b52fb 100644 --- a/src/sp-flowregion.cpp +++ b/src/sp-flowregion.cpp @@ -543,7 +543,7 @@ static void GetDest(SPObject* child,Shape **computed,NR::Matrix itr_mat) delete uncross; delete n_shp; delete temp; - sp_curve_unref(curve); + curve->unref(); } else { // printf("no curve\n"); } diff --git a/src/sp-image.cpp b/src/sp-image.cpp index 95e104b76..6ba348fbe 100644 --- a/src/sp-image.cpp +++ b/src/sp-image.cpp @@ -618,7 +618,7 @@ sp_image_release (SPObject *object) #endif // ENABLE_LCMS if (image->curve) { - image->curve = sp_curve_unref (image->curve); + image->curve = image->curve->unref(); } if (((SPObjectClass *) parent_class)->release) @@ -1454,7 +1454,7 @@ sp_image_set_curve(SPImage *image) //create a curve at the image's boundary for snapping if ((image->height.computed < 1e-18) || (image->width.computed < 1e-18) || (image->clip_ref->getObject())) { if (image->curve) { - image->curve = sp_curve_unref(image->curve); + image->curve = image->curve->unref(); } return; } @@ -1462,17 +1462,17 @@ sp_image_set_curve(SPImage *image) NRRect rect; sp_image_bbox(image, &rect, NR::identity(), 0); NR::Maybe rect2 = rect.upgrade(); - SPCurve *c = sp_curve_new_from_rect(rect2); + SPCurve *c = SPCurve::new_from_rect(rect2); if (image->curve) { - image->curve = sp_curve_unref(image->curve); + image->curve = image->curve->unref(); } if (c) { - image->curve = sp_curve_ref(c); + image->curve = c->ref(); } - sp_curve_unref(c); + c->unref(); } /** @@ -1482,7 +1482,7 @@ SPCurve * sp_image_get_curve (SPImage *image) { if (image->curve) { - return sp_curve_copy(image->curve); + return image->curve->copy(); } return NULL; } diff --git a/src/sp-line.cpp b/src/sp-line.cpp index 9be7cf928..5fed6a62e 100644 --- a/src/sp-line.cpp +++ b/src/sp-line.cpp @@ -218,12 +218,12 @@ sp_line_set_shape (SPShape *shape) { SPLine *line = SP_LINE (shape); - SPCurve *c = sp_curve_new (); + SPCurve *c = new SPCurve (); - sp_curve_moveto (c, line->x1.computed, line->y1.computed); - sp_curve_lineto (c, line->x2.computed, line->y2.computed); + c->moveto(line->x1.computed, line->y1.computed); + c->lineto(line->x2.computed, line->y2.computed); sp_shape_set_curve_insync (shape, c, TRUE); // *_insync does not call update, avoiding infinite recursion when set_shape is called by update - sp_curve_unref (c); + c->unref(); } diff --git a/src/sp-offset.cpp b/src/sp-offset.cpp index 44384dee9..d866df068 100644 --- a/src/sp-offset.cpp +++ b/src/sp-offset.cpp @@ -354,10 +354,10 @@ sp_offset_set(SPObject *object, unsigned key, gchar const *value) offset->original = strdup (value); bpath = sp_svg_read_path (offset->original); - curve = sp_curve_new_from_bpath (bpath); // curve se chargera de detruire bpath + curve = SPCurve::new_from_bpath (bpath); // curve se chargera de detruire bpath g_assert (curve != NULL); offset->originalPath = bpath_to_liv_path (SP_CURVE_BPATH(curve)); - sp_curve_unref (curve); + curve->unref(); offset->knotSet = false; if ( offset->isUpdating == false ) object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG); @@ -533,10 +533,10 @@ sp_offset_set_shape(SPShape *shape) const char *res_d = SP_OBJECT(shape)->repr->attribute("inkscape:original"); if ( res_d ) { NArtBpath *bpath = sp_svg_read_path (res_d); - SPCurve *c = sp_curve_new_from_bpath (bpath); + SPCurve *c = SPCurve::new_from_bpath (bpath); g_assert(c != NULL); sp_shape_set_curve_insync ((SPShape *) offset, c, TRUE); - sp_curve_unref (c); + c->unref(); } return; } @@ -782,10 +782,10 @@ sp_offset_set_shape(SPShape *shape) delete orig; NArtBpath *bpath = sp_svg_read_path (res_d); - SPCurve *c = sp_curve_new_from_bpath (bpath); + SPCurve *c = SPCurve::new_from_bpath (bpath); g_assert(c != NULL); sp_shape_set_curve_insync ((SPShape *) offset, c, TRUE); - sp_curve_unref (c); + c->unref(); free (res_d); } @@ -1036,7 +1036,7 @@ sp_offset_top_point (SPOffset * offset, NR::Point *px) Path *finalPath = bpath_to_liv_path (SP_CURVE_BPATH(curve)); if (finalPath == NULL) { - sp_curve_unref (curve); + curve->unref(); return; } @@ -1053,7 +1053,7 @@ sp_offset_top_point (SPOffset * offset, NR::Point *px) delete theShape; delete finalPath; - sp_curve_unref (curve); + curve->unref(); } // the listening functions @@ -1178,7 +1178,7 @@ refresh_offset_source(SPOffset* offset) return; } orig = bpath_to_liv_path (SP_CURVE_BPATH(curve)); - sp_curve_unref (curve); + curve->unref(); // Finish up. diff --git a/src/sp-path.cpp b/src/sp-path.cpp index 99670882a..b25397a31 100644 --- a/src/sp-path.cpp +++ b/src/sp-path.cpp @@ -232,7 +232,7 @@ sp_path_release(SPObject *object) path->connEndPair.release(); if (path->original_curve) { - path->original_curve = sp_curve_unref (path->original_curve); + path->original_curve = path->original_curve->unref(); } if (((SPObjectClass *) parent_class)->release) { @@ -253,10 +253,10 @@ sp_path_set(SPObject *object, unsigned int key, gchar const *value) case SP_ATTR_INKSCAPE_ORIGINAL_D: if (value) { NArtBpath *bpath = sp_svg_read_path(value); - SPCurve *curve = sp_curve_new_from_bpath(bpath); + SPCurve *curve = SPCurve::new_from_bpath(bpath); if (curve) { sp_path_set_original_curve(path, curve, TRUE, true); - sp_curve_unref(curve); + curve->unref(); } } else { sp_path_set_original_curve(path, NULL, TRUE, true); @@ -267,10 +267,10 @@ sp_path_set(SPObject *object, unsigned int key, gchar const *value) if (!sp_lpe_item_has_path_effect_recursive(SP_LPE_ITEM(path))) { if (value) { NArtBpath *bpath = sp_svg_read_path(value); - SPCurve *curve = sp_curve_new_from_bpath(bpath); + SPCurve *curve = SPCurve::new_from_bpath(bpath); if (curve) { sp_shape_set_curve((SPShape *) path, curve, TRUE); - sp_curve_unref(curve); + curve->unref(); } } else { sp_shape_set_curve((SPShape *) path, NULL, TRUE); @@ -313,7 +313,7 @@ sp_path_write(SPObject *object, Inkscape::XML::Node *repr, guint flags) } if ( shape->curve != NULL ) { - NArtBpath *abp = sp_curve_first_bpath(shape->curve); + NArtBpath *abp = shape->curve->first_bpath(); if (abp) { gchar *str = sp_svg_write_path(abp); repr->setAttribute("d", str); @@ -327,7 +327,7 @@ sp_path_write(SPObject *object, Inkscape::XML::Node *repr, guint flags) SPPath *path = (SPPath *) object; if ( path->original_curve != NULL ) { - NArtBpath *abp = sp_curve_first_bpath(path->original_curve); + NArtBpath *abp = path->original_curve->first_bpath(); if (abp) { gchar *str = sp_svg_write_path(abp); repr->setAttribute("inkscape:original-d", str); @@ -380,15 +380,15 @@ sp_path_set_transform(SPItem *item, NR::Matrix const &xform) // Transform the original-d path or the (ordinary) path bool original_path = (bool)path->original_curve; SPCurve *srccurve = original_path ? path->original_curve : shape->curve; - SPCurve *dstcurve = sp_curve_copy(srccurve); + SPCurve *dstcurve = srccurve->copy(); if (dstcurve) { - sp_curve_transform(dstcurve, xform); + dstcurve->transform(xform); if (original_path) { sp_path_set_original_curve(path, dstcurve, TRUE, true); } else { sp_shape_set_curve(shape, dstcurve, TRUE); } - sp_curve_unref(dstcurve); + dstcurve->unref(); } // Adjust stroke @@ -415,16 +415,16 @@ sp_path_update_patheffect(SPLPEItem *lpeitem, bool write) SPShape *shape = (SPShape *) lpeitem; SPPath *path = (SPPath *) lpeitem; if (path->original_curve) { - SPCurve *curve = sp_curve_copy (path->original_curve); + SPCurve *curve = path->original_curve->copy(); sp_lpe_item_perform_path_effect(SP_LPE_ITEM(shape), curve); sp_shape_set_curve(shape, curve, TRUE); - sp_curve_unref(curve); + curve->unref(); if (write) { // could also do SP_OBJECT(shape)->updateRepr(); but only the d attribute needs updating. Inkscape::XML::Node *repr = SP_OBJECT_REPR(shape); if ( shape->curve != NULL ) { - NArtBpath *abp = sp_curve_first_bpath(shape->curve); + NArtBpath *abp = shape->curve->first_bpath(); if (abp) { gchar *str = sp_svg_write_path(abp); repr->setAttribute("d", str); @@ -454,13 +454,13 @@ void sp_path_set_original_curve (SPPath *path, SPCurve *curve, unsigned int owner, bool write) { if (path->original_curve) { - path->original_curve = sp_curve_unref (path->original_curve); + path->original_curve = path->original_curve->unref(); } if (curve) { if (owner) { - path->original_curve = sp_curve_ref (curve); + path->original_curve = curve->ref(); } else { - path->original_curve = sp_curve_copy (curve); + path->original_curve = curve->copy(); } } sp_path_update_patheffect(path, write); @@ -474,7 +474,7 @@ SPCurve * sp_path_get_original_curve (SPPath *path) { if (path->original_curve) { - return sp_curve_copy (path->original_curve); + return path->original_curve->copy(); } return NULL; } diff --git a/src/sp-polygon.cpp b/src/sp-polygon.cpp index 1fb43c036..23225d714 100644 --- a/src/sp-polygon.cpp +++ b/src/sp-polygon.cpp @@ -126,7 +126,7 @@ static Inkscape::XML::Node *sp_polygon_write(SPObject *object, Inkscape::XML::No } /* We can safely write points here, because all subclasses require it too (Lauris) */ - NArtBpath *abp = sp_curve_first_bpath(shape->curve); + NArtBpath *abp = shape->curve->first_bpath(); gchar *str = sp_svg_write_polygon(abp); repr->setAttribute("points", str); g_free(str); @@ -171,7 +171,7 @@ static void sp_polygon_set(SPObject *object, unsigned int key, const gchar *valu * http://www.w3.org/TR/SVG11/implnote.html#ErrorProcessing. */ break; } - SPCurve *curve = sp_curve_new(); + SPCurve *curve = new SPCurve(); gboolean hascpt = FALSE; gchar const *cptr = value; @@ -198,9 +198,9 @@ static void sp_polygon_set(SPObject *object, unsigned int key, const gchar *valu } if (hascpt) { - sp_curve_lineto(curve, x, y); + curve->lineto(x, y); } else { - sp_curve_moveto(curve, x, y); + curve->moveto(x, y); hascpt = TRUE; } } @@ -214,12 +214,12 @@ static void sp_polygon_set(SPObject *object, unsigned int key, const gchar *valu * doesn't seem to like simply moveto followed by closepath. The following works, * but won't round-trip properly: I believe it will write as two points rather than * one. */ - sp_curve_lineto(curve, curve->movePos); + curve->lineto(curve->movePos); } else if (hascpt) { - sp_curve_closepath(curve); + curve->closepath(); } sp_shape_set_curve(SP_SHAPE(polygon), curve, TRUE); - sp_curve_unref(curve); + curve->unref(); break; } default: diff --git a/src/sp-polyline.cpp b/src/sp-polyline.cpp index d974f61e3..4a39afd1b 100644 --- a/src/sp-polyline.cpp +++ b/src/sp-polyline.cpp @@ -105,7 +105,7 @@ sp_polyline_set (SPObject *object, unsigned int key, const gchar *value) gboolean hascpt; if (!value) break; - curve = sp_curve_new (); + curve = new SPCurve (); hascpt = FALSE; cptr = value; @@ -132,15 +132,15 @@ sp_polyline_set (SPObject *object, unsigned int key, const gchar *value) if (eptr == cptr) break; cptr = eptr; if (hascpt) { - sp_curve_lineto (curve, x, y); + curve->lineto(x, y); } else { - sp_curve_moveto (curve, x, y); + curve->moveto(x, y); hascpt = TRUE; } } sp_shape_set_curve (SP_SHAPE (polyline), curve, TRUE); - sp_curve_unref (curve); + curve->unref(); break; } default: diff --git a/src/sp-rect.cpp b/src/sp-rect.cpp index 2e9befa32..b02f52f1e 100644 --- a/src/sp-rect.cpp +++ b/src/sp-rect.cpp @@ -239,7 +239,7 @@ sp_rect_set_shape(SPShape *shape) return; } - SPCurve *c = sp_curve_new(); + SPCurve *c = new SPCurve(); double const x = rect->x.computed; double const y = rect->y.computed; @@ -268,26 +268,26 @@ sp_rect_set_shape(SPShape *shape) * arc fairly well. */ if ((rx > 1e-18) && (ry > 1e-18)) { - sp_curve_moveto(c, x + rx, y); - if (rx < w2) sp_curve_lineto(c, x + w - rx, y); - sp_curve_curveto(c, x + w - rx * (1 - C1), y, x + w, y + ry * (1 - C1), x + w, y + ry); - if (ry < h2) sp_curve_lineto(c, x + w, y + h - ry); - sp_curve_curveto(c, x + w, y + h - ry * (1 - C1), x + w - rx * (1 - C1), y + h, x + w - rx, y + h); - if (rx < w2) sp_curve_lineto(c, x + rx, y + h); - sp_curve_curveto(c, x + rx * (1 - C1), y + h, x, y + h - ry * (1 - C1), x, y + h - ry); - if (ry < h2) sp_curve_lineto(c, x, y + ry); - sp_curve_curveto(c, x, y + ry * (1 - C1), x + rx * (1 - C1), y, x + rx, y); + c->moveto(x + rx, y); + if (rx < w2) c->lineto(x + w - rx, y); + c->curveto(x + w - rx * (1 - C1), y, x + w, y + ry * (1 - C1), x + w, y + ry); + if (ry < h2) c->lineto(x + w, y + h - ry); + c->curveto(x + w, y + h - ry * (1 - C1), x + w - rx * (1 - C1), y + h, x + w - rx, y + h); + if (rx < w2) c->lineto(x + rx, y + h); + c->curveto(x + rx * (1 - C1), y + h, x, y + h - ry * (1 - C1), x, y + h - ry); + if (ry < h2) c->lineto(x, y + ry); + c->curveto(x, y + ry * (1 - C1), x + rx * (1 - C1), y, x + rx, y); } else { - sp_curve_moveto(c, x + 0.0, y + 0.0); - sp_curve_lineto(c, x + w, y + 0.0); - sp_curve_lineto(c, x + w, y + h); - sp_curve_lineto(c, x + 0.0, y + h); - sp_curve_lineto(c, x + 0.0, y + 0.0); + c->moveto(x + 0.0, y + 0.0); + c->lineto(x + w, y + 0.0); + c->lineto(x + w, y + h); + c->lineto(x + 0.0, y + h); + c->lineto(x + 0.0, y + 0.0); } - sp_curve_closepath_current(c); + c->closepath_current(); sp_shape_set_curve_insync(SP_SHAPE(rect), c, TRUE); - sp_curve_unref(c); + c->unref(); } /* fixme: Think (Lauris) */ diff --git a/src/sp-shape.cpp b/src/sp-shape.cpp index e45245793..99ebdbe23 100644 --- a/src/sp-shape.cpp +++ b/src/sp-shape.cpp @@ -199,7 +199,7 @@ sp_shape_release (SPObject *object) } } if (shape->curve) { - shape->curve = sp_curve_unref (shape->curve); + shape->curve = shape->curve->unref(); } if (((SPObjectClass *) parent_class)->release) { @@ -991,13 +991,13 @@ void sp_shape_set_curve (SPShape *shape, SPCurve *curve, unsigned int owner) { if (shape->curve) { - shape->curve = sp_curve_unref (shape->curve); + shape->curve = shape->curve->unref(); } if (curve) { if (owner) { - shape->curve = sp_curve_ref (curve); + shape->curve = curve->ref(); } else { - shape->curve = sp_curve_copy (curve); + shape->curve = curve->copy(); } } SP_OBJECT(shape)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG); @@ -1010,7 +1010,7 @@ SPCurve * sp_shape_get_curve (SPShape *shape) { if (shape->curve) { - return sp_curve_copy (shape->curve); + return shape->curve->copy(); } return NULL; } @@ -1022,13 +1022,13 @@ void sp_shape_set_curve_insync (SPShape *shape, SPCurve *curve, unsigned int owner) { if (shape->curve) { - shape->curve = sp_curve_unref (shape->curve); + shape->curve = shape->curve->unref(); } if (curve) { if (owner) { - shape->curve = sp_curve_ref (curve); + shape->curve = curve->ref(); } else { - shape->curve = sp_curve_copy (curve); + shape->curve = curve->copy(); } } } diff --git a/src/sp-spiral.cpp b/src/sp-spiral.cpp index 45dc6d2e3..d543aa00f 100644 --- a/src/sp-spiral.cpp +++ b/src/sp-spiral.cpp @@ -308,7 +308,7 @@ sp_spiral_update_patheffect(SPLPEItem *lpeitem, bool write) if (write) { Inkscape::XML::Node *repr = SP_OBJECT_REPR(shape); if ( shape->curve != NULL ) { - NArtBpath *abp = sp_curve_first_bpath(shape->curve); + NArtBpath *abp = shape->curve->first_bpath(); if (abp) { gchar *str = sp_svg_write_path(abp); repr->setAttribute("d", str); @@ -411,8 +411,7 @@ sp_spiral_fit_and_draw (SPSpiral const *spiral, #endif if (depth != -1) { for (i = 0; i < 4*depth; i += 4) { - sp_curve_curveto (c, - bezier[i + 1], + c->curveto(bezier[i + 1], bezier[i + 2], bezier[i + 3]); } @@ -421,7 +420,7 @@ sp_spiral_fit_and_draw (SPSpiral const *spiral, g_print ("cant_fit_cubic: t=%g\n", *t); #endif for (i = 1; i < SAMPLE_SIZE; i++) - sp_curve_lineto (c, darray[i]); + c->lineto(darray[i]); } *t = next_t; g_assert (is_unit_vector (hat2)); @@ -437,7 +436,7 @@ sp_spiral_set_shape (SPShape *shape) SP_OBJECT (spiral)->requestModified(SP_OBJECT_MODIFIED_FLAG); - SPCurve *c = sp_curve_new (); + SPCurve *c = new SPCurve (); #ifdef SPIRAL_VERBOSE g_print ("cx=%g, cy=%g, exp=%g, revo=%g, rad=%g, arg=%g, t0=%g\n", @@ -451,7 +450,7 @@ sp_spiral_set_shape (SPShape *shape) #endif /* Initial moveto. */ - sp_curve_moveto(c, sp_spiral_get_xy(spiral, spiral->t0)); + c->moveto(sp_spiral_get_xy(spiral, spiral->t0)); double const tstep = SAMPLE_STEP / spiral->revo; double const dstep = tstep / (SAMPLE_SIZE - 1); @@ -469,7 +468,7 @@ sp_spiral_set_shape (SPShape *shape) sp_lpe_item_perform_path_effect(SP_LPE_ITEM (spiral), c); sp_shape_set_curve_insync ((SPShape *) spiral, c, TRUE); - sp_curve_unref (c); + c->unref(); } /** diff --git a/src/sp-star.cpp b/src/sp-star.cpp index 2aeb0cfc0..4c5f9623b 100644 --- a/src/sp-star.cpp +++ b/src/sp-star.cpp @@ -285,7 +285,7 @@ sp_star_update_patheffect(SPLPEItem *lpeitem, bool write) if (write) { Inkscape::XML::Node *repr = SP_OBJECT_REPR(shape); if ( shape->curve != NULL ) { - NArtBpath *abp = sp_curve_first_bpath(shape->curve); + NArtBpath *abp = shape->curve->first_bpath(); if (abp) { gchar *str = sp_svg_write_path(abp); repr->setAttribute("d", str); @@ -434,7 +434,7 @@ sp_star_set_shape (SPShape *shape) { SPStar *star = SP_STAR (shape); - SPCurve *c = sp_curve_new (); + SPCurve *c = new SPCurve (); gint sides = star->sides; bool not_rounded = (fabs (star->rounded) < 1e-4); @@ -443,13 +443,12 @@ sp_star_set_shape (SPShape *shape) // other places that call that function (e.g. the knotholder) need the exact point // draw 1st segment - sp_curve_moveto (c, sp_star_get_xy (star, SP_STAR_POINT_KNOT1, 0, true)); + c->moveto(sp_star_get_xy (star, SP_STAR_POINT_KNOT1, 0, true)); if (star->flatsided == false) { if (not_rounded) { - sp_curve_lineto (c, sp_star_get_xy (star, SP_STAR_POINT_KNOT2, 0, true)); + c->lineto(sp_star_get_xy (star, SP_STAR_POINT_KNOT2, 0, true)); } else { - sp_curve_curveto (c, - sp_star_get_curvepoint (star, SP_STAR_POINT_KNOT1, 0, NEXT), + c->curveto(sp_star_get_curvepoint (star, SP_STAR_POINT_KNOT1, 0, NEXT), sp_star_get_curvepoint (star, SP_STAR_POINT_KNOT2, 0, PREV), sp_star_get_xy (star, SP_STAR_POINT_KNOT2, 0, true)); } @@ -458,16 +457,14 @@ sp_star_set_shape (SPShape *shape) // draw all middle segments for (gint i = 1; i < sides; i++) { if (not_rounded) { - sp_curve_lineto (c, sp_star_get_xy (star, SP_STAR_POINT_KNOT1, i, true)); + c->lineto(sp_star_get_xy (star, SP_STAR_POINT_KNOT1, i, true)); } else { if (star->flatsided == false) { - sp_curve_curveto (c, - sp_star_get_curvepoint (star, SP_STAR_POINT_KNOT2, i - 1, NEXT), + c->curveto(sp_star_get_curvepoint (star, SP_STAR_POINT_KNOT2, i - 1, NEXT), sp_star_get_curvepoint (star, SP_STAR_POINT_KNOT1, i, PREV), sp_star_get_xy (star, SP_STAR_POINT_KNOT1, i, true)); } else { - sp_curve_curveto (c, - sp_star_get_curvepoint (star, SP_STAR_POINT_KNOT1, i - 1, NEXT), + c->curveto(sp_star_get_curvepoint (star, SP_STAR_POINT_KNOT1, i - 1, NEXT), sp_star_get_curvepoint (star, SP_STAR_POINT_KNOT1, i, PREV), sp_star_get_xy (star, SP_STAR_POINT_KNOT1, i, true)); } @@ -475,10 +472,9 @@ sp_star_set_shape (SPShape *shape) if (star->flatsided == false) { if (not_rounded) { - sp_curve_lineto (c, sp_star_get_xy (star, SP_STAR_POINT_KNOT2, i, true)); + c->lineto(sp_star_get_xy (star, SP_STAR_POINT_KNOT2, i, true)); } else { - sp_curve_curveto (c, - sp_star_get_curvepoint (star, SP_STAR_POINT_KNOT1, i, NEXT), + c->curveto(sp_star_get_curvepoint (star, SP_STAR_POINT_KNOT1, i, NEXT), sp_star_get_curvepoint (star, SP_STAR_POINT_KNOT2, i, PREV), sp_star_get_xy (star, SP_STAR_POINT_KNOT2, i, true)); } @@ -487,25 +483,23 @@ sp_star_set_shape (SPShape *shape) // draw last segment if (not_rounded) { - sp_curve_lineto (c, sp_star_get_xy (star, SP_STAR_POINT_KNOT1, 0, true)); + c->lineto(sp_star_get_xy (star, SP_STAR_POINT_KNOT1, 0, true)); } else { if (star->flatsided == false) { - sp_curve_curveto (c, - sp_star_get_curvepoint (star, SP_STAR_POINT_KNOT2, sides - 1, NEXT), + c->curveto(sp_star_get_curvepoint (star, SP_STAR_POINT_KNOT2, sides - 1, NEXT), sp_star_get_curvepoint (star, SP_STAR_POINT_KNOT1, 0, PREV), sp_star_get_xy (star, SP_STAR_POINT_KNOT1, 0, true)); } else { - sp_curve_curveto (c, - sp_star_get_curvepoint (star, SP_STAR_POINT_KNOT1, sides - 1, NEXT), + c->curveto(sp_star_get_curvepoint (star, SP_STAR_POINT_KNOT1, sides - 1, NEXT), sp_star_get_curvepoint (star, SP_STAR_POINT_KNOT1, 0, PREV), sp_star_get_xy (star, SP_STAR_POINT_KNOT1, 0, true)); } } - sp_curve_closepath (c); + c->closepath(); sp_lpe_item_perform_path_effect(SP_LPE_ITEM (star), c); sp_shape_set_curve_insync (SP_SHAPE (star), c, TRUE); - sp_curve_unref (c); + c->unref(); } void diff --git a/src/sp-use-reference.cpp b/src/sp-use-reference.cpp index 1474a43a9..a1cb045e5 100644 --- a/src/sp-use-reference.cpp +++ b/src/sp-use-reference.cpp @@ -232,7 +232,7 @@ void SPUsePath::refresh_source() } originalPath = new Path; originalPath->LoadArtBPath(SP_CURVE_BPATH(curve), NR::Matrix(item->transform), true); - sp_curve_unref(curve); + curve->unref(); } diff --git a/src/splivarot.cpp b/src/splivarot.cpp index 01331d2f8..a6bd60cd6 100644 --- a/src/splivarot.cpp +++ b/src/splivarot.cpp @@ -639,7 +639,7 @@ sp_selected_path_outline() gchar const *val = sp_repr_css_property(css, "stroke", NULL); if (val == NULL || strcmp(val, "none") == 0) { - sp_curve_unref(curve); + curve->unref(); continue; } } @@ -716,7 +716,7 @@ sp_selected_path_outline() Path *orig = Path_for_item(item, false); if (orig == NULL) { g_free(style); - sp_curve_unref(curve); + curve->unref(); continue; } @@ -877,7 +877,7 @@ sp_selected_path_outline() Inkscape::GC::release(repr); - sp_curve_unref(curve); + curve->unref(); selection->remove(item); SP_OBJECT(item)->deleteObject(false); @@ -1052,7 +1052,7 @@ sp_selected_path_create_offset_object(int expand, bool updating) if (orig == NULL) { g_free(style); - sp_curve_unref(curve); + curve->unref(); return; } @@ -1089,7 +1089,7 @@ sp_selected_path_create_offset_object(int expand, bool updating) delete theRes; } - sp_curve_unref(curve); + curve->unref(); if (res->descr_cmd.size() <= 1) { @@ -1274,7 +1274,7 @@ sp_selected_path_do_offset(bool expand, double prefOffset) Path *orig = Path_for_item(item, false); if (orig == NULL) { g_free(style); - sp_curve_unref(curve); + curve->unref(); continue; } @@ -1362,7 +1362,7 @@ sp_selected_path_do_offset(bool expand, double prefOffset) did = true; - sp_curve_unref(curve); + curve->unref(); // remember the position of the item gint pos = SP_OBJECT_REPR(item)->position(); // remember parent @@ -1482,11 +1482,11 @@ sp_selected_path_simplify_item(SPDesktop *desktop, Path *orig = Path_for_item(item, false); if (orig == NULL) { g_free(style); - sp_curve_unref(curve); + curve->unref(); return false; } - sp_curve_unref(curve); + curve->unref(); // remember the position of the item gint pos = SP_OBJECT_REPR(item)->position(); // remember parent @@ -1733,7 +1733,7 @@ Path_for_item(SPItem *item, bool doTransformation, bool transformFull) g_free(bpath); // see comment in bpath_for_curve } - sp_curve_unref(curve); + curve->unref(); return dest; } diff --git a/src/tweak-context.cpp b/src/tweak-context.cpp index 663aca60e..d60282d71 100644 --- a/src/tweak-context.cpp +++ b/src/tweak-context.cpp @@ -239,9 +239,9 @@ sp_tweak_context_setup(SPEventContext *ec) ((SPEventContextClass *) parent_class)->setup(ec); { - SPCurve *c = sp_curve_new_from_foreign_bpath(hatch_area_circle); + SPCurve *c = SPCurve::new_from_foreign_bpath(hatch_area_circle); tc->dilate_area = sp_canvas_bpath_new(sp_desktop_controls(ec->desktop), c); - sp_curve_unref(c); + c->unref(); sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(tc->dilate_area), 0x00000000,(SPWindRule)0); sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(tc->dilate_area), 0xff9900ff, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); sp_canvas_item_hide(tc->dilate_area); diff --git a/src/verbs.cpp b/src/verbs.cpp index 60982e036..1fb179660 100644 --- a/src/verbs.cpp +++ b/src/verbs.cpp @@ -1565,8 +1565,8 @@ ZoomVerb::perform(SPAction *action, void *data, void */*pdata*/) // While drawing with the pen/pencil tool, zoom towards the end of the unfinished path if (tools_isactive(dt, TOOLS_FREEHAND_PENCIL) || tools_isactive(dt, TOOLS_FREEHAND_PEN)) { SPCurve *rc = SP_DRAW_CONTEXT(ec)->red_curve; - if (sp_curve_last_bpath(rc)) { - NR::Point const zoom_to (sp_curve_last_point(rc)); + if (rc->last_bpath()) { + NR::Point const zoom_to (rc->last_point()); dt->zoom_relative_keep_point(zoom_to, mul*zoom_inc); break; } @@ -1583,8 +1583,8 @@ ZoomVerb::perform(SPAction *action, void *data, void */*pdata*/) // While drawing with the pen/pencil tool, zoom away from the end of the unfinished path if (tools_isactive(dt, TOOLS_FREEHAND_PENCIL) || tools_isactive(dt, TOOLS_FREEHAND_PEN)) { SPCurve *rc = SP_DRAW_CONTEXT(ec)->red_curve; - if (sp_curve_last_bpath(rc)) { - NR::Point const zoom_to (sp_curve_last_point(rc)); + if (rc->last_bpath()) { + NR::Point const zoom_to (rc->last_point()); dt->zoom_relative_keep_point(zoom_to, 1 / (mul*zoom_inc)); break; }