[Conic Gradients] Add support for parsing conic gradients
[WebKit-https.git] / Source / WebCore / css / CSSGradientValue.h
1 /*
2  * Copyright (C) 2008 Apple Inc. 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  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #pragma once
27
28 #include "CSSImageGeneratorValue.h"
29 #include "CSSPrimitiveValue.h"
30 #include <wtf/Vector.h>
31
32 namespace WebCore {
33
34 class FloatPoint;
35 class Gradient;
36 class StyleResolver;
37
38 enum CSSGradientType {
39     CSSDeprecatedLinearGradient,
40     CSSDeprecatedRadialGradient,
41     CSSPrefixedLinearGradient,
42     CSSPrefixedRadialGradient,
43     CSSLinearGradient,
44     CSSRadialGradient,
45     CSSConicGradient
46 };
47 enum CSSGradientRepeat { NonRepeating, Repeating };
48
49 struct CSSGradientColorStop {
50     RefPtr<CSSPrimitiveValue> m_position; // percentage or length
51     RefPtr<CSSPrimitiveValue> m_color;
52     Color m_resolvedColor;
53     bool m_colorIsDerivedFromElement = false;
54     bool isMidpoint = false;
55     bool operator==(const CSSGradientColorStop& other) const
56     {
57         return compareCSSValuePtr(m_color, other.m_color)
58             && compareCSSValuePtr(m_position, other.m_position);
59     }
60 };
61
62 class CSSGradientValue : public CSSImageGeneratorValue {
63 public:
64     RefPtr<Image> image(RenderElement&, const FloatSize&);
65
66     void setFirstX(RefPtr<CSSPrimitiveValue>&& val) { m_firstX = WTFMove(val); }
67     void setFirstY(RefPtr<CSSPrimitiveValue>&& val) { m_firstY = WTFMove(val); }
68     void setSecondX(RefPtr<CSSPrimitiveValue>&& val) { m_secondX = WTFMove(val); }
69     void setSecondY(RefPtr<CSSPrimitiveValue>&& val) { m_secondY = WTFMove(val); }
70
71     void addStop(const CSSGradientColorStop& stop) { m_stops.append(stop); }
72
73     unsigned stopCount() const { return m_stops.size(); }
74
75     void sortStopsIfNeeded();
76
77     bool isRepeating() const { return m_repeating; }
78
79     CSSGradientType gradientType() const { return m_gradientType; }
80
81     bool isFixedSize() const { return false; }
82     FloatSize fixedSize(const RenderElement&) const { return FloatSize(); }
83
84     bool isPending() const { return false; }
85     bool knownToBeOpaque() const;
86
87     void loadSubimages(CachedResourceLoader&, const ResourceLoaderOptions&) { }
88     Ref<CSSGradientValue> gradientWithStylesResolved(const StyleResolver&);
89
90 protected:
91     CSSGradientValue(ClassType classType, CSSGradientRepeat repeat, CSSGradientType gradientType)
92         : CSSImageGeneratorValue(classType)
93         , m_stopsSorted(false)
94         , m_gradientType(gradientType)
95         , m_repeating(repeat == Repeating)
96     {
97     }
98
99     CSSGradientValue(const CSSGradientValue& other, ClassType classType, CSSGradientType gradientType)
100         : CSSImageGeneratorValue(classType)
101         , m_firstX(other.m_firstX)
102         , m_firstY(other.m_firstY)
103         , m_secondX(other.m_secondX)
104         , m_secondY(other.m_secondY)
105         , m_stops(other.m_stops)
106         , m_stopsSorted(other.m_stopsSorted)
107         , m_gradientType(gradientType)
108         , m_repeating(other.isRepeating() ? Repeating : NonRepeating)
109     {
110     }
111
112     void addStops(Gradient&, const CSSToLengthConversionData&, float maxLengthForRepeat = 0);
113
114     // Resolve points/radii to front end values.
115     FloatPoint computeEndPoint(CSSPrimitiveValue*, CSSPrimitiveValue*, const CSSToLengthConversionData&, const FloatSize&);
116
117     bool isCacheable() const;
118
119     // Points. Some of these may be null.
120     RefPtr<CSSPrimitiveValue> m_firstX;
121     RefPtr<CSSPrimitiveValue> m_firstY;
122
123     RefPtr<CSSPrimitiveValue> m_secondX;
124     RefPtr<CSSPrimitiveValue> m_secondY;
125
126     // Stops
127     Vector<CSSGradientColorStop, 2> m_stops;
128     bool m_stopsSorted;
129     CSSGradientType m_gradientType;
130     bool m_repeating;
131 };
132
133 class CSSLinearGradientValue final : public CSSGradientValue {
134 public:
135     static Ref<CSSLinearGradientValue> create(CSSGradientRepeat repeat, CSSGradientType gradientType = CSSLinearGradient)
136     {
137         return adoptRef(*new CSSLinearGradientValue(repeat, gradientType));
138     }
139
140     void setAngle(Ref<CSSPrimitiveValue>&& val) { m_angle = WTFMove(val); }
141
142     String customCSSText() const;
143
144     // Create the gradient for a given size.
145     Ref<Gradient> createGradient(RenderElement&, const FloatSize&);
146
147     Ref<CSSLinearGradientValue> clone() const
148     {
149         return adoptRef(*new CSSLinearGradientValue(*this));
150     }
151
152     bool equals(const CSSLinearGradientValue&) const;
153
154 private:
155     CSSLinearGradientValue(CSSGradientRepeat repeat, CSSGradientType gradientType = CSSLinearGradient)
156         : CSSGradientValue(LinearGradientClass, repeat, gradientType)
157     {
158     }
159
160     CSSLinearGradientValue(const CSSLinearGradientValue& other)
161         : CSSGradientValue(other, LinearGradientClass, other.gradientType())
162         , m_angle(other.m_angle)
163     {
164     }
165
166     RefPtr<CSSPrimitiveValue> m_angle; // may be null.
167 };
168
169 class CSSRadialGradientValue final : public CSSGradientValue {
170 public:
171     static Ref<CSSRadialGradientValue> create(CSSGradientRepeat repeat, CSSGradientType gradientType = CSSRadialGradient)
172     {
173         return adoptRef(*new CSSRadialGradientValue(repeat, gradientType));
174     }
175
176     Ref<CSSRadialGradientValue> clone() const
177     {
178         return adoptRef(*new CSSRadialGradientValue(*this));
179     }
180
181     String customCSSText() const;
182
183     void setFirstRadius(RefPtr<CSSPrimitiveValue>&& val) { m_firstRadius = WTFMove(val); }
184     void setSecondRadius(RefPtr<CSSPrimitiveValue>&& val) { m_secondRadius = WTFMove(val); }
185
186     void setShape(RefPtr<CSSPrimitiveValue>&& val) { m_shape = WTFMove(val); }
187     void setSizingBehavior(RefPtr<CSSPrimitiveValue>&& val) { m_sizingBehavior = WTFMove(val); }
188
189     void setEndHorizontalSize(RefPtr<CSSPrimitiveValue>&& val) { m_endHorizontalSize = WTFMove(val); }
190     void setEndVerticalSize(RefPtr<CSSPrimitiveValue>&& val) { m_endVerticalSize = WTFMove(val); }
191
192     // Create the gradient for a given size.
193     Ref<Gradient> createGradient(RenderElement&, const FloatSize&);
194
195     bool equals(const CSSRadialGradientValue&) const;
196
197 private:
198     CSSRadialGradientValue(CSSGradientRepeat repeat, CSSGradientType gradientType = CSSRadialGradient)
199         : CSSGradientValue(RadialGradientClass, repeat, gradientType)
200     {
201     }
202
203     CSSRadialGradientValue(const CSSRadialGradientValue& other)
204         : CSSGradientValue(other, RadialGradientClass, other.gradientType())
205         , m_firstRadius(other.m_firstRadius)
206         , m_secondRadius(other.m_secondRadius)
207         , m_shape(other.m_shape)
208         , m_sizingBehavior(other.m_sizingBehavior)
209         , m_endHorizontalSize(other.m_endHorizontalSize)
210         , m_endVerticalSize(other.m_endVerticalSize)
211     {
212     }
213
214     // Resolve points/radii to front end values.
215     float resolveRadius(CSSPrimitiveValue&, const CSSToLengthConversionData&, float* widthOrHeight = 0);
216
217     // These may be null for non-deprecated gradients.
218     RefPtr<CSSPrimitiveValue> m_firstRadius;
219     RefPtr<CSSPrimitiveValue> m_secondRadius;
220
221     // The below are only used for non-deprecated gradients. Any of them may be null.
222     RefPtr<CSSPrimitiveValue> m_shape;
223     RefPtr<CSSPrimitiveValue> m_sizingBehavior;
224
225     RefPtr<CSSPrimitiveValue> m_endHorizontalSize;
226     RefPtr<CSSPrimitiveValue> m_endVerticalSize;
227 };
228
229 class CSSConicGradientValue final : public CSSGradientValue {
230 public:
231     static Ref<CSSConicGradientValue> create(CSSGradientRepeat repeat)
232     {
233         return adoptRef(*new CSSConicGradientValue(repeat));
234     }
235
236     Ref<CSSConicGradientValue> clone() const
237     {
238         return adoptRef(*new CSSConicGradientValue(*this));
239     }
240
241     String customCSSText() const;
242
243     void setAngle(RefPtr<CSSPrimitiveValue>&& val) { m_angle = WTFMove(val); }
244
245     // Create the gradient for a given size.
246     Ref<Gradient> createGradient(RenderElement&, const FloatSize&);
247
248     bool equals(const CSSConicGradientValue&) const;
249
250 private:
251     CSSConicGradientValue(CSSGradientRepeat repeat)
252         : CSSGradientValue(ConicGradientClass, repeat, CSSConicGradient)
253     {
254     }
255
256     CSSConicGradientValue(const CSSConicGradientValue& other)
257         : CSSGradientValue(other, ConicGradientClass, other.gradientType())
258         , m_angle(other.m_angle)
259     {
260     }
261
262     RefPtr<CSSPrimitiveValue> m_angle; // may be null.
263 };
264
265 } // namespace WebCore
266
267 SPECIALIZE_TYPE_TRAITS_CSS_VALUE(CSSGradientValue, isGradientValue())
268 SPECIALIZE_TYPE_TRAITS_CSS_VALUE(CSSLinearGradientValue, isLinearGradientValue())
269 SPECIALIZE_TYPE_TRAITS_CSS_VALUE(CSSRadialGradientValue, isRadialGradientValue())
270 SPECIALIZE_TYPE_TRAITS_CSS_VALUE(CSSConicGradientValue, isConicGradientValue())