Remove GraphicsContext::drawConvexPolygon() and GraphicsContext::clipConvexPolygon()
[WebKit-https.git] / Source / WebCore / platform / graphics / Path.h
1 /*
2  * Copyright (C) 2003, 2006, 2009 Apple Inc. All rights reserved.
3  *               2006 Rob Buis <buis@kde.org>
4  * Copyright (C) 2007-2008 Torch Mobile, Inc.
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 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 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 #ifndef Path_h
29 #define Path_h
30
31 #include "FloatRect.h"
32 #include "WindRule.h"
33 #include <functional>
34 #include <wtf/FastMalloc.h>
35 #include <wtf/Forward.h>
36 #include <wtf/Vector.h>
37
38 #if USE(CG)
39
40 #include <wtf/RetainPtr.h>
41 #include <CoreGraphics/CGPath.h>
42 typedef struct CGPath PlatformPath;
43
44 #elif USE(CAIRO)
45
46 namespace WebCore {
47 class CairoPath;
48 }
49 typedef WebCore::CairoPath PlatformPath;
50
51 #elif USE(WINGDI)
52
53 namespace WebCore {
54 class PlatformPath;
55 }
56 typedef WebCore::PlatformPath PlatformPath;
57
58 #else
59
60 typedef void PlatformPath;
61
62 #endif
63
64 typedef PlatformPath* PlatformPathPtr;
65
66 namespace WebCore {
67
68     class AffineTransform;
69     class FloatPoint;
70     class FloatRoundedRect;
71     class FloatSize;
72     class GraphicsContext;
73     class PathTraversalState;
74     class RoundedRect;
75     class StrokeStyleApplier;
76     class TextStream;
77
78     enum PathElementType {
79         PathElementMoveToPoint, // The points member will contain 1 value.
80         PathElementAddLineToPoint, // The points member will contain 1 value.
81         PathElementAddQuadCurveToPoint, // The points member will contain 2 values.
82         PathElementAddCurveToPoint, // The points member will contain 3 values.
83         PathElementCloseSubpath // The points member will contain no values.
84     };
85
86     // The points in the structure are the same as those that would be used with the
87     // add... method. For example, a line returns the endpoint, while a cubic returns
88     // two tangent points and the endpoint.
89     struct PathElement {
90         PathElementType type;
91         FloatPoint* points;
92     };
93
94     typedef std::function<void (const PathElement&)> PathApplierFunction;
95
96     class Path {
97         WTF_MAKE_FAST_ALLOCATED;
98     public:
99         WEBCORE_EXPORT Path();
100 #if USE(CG)
101         Path(RetainPtr<CGMutablePathRef>);
102 #endif
103         WEBCORE_EXPORT ~Path();
104
105         WEBCORE_EXPORT Path(const Path&);
106         WEBCORE_EXPORT Path& operator=(const Path&);
107         
108         static Path polygonPathFromPoints(const Vector<FloatPoint>&);
109
110         bool contains(const FloatPoint&, WindRule rule = RULE_NONZERO) const;
111         bool strokeContains(StrokeStyleApplier*, const FloatPoint&) const;
112         // fastBoundingRect() should equal or contain boundingRect(); boundingRect()
113         // should perfectly bound the points within the path.
114         FloatRect boundingRect() const;
115         FloatRect fastBoundingRect() const;
116         FloatRect strokeBoundingRect(StrokeStyleApplier* = 0) const;
117
118         float length() const;
119         PathTraversalState traversalStateAtLength(float length, bool& success) const;
120         FloatPoint pointAtLength(float length, bool& success) const;
121         float normalAngleAtLength(float length, bool& success) const;
122
123         WEBCORE_EXPORT void clear();
124         bool isNull() const { return !m_path; }
125         bool isEmpty() const;
126         // Gets the current point of the current path, which is conceptually the final point reached by the path so far.
127         // Note the Path can be empty (isEmpty() == true) and still have a current point.
128         bool hasCurrentPoint() const;
129         FloatPoint currentPoint() const;
130
131         WEBCORE_EXPORT void moveTo(const FloatPoint&);
132         WEBCORE_EXPORT void addLineTo(const FloatPoint&);
133         WEBCORE_EXPORT void addQuadCurveTo(const FloatPoint& controlPoint, const FloatPoint& endPoint);
134         WEBCORE_EXPORT void addBezierCurveTo(const FloatPoint& controlPoint1, const FloatPoint& controlPoint2, const FloatPoint& endPoint);
135         void addArcTo(const FloatPoint&, const FloatPoint&, float radius);
136         WEBCORE_EXPORT void closeSubpath();
137
138         void addArc(const FloatPoint&, float radius, float startAngle, float endAngle, bool anticlockwise);
139         void addRect(const FloatRect&);
140         void addEllipse(FloatPoint, float radiusX, float radiusY, float rotation, float startAngle, float endAngle, bool anticlockwise);
141         void addEllipse(const FloatRect&);
142
143         enum RoundedRectStrategy {
144             PreferNativeRoundedRect,
145             PreferBezierRoundedRect
146         };
147
148         WEBCORE_EXPORT void addRoundedRect(const FloatRect&, const FloatSize& roundingRadii, RoundedRectStrategy = PreferNativeRoundedRect);
149         WEBCORE_EXPORT void addRoundedRect(const FloatRoundedRect&, RoundedRectStrategy = PreferNativeRoundedRect);
150         void addRoundedRect(const RoundedRect&);
151
152         void addPath(const Path&, const AffineTransform&);
153
154         void translate(const FloatSize&);
155
156         // To keep Path() cheap, it does not allocate a PlatformPath immediately
157         // meaning Path::platformPath() can return null.
158         PlatformPathPtr platformPath() const { return m_path; }
159         // ensurePlatformPath() will allocate a PlatformPath if it has not yet been and will never return null.
160         WEBCORE_EXPORT PlatformPathPtr ensurePlatformPath();
161
162         WEBCORE_EXPORT void apply(const PathApplierFunction&) const;
163         void transform(const AffineTransform&);
164
165         void addBeziersForRoundedRect(const FloatRect&, const FloatSize& topLeftRadius, const FloatSize& topRightRadius, const FloatSize& bottomLeftRadius, const FloatSize& bottomRightRadius);
166
167 #if USE(CG)
168         void platformAddPathForRoundedRect(const FloatRect&, const FloatSize& topLeftRadius, const FloatSize& topRightRadius, const FloatSize& bottomLeftRadius, const FloatSize& bottomRightRadius);
169 #endif
170
171 #ifndef NDEBUG
172         void dump() const;
173 #endif
174
175     private:
176         PlatformPathPtr m_path;
177     };
178
179 TextStream& operator<<(TextStream&, const Path&);
180
181 }
182
183 #endif