![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
index 027a89e828e0c326eade6a4aa177a9690a09bd79..a3e550fc59c1e1d39a9ebc9b770889199df3d934 100644 (file)
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
-#include <libnr/n-art-bpath.h>
-#include <libnr/nr-matrix-ops.h>
-#include <libnr/nr-matrix-fns.h>
+
#include <libnr/nr-pixblock.h>
#include <libnr/nr-convert2geom.h>
#include "../style.h"
#include "nr-arena.h"
+#include "sp-canvas.h"
#include <2geom/pathvector.h>
+#include <2geom/bezier-curve.h>
+#include <2geom/hvlinesegment.h>
#include <2geom/matrix.h>
#include <2geom/point.h>
#include <2geom/path.h>
#include <2geom/transforms.h>
#include <2geom/sbasis-to-bezier.h>
+#include "helper/geom-curves.h"
/** Creates a cairo context to render to the given pixblock on the given area */
cairo_t *
-nr_create_cairo_context (NRRectL *area, NRPixBlock *pb)
+nr_create_cairo_context_for_data (NRRectL *area, NRRectL *buf_area, unsigned char *px, unsigned int rowstride)
{
- if (!nr_rect_l_test_intersect (&pb->area, area))
+ if (!nr_rect_l_test_intersect_ptr(buf_area, area))
return NULL;
NRRectL clip;
- nr_rect_l_intersect (&clip, &pb->area, area);
- unsigned char *dpx = NR_PIXBLOCK_PX (pb) + (clip.y0 - pb->area.y0) * pb->rs + NR_PIXBLOCK_BPP (pb) * (clip.x0 - pb->area.x0);
+ nr_rect_l_intersect (&clip, buf_area, area);
+ unsigned char *dpx = px + (clip.y0 - buf_area->y0) * rowstride + 4 * (clip.x0 - buf_area->x0);
int width = area->x1 - area->x0;
int height = area->y1 - area->y0;
// even though cairo cannot draw in nonpremul mode, select ARGB32 for R8G8B8A8N as the closest; later eliminate R8G8B8A8N everywhere
cairo_surface_t* cst = cairo_image_surface_create_for_data
(dpx,
- ((pb->mode == NR_PIXBLOCK_MODE_R8G8B8A8P || pb->mode == NR_PIXBLOCK_MODE_R8G8B8A8N) ? CAIRO_FORMAT_ARGB32 : (pb->mode == NR_PIXBLOCK_MODE_R8G8B8? CAIRO_FORMAT_RGB24 : CAIRO_FORMAT_A8)),
+ CAIRO_FORMAT_ARGB32,
width,
height,
- pb->rs);
+ rowstride);
cairo_t *ct = cairo_create (cst);
return ct;
}
-/** Feeds path-creating calls to the cairo context translating them from the SPCurve, with the given transform and shift */
-void
-feed_curve_to_cairo (cairo_t *ct, NArtBpath const *bpath, NR::Matrix trans, NR::Maybe<NR::Rect> area, bool optimize_stroke, double stroke_width)
+/** Creates a cairo context to render to the given SPCanvasBuf on the given area */
+cairo_t *
+nr_create_cairo_context_canvasbuf (NRRectL */*area*/, SPCanvasBuf *b)
{
- NR::Point next(0,0), last(0,0);
- if (!area || area->isEmpty())
- return;
- NR::Point shift = area->min();
- NR::Rect view = *area;
- view.growBy (stroke_width);
- NR::Rect swept;
- bool closed = false;
- NR::Point startpath(0,0);
- for (int i = 0; bpath[i].code != NR_END; i++) {
- switch (bpath[i].code) {
- case NR_MOVETO_OPEN:
- case NR_MOVETO:
- if (closed) {
- // we cannot use close_path because some of the curves/lines may have been optimized out
- cairo_line_to(ct, startpath[NR::X], startpath[NR::Y]);
- }
- next[NR::X] = bpath[i].x3;
- next[NR::Y] = bpath[i].y3;
- next *= trans;
- last = next;
- next -= shift;
- if (bpath[i].code == NR_MOVETO) {
- // remember the start point of the subpath, for closing it later
- closed = true;
- startpath = next;
- } else {
- closed = false;
- }
- cairo_move_to(ct, next[NR::X], next[NR::Y]);
- break;
-
- case NR_LINETO:
- next[NR::X] = bpath[i].x3;
- next[NR::Y] = bpath[i].y3;
- next *= trans;
- if (optimize_stroke) {
- swept = NR::Rect(last, next);
- //std::cout << "swept: " << swept;
- //std::cout << "view: " << view;
- //std::cout << "intersects? " << (swept.intersects(view)? "YES" : "NO") << "\n";
- }
- last = next;
- next -= shift;
- if (!optimize_stroke || swept.intersects(view))
- cairo_line_to(ct, next[NR::X], next[NR::Y]);
- else
- cairo_move_to(ct, next[NR::X], next[NR::Y]);
- break;
-
- case NR_CURVETO: {
- NR::Point tm1, tm2, tm3;
- tm1[0]=bpath[i].x1;
- tm1[1]=bpath[i].y1;
- tm2[0]=bpath[i].x2;
- tm2[1]=bpath[i].y2;
- tm3[0]=bpath[i].x3;
- tm3[1]=bpath[i].y3;
- tm1 *= trans;
- tm2 *= trans;
- tm3 *= trans;
- if (optimize_stroke) {
- swept = NR::Rect(last, last);
- swept.expandTo(tm1);
- swept.expandTo(tm2);
- swept.expandTo(tm3);
- }
- last = tm3;
- tm1 -= shift;
- tm2 -= shift;
- tm3 -= shift;
- if (!optimize_stroke || swept.intersects(view))
- cairo_curve_to (ct, tm1[NR::X], tm1[NR::Y], tm2[NR::X], tm2[NR::Y], tm3[NR::X], tm3[NR::Y]);
- else
- cairo_move_to(ct, tm3[NR::X], tm3[NR::Y]);
- break;
- }
-
- default:
- break;
- }
- }
+ return nr_create_cairo_context_for_data (&(b->rect), &(b->rect), b->buf, b->buf_rowstride);
}
+/** Creates a cairo context to render to the given NRPixBlock on the given area */
+cairo_t *
+nr_create_cairo_context (NRRectL *area, NRPixBlock *pb)
+{
+ return nr_create_cairo_context_for_data (area, &(pb->area), NR_PIXBLOCK_PX (pb), pb->rs);
+}
+
+/*
+ * Can be called recursively.
+ * If optimize_stroke == false, the view Rect is not used.
+ */
static void
-feed_curve_to_cairo(cairo_t *cr, Geom::Curve const &c, Geom::Rect view, bool optimize_stroke)
+feed_curve_to_cairo(cairo_t *cr, Geom::Curve const &c, Geom::Matrix const & trans, Geom::Rect view, bool optimize_stroke)
{
- if(Geom::LineSegment const* line_segment = dynamic_cast<Geom::LineSegment const*>(&c)) {
+ if( is_straight_curve(c) )
+ {
+ Geom::Point end_tr = c.finalPoint() * trans;
if (!optimize_stroke) {
- cairo_line_to(cr, (*line_segment)[1][0], (*line_segment)[1][1]);
+ cairo_line_to(cr, end_tr[0], end_tr[1]);
} else {
- Geom::Rect swept((*line_segment)[0], (*line_segment)[1]);
+ Geom::Rect swept(c.initialPoint()*trans, end_tr);
if (swept.intersects(view)) {
- cairo_line_to(cr, (*line_segment)[1][0], (*line_segment)[1][1]);
+ cairo_line_to(cr, end_tr[0], end_tr[1]);
} else {
- cairo_move_to(cr, (*line_segment)[1][0], (*line_segment)[1][1]);
+ cairo_move_to(cr, end_tr[0], end_tr[1]);
}
}
}
else if(Geom::QuadraticBezier const *quadratic_bezier = dynamic_cast<Geom::QuadraticBezier const*>(&c)) {
std::vector<Geom::Point> points = quadratic_bezier->points();
+ points[0] *= trans;
+ points[1] *= trans;
+ points[2] *= trans;
Geom::Point b1 = points[0] + (2./3) * (points[1] - points[0]);
Geom::Point b2 = b1 + (1./3) * (points[2] - points[0]);
if (!optimize_stroke) {
@@ -173,9 +110,14 @@ feed_curve_to_cairo(cairo_t *cr, Geom::Curve const &c, Geom::Rect view, bool opt
}
else if(Geom::CubicBezier const *cubic_bezier = dynamic_cast<Geom::CubicBezier const*>(&c)) {
std::vector<Geom::Point> points = cubic_bezier->points();
+ //points[0] *= trans; // don't do this one here for fun: it is only needed for optimized strokes
+ points[1] *= trans;
+ points[2] *= trans;
+ points[3] *= trans;
if (!optimize_stroke) {
cairo_curve_to(cr, points[1][0], points[1][1], points[2][0], points[2][1], points[3][0], points[3][1]);
} else {
+ points[0] *= trans; // didn't transform this point yet
Geom::Rect swept(points[0], points[3]);
swept.expandTo(points[1]);
swept.expandTo(points[2]);
@@ -186,53 +128,92 @@ feed_curve_to_cairo(cairo_t *cr, Geom::Curve const &c, Geom::Rect view, bool opt
}
}
}
-// else if(Geom::EllipticalArc const *svg_elliptical_arc = dynamic_cast<Geom::EllipticalArc *>(c)) {
+// else if(Geom::SVGEllipticalArc const *svg_elliptical_arc = dynamic_cast<Geom::SVGEllipticalArc *>(c)) {
// //TODO: get at the innards and spit them out to cairo
// }
else {
//this case handles sbasis as well as all other curve types
- Geom::Path sbasis_path = path_from_sbasis(c.toSBasis(), 0.1);
+ Geom::Path sbasis_path = Geom::cubicbezierpath_from_sbasis(c.toSBasis(), 0.1);
//recurse to convert the new path resulting from the sbasis to svgd
for(Geom::Path::iterator iter = sbasis_path.begin(); iter != sbasis_path.end(); ++iter) {
- feed_curve_to_cairo(cr, *iter, view, optimize_stroke);
+ feed_curve_to_cairo(cr, *iter, trans, view, optimize_stroke);
}
}
}
-/** Feeds path-creating calls to the cairo context translating them from the SPCurve, with the given transform and shift */
-void
-feed_path_to_cairo (cairo_t *ct, Geom::Path const &path, Geom::Matrix trans, NR::Maybe<NR::Rect> area, bool optimize_stroke, double stroke_width)
+/** Feeds path-creating calls to the cairo context translating them from the Path */
+static void
+feed_path_to_cairo (cairo_t *ct, Geom::Path const &path)
{
- if (!area || area->isEmpty())
- return;
if (path.empty())
return;
- // Transform all coordinates to coords within "area"
- Geom::Point shift = to_2geom(area->min());
- NR::Rect view = *area;
- view.growBy (stroke_width);
- view = view * from_2geom(Geom::Translate(-shift));
- Geom::Path const path_trans = path * (trans * Geom::Translate(-shift));
+ cairo_move_to(ct, path.initialPoint()[0], path.initialPoint()[1] );
+
+ for(Geom::Path::const_iterator cit = path.begin(); cit != path.end_open(); ++cit) {
+ feed_curve_to_cairo(ct, *cit, Geom::identity(), Geom::Rect(), false); // optimize_stroke is false, so the view rect is not used
+ }
- cairo_move_to(ct, path_trans.initialPoint()[0], path_trans.initialPoint()[1] );
+ if (path.closed()) {
+ cairo_close_path(ct);
+ }
+}
- for(Geom::Path::const_iterator cit = path_trans.begin(); cit != path_trans.end_open(); ++cit) {
- feed_curve_to_cairo(ct, *cit, to_2geom(view), optimize_stroke);
+/** Feeds path-creating calls to the cairo context translating them from the Path, with the given transform and shift */
+static void
+feed_path_to_cairo (cairo_t *ct, Geom::Path const &path, Geom::Matrix trans, Geom::OptRect area, bool optimize_stroke, double stroke_width)
+{
+ if (!area)
+ return;
+ if (path.empty())
+ return;
+
+ // Transform all coordinates to coords within "area"
+ Geom::Point shift = area->min();
+ Geom::Rect view = *area;
+ view.expandBy (stroke_width);
+ view = view * (Geom::Matrix)Geom::Translate(-shift);
+ // Pass transformation to feed_curve, so that we don't need to create a whole new path.
+ Geom::Matrix transshift(trans * Geom::Translate(-shift));
+
+ Geom::Point initial = path.initialPoint() * transshift;
+ cairo_move_to(ct, initial[0], initial[1] );
+
+ for(Geom::Path::const_iterator cit = path.begin(); cit != path.end_open(); ++cit) {
+ feed_curve_to_cairo(ct, *cit, transshift, view, optimize_stroke);
}
if (path.closed()) {
- cairo_line_to(ct, path_trans.initialPoint()[0], path_trans.initialPoint()[1] );
+ if (!optimize_stroke) {
+ cairo_close_path(ct);
+ } else {
+ cairo_line_to(ct, initial[0], initial[1]);
+ /* We cannot use cairo_close_path(ct) here because some parts of the path may have been
+ clipped and not drawn (maybe the before last segment was outside view area), which
+ would result in closing the "subpath" after the last interruption, not the entire path.
+
+ However, according to cairo documentation:
+ The behavior of cairo_close_path() is distinct from simply calling cairo_line_to() with the equivalent coordinate
+ in the case of stroking. When a closed sub-path is stroked, there are no caps on the ends of the sub-path. Instead,
+ there is a line join connecting the final and initial segments of the sub-path.
+
+ The correct fix will be possible when cairo introduces methods for moving without
+ ending/starting subpaths, which we will use for skipping invisible segments; then we
+ will be able to use cairo_close_path here. This issue also affects ps/eps/pdf export,
+ see bug 168129
+ */
+ }
}
}
-/** Feeds path-creating calls to the cairo context translating them from the SPCurve, with the given transform and shift */
+/** Feeds path-creating calls to the cairo context translating them from the PathVector, with the given transform and shift
+ * One must have done cairo_new_path(ct); before calling this function. */
void
-feed_pathvector_to_cairo (cairo_t *ct, Geom::PathVector const &pathv, Geom::Matrix trans, NR::Maybe<NR::Rect> area, bool optimize_stroke, double stroke_width)
+feed_pathvector_to_cairo (cairo_t *ct, Geom::PathVector const &pathv, Geom::Matrix trans, Geom::OptRect area, bool optimize_stroke, double stroke_width)
{
- if (!area || area->isEmpty())
+ if (!area)
return;
if (pathv.empty())
return;
@@ -242,6 +223,19 @@ feed_pathvector_to_cairo (cairo_t *ct, Geom::PathVector const &pathv, Geom::Matr
}
}
+/** Feeds path-creating calls to the cairo context translating them from the PathVector
+ * One must have done cairo_new_path(ct); before calling this function. */
+void
+feed_pathvector_to_cairo (cairo_t *ct, Geom::PathVector const &pathv)
+{
+ if (pathv.empty())
+ return;
+
+ for(Geom::PathVector::const_iterator it = pathv.begin(); it != pathv.end(); ++it) {
+ feed_path_to_cairo(ct, *it);
+ }
+}
+
/*
Local Variables:
mode:c++