Use a Ref<CachedResourceLoader> in Document instead of a RefPtr
[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 #ifndef CSSGradientValue_h
27 #define CSSGradientValue_h
28
29 #include "CSSImageGeneratorValue.h"
30 #include "CSSPrimitiveValue.h"
31 #include <wtf/RefPtr.h>
32 #include <wtf/Vector.h>
33
34 namespace WebCore {
35
36 class FloatPoint;
37 class Gradient;
38 class RenderView;
39
40 enum CSSGradientType {
41     CSSDeprecatedLinearGradient,
42     CSSDeprecatedRadialGradient,
43     CSSPrefixedLinearGradient,
44     CSSPrefixedRadialGradient,
45     CSSLinearGradient,
46     CSSRadialGradient
47 };
48 enum CSSGradientRepeat { NonRepeating, Repeating };
49
50 struct CSSGradientColorStop {
51     RefPtr<CSSPrimitiveValue> m_position; // percentage or length
52     RefPtr<CSSPrimitiveValue> m_color;
53     Color m_resolvedColor;
54     bool m_colorIsDerivedFromElement = false;
55     bool isMidpoint = false;
56     bool operator==(const CSSGradientColorStop& other) const
57     {
58         return compareCSSValuePtr(m_color, other.m_color)
59             && compareCSSValuePtr(m_position, other.m_position);
60     }
61 };
62
63 class CSSGradientValue : public CSSImageGeneratorValue {
64 public:
65     PassRefPtr<Image> image(RenderElement*, const FloatSize&);
66
67     void setFirstX(PassRefPtr<CSSPrimitiveValue> val) { m_firstX = val; }
68     void setFirstY(PassRefPtr<CSSPrimitiveValue> val) { m_firstY = val; }
69     void setSecondX(PassRefPtr<CSSPrimitiveValue> val) { m_secondX = val; }
70     void setSecondY(PassRefPtr<CSSPrimitiveValue> val) { m_secondY = val; }
71
72     void addStop(const CSSGradientColorStop& stop) { m_stops.append(stop); }
73
74     unsigned stopCount() const { return m_stops.size(); }
75
76     void sortStopsIfNeeded();
77
78     bool isRepeating() const { return m_repeating; }
79
80     CSSGradientType gradientType() const { return m_gradientType; }
81
82     bool isFixedSize() const { return false; }
83     FloatSize fixedSize(const RenderElement*) const { return FloatSize(); }
84
85     bool isPending() const { return false; }
86     bool knownToBeOpaque(const RenderElement*) const;
87
88     void loadSubimages(CachedResourceLoader&) { }
89     PassRefPtr<CSSGradientValue> gradientWithStylesResolved(StyleResolver*);
90
91 protected:
92     CSSGradientValue(ClassType classType, CSSGradientRepeat repeat, CSSGradientType gradientType)
93         : CSSImageGeneratorValue(classType)
94         , m_stopsSorted(false)
95         , m_gradientType(gradientType)
96         , m_repeating(repeat == Repeating)
97     {
98     }
99
100     CSSGradientValue(const CSSGradientValue& other, ClassType classType, CSSGradientType gradientType)
101         : CSSImageGeneratorValue(classType)
102         , m_firstX(other.m_firstX)
103         , m_firstY(other.m_firstY)
104         , m_secondX(other.m_secondX)
105         , m_secondY(other.m_secondY)
106         , m_stops(other.m_stops)
107         , m_stopsSorted(other.m_stopsSorted)
108         , m_gradientType(gradientType)
109         , m_repeating(other.isRepeating() ? Repeating : NonRepeating)
110     {
111     }
112
113     void addStops(Gradient&, const CSSToLengthConversionData&, float maxLengthForRepeat = 0);
114
115     // Resolve points/radii to front end values.
116     FloatPoint computeEndPoint(CSSPrimitiveValue*, CSSPrimitiveValue*, const CSSToLengthConversionData&, const FloatSize&);
117
118     bool isCacheable() const;
119
120     // Points. Some of these may be null.
121     RefPtr<CSSPrimitiveValue> m_firstX;
122     RefPtr<CSSPrimitiveValue> m_firstY;
123
124     RefPtr<CSSPrimitiveValue> m_secondX;
125     RefPtr<CSSPrimitiveValue> m_secondY;
126
127     // Stops
128     Vector<CSSGradientColorStop, 2> m_stops;
129     bool m_stopsSorted;
130     CSSGradientType m_gradientType;
131     bool m_repeating;
132 };
133
134 class CSSLinearGradientValue : public CSSGradientValue {
135 public:
136
137     static Ref<CSSLinearGradientValue> create(CSSGradientRepeat repeat, CSSGradientType gradientType = CSSLinearGradient)
138     {
139         return adoptRef(*new CSSLinearGradientValue(repeat, gradientType));
140     }
141
142     void setAngle(PassRefPtr<CSSPrimitiveValue> val) { m_angle = val; }
143
144     String customCSSText() const;
145
146     // Create the gradient for a given size.
147     PassRefPtr<Gradient> createGradient(RenderElement&, const FloatSize&);
148
149     Ref<CSSLinearGradientValue> clone() const
150     {
151         return adoptRef(*new CSSLinearGradientValue(*this));
152     }
153
154     bool equals(const CSSLinearGradientValue&) const;
155
156 private:
157     CSSLinearGradientValue(CSSGradientRepeat repeat, CSSGradientType gradientType = CSSLinearGradient)
158         : CSSGradientValue(LinearGradientClass, repeat, gradientType)
159     {
160     }
161
162     CSSLinearGradientValue(const CSSLinearGradientValue& other)
163         : CSSGradientValue(other, LinearGradientClass, other.gradientType())
164         , m_angle(other.m_angle)
165     {
166     }
167
168     RefPtr<CSSPrimitiveValue> m_angle; // may be null.
169 };
170
171 class CSSRadialGradientValue : public CSSGradientValue {
172 public:
173     static Ref<CSSRadialGradientValue> create(CSSGradientRepeat repeat, CSSGradientType gradientType = CSSRadialGradient)
174     {
175         return adoptRef(*new CSSRadialGradientValue(repeat, gradientType));
176     }
177
178     Ref<CSSRadialGradientValue> clone() const
179     {
180         return adoptRef(*new CSSRadialGradientValue(*this));
181     }
182
183     String customCSSText() const;
184
185     void setFirstRadius(PassRefPtr<CSSPrimitiveValue> val) { m_firstRadius = val; }
186     void setSecondRadius(PassRefPtr<CSSPrimitiveValue> val) { m_secondRadius = val; }
187
188     void setShape(PassRefPtr<CSSPrimitiveValue> val) { m_shape = val; }
189     void setSizingBehavior(PassRefPtr<CSSPrimitiveValue> val) { m_sizingBehavior = val; }
190
191     void setEndHorizontalSize(PassRefPtr<CSSPrimitiveValue> val) { m_endHorizontalSize = val; }
192     void setEndVerticalSize(PassRefPtr<CSSPrimitiveValue> val) { m_endVerticalSize = val; }
193
194     // Create the gradient for a given size.
195     PassRefPtr<Gradient> createGradient(RenderElement&, const FloatSize&);
196
197     bool equals(const CSSRadialGradientValue&) const;
198
199 private:
200     CSSRadialGradientValue(CSSGradientRepeat repeat, CSSGradientType gradientType = CSSRadialGradient)
201         : CSSGradientValue(RadialGradientClass, repeat, gradientType)
202     {
203     }
204
205     CSSRadialGradientValue(const CSSRadialGradientValue& other)
206         : CSSGradientValue(other, RadialGradientClass, other.gradientType())
207         , m_firstRadius(other.m_firstRadius)
208         , m_secondRadius(other.m_secondRadius)
209         , m_shape(other.m_shape)
210         , m_sizingBehavior(other.m_sizingBehavior)
211         , m_endHorizontalSize(other.m_endHorizontalSize)
212         , m_endVerticalSize(other.m_endVerticalSize)
213     {
214     }
215
216
217     // Resolve points/radii to front end values.
218     float resolveRadius(CSSPrimitiveValue&, const CSSToLengthConversionData&, float* widthOrHeight = 0);
219
220     // These may be null for non-deprecated gradients.
221     RefPtr<CSSPrimitiveValue> m_firstRadius;
222     RefPtr<CSSPrimitiveValue> m_secondRadius;
223
224     // The below are only used for non-deprecated gradients. Any of them may be null.
225     RefPtr<CSSPrimitiveValue> m_shape;
226     RefPtr<CSSPrimitiveValue> m_sizingBehavior;
227
228     RefPtr<CSSPrimitiveValue> m_endHorizontalSize;
229     RefPtr<CSSPrimitiveValue> m_endVerticalSize;
230 };
231
232 } // namespace WebCore
233
234 SPECIALIZE_TYPE_TRAITS_CSS_VALUE(CSSGradientValue, isGradientValue())
235 SPECIALIZE_TYPE_TRAITS_CSS_VALUE(CSSLinearGradientValue, isLinearGradientValue())
236 SPECIALIZE_TYPE_TRAITS_CSS_VALUE(CSSRadialGradientValue, isRadialGradientValue())
237
238 #endif // CSSGradientValue_h