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