2009-07-14 Dmitry Titov <dimich@chromium.org>
[WebKit-https.git] / WebCore / platform / graphics / skia / PathSkia.cpp
1 // Copyright (c) 2008, Google Inc.
2 // All rights reserved.
3 // 
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
6 // met:
7 // 
8 //     * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 //     * Redistributions in binary form must reproduce the above
11 // copyright notice, this list of conditions and the following disclaimer
12 // in the documentation and/or other materials provided with the
13 // distribution.
14 //     * Neither the name of Google Inc. nor the names of its
15 // contributors may be used to endorse or promote products derived from
16 // this software without specific prior written permission.
17 // 
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30 #include "config.h"
31 #include "Path.h"
32
33 #include "FloatRect.h"
34 #include "ImageBuffer.h"
35 #include "StrokeStyleApplier.h"
36
37 #include "SkPath.h"
38 #include "SkRegion.h"
39 #include "SkiaUtils.h"
40
41 #include <wtf/MathExtras.h>
42
43 namespace WebCore {
44
45 Path::Path()
46 {
47     m_path = new SkPath;
48 }
49
50 Path::Path(const Path& other)
51 {
52     m_path = new SkPath(*other.m_path);
53 }
54
55 Path::~Path()
56 {
57     delete m_path;
58 }
59
60 Path& Path::operator=(const Path& other)
61 {
62     *m_path = *other.m_path;
63     return *this;
64 }
65
66 bool Path::isEmpty() const
67 {
68     return m_path->isEmpty();
69 }
70
71 bool Path::hasCurrentPoint() const
72 {
73     return true;
74 }
75
76 bool Path::contains(const FloatPoint& point, WindRule rule) const
77 {
78     return SkPathContainsPoint(m_path, point,
79       rule == RULE_NONZERO ? SkPath::kWinding_FillType : SkPath::kEvenOdd_FillType);
80 }
81
82 void Path::translate(const FloatSize& size)
83 {
84     m_path->offset(WebCoreFloatToSkScalar(size.width()), WebCoreFloatToSkScalar(size.height()));
85 }
86
87 FloatRect Path::boundingRect() const
88 {
89     return m_path->getBounds();
90 }
91
92 void Path::moveTo(const FloatPoint& point)
93 {
94     m_path->moveTo(point);
95 }
96
97 void Path::addLineTo(const FloatPoint& point)
98 {
99     m_path->lineTo(point);
100 }
101
102 void Path::addQuadCurveTo(const FloatPoint& cp, const FloatPoint& ep)
103 {
104     m_path->quadTo(cp, ep);
105 }
106
107 void Path::addBezierCurveTo(const FloatPoint& p1, const FloatPoint& p2, const FloatPoint& ep)
108 {
109     m_path->cubicTo(p1, p2, ep);
110 }
111
112 void Path::addArcTo(const FloatPoint& p1, const FloatPoint& p2, float radius)
113 {
114     m_path->arcTo(p1, p2, WebCoreFloatToSkScalar(radius));
115 }
116
117 void Path::closeSubpath()
118 {
119     m_path->close();
120 }
121
122 void Path::addArc(const FloatPoint& p, float r, float sa, float ea, bool anticlockwise) {
123     SkScalar cx = WebCoreFloatToSkScalar(p.x());
124     SkScalar cy = WebCoreFloatToSkScalar(p.y());
125     SkScalar radius = WebCoreFloatToSkScalar(r);
126
127     SkRect oval;
128     oval.set(cx - radius, cy - radius, cx + radius, cy + radius);
129
130     float sweep = ea - sa;
131     // check for a circle
132     if (sweep >= 2 * piFloat || sweep <= -2 * piFloat)
133         m_path->addOval(oval);
134     else {
135         SkScalar startDegrees = WebCoreFloatToSkScalar(sa * 180 / piFloat);
136         SkScalar sweepDegrees = WebCoreFloatToSkScalar(sweep * 180 / piFloat);
137
138         // Counterclockwise arcs should be drawn with negative sweeps, while
139         // clockwise arcs should be drawn with positive sweeps. Check to see
140         // if the situation is reversed and correct it by adding or subtracting
141         // a full circle
142         if (anticlockwise && sweepDegrees > 0) {
143             sweepDegrees -= SkIntToScalar(360);
144         } else if (!anticlockwise && sweepDegrees < 0) {
145             sweepDegrees += SkIntToScalar(360);
146         }
147
148         m_path->arcTo(oval, startDegrees, sweepDegrees, false);
149     }
150 }
151
152 void Path::addRect(const FloatRect& rect)
153 {
154     m_path->addRect(rect);
155 }
156
157 void Path::addEllipse(const FloatRect& rect)
158 {
159     m_path->addOval(rect);
160 }
161
162 void Path::clear()
163 {
164     m_path->reset();
165 }
166
167 static FloatPoint* convertPathPoints(FloatPoint dst[], const SkPoint src[], int count)
168 {
169     for (int i = 0; i < count; i++) {
170         dst[i].setX(SkScalarToFloat(src[i].fX));
171         dst[i].setY(SkScalarToFloat(src[i].fY));
172     }
173     return dst;
174 }
175
176 void Path::apply(void* info, PathApplierFunction function) const
177 {
178     SkPath::Iter iter(*m_path, false);
179     SkPoint pts[4];
180     PathElement pathElement;
181     FloatPoint pathPoints[3];
182
183     for (;;) {
184         switch (iter.next(pts)) {
185         case SkPath::kMove_Verb:
186             pathElement.type = PathElementMoveToPoint;
187             pathElement.points = convertPathPoints(pathPoints, &pts[0], 1);
188             break;
189         case SkPath::kLine_Verb:
190             pathElement.type = PathElementAddLineToPoint;
191             pathElement.points = convertPathPoints(pathPoints, &pts[1], 1);
192             break;
193         case SkPath::kQuad_Verb:
194             pathElement.type = PathElementAddQuadCurveToPoint;
195             pathElement.points = convertPathPoints(pathPoints, &pts[1], 2);
196             break;
197         case SkPath::kCubic_Verb:
198             pathElement.type = PathElementAddCurveToPoint;
199             pathElement.points = convertPathPoints(pathPoints, &pts[1], 3);
200             break;
201         case SkPath::kClose_Verb:
202             pathElement.type = PathElementCloseSubpath;
203             pathElement.points = convertPathPoints(pathPoints, 0, 0);
204             break;
205         case SkPath::kDone_Verb:
206             return;
207         }
208         function(info, &pathElement);
209     }
210 }
211
212 void Path::transform(const TransformationMatrix& xform)
213 {
214     m_path->transform(xform);
215 }
216
217 String Path::debugString() const
218 {
219     String result;
220
221     SkPath::Iter iter(*m_path, false);
222     SkPoint pts[4];
223
224     int numPoints = m_path->getPoints(0, 0);
225     SkPath::Verb verb;
226
227     do {
228         verb = iter.next(pts);
229         switch (verb) {
230         case SkPath::kMove_Verb:
231             result += String::format("M%.2f,%.2f ", pts[0].fX, pts[0].fY);
232             numPoints -= 1;
233             break;
234         case SkPath::kLine_Verb:
235           if (!iter.isCloseLine()) {
236                 result += String::format("L%.2f,%.2f ", pts[1].fX, pts[1].fY); 
237                 numPoints -= 1;
238             }
239             break;
240         case SkPath::kQuad_Verb:
241             result += String::format("Q%.2f,%.2f,%.2f,%.2f ",
242                 pts[1].fX, pts[1].fY,
243                 pts[2].fX, pts[2].fY);
244             numPoints -= 2;
245             break;
246         case SkPath::kCubic_Verb:
247             result += String::format("C%.2f,%.2f,%.2f,%.2f,%.2f,%.2f ",
248                 pts[1].fX, pts[1].fY,
249                 pts[2].fX, pts[2].fY,
250                 pts[3].fX, pts[3].fY);
251             numPoints -= 3;
252             break;
253         case SkPath::kClose_Verb:
254             result += "Z ";
255             break;
256         case SkPath::kDone_Verb:
257             break;
258         }
259     } while (verb != SkPath::kDone_Verb);
260
261     // If you have a path that ends with an M, Skia will not iterate the
262     // trailing M. That's nice of it, but Apple's paths output the trailing M
263     // and we want out layout dumps to look like theirs
264     if (numPoints) {
265         ASSERT(numPoints==1);
266         m_path->getLastPt(pts);
267         result += String::format("M%.2f,%.2f ", pts[0].fX, pts[0].fY);
268     }
269
270     return result.stripWhiteSpace();
271 }
272
273 // Computes the bounding box for the stroke and style currently selected into
274 // the given bounding box. This also takes into account the stroke width.
275 static FloatRect boundingBoxForCurrentStroke(const GraphicsContext* context)
276 {
277     SkPaint paint;
278     context->platformContext()->setupPaintForStroking(&paint, 0, 0);
279     SkPath boundingPath;
280     paint.getFillPath(context->platformContext()->currentPathInLocalCoordinates(), &boundingPath);
281     return boundingPath.getBounds();
282 }
283
284 FloatRect Path::strokeBoundingRect(StrokeStyleApplier* applier)
285 {
286     GraphicsContext* scratch = scratchContext();
287     scratch->save();
288     scratch->beginPath();
289     scratch->addPath(*this);
290
291     if (applier)
292         applier->strokeStyle(scratch);
293
294     FloatRect r = boundingBoxForCurrentStroke(scratch);
295     scratch->restore();
296     return r;
297 }
298
299 bool Path::strokeContains(StrokeStyleApplier* applier, const FloatPoint& point) const
300 {
301     ASSERT(applier);
302     GraphicsContext* scratch = scratchContext();
303     scratch->save();
304
305     applier->strokeStyle(scratch);
306
307     SkPaint paint;
308     scratch->platformContext()->setupPaintForStroking(&paint, 0, 0);
309     SkPath strokePath;
310     paint.getFillPath(*platformPath(), &strokePath);
311     bool contains = SkPathContainsPoint(&strokePath, point,
312                                         SkPath::kWinding_FillType);
313
314     scratch->restore();
315     return contains;
316 }
317 } // namespace WebCore