[CSS3 Backgrounds and Borders] Remove CSS3_BACKGROUND feature flag.
[WebKit-https.git] / Source / WebCore / rendering / style / FillLayer.cpp
1 /*
2  * Copyright (C) 1999 Antti Koivisto (koivisto@kde.org)
3  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Library General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Library General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public License
16  * along with this library; see the file COPYING.LIB.  If not, write to
17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  * Boston, MA 02110-1301, USA.
19  *
20  */
21
22 #include "config.h"
23 #include "FillLayer.h"
24
25 namespace WebCore {
26
27 struct SameSizeAsFillLayer {
28     FillLayer* m_next;
29
30     RefPtr<StyleImage> m_image;
31
32     Length m_xPosition;
33     Length m_yPosition;
34
35     LengthSize m_sizeLength;
36
37     unsigned m_bitfields: 32;
38     unsigned m_bitfields2: 1;
39 };
40
41 COMPILE_ASSERT(sizeof(FillLayer) == sizeof(SameSizeAsFillLayer), FillLayer_should_stay_small);
42
43 FillLayer::FillLayer(EFillLayerType type)
44     : m_next(0)
45     , m_image(FillLayer::initialFillImage(type))
46     , m_xPosition(FillLayer::initialFillXPosition(type))
47     , m_yPosition(FillLayer::initialFillYPosition(type))
48     , m_sizeLength(FillLayer::initialFillSizeLength(type))
49     , m_attachment(FillLayer::initialFillAttachment(type))
50     , m_clip(FillLayer::initialFillClip(type))
51     , m_origin(FillLayer::initialFillOrigin(type))
52     , m_repeatX(FillLayer::initialFillRepeatX(type))
53     , m_repeatY(FillLayer::initialFillRepeatY(type))
54     , m_composite(FillLayer::initialFillComposite(type))
55     , m_sizeType(SizeNone)
56     , m_imageSet(false)
57     , m_attachmentSet(false)
58     , m_clipSet(false)
59     , m_originSet(false)
60     , m_repeatXSet(false)
61     , m_repeatYSet(false)
62     , m_xPosSet(false)
63     , m_yPosSet(false)
64     , m_backgroundOriginSet(false)
65     , m_backgroundXOrigin(LeftEdge)
66     , m_backgroundYOrigin(TopEdge)
67     , m_compositeSet(type == MaskFillLayer)
68     , m_type(type)
69 {
70 }
71
72 FillLayer::FillLayer(const FillLayer& o)
73     : m_next(o.m_next ? new FillLayer(*o.m_next) : 0)
74     , m_image(o.m_image)
75     , m_xPosition(o.m_xPosition)
76     , m_yPosition(o.m_yPosition)
77     , m_sizeLength(o.m_sizeLength)
78     , m_attachment(o.m_attachment)
79     , m_clip(o.m_clip)
80     , m_origin(o.m_origin)
81     , m_repeatX(o.m_repeatX)
82     , m_repeatY(o.m_repeatY)
83     , m_composite(o.m_composite)
84     , m_sizeType(o.m_sizeType)
85     , m_imageSet(o.m_imageSet)
86     , m_attachmentSet(o.m_attachmentSet)
87     , m_clipSet(o.m_clipSet)
88     , m_originSet(o.m_originSet)
89     , m_repeatXSet(o.m_repeatXSet)
90     , m_repeatYSet(o.m_repeatYSet)
91     , m_xPosSet(o.m_xPosSet)
92     , m_yPosSet(o.m_yPosSet)
93     , m_backgroundOriginSet(o.m_backgroundOriginSet)
94     , m_backgroundXOrigin(o.m_backgroundXOrigin)
95     , m_backgroundYOrigin(o.m_backgroundYOrigin)
96     , m_compositeSet(o.m_compositeSet)
97     , m_type(o.m_type)
98 {
99 }
100
101 FillLayer::~FillLayer()
102 {
103     delete m_next;
104 }
105
106 FillLayer& FillLayer::operator=(const FillLayer& o)
107 {
108     if (m_next != o.m_next) {
109         delete m_next;
110         m_next = o.m_next ? new FillLayer(*o.m_next) : 0;
111     }
112
113     m_image = o.m_image;
114     m_xPosition = o.m_xPosition;
115     m_yPosition = o.m_yPosition;
116     m_backgroundXOrigin = o.m_backgroundXOrigin;
117     m_backgroundYOrigin = o.m_backgroundYOrigin;
118     m_backgroundOriginSet = o.m_backgroundOriginSet;
119     m_sizeLength = o.m_sizeLength;
120     m_attachment = o.m_attachment;
121     m_clip = o.m_clip;
122     m_composite = o.m_composite;
123     m_origin = o.m_origin;
124     m_repeatX = o.m_repeatX;
125     m_repeatY = o.m_repeatY;
126     m_sizeType = o.m_sizeType;
127
128     m_imageSet = o.m_imageSet;
129     m_attachmentSet = o.m_attachmentSet;
130     m_clipSet = o.m_clipSet;
131     m_compositeSet = o.m_compositeSet;
132     m_originSet = o.m_originSet;
133     m_repeatXSet = o.m_repeatXSet;
134     m_repeatYSet = o.m_repeatYSet;
135     m_xPosSet = o.m_xPosSet;
136     m_yPosSet = o.m_yPosSet;
137     
138     m_type = o.m_type;
139
140     return *this;
141 }
142
143 bool FillLayer::operator==(const FillLayer& o) const
144 {
145     // We do not check the "isSet" booleans for each property, since those are only used during initial construction
146     // to propagate patterns into layers.  All layer comparisons happen after values have all been filled in anyway.
147     return StyleImage::imagesEquivalent(m_image.get(), o.m_image.get()) && m_xPosition == o.m_xPosition && m_yPosition == o.m_yPosition
148             && m_backgroundXOrigin == o.m_backgroundXOrigin && m_backgroundYOrigin == o.m_backgroundYOrigin
149             && m_attachment == o.m_attachment && m_clip == o.m_clip
150             && m_composite == o.m_composite && m_origin == o.m_origin && m_repeatX == o.m_repeatX
151             && m_repeatY == o.m_repeatY && m_sizeType == o.m_sizeType && m_sizeLength == o.m_sizeLength
152             && m_type == o.m_type && ((m_next && o.m_next) ? *m_next == *o.m_next : m_next == o.m_next);
153 }
154
155 void FillLayer::fillUnsetProperties()
156 {
157     FillLayer* curr;
158     for (curr = this; curr && curr->isXPositionSet(); curr = curr->next()) { }
159     if (curr && curr != this) {
160         // We need to fill in the remaining values with the pattern specified.
161         for (FillLayer* pattern = this; curr; curr = curr->next()) {
162             curr->m_xPosition = pattern->m_xPosition;
163             if (pattern->isBackgroundOriginSet()) {
164                 curr->m_backgroundXOrigin = pattern->m_backgroundXOrigin;
165                 curr->m_backgroundYOrigin = pattern->m_backgroundYOrigin;
166             }
167             pattern = pattern->next();
168             if (pattern == curr || !pattern)
169                 pattern = this;
170         }
171     }
172     
173     for (curr = this; curr && curr->isYPositionSet(); curr = curr->next()) { }
174     if (curr && curr != this) {
175         // We need to fill in the remaining values with the pattern specified.
176         for (FillLayer* pattern = this; curr; curr = curr->next()) {
177             curr->m_yPosition = pattern->m_yPosition;
178             if (pattern->isBackgroundOriginSet()) {
179                 curr->m_backgroundXOrigin = pattern->m_backgroundXOrigin;
180                 curr->m_backgroundYOrigin = pattern->m_backgroundYOrigin;
181             }
182             pattern = pattern->next();
183             if (pattern == curr || !pattern)
184                 pattern = this;
185         }
186     }
187
188     for (curr = this; curr && curr->isAttachmentSet(); curr = curr->next()) { }
189     if (curr && curr != this) {
190         // We need to fill in the remaining values with the pattern specified.
191         for (FillLayer* pattern = this; curr; curr = curr->next()) {
192             curr->m_attachment = pattern->m_attachment;
193             pattern = pattern->next();
194             if (pattern == curr || !pattern)
195                 pattern = this;
196         }
197     }
198     
199     for (curr = this; curr && curr->isClipSet(); curr = curr->next()) { }
200     if (curr && curr != this) {
201         // We need to fill in the remaining values with the pattern specified.
202         for (FillLayer* pattern = this; curr; curr = curr->next()) {
203             curr->m_clip = pattern->m_clip;
204             pattern = pattern->next();
205             if (pattern == curr || !pattern)
206                 pattern = this;
207         }
208     }
209
210     for (curr = this; curr && curr->isCompositeSet(); curr = curr->next()) { }
211     if (curr && curr != this) {
212         // We need to fill in the remaining values with the pattern specified.
213         for (FillLayer* pattern = this; curr; curr = curr->next()) {
214             curr->m_composite = pattern->m_composite;
215             pattern = pattern->next();
216             if (pattern == curr || !pattern)
217                 pattern = this;
218         }
219     }
220
221     for (curr = this; curr && curr->isOriginSet(); curr = curr->next()) { }
222     if (curr && curr != this) {
223         // We need to fill in the remaining values with the pattern specified.
224         for (FillLayer* pattern = this; curr; curr = curr->next()) {
225             curr->m_origin = pattern->m_origin;
226             pattern = pattern->next();
227             if (pattern == curr || !pattern)
228                 pattern = this;
229         }
230     }
231
232     for (curr = this; curr && curr->isRepeatXSet(); curr = curr->next()) { }
233     if (curr && curr != this) {
234         // We need to fill in the remaining values with the pattern specified.
235         for (FillLayer* pattern = this; curr; curr = curr->next()) {
236             curr->m_repeatX = pattern->m_repeatX;
237             pattern = pattern->next();
238             if (pattern == curr || !pattern)
239                 pattern = this;
240         }
241     }
242
243     for (curr = this; curr && curr->isRepeatYSet(); curr = curr->next()) { }
244     if (curr && curr != this) {
245         // We need to fill in the remaining values with the pattern specified.
246         for (FillLayer* pattern = this; curr; curr = curr->next()) {
247             curr->m_repeatY = pattern->m_repeatY;
248             pattern = pattern->next();
249             if (pattern == curr || !pattern)
250                 pattern = this;
251         }
252     }
253     
254     for (curr = this; curr && curr->isSizeSet(); curr = curr->next()) { }
255     if (curr && curr != this) {
256         // We need to fill in the remaining values with the pattern specified.
257         for (FillLayer* pattern = this; curr; curr = curr->next()) {
258             curr->m_sizeType = pattern->m_sizeType;
259             curr->m_sizeLength = pattern->m_sizeLength;
260             pattern = pattern->next();
261             if (pattern == curr || !pattern)
262                 pattern = this;
263         }
264     }
265 }
266
267 void FillLayer::cullEmptyLayers()
268 {
269     FillLayer* next;
270     for (FillLayer* p = this; p; p = next) {
271         next = p->m_next;
272         if (next && !next->isImageSet()) {
273             delete next;
274             p->m_next = 0;
275             break;
276         }
277     }
278 }
279
280 static EFillBox clipMax(EFillBox clipA, EFillBox clipB)
281 {
282     if (clipA == BorderFillBox || clipB == BorderFillBox)
283         return BorderFillBox;
284     if (clipA == PaddingFillBox || clipB == PaddingFillBox)
285         return PaddingFillBox;
286     if (clipA == ContentFillBox || clipB == ContentFillBox)
287         return ContentFillBox;
288     return TextFillBox;
289 }
290
291 void FillLayer::computeClipMax() const
292 {
293     if (m_next) {
294         m_next->computeClipMax();
295         m_clipMax = clipMax(clip(), m_next->clip());
296     } else
297         m_clipMax = m_clip;
298 }
299
300 bool FillLayer::clipOccludesNextLayers(bool firstLayer) const
301 {
302     if (firstLayer)
303         computeClipMax();
304     return m_clip == m_clipMax;
305 }
306
307 bool FillLayer::containsImage(StyleImage* s) const
308 {
309     if (!s)
310         return false;
311     if (m_image && *s == *m_image)
312         return true;
313     if (m_next)
314         return m_next->containsImage(s);
315     return false;
316 }
317
318 bool FillLayer::imagesAreLoaded() const
319 {
320     const FillLayer* curr;
321     for (curr = this; curr; curr = curr->next()) {
322         if (curr->m_image && !curr->m_image->isLoaded())
323             return false;
324     }
325
326     return true;
327 }
328
329 bool FillLayer::hasOpaqueImage(const RenderObject* renderer) const
330 {
331     if (!m_image)
332         return false;
333
334     if (m_composite == CompositeClear || m_composite == CompositeCopy)
335         return true;
336
337     if (m_composite == CompositeSourceOver)
338         return !m_image->hasAlpha(renderer);
339
340     return false;
341 }
342
343 bool FillLayer::hasRepeatXY() const
344 {
345     return m_repeatX == RepeatFill && m_repeatY == RepeatFill;
346 }
347
348 } // namespace WebCore