src/display/inkscape-cairo.cpp

   1 /*
   2  * Helper functions to use cairo with inkscape
   3  *
   4  * Copyright (C) 2007 bulia byak
   5  * Copyright (C) 2008 Johan Engelen
   6  *
   7  * Released under GNU GPL
   8  *
   9  */
  10
  11 #include <cairo.h>
  12
  13 #ifdef HAVE_CONFIG_H
  14 # include <config.h>
  15 #endif
  16
  17 #include <libnr/nr-pixblock.h>
  18 #include <libnr/nr-convert2geom.h>
  19 #include "../style.h"
  20 #include "nr-arena.h"
  21 #include "sp-canvas.h"
  22 #include <2geom/pathvector.h>
  23 #include <2geom/bezier-curve.h>
  24 #include <2geom/hvlinesegment.h>
  25 #include <2geom/matrix.h>
  26 #include <2geom/point.h>
  27 #include <2geom/path.h>
  28 #include <2geom/transforms.h>
  29 #include <2geom/sbasis-to-bezier.h>
  30 #include "helper/geom-curves.h"
  31
  32 /** Creates a cairo context to render to the given pixblock on the given area */
  33 cairo_t *
  34 nr_create_cairo_context_for_data (NRRectL *area, NRRectL *buf_area, unsigned char *px, unsigned int rowstride)
  35 {
  36     if (!nr_rect_l_test_intersect_ptr(buf_area, area))
  37         return NULL;
  38
  39     NRRectL clip;
  40     nr_rect_l_intersect (&clip, buf_area, area);
  41     unsigned char *dpx = px + (clip.y0 - buf_area->y0) * rowstride + 4 * (clip.x0 - buf_area->x0);
  42     int width = area->x1 - area->x0;
  43     int height = area->y1 - area->y0;
  44     // even though cairo cannot draw in nonpremul mode, select ARGB32 for R8G8B8A8N as the closest; later eliminate R8G8B8A8N everywhere
  45     cairo_surface_t* cst = cairo_image_surface_create_for_data
  46         (dpx,
  47          CAIRO_FORMAT_ARGB32,
  48          width,
  49          height,
  50          rowstride);
  51     cairo_t *ct = cairo_create (cst);
  52
  53     return ct;
  54 }
  55
  56 /** Creates a cairo context to render to the given SPCanvasBuf on the given area */
  57 cairo_t *
  58 nr_create_cairo_context_canvasbuf (NRRectL */*area*/, SPCanvasBuf *b)
  59 {
  60     return nr_create_cairo_context_for_data (&(b->rect), &(b->rect), b->buf, b->buf_rowstride);
  61 }
  62
  63
  64 /** Creates a cairo context to render to the given NRPixBlock on the given area */
  65 cairo_t *
  66 nr_create_cairo_context (NRRectL *area, NRPixBlock *pb)
  67 {
  68     return nr_create_cairo_context_for_data (area, &(pb->area), NR_PIXBLOCK_PX (pb), pb->rs);
  69 }
  70
  71 /*
  72  * Can be called recursively.
  73  * If optimize_stroke == false, the view Rect is not used.
  74  */
  75 static void
  76 feed_curve_to_cairo(cairo_t *cr, Geom::Curve const &c, Geom::Matrix const & trans, Geom::Rect view, bool optimize_stroke)
  77 {
  78     if( is_straight_curve(c) )
  79     {
  80         Geom::Point end_tr = c.finalPoint() * trans;
  81         if (!optimize_stroke) {
  82             cairo_line_to(cr, end_tr[0], end_tr[1]);
  83         } else {
  84             Geom::Rect swept(c.initialPoint()*trans, end_tr);
  85             if (swept.intersects(view)) {
  86                 cairo_line_to(cr, end_tr[0], end_tr[1]);
  87             } else {
  88                 cairo_move_to(cr, end_tr[0], end_tr[1]);
  89             }
  90         }
  91     }
  92     else if(Geom::QuadraticBezier const *quadratic_bezier = dynamic_cast<Geom::QuadraticBezier const*>(&c)) {
  93         std::vector<Geom::Point> points = quadratic_bezier->points();
  94         points[0] *= trans;
  95         points[1] *= trans;
  96         points[2] *= trans;
  97         Geom::Point b1 = points[0] + (2./3) * (points[1] - points[0]);
  98         Geom::Point b2 = b1 + (1./3) * (points[2] - points[0]);
  99         if (!optimize_stroke) {
 100             cairo_curve_to(cr, b1[0], b1[1], b2[0], b2[1], points[2][0], points[2][1]);
 101         } else {
 102             Geom::Rect swept(points[0], points[2]);
 103             swept.expandTo(points[1]);
 104             if (swept.intersects(view)) {
 105                 cairo_curve_to(cr, b1[0], b1[1], b2[0], b2[1], points[2][0], points[2][1]);
 106             } else {
 107                 cairo_move_to(cr, points[2][0], points[2][1]);
 108             }
 109         }
 110     }
 111     else if(Geom::CubicBezier const *cubic_bezier = dynamic_cast<Geom::CubicBezier const*>(&c)) {
 112         std::vector<Geom::Point> points = cubic_bezier->points();
 113         //points[0] *= trans; // don't do this one here for fun: it is only needed for optimized strokes
 114         points[1] *= trans;
 115         points[2] *= trans;
 116         points[3] *= trans;
 117         if (!optimize_stroke) {
 118             cairo_curve_to(cr, points[1][0], points[1][1], points[2][0], points[2][1], points[3][0], points[3][1]);
 119         } else {
 120             points[0] *= trans;  // didn't transform this point yet
 121             Geom::Rect swept(points[0], points[3]);
 122             swept.expandTo(points[1]);
 123             swept.expandTo(points[2]);
 124             if (swept.intersects(view)) {
 125                 cairo_curve_to(cr, points[1][0], points[1][1], points[2][0], points[2][1], points[3][0], points[3][1]);
 126             } else {
 127                 cairo_move_to(cr, points[3][0], points[3][1]);
 128             }
 129         }
 130     }
 131 //    else if(Geom::SVGEllipticalArc const *svg_elliptical_arc = dynamic_cast<Geom::SVGEllipticalArc *>(c)) {
 132 //        //TODO: get at the innards and spit them out to cairo
 133 //    }
 134     else {
 135         //this case handles sbasis as well as all other curve types
 136         Geom::Path sbasis_path = Geom::cubicbezierpath_from_sbasis(c.toSBasis(), 0.1);
 137
 138         //recurse to convert the new path resulting from the sbasis to svgd
 139         for(Geom::Path::iterator iter = sbasis_path.begin(); iter != sbasis_path.end(); ++iter) {
 140             feed_curve_to_cairo(cr, *iter, trans, view, optimize_stroke);
 141         }
 142     }
 143 }
 144
 145
 146 /** Feeds path-creating calls to the cairo context translating them from the Path */
 147 static void
 148 feed_path_to_cairo (cairo_t *ct, Geom::Path const &path)
 149 {
 150     if (path.empty())
 151         return;
 152
 153     cairo_move_to(ct, path.initialPoint()[0], path.initialPoint()[1] );
 154
 155     for(Geom::Path::const_iterator cit = path.begin(); cit != path.end_open(); ++cit) {
 156         feed_curve_to_cairo(ct, *cit, Geom::identity(), Geom::Rect(), false); // optimize_stroke is false, so the view rect is not used
 157     }
 158
 159     if (path.closed()) {
 160         cairo_line_to(ct, path.initialPoint()[0], path.initialPoint()[1]);
 161 //        cairo_close_path(ct);
 162         /* I think we should use cairo_close_path(ct) here but it doesn't work. (the closing line is not rendered completely)
 163            According to cairo documentation:
 164            The behavior of cairo_close_path() is distinct from simply calling cairo_line_to() with the equivalent coordinate
 165            in the case of stroking. When a closed sub-path is stroked, there are no caps on the ends of the sub-path. Instead,
 166            there is a line join connecting the final and initial segments of the sub-path.
 167         */
 168     }
 169 }
 170
 171 /** Feeds path-creating calls to the cairo context translating them from the Path, with the given transform and shift */
 172 static void
 173 feed_path_to_cairo (cairo_t *ct, Geom::Path const &path, Geom::Matrix trans, Geom::OptRect area, bool optimize_stroke, double stroke_width)
 174 {
 175     if (!area)
 176         return;
 177     if (path.empty())
 178         return;
 179
 180     // Transform all coordinates to coords within "area"
 181     Geom::Point shift = area->min();
 182     Geom::Rect view = *area;
 183     view.expandBy (stroke_width);
 184     view = view * (Geom::Matrix)Geom::Translate(-shift);
 185     //  Pass transformation to feed_curve, so that we don't need to create a whole new path.
 186     Geom::Matrix transshift(trans * Geom::Translate(-shift));
 187
 188     Geom::Point initial = path.initialPoint() * transshift;
 189     cairo_move_to(ct, initial[0], initial[1] );
 190
 191     for(Geom::Path::const_iterator cit = path.begin(); cit != path.end_open(); ++cit) {
 192         feed_curve_to_cairo(ct, *cit, transshift, view, optimize_stroke);
 193     }
 194
 195     if (path.closed()) {
 196         cairo_line_to(ct, initial[0], initial[1]);
 197         /* We cannot use cairo_close_path(ct) here because some parts of the path may have been
 198            clipped and not drawn (maybe the before last segment was outside view area), which
 199            would result in closing the "subpath" after the last interruption, not the entire path.
 200
 201            However, according to cairo documentation:
 202            The behavior of cairo_close_path() is distinct from simply calling cairo_line_to() with the equivalent coordinate
 203            in the case of stroking. When a closed sub-path is stroked, there are no caps on the ends of the sub-path. Instead,
 204            there is a line join connecting the final and initial segments of the sub-path.
 205
 206            The correct fix will be possible when cairo introduces methods for moving without
 207            ending/starting subpaths, which we will use for skipping invisible segments; then we
 208            will be able to use cairo_close_path here. This issue also affects ps/eps/pdf export,
 209            see bug 168129
 210         */
 211     }
 212 }
 213
 214 /** Feeds path-creating calls to the cairo context translating them from the PathVector, with the given transform and shift
 215  *  One must have done cairo_new_path(ct); before calling this function. */
 216 void
 217 feed_pathvector_to_cairo (cairo_t *ct, Geom::PathVector const &pathv, Geom::Matrix trans, Geom::OptRect area, bool optimize_stroke, double stroke_width)
 218 {
 219     if (!area)
 220         return;
 221     if (pathv.empty())
 222         return;
 223
 224     for(Geom::PathVector::const_iterator it = pathv.begin(); it != pathv.end(); ++it) {
 225         feed_path_to_cairo(ct, *it, trans, area, optimize_stroke, stroke_width);
 226     }
 227 }
 228
 229 /** Feeds path-creating calls to the cairo context translating them from the PathVector
 230  *  One must have done cairo_new_path(ct); before calling this function. */
 231 void
 232 feed_pathvector_to_cairo (cairo_t *ct, Geom::PathVector const &pathv)
 233 {
 234     if (pathv.empty())
 235         return;
 236
 237     for(Geom::PathVector::const_iterator it = pathv.begin(); it != pathv.end(); ++it) {
 238         feed_path_to_cairo(ct, *it);
 239     }
 240 }
 241
 242 /*
 243   Local Variables:
 244   mode:c++
 245   c-file-style:"stroustrup"
 246   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 247   indent-tabs-mode:nil
 248   fill-column:99
 249   End:
 250 */
 251 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :