1 /*
2 * Copyright (C) 2003, 2006 Apple Computer, Inc. All rights reserved.
3 * 2006 Rob Buis <buis@kde.org>
4 * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
16 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
19 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
23 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28
29 #include "config.h"
30 #include "Path.h"
31
32 #include "FloatPoint.h"
33 #include "FloatRect.h"
34 #include "PathTraversalState.h"
35 #include <math.h>
36 #include <wtf/MathExtras.h>
37
38 static const float QUARTER = 0.552f; // approximation of control point positions on a bezier
39 // to simulate a quarter of a circle.
40 namespace WebCore {
41
pathLengthApplierFunction(void * info,const PathElement * element)42 static void pathLengthApplierFunction(void* info, const PathElement* element)
43 {
44 PathTraversalState& traversalState = *static_cast<PathTraversalState*>(info);
45 if (traversalState.m_success)
46 return;
47 traversalState.m_previous = traversalState.m_current;
48 FloatPoint* points = element->points;
49 float segmentLength = 0.0f;
50 switch (element->type) {
51 case PathElementMoveToPoint:
52 segmentLength = traversalState.moveTo(points[0]);
53 break;
54 case PathElementAddLineToPoint:
55 segmentLength = traversalState.lineTo(points[0]);
56 break;
57 case PathElementAddQuadCurveToPoint:
58 segmentLength = traversalState.quadraticBezierTo(points[0], points[1]);
59 break;
60 case PathElementAddCurveToPoint:
61 segmentLength = traversalState.cubicBezierTo(points[0], points[1], points[2]);
62 break;
63 case PathElementCloseSubpath:
64 segmentLength = traversalState.closeSubpath();
65 break;
66 }
67 traversalState.m_totalLength += segmentLength;
68 if ((traversalState.m_action == PathTraversalState::TraversalPointAtLength ||
69 traversalState.m_action == PathTraversalState::TraversalNormalAngleAtLength) &&
70 (traversalState.m_totalLength >= traversalState.m_desiredLength)) {
71 FloatSize change = traversalState.m_current - traversalState.m_previous;
72 float slope = atan2f(change.height(), change.width());
73
74 if (traversalState.m_action == PathTraversalState::TraversalPointAtLength) {
75 float offset = traversalState.m_desiredLength - traversalState.m_totalLength;
76 traversalState.m_current.move(offset * cosf(slope), offset * sinf(slope));
77 } else {
78 static const float rad2deg = 180.0f / piFloat;
79 traversalState.m_normalAngle = slope * rad2deg;
80 }
81
82 traversalState.m_success = true;
83 }
84 }
85
length()86 float Path::length()
87 {
88 PathTraversalState traversalState(PathTraversalState::TraversalTotalLength);
89 apply(&traversalState, pathLengthApplierFunction);
90 return traversalState.m_totalLength;
91 }
92
pointAtLength(float length,bool & ok)93 FloatPoint Path::pointAtLength(float length, bool& ok)
94 {
95 PathTraversalState traversalState(PathTraversalState::TraversalPointAtLength);
96 traversalState.m_desiredLength = length;
97 apply(&traversalState, pathLengthApplierFunction);
98 ok = traversalState.m_success;
99 return traversalState.m_current;
100 }
101
normalAngleAtLength(float length,bool & ok)102 float Path::normalAngleAtLength(float length, bool& ok)
103 {
104 PathTraversalState traversalState(PathTraversalState::TraversalNormalAngleAtLength);
105 traversalState.m_desiredLength = length;
106 apply(&traversalState, pathLengthApplierFunction);
107 ok = traversalState.m_success;
108 return traversalState.m_normalAngle;
109 }
110
createRoundedRectangle(const FloatRect & rectangle,const FloatSize & roundingRadii)111 Path Path::createRoundedRectangle(const FloatRect& rectangle, const FloatSize& roundingRadii)
112 {
113 Path path;
114 float x = rectangle.x();
115 float y = rectangle.y();
116 float width = rectangle.width();
117 float height = rectangle.height();
118 float rx = roundingRadii.width();
119 float ry = roundingRadii.height();
120 if (width <= 0.0f || height <= 0.0f)
121 return path;
122
123 float dx = rx, dy = ry;
124 // If rx is greater than half of the width of the rectangle
125 // then set rx to half of the width (required in SVG spec)
126 if (dx > width * 0.5f)
127 dx = width * 0.5f;
128
129 // If ry is greater than half of the height of the rectangle
130 // then set ry to half of the height (required in SVG spec)
131 if (dy > height * 0.5f)
132 dy = height * 0.5f;
133
134 path.moveTo(FloatPoint(x + dx, y));
135
136 if (dx < width * 0.5f)
137 path.addLineTo(FloatPoint(x + width - rx, y));
138
139 path.addBezierCurveTo(FloatPoint(x + width - dx * (1 - QUARTER), y), FloatPoint(x + width, y + dy * (1 - QUARTER)), FloatPoint(x + width, y + dy));
140
141 if (dy < height * 0.5)
142 path.addLineTo(FloatPoint(x + width, y + height - dy));
143
144 path.addBezierCurveTo(FloatPoint(x + width, y + height - dy * (1 - QUARTER)), FloatPoint(x + width - dx * (1 - QUARTER), y + height), FloatPoint(x + width - dx, y + height));
145
146 if (dx < width * 0.5)
147 path.addLineTo(FloatPoint(x + dx, y + height));
148
149 path.addBezierCurveTo(FloatPoint(x + dx * (1 - QUARTER), y + height), FloatPoint(x, y + height - dy * (1 - QUARTER)), FloatPoint(x, y + height - dy));
150
151 if (dy < height * 0.5)
152 path.addLineTo(FloatPoint(x, y + dy));
153
154 path.addBezierCurveTo(FloatPoint(x, y + dy * (1 - QUARTER)), FloatPoint(x + dx * (1 - QUARTER), y), FloatPoint(x + dx, y));
155
156 path.closeSubpath();
157
158 return path;
159 }
160
createRoundedRectangle(const FloatRect & rectangle,const FloatSize & topLeftRadius,const FloatSize & topRightRadius,const FloatSize & bottomLeftRadius,const FloatSize & bottomRightRadius)161 Path Path::createRoundedRectangle(const FloatRect& rectangle, const FloatSize& topLeftRadius, const FloatSize& topRightRadius, const FloatSize& bottomLeftRadius, const FloatSize& bottomRightRadius)
162 {
163 Path path;
164
165 float width = rectangle.width();
166 float height = rectangle.height();
167 if (width <= 0.0 || height <= 0.0)
168 return path;
169
170 if (width < topLeftRadius.width() + topRightRadius.width()
171 || width < bottomLeftRadius.width() + bottomRightRadius.width()
172 || height < topLeftRadius.height() + bottomLeftRadius.height()
173 || height < topRightRadius.height() + bottomRightRadius.height())
174 // If all the radii cannot be accommodated, return a rect.
175 return createRectangle(rectangle);
176
177 float x = rectangle.x();
178 float y = rectangle.y();
179
180 path.moveTo(FloatPoint(x + topLeftRadius.width(), y));
181
182 path.addLineTo(FloatPoint(x + width - topRightRadius.width(), y));
183
184 path.addBezierCurveTo(FloatPoint(x + width - topRightRadius.width() * (1 - QUARTER), y), FloatPoint(x + width, y + topRightRadius.height() * (1 - QUARTER)), FloatPoint(x + width, y + topRightRadius.height()));
185
186 path.addLineTo(FloatPoint(x + width, y + height - bottomRightRadius.height()));
187
188 path.addBezierCurveTo(FloatPoint(x + width, y + height - bottomRightRadius.height() * (1 - QUARTER)), FloatPoint(x + width - bottomRightRadius.width() * (1 - QUARTER), y + height), FloatPoint(x + width - bottomRightRadius.width(), y + height));
189
190 path.addLineTo(FloatPoint(x + bottomLeftRadius.width(), y + height));
191
192 path.addBezierCurveTo(FloatPoint(x + bottomLeftRadius.width() * (1 - QUARTER), y + height), FloatPoint(x, y + height - bottomLeftRadius.height() * (1 - QUARTER)), FloatPoint(x, y + height - bottomLeftRadius.height()));
193
194 path.addLineTo(FloatPoint(x, y + topLeftRadius.height()));
195
196 path.addBezierCurveTo(FloatPoint(x, y + topLeftRadius.height() * (1 - QUARTER)), FloatPoint(x + topLeftRadius.width() * (1 - QUARTER), y), FloatPoint(x + topLeftRadius.width(), y));
197
198 path.closeSubpath();
199
200 return path;
201 }
202
createRectangle(const FloatRect & rectangle)203 Path Path::createRectangle(const FloatRect& rectangle)
204 {
205 Path path;
206 float x = rectangle.x();
207 float y = rectangle.y();
208 float width = rectangle.width();
209 float height = rectangle.height();
210 if (width <= 0.0f || height <= 0.0f)
211 return path;
212
213 path.moveTo(FloatPoint(x, y));
214 path.addLineTo(FloatPoint(x + width, y));
215 path.addLineTo(FloatPoint(x + width, y + height));
216 path.addLineTo(FloatPoint(x, y + height));
217 path.closeSubpath();
218
219 return path;
220 }
221
createEllipse(const FloatPoint & center,float rx,float ry)222 Path Path::createEllipse(const FloatPoint& center, float rx, float ry)
223 {
224 float cx = center.x();
225 float cy = center.y();
226 Path path;
227 if (rx <= 0.0f || ry <= 0.0f)
228 return path;
229
230 float x = cx;
231 float y = cy;
232
233 unsigned step = 0, num = 100;
234 bool running = true;
235 while (running)
236 {
237 if (step == num)
238 {
239 running = false;
240 break;
241 }
242
243 float angle = static_cast<float>(step) / static_cast<float>(num) * 2.0f * piFloat;
244 x = cx + cosf(angle) * rx;
245 y = cy + sinf(angle) * ry;
246
247 step++;
248 if (step == 1)
249 path.moveTo(FloatPoint(x, y));
250 else
251 path.addLineTo(FloatPoint(x, y));
252 }
253
254 path.closeSubpath();
255
256 return path;
257 }
258
createCircle(const FloatPoint & center,float r)259 Path Path::createCircle(const FloatPoint& center, float r)
260 {
261 return createEllipse(center, r, r);
262 }
263
createLine(const FloatPoint & start,const FloatPoint & end)264 Path Path::createLine(const FloatPoint& start, const FloatPoint& end)
265 {
266 Path path;
267 if (start.x() == end.x() && start.y() == end.y())
268 return path;
269
270 path.moveTo(start);
271 path.addLineTo(end);
272
273 return path;
274 }
275
276 }
277