Subpixel rendering: Transition class CSSImageGeneratorValue/class StyleImage (and...
[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
39 enum CSSGradientType {
40     CSSDeprecatedLinearGradient,
41     CSSDeprecatedRadialGradient,
42     CSSPrefixedLinearGradient,
43     CSSPrefixedRadialGradient,
44     CSSLinearGradient,
45     CSSRadialGradient
46 };
47 enum CSSGradientRepeat { NonRepeating, Repeating };
48
49 struct CSSGradientColorStop {
50     CSSGradientColorStop() : m_colorIsDerivedFromElement(false) { };
51     RefPtr<CSSPrimitiveValue> m_position; // percentage or length
52     RefPtr<CSSPrimitiveValue> m_color;
53     Color m_resolvedColor;
54     bool m_colorIsDerivedFromElement;
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     PassRefPtr<Image> image(RenderElement*, const FloatSize&);
65
66     void setFirstX(PassRefPtr<CSSPrimitiveValue> val) { m_firstX = val; }
67     void setFirstY(PassRefPtr<CSSPrimitiveValue> val) { m_firstY = val; }
68     void setSecondX(PassRefPtr<CSSPrimitiveValue> val) { m_secondX = val; }
69     void setSecondY(PassRefPtr<CSSPrimitiveValue> val) { m_secondY = 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 RenderElement*) const;
86
87     void loadSubimages(CachedResourceLoader*) { }
88     PassRefPtr<CSSGradientValue> gradientWithStylesResolved(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*, RenderElement*, const RenderStyle& rootStyle, float maxLengthForRepeat = 0);
113
114     // Resolve points/radii to front end values.
115     FloatPoint computeEndPoint(CSSPrimitiveValue*, CSSPrimitiveValue*, const RenderStyle&, const RenderStyle& rootStyle, 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 CSS_VALUE_TYPE_CASTS(CSSGradientValue, isGradientValue())
134
135 class CSSLinearGradientValue : public CSSGradientValue {
136 public:
137
138     static PassRef<CSSLinearGradientValue> create(CSSGradientRepeat repeat, CSSGradientType gradientType = CSSLinearGradient)
139     {
140         return adoptRef(*new CSSLinearGradientValue(repeat, gradientType));
141     }
142
143     void setAngle(PassRefPtr<CSSPrimitiveValue> val) { m_angle = val; }
144
145     String customCSSText() const;
146
147     // Create the gradient for a given size.
148     PassRefPtr<Gradient> createGradient(RenderElement*, const FloatSize&);
149
150     PassRef<CSSLinearGradientValue> clone() const
151     {
152         return adoptRef(*new CSSLinearGradientValue(*this));
153     }
154
155     bool equals(const CSSLinearGradientValue&) const;
156
157 private:
158     CSSLinearGradientValue(CSSGradientRepeat repeat, CSSGradientType gradientType = CSSLinearGradient)
159         : CSSGradientValue(LinearGradientClass, repeat, gradientType)
160     {
161     }
162
163     CSSLinearGradientValue(const CSSLinearGradientValue& other)
164         : CSSGradientValue(other, LinearGradientClass, other.gradientType())
165         , m_angle(other.m_angle)
166     {
167     }
168
169     RefPtr<CSSPrimitiveValue> m_angle; // may be null.
170 };
171
172 CSS_VALUE_TYPE_CASTS(CSSLinearGradientValue, isLinearGradientValue())
173
174 class CSSRadialGradientValue : public CSSGradientValue {
175 public:
176     static PassRef<CSSRadialGradientValue> create(CSSGradientRepeat repeat, CSSGradientType gradientType = CSSRadialGradient)
177     {
178         return adoptRef(*new CSSRadialGradientValue(repeat, gradientType));
179     }
180
181     PassRef<CSSRadialGradientValue> clone() const
182     {
183         return adoptRef(*new CSSRadialGradientValue(*this));
184     }
185
186     String customCSSText() const;
187
188     void setFirstRadius(PassRefPtr<CSSPrimitiveValue> val) { m_firstRadius = val; }
189     void setSecondRadius(PassRefPtr<CSSPrimitiveValue> val) { m_secondRadius = val; }
190
191     void setShape(PassRefPtr<CSSPrimitiveValue> val) { m_shape = val; }
192     void setSizingBehavior(PassRefPtr<CSSPrimitiveValue> val) { m_sizingBehavior = val; }
193
194     void setEndHorizontalSize(PassRefPtr<CSSPrimitiveValue> val) { m_endHorizontalSize = val; }
195     void setEndVerticalSize(PassRefPtr<CSSPrimitiveValue> val) { m_endVerticalSize = val; }
196
197     // Create the gradient for a given size.
198     PassRefPtr<Gradient> createGradient(RenderElement*, const FloatSize&);
199
200     bool equals(const CSSRadialGradientValue&) const;
201
202 private:
203     CSSRadialGradientValue(CSSGradientRepeat repeat, CSSGradientType gradientType = CSSRadialGradient)
204         : CSSGradientValue(RadialGradientClass, repeat, gradientType)
205     {
206     }
207
208     CSSRadialGradientValue(const CSSRadialGradientValue& other)
209         : CSSGradientValue(other, RadialGradientClass, other.gradientType())
210         , m_firstRadius(other.m_firstRadius)
211         , m_secondRadius(other.m_secondRadius)
212         , m_shape(other.m_shape)
213         , m_sizingBehavior(other.m_sizingBehavior)
214         , m_endHorizontalSize(other.m_endHorizontalSize)
215         , m_endVerticalSize(other.m_endVerticalSize)
216     {
217     }
218
219
220     // Resolve points/radii to front end values.
221     float resolveRadius(CSSPrimitiveValue*, const RenderStyle&, const RenderStyle& rootStyle, float* widthOrHeight = 0);
222
223     // These may be null for non-deprecated gradients.
224     RefPtr<CSSPrimitiveValue> m_firstRadius;
225     RefPtr<CSSPrimitiveValue> m_secondRadius;
226
227     // The below are only used for non-deprecated gradients. Any of them may be null.
228     RefPtr<CSSPrimitiveValue> m_shape;
229     RefPtr<CSSPrimitiveValue> m_sizingBehavior;
230
231     RefPtr<CSSPrimitiveValue> m_endHorizontalSize;
232     RefPtr<CSSPrimitiveValue> m_endVerticalSize;
233 };
234
235 CSS_VALUE_TYPE_CASTS(CSSRadialGradientValue, isRadialGradientValue())
236
237 } // namespace WebCore
238
239 #endif // CSSGradientValue_h