Add WTF::move()
[WebKit-https.git] / Source / WebCore / rendering / style / BasicShapes.h
1 /*
2  * Copyright (C) 2012 Adobe Systems Incorporated. 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
6  * are met:
7  *
8  * 1. Redistributions of source code must retain the above
9  *    copyright notice, this list of conditions and the following
10  *    disclaimer.
11  * 2. Redistributions in binary form must reproduce the above
12  *    copyright notice, this list of conditions and the following
13  *    disclaimer in the documentation and/or other materials
14  *    provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
21  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
25  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
26  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29
30 #ifndef BasicShapes_h
31 #define BasicShapes_h
32
33 #include "Length.h"
34 #include "LengthSize.h"
35 #include "RenderStyleConstants.h"
36 #include "WindRule.h"
37 #include <wtf/RefCounted.h>
38 #include <wtf/RefPtr.h>
39 #include <wtf/Vector.h>
40
41 namespace WebCore {
42
43 class FloatRect;
44 class Path;
45 class RenderBox;
46
47 class BasicShape : public RefCounted<BasicShape> {
48 public:
49     virtual ~BasicShape() { }
50
51     enum Type {
52         BasicShapePolygonType,
53         BasicShapeCircleType,
54         BasicShapeEllipseType,
55         BasicShapeInsetType
56     };
57
58     bool canBlend(const BasicShape*) const;
59
60     virtual void path(Path&, const FloatRect&) = 0;
61     virtual WindRule windRule() const { return RULE_NONZERO; }
62     virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const = 0;
63
64     virtual Type type() const = 0;
65 };
66
67 class BasicShapeCenterCoordinate {
68 public:
69     enum Direction {
70         TopLeft,
71         BottomRight
72     };
73
74     BasicShapeCenterCoordinate()
75         : m_direction(TopLeft)
76         , m_length(Undefined)
77     {
78         updateComputedLength();
79     }
80
81     BasicShapeCenterCoordinate(Direction direction, Length length)
82         : m_direction(direction)
83         , m_length(length)
84     {
85         updateComputedLength();
86     }
87
88     BasicShapeCenterCoordinate(const BasicShapeCenterCoordinate& other)
89         : m_direction(other.direction())
90         , m_length(other.length())
91         , m_computedLength(other.m_computedLength)
92     {
93     }
94
95     Direction direction() const { return m_direction; }
96     const Length& length() const { return m_length; }
97     const Length& computedLength() const { return m_computedLength; }
98
99     BasicShapeCenterCoordinate blend(const BasicShapeCenterCoordinate& other, double progress) const
100     {
101         return BasicShapeCenterCoordinate(TopLeft, m_computedLength.blend(other.m_computedLength, progress));
102     }
103
104 private:
105     Direction m_direction;
106     Length m_length;
107     Length m_computedLength;
108
109     void updateComputedLength();
110 };
111
112 class BasicShapeRadius {
113 public:
114     enum Type {
115         Value,
116         ClosestSide,
117         FarthestSide
118     };
119     BasicShapeRadius() : m_value(Undefined), m_type(ClosestSide) { }
120     explicit BasicShapeRadius(Length v) : m_value(v), m_type(Value) { }
121     explicit BasicShapeRadius(Type t) : m_value(Undefined), m_type(t) { }
122     BasicShapeRadius(const BasicShapeRadius& other) : m_value(other.value()), m_type(other.type()) { }
123
124     const Length& value() const { return m_value; }
125     Type type() const { return m_type; }
126
127     bool canBlend(const BasicShapeRadius& other) const
128     {
129         // FIXME determine how to interpolate between keywords. See bug 125108.
130         return m_type == Value && other.type() == Value;
131     }
132
133     BasicShapeRadius blend(const BasicShapeRadius& other, double progress) const
134     {
135         if (m_type != Value || other.type() != Value)
136             return BasicShapeRadius(other);
137
138         return BasicShapeRadius(m_value.blend(other.value(), progress));
139     }
140
141 private:
142     Length m_value;
143     Type m_type;
144
145 };
146
147 class BasicShapeCircle : public BasicShape {
148 public:
149     static PassRefPtr<BasicShapeCircle> create() { return adoptRef(new BasicShapeCircle); }
150
151     const BasicShapeCenterCoordinate& centerX() const { return m_centerX; }
152     const BasicShapeCenterCoordinate& centerY() const { return m_centerY; }
153     const BasicShapeRadius& radius() const { return m_radius; }
154     float floatValueForRadiusInBox(float boxWidth, float boxHeight) const;
155
156     void setCenterX(BasicShapeCenterCoordinate centerX) { m_centerX = WTF::move(centerX); }
157     void setCenterY(BasicShapeCenterCoordinate centerY) { m_centerY = WTF::move(centerY); }
158     void setRadius(BasicShapeRadius radius) { m_radius = WTF::move(radius); }
159
160     virtual void path(Path&, const FloatRect&) override;
161     virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const override;
162
163     virtual Type type() const override { return BasicShapeCircleType; }
164 private:
165     BasicShapeCircle() { }
166
167     BasicShapeCenterCoordinate m_centerX;
168     BasicShapeCenterCoordinate m_centerY;
169     BasicShapeRadius m_radius;
170 };
171
172 class BasicShapeEllipse : public BasicShape {
173 public:
174     static PassRefPtr<BasicShapeEllipse> create() { return adoptRef(new BasicShapeEllipse); }
175
176     const BasicShapeCenterCoordinate& centerX() const { return m_centerX; }
177     const BasicShapeCenterCoordinate& centerY() const { return m_centerY; }
178     const BasicShapeRadius& radiusX() const { return m_radiusX; }
179     const BasicShapeRadius& radiusY() const { return m_radiusY; }
180     float floatValueForRadiusInBox(const BasicShapeRadius&, float center, float boxWidthOrHeight) const;
181
182     void setCenterX(BasicShapeCenterCoordinate centerX) { m_centerX = WTF::move(centerX); }
183     void setCenterY(BasicShapeCenterCoordinate centerY) { m_centerY = WTF::move(centerY); }
184     void setRadiusX(BasicShapeRadius radiusX) { m_radiusX = WTF::move(radiusX); }
185     void setRadiusY(BasicShapeRadius radiusY) { m_radiusY = WTF::move(radiusY); }
186
187     virtual void path(Path&, const FloatRect&) override;
188     virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const override;
189
190     virtual Type type() const override { return BasicShapeEllipseType; }
191 private:
192     BasicShapeEllipse() { }
193
194     BasicShapeCenterCoordinate m_centerX;
195     BasicShapeCenterCoordinate m_centerY;
196     BasicShapeRadius m_radiusX;
197     BasicShapeRadius m_radiusY;
198 };
199
200 class BasicShapePolygon : public BasicShape {
201 public:
202     static PassRefPtr<BasicShapePolygon> create() { return adoptRef(new BasicShapePolygon); }
203
204     const Vector<Length>& values() const { return m_values; }
205     const Length& getXAt(unsigned i) const { return m_values[2 * i]; }
206     const Length& getYAt(unsigned i) const { return m_values[2 * i + 1]; }
207
208     void setWindRule(WindRule windRule) { m_windRule = windRule; }
209     void appendPoint(Length x, Length y) { m_values.append(WTF::move(x)); m_values.append(WTF::move(y)); }
210
211     virtual void path(Path&, const FloatRect&) override;
212     virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const override;
213
214     virtual WindRule windRule() const override { return m_windRule; }
215
216     virtual Type type() const override { return BasicShapePolygonType; }
217 private:
218     BasicShapePolygon()
219         : m_windRule(RULE_NONZERO)
220     { }
221
222     WindRule m_windRule;
223     Vector<Length> m_values;
224 };
225
226 class BasicShapeInset : public BasicShape {
227 public:
228     static PassRefPtr<BasicShapeInset> create() { return adoptRef(new BasicShapeInset); }
229
230     const Length& top() const { return m_top; }
231     const Length& right() const { return m_right; }
232     const Length& bottom() const { return m_bottom; }
233     const Length& left() const { return m_left; }
234
235     const LengthSize& topLeftRadius() const { return m_topLeftRadius; }
236     const LengthSize& topRightRadius() const { return m_topRightRadius; }
237     const LengthSize& bottomRightRadius() const { return m_bottomRightRadius; }
238     const LengthSize& bottomLeftRadius() const { return m_bottomLeftRadius; }
239
240     void setTop(Length top) { m_top = WTF::move(top); }
241     void setRight(Length right) { m_right = WTF::move(right); }
242     void setBottom(Length bottom) { m_bottom = WTF::move(bottom); }
243     void setLeft(Length left) { m_left = WTF::move(left); }
244
245     void setTopLeftRadius(LengthSize radius) { m_topLeftRadius = WTF::move(radius); }
246     void setTopRightRadius(LengthSize radius) { m_topRightRadius = WTF::move(radius); }
247     void setBottomRightRadius(LengthSize radius) { m_bottomRightRadius = WTF::move(radius); }
248     void setBottomLeftRadius(LengthSize radius) { m_bottomLeftRadius = WTF::move(radius); }
249
250     virtual void path(Path&, const FloatRect&) override;
251     virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const override;
252
253     virtual Type type() const override { return BasicShapeInsetType; }
254 private:
255     BasicShapeInset() { }
256
257     Length m_right;
258     Length m_top;
259     Length m_bottom;
260     Length m_left;
261
262     LengthSize m_topLeftRadius;
263     LengthSize m_topRightRadius;
264     LengthSize m_bottomRightRadius;
265     LengthSize m_bottomLeftRadius;
266 };
267
268 }
269 #endif