06a791ace6b175acca0453147976adeb4197d647
[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::contains(const FloatPoint& point, WindRule rule) const
72 {
73     return SkPathContainsPoint(m_path, point,
74       rule == RULE_NONZERO ? SkPath::kWinding_FillType : SkPath::kEvenOdd_FillType);
75 }
76
77 void Path::translate(const FloatSize& size)
78 {
79     m_path->offset(WebCoreFloatToSkScalar(size.width()), WebCoreFloatToSkScalar(size.height()));
80 }
81
82 FloatRect Path::boundingRect() const
83 {
84     SkRect rect;
85     m_path->computeBounds(&rect, SkPath::kExact_BoundsType);
86     return rect;
87 }
88
89 void Path::moveTo(const FloatPoint& point)
90 {
91     m_path->moveTo(point);
92 }
93
94 void Path::addLineTo(const FloatPoint& point)
95 {
96     m_path->lineTo(point);
97 }
98
99 void Path::addQuadCurveTo(const FloatPoint& cp, const FloatPoint& ep)
100 {
101     m_path->quadTo(cp, ep);
102 }
103
104 void Path::addBezierCurveTo(const FloatPoint& p1, const FloatPoint& p2, const FloatPoint& ep)
105 {
106     m_path->cubicTo(p1, p2, ep);
107 }
108
109 void Path::addArcTo(const FloatPoint& p1, const FloatPoint& p2, float radius)
110 {
111     m_path->arcTo(p1, p2, WebCoreFloatToSkScalar(radius));
112 }
113
114 void Path::closeSubpath()
115 {
116     m_path->close();
117 }
118
119 void Path::addArc(const FloatPoint& p, float r, float sa, float ea, bool anticlockwise) {
120     SkScalar cx = WebCoreFloatToSkScalar(p.x());
121     SkScalar cy = WebCoreFloatToSkScalar(p.y());
122     SkScalar radius = WebCoreFloatToSkScalar(r);
123
124     SkRect oval;
125     oval.set(cx - radius, cy - radius, cx + radius, cy + radius);
126
127     float sweep = ea - sa;
128     // check for a circle
129     if (sweep >= 2 * piFloat || sweep <= -2 * piFloat)
130         m_path->addOval(oval);
131     else {
132         SkScalar startDegrees = WebCoreFloatToSkScalar(sa * 180 / piFloat);
133         SkScalar sweepDegrees = WebCoreFloatToSkScalar(sweep * 180 / piFloat);
134
135         // Counterclockwise arcs should be drawn with negative sweeps, while
136         // clockwise arcs should be drawn with positive sweeps. Check to see
137         // if the situation is reversed and correct it by adding or subtracting
138         // a full circle
139         if (anticlockwise && sweepDegrees > 0) {
140             sweepDegrees -= SkIntToScalar(360);
141         } else if (!anticlockwise && sweepDegrees < 0) {
142             sweepDegrees += SkIntToScalar(360);
143         }
144
145         m_path->arcTo(oval, startDegrees, sweepDegrees, false);
146     }
147 }
148
149 void Path::addRect(const FloatRect& rect)
150 {
151     m_path->addRect(rect);
152 }
153
154 void Path::addEllipse(const FloatRect& rect)
155 {
156     m_path->addOval(rect);
157 }
158
159 void Path::clear()
160 {
161     m_path->reset();
162 }
163
164 static FloatPoint* convertPathPoints(FloatPoint dst[], const SkPoint src[], int count)
165 {
166     for (int i = 0; i < count; i++) {
167         dst[i].setX(SkScalarToFloat(src[i].fX));
168         dst[i].setY(SkScalarToFloat(src[i].fY));
169     }
170     return dst;
171 }
172
173 void Path::apply(void* info, PathApplierFunction function) const
174 {
175     SkPath::Iter iter(*m_path, false);
176     SkPoint pts[4];
177
178     PathElement pathElement;
179     FloatPoint pathPoints[3];
180
181     for (;;) {
182         switch (iter.next(pts)) {
183         case SkPath::kMove_Verb:
184             pathElement.type = PathElementMoveToPoint;
185             pathElement.points = convertPathPoints(pathPoints, &pts[0], 1);
186             break;
187         case SkPath::kLine_Verb:
188             pathElement.type = PathElementAddLineToPoint;
189             pathElement.points = convertPathPoints(pathPoints, &pts[1], 1);
190             break;
191         case SkPath::kQuad_Verb:
192             pathElement.type = PathElementAddQuadCurveToPoint;
193             pathElement.points = convertPathPoints(pathPoints, &pts[1], 2);
194             break;
195         case SkPath::kCubic_Verb:
196             pathElement.type = PathElementAddCurveToPoint;
197             pathElement.points = convertPathPoints(pathPoints, &pts[1], 3);
198             break;
199         case SkPath::kClose_Verb:
200             pathElement.type = PathElementCloseSubpath;
201             pathElement.points = convertPathPoints(pathPoints, 0, 0);
202             break;
203         case SkPath::kDone_Verb:
204             return;
205         }
206         function(info, &pathElement);
207     }
208 }
209
210 void Path::transform(const TransformationMatrix& xform)
211 {
212     m_path->transform(xform);
213 }
214
215 String Path::debugString() const
216 {
217     String result;
218
219     SkPath::Iter iter(*m_path, false);
220     SkPoint pts[4];
221
222     int numPoints = m_path->getPoints(0, 0);
223     SkPath::Verb verb;
224
225     do {
226         verb = iter.next(pts);
227         switch (verb) {
228         case SkPath::kMove_Verb:
229             result += String::format("M%.2f,%.2f ", pts[0].fX, pts[0].fY);
230             numPoints -= 1;
231             break;
232         case SkPath::kLine_Verb:
233           if (!iter.isCloseLine()) {
234                 result += String::format("L%.2f,%.2f ", pts[1].fX, pts[1].fY); 
235                 numPoints -= 1;
236             }
237             break;
238         case SkPath::kQuad_Verb:
239             result += String::format("Q%.2f,%.2f,%.2f,%.2f ",
240                 pts[1].fX, pts[1].fY,
241                 pts[2].fX, pts[2].fY);
242             numPoints -= 2;
243             break;
244         case SkPath::kCubic_Verb:
245             result += String::format("C%.2f,%.2f,%.2f,%.2f,%.2f,%.2f ",
246                 pts[1].fX, pts[1].fY,
247                 pts[2].fX, pts[2].fY,
248                 pts[3].fX, pts[3].fY);
249             numPoints -= 3;
250             break;
251         case SkPath::kClose_Verb:
252             result += "Z ";
253             break;
254         case SkPath::kDone_Verb:
255             break;
256         }
257     } while (verb != SkPath::kDone_Verb);
258
259     // If you have a path that ends with an M, Skia will not iterate the
260     // trailing M. That's nice of it, but Apple's paths output the trailing M
261     // and we want out layout dumps to look like theirs
262     if (numPoints) {
263         ASSERT(numPoints==1);
264         m_path->getLastPt(pts);
265         result += String::format("M%.2f,%.2f ", pts[0].fX, pts[0].fY);
266     }
267
268     return result.stripWhiteSpace();
269 }
270
271 // Computes the bounding box for the stroke and style currently selected into
272 // the given bounding box. This also takes into account the stroke width.
273 static FloatRect boundingBoxForCurrentStroke(const GraphicsContext* context)
274 {
275     SkPaint paint;
276     context->platformContext()->setupPaintForStroking(&paint, 0, 0);
277     SkPath boundingPath;
278     paint.getFillPath(*context->platformContext()->currentPath(), &boundingPath);
279     SkRect r;
280     boundingPath.computeBounds(&r, SkPath::kExact_BoundsType);
281     return r;
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 } // namespace WebCore