Rubber-stamped by Sam Weinig.
[WebKit-https.git] / WebCore / rendering / style / RenderStyle.h
1 /*
2  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
3  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2000 Dirk Mueller (mueller@kde.org)
5  * Copyright (C) 2003, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
6  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  *
23  */
24
25 #ifndef RenderStyle_h
26 #define RenderStyle_h
27
28 #include "TransformationMatrix.h"
29 #include "AnimationList.h"
30 #include "BorderData.h"
31 #include "BorderValue.h"
32 #include "CSSHelper.h"
33 #include "CSSImageGeneratorValue.h"
34 #include "CSSPrimitiveValue.h"
35 #include "CSSReflectionDirection.h"
36 #include "CSSValueList.h"
37 #include "CachedImage.h"
38 #include "CollapsedBorderValue.h"
39 #include "Color.h"
40 #include "ColorSpace.h"
41 #include "ContentData.h"
42 #include "CounterDirectives.h"
43 #include "CursorList.h"
44 #include "DataRef.h"
45 #include "FillLayer.h"
46 #include "FloatPoint.h"
47 #include "Font.h"
48 #include "GraphicsTypes.h"
49 #include "IntRect.h"
50 #include "Length.h"
51 #include "LengthBox.h"
52 #include "LengthSize.h"
53 #include "LineClampValue.h"
54 #include "NinePieceImage.h"
55 #include "OutlineValue.h"
56 #include "Pair.h"
57 #include "RenderStyleConstants.h"
58 #include "ShadowData.h"
59 #include "StyleBackgroundData.h"
60 #include "StyleBoxData.h"
61 #include "StyleFlexibleBoxData.h"
62 #include "StyleInheritedData.h"
63 #include "StyleMarqueeData.h"
64 #include "StyleMultiColData.h"
65 #include "StyleRareInheritedData.h"
66 #include "StyleRareNonInheritedData.h"
67 #include "StyleReflection.h"
68 #include "StyleSurroundData.h"
69 #include "StyleTransformData.h"
70 #include "StyleVisualData.h"
71 #include "TextDirection.h"
72 #include "ThemeTypes.h"
73 #include "TimingFunction.h"
74 #include "TransformOperations.h"
75 #include <wtf/OwnPtr.h>
76 #include <wtf/RefCounted.h>
77 #include <wtf/StdLibExtras.h>
78 #include <wtf/Vector.h>
79
80 #if ENABLE(DASHBOARD_SUPPORT)
81 #include "StyleDashboardRegion.h"
82 #endif
83
84 #if ENABLE(SVG)
85 #include "SVGRenderStyle.h"
86 #endif
87
88 #if ENABLE(XBL)
89 #include "BindingURI.h"
90 #endif
91
92 #if COMPILER(WINSCW)
93 #define compareEqual(t, u)      ((t) == (u))
94 #else
95 template<typename T, typename U> inline bool compareEqual(const T& t, const U& u) { return t == static_cast<T>(u); }
96 #endif
97
98 #define SET_VAR(group, variable, value) \
99     if (!compareEqual(group->variable, value)) \
100         group.access()->variable = value;
101
102 namespace WebCore {
103
104 using std::max;
105
106 class CSSStyleSelector;
107 class CSSValueList;
108 class CachedImage;
109 class Pair;
110 class StringImpl;
111 class StyleImage;
112
113 class RenderStyle: public RefCounted<RenderStyle> {
114     friend class CSSStyleSelector;
115 protected:
116
117     // The following bitfield is 32-bits long, which optimizes padding with the
118     // int refCount in the base class. Beware when adding more bits.
119     unsigned m_pseudoState : 3; // PseudoState
120     bool m_affectedByAttributeSelectors : 1;
121     bool m_unique : 1;
122
123     // Bits for dynamic child matching.
124     bool m_affectedByEmpty : 1;
125     bool m_emptyState : 1;
126
127     // We optimize for :first-child and :last-child.  The other positional child selectors like nth-child or
128     // *-child-of-type, we will just give up and re-evaluate whenever children change at all.
129     bool m_childrenAffectedByFirstChildRules : 1;
130     bool m_childrenAffectedByLastChildRules : 1;
131     bool m_childrenAffectedByDirectAdjacentRules : 1;
132     bool m_childrenAffectedByForwardPositionalRules : 1;
133     bool m_childrenAffectedByBackwardPositionalRules : 1;
134     bool m_firstChildState : 1;
135     bool m_lastChildState : 1;
136     unsigned m_childIndex : 18; // Plenty of bits to cache an index.
137
138     // non-inherited attributes
139     DataRef<StyleBoxData> box;
140     DataRef<StyleVisualData> visual;
141     DataRef<StyleBackgroundData> background;
142     DataRef<StyleSurroundData> surround;
143     DataRef<StyleRareNonInheritedData> rareNonInheritedData;
144
145     // inherited attributes
146     DataRef<StyleRareInheritedData> rareInheritedData;
147     DataRef<StyleInheritedData> inherited;
148
149     // list of associated pseudo styles
150     RefPtr<RenderStyle> m_cachedPseudoStyle;
151
152 #if ENABLE(SVG)
153     DataRef<SVGRenderStyle> m_svgStyle;
154 #endif
155
156 // !START SYNC!: Keep this in sync with the copy constructor in RenderStyle.cpp
157
158     // inherit
159     struct InheritedFlags {
160         bool operator==(const InheritedFlags& other) const
161         {
162             return (_empty_cells == other._empty_cells) &&
163                    (_caption_side == other._caption_side) &&
164                    (_list_style_type == other._list_style_type) &&
165                    (_list_style_position == other._list_style_position) &&
166                    (_visibility == other._visibility) &&
167                    (_text_align == other._text_align) &&
168                    (_text_transform == other._text_transform) &&
169                    (_text_decorations == other._text_decorations) &&
170                    (_text_transform == other._text_transform) &&
171                    (_cursor_style == other._cursor_style) &&
172                    (_direction == other._direction) &&
173                    (_border_collapse == other._border_collapse) &&
174                    (_white_space == other._white_space) &&
175                    (_box_direction == other._box_direction) &&
176                    (_visuallyOrdered == other._visuallyOrdered) &&
177                    (_htmlHacks == other._htmlHacks) &&
178                    (_force_backgrounds_to_white == other._force_backgrounds_to_white) &&
179                    (_pointerEvents == other._pointerEvents);
180         }
181
182         bool operator!=(const InheritedFlags& other) const { return !(*this == other); }
183
184         unsigned _empty_cells : 1; // EEmptyCell
185         unsigned _caption_side : 2; // ECaptionSide
186         unsigned _list_style_type : 5 ; // EListStyleType
187         unsigned _list_style_position : 1; // EListStylePosition
188         unsigned _visibility : 2; // EVisibility
189         unsigned _text_align : 3; // ETextAlign
190         unsigned _text_transform : 2; // ETextTransform
191         unsigned _text_decorations : 4;
192         unsigned _cursor_style : 6; // ECursor
193         unsigned _direction : 1; // TextDirection
194         bool _border_collapse : 1 ;
195         unsigned _white_space : 3; // EWhiteSpace
196         unsigned _box_direction : 1; // EBoxDirection (CSS3 box_direction property, flexible box layout module)
197         // 32 bits
198         
199         // non CSS2 inherited
200         bool _visuallyOrdered : 1;
201         bool _htmlHacks : 1;
202         bool _force_backgrounds_to_white : 1;
203         unsigned _pointerEvents : 4; // EPointerEvents
204         // 39 bits
205     } inherited_flags;
206
207 // don't inherit
208     struct NonInheritedFlags {
209         bool operator==(const NonInheritedFlags& other) const
210         {
211             return (_effectiveDisplay == other._effectiveDisplay) &&
212             (_originalDisplay == other._originalDisplay) &&
213             (_overflowX == other._overflowX) &&
214             (_overflowY == other._overflowY) &&
215             (_vertical_align == other._vertical_align) &&
216             (_clear == other._clear) &&
217             (_position == other._position) &&
218             (_floating == other._floating) &&
219             (_table_layout == other._table_layout) &&
220             (_page_break_before == other._page_break_before) &&
221             (_page_break_after == other._page_break_after) &&
222             (_styleType == other._styleType) &&
223             (_affectedByHover == other._affectedByHover) &&
224             (_affectedByActive == other._affectedByActive) &&
225             (_affectedByDrag == other._affectedByDrag) &&
226             (_pseudoBits == other._pseudoBits) &&
227             (_unicodeBidi == other._unicodeBidi);
228         }
229
230         bool operator!=(const NonInheritedFlags& other) const { return !(*this == other); }
231
232         unsigned _effectiveDisplay : 5; // EDisplay
233         unsigned _originalDisplay : 5; // EDisplay
234         unsigned _overflowX : 3; // EOverflow
235         unsigned _overflowY : 3; // EOverflow
236         unsigned _vertical_align : 4; // EVerticalAlign
237         unsigned _clear : 2; // EClear
238         unsigned _position : 2; // EPosition
239         unsigned _floating : 2; // EFloat
240         unsigned _table_layout : 1; // ETableLayout
241
242         unsigned _page_break_before : 2; // EPageBreak
243         unsigned _page_break_after : 2; // EPageBreak
244
245         unsigned _styleType : 5; // PseudoId
246         bool _affectedByHover : 1;
247         bool _affectedByActive : 1;
248         bool _affectedByDrag : 1;
249         unsigned _pseudoBits : 7;
250         unsigned _unicodeBidi : 2; // EUnicodeBidi
251         // 48 bits
252     } noninherited_flags;
253
254 // !END SYNC!
255
256 protected:
257     void setBitDefaults()
258     {
259         inherited_flags._empty_cells = initialEmptyCells();
260         inherited_flags._caption_side = initialCaptionSide();
261         inherited_flags._list_style_type = initialListStyleType();
262         inherited_flags._list_style_position = initialListStylePosition();
263         inherited_flags._visibility = initialVisibility();
264         inherited_flags._text_align = initialTextAlign();
265         inherited_flags._text_transform = initialTextTransform();
266         inherited_flags._text_decorations = initialTextDecoration();
267         inherited_flags._cursor_style = initialCursor();
268         inherited_flags._direction = initialDirection();
269         inherited_flags._border_collapse = initialBorderCollapse();
270         inherited_flags._white_space = initialWhiteSpace();
271         inherited_flags._visuallyOrdered = initialVisuallyOrdered();
272         inherited_flags._htmlHacks=false;
273         inherited_flags._box_direction = initialBoxDirection();
274         inherited_flags._force_backgrounds_to_white = false;
275         inherited_flags._pointerEvents = initialPointerEvents();
276
277         noninherited_flags._effectiveDisplay = noninherited_flags._originalDisplay = initialDisplay();
278         noninherited_flags._overflowX = initialOverflowX();
279         noninherited_flags._overflowY = initialOverflowY();
280         noninherited_flags._vertical_align = initialVerticalAlign();
281         noninherited_flags._clear = initialClear();
282         noninherited_flags._position = initialPosition();
283         noninherited_flags._floating = initialFloating();
284         noninherited_flags._table_layout = initialTableLayout();
285         noninherited_flags._page_break_before = initialPageBreak();
286         noninherited_flags._page_break_after = initialPageBreak();
287         noninherited_flags._styleType = NOPSEUDO;
288         noninherited_flags._affectedByHover = false;
289         noninherited_flags._affectedByActive = false;
290         noninherited_flags._affectedByDrag = false;
291         noninherited_flags._pseudoBits = 0;
292         noninherited_flags._unicodeBidi = initialUnicodeBidi();
293     }
294
295 protected:
296     RenderStyle();
297     // used to create the default style.
298     RenderStyle(bool);
299     RenderStyle(const RenderStyle&);
300
301 public:
302     static PassRefPtr<RenderStyle> create();
303     static PassRefPtr<RenderStyle> createDefaultStyle();
304     static PassRefPtr<RenderStyle> clone(const RenderStyle*);
305
306     ~RenderStyle();
307
308     void inheritFrom(const RenderStyle* inheritParent);
309
310     PseudoId styleType() const { return static_cast<PseudoId>(noninherited_flags._styleType); }
311     void setStyleType(PseudoId styleType) { noninherited_flags._styleType = styleType; }
312
313     RenderStyle* getCachedPseudoStyle(PseudoId) const;
314     RenderStyle* addCachedPseudoStyle(PassRefPtr<RenderStyle>);
315
316     typedef Vector<RenderStyle*, 10> PseudoStyleCache;
317     void getPseudoStyleCache(PseudoStyleCache&) const;
318
319     bool affectedByHoverRules() const { return noninherited_flags._affectedByHover; }
320     bool affectedByActiveRules() const { return noninherited_flags._affectedByActive; }
321     bool affectedByDragRules() const { return noninherited_flags._affectedByDrag; }
322
323     void setAffectedByHoverRules(bool b) { noninherited_flags._affectedByHover = b; }
324     void setAffectedByActiveRules(bool b) { noninherited_flags._affectedByActive = b; }
325     void setAffectedByDragRules(bool b) { noninherited_flags._affectedByDrag = b; }
326
327     bool operator==(const RenderStyle& other) const;
328     bool operator!=(const RenderStyle& other) const { return !(*this == other); }
329     bool isFloating() const { return !(noninherited_flags._floating == FNONE); }
330     bool hasMargin() const { return surround->margin.nonZero(); }
331     bool hasBorder() const { return surround->border.hasBorder(); }
332     bool hasPadding() const { return surround->padding.nonZero(); }
333     bool hasOffset() const { return surround->offset.nonZero(); }
334
335     bool hasBackground() const
336     {
337         if (backgroundColor().isValid() && backgroundColor().alpha() > 0)
338             return true;
339         return background->m_background.hasImage();
340     }
341     bool hasBackgroundImage() const { return background->m_background.hasImage(); }
342     bool hasFixedBackgroundImage() const { return background->m_background.hasFixedImage(); }
343     bool hasAppearance() const { return appearance() != NoControlPart; }
344
345     bool visuallyOrdered() const { return inherited_flags._visuallyOrdered; }
346     void setVisuallyOrdered(bool b) { inherited_flags._visuallyOrdered = b; }
347
348     bool isStyleAvailable() const;
349
350     bool hasPseudoStyle(PseudoId pseudo) const;
351     void setHasPseudoStyle(PseudoId pseudo);
352
353     // attribute getter methods
354
355     EDisplay display() const { return static_cast<EDisplay>(noninherited_flags._effectiveDisplay); }
356     EDisplay originalDisplay() const { return static_cast<EDisplay>(noninherited_flags._originalDisplay); }
357
358     Length left() const { return surround->offset.left(); }
359     Length right() const { return surround->offset.right(); }
360     Length top() const { return surround->offset.top(); }
361     Length bottom() const { return surround->offset.bottom(); }
362
363     // Whether or not a positioned element requires normal flow x/y to be computed
364     // to determine its position.
365     bool hasStaticX() const { return (left().isAuto() && right().isAuto()) || left().isStatic() || right().isStatic(); }
366     bool hasStaticY() const { return (top().isAuto() && bottom().isAuto()) || top().isStatic(); }
367
368     EPosition position() const { return static_cast<EPosition>(noninherited_flags._position); }
369     EFloat floating() const { return static_cast<EFloat>(noninherited_flags._floating); }
370
371     Length width() const { return box->width; }
372     Length height() const { return box->height; }
373     Length minWidth() const { return box->min_width; }
374     Length maxWidth() const { return box->max_width; }
375     Length minHeight() const { return box->min_height; }
376     Length maxHeight() const { return box->max_height; }
377
378     const BorderData& border() const { return surround->border; }
379     const BorderValue& borderLeft() const { return surround->border.left; }
380     const BorderValue& borderRight() const { return surround->border.right; }
381     const BorderValue& borderTop() const { return surround->border.top; }
382     const BorderValue& borderBottom() const { return surround->border.bottom; }
383
384     const NinePieceImage& borderImage() const { return surround->border.image; }
385
386     const IntSize& borderTopLeftRadius() const { return surround->border.topLeft; }
387     const IntSize& borderTopRightRadius() const { return surround->border.topRight; }
388     const IntSize& borderBottomLeftRadius() const { return surround->border.bottomLeft; }
389     const IntSize& borderBottomRightRadius() const { return surround->border.bottomRight; }
390     bool hasBorderRadius() const { return surround->border.hasBorderRadius(); }
391
392     unsigned short borderLeftWidth() const { return surround->border.borderLeftWidth(); }
393     EBorderStyle borderLeftStyle() const { return surround->border.left.style(); }
394     const Color& borderLeftColor() const { return surround->border.left.color; }
395     bool borderLeftIsTransparent() const { return surround->border.left.isTransparent(); }
396     unsigned short borderRightWidth() const { return surround->border.borderRightWidth(); }
397     EBorderStyle borderRightStyle() const { return surround->border.right.style(); }
398     const Color& borderRightColor() const { return surround->border.right.color; }
399     bool borderRightIsTransparent() const { return surround->border.right.isTransparent(); }
400     unsigned short borderTopWidth() const { return surround->border.borderTopWidth(); }
401     EBorderStyle borderTopStyle() const { return surround->border.top.style(); }
402     const Color& borderTopColor() const { return surround->border.top.color; }
403     bool borderTopIsTransparent() const { return surround->border.top.isTransparent(); }
404     unsigned short borderBottomWidth() const { return surround->border.borderBottomWidth(); }
405     EBorderStyle borderBottomStyle() const { return surround->border.bottom.style(); }
406     const Color& borderBottomColor() const { return surround->border.bottom.color; }
407     bool borderBottomIsTransparent() const { return surround->border.bottom.isTransparent(); }
408
409     unsigned short outlineSize() const { return max(0, outlineWidth() + outlineOffset()); }
410     unsigned short outlineWidth() const
411     {
412         if (background->m_outline.style() == BNONE)
413             return 0;
414         return background->m_outline.width;
415     }
416     bool hasOutline() const { return outlineWidth() > 0 && outlineStyle() > BHIDDEN; }
417     EBorderStyle outlineStyle() const { return background->m_outline.style(); }
418     bool outlineStyleIsAuto() const { return background->m_outline._auto; }
419     const Color& outlineColor() const { return background->m_outline.color; }
420
421     EOverflow overflowX() const { return static_cast<EOverflow>(noninherited_flags._overflowX); }
422     EOverflow overflowY() const { return static_cast<EOverflow>(noninherited_flags._overflowY); }
423
424     EVisibility visibility() const { return static_cast<EVisibility>(inherited_flags._visibility); }
425     EVerticalAlign verticalAlign() const { return static_cast<EVerticalAlign>(noninherited_flags._vertical_align); }
426     Length verticalAlignLength() const { return box->vertical_align; }
427
428     Length clipLeft() const { return visual->clip.left(); }
429     Length clipRight() const { return visual->clip.right(); }
430     Length clipTop() const { return visual->clip.top(); }
431     Length clipBottom() const { return visual->clip.bottom(); }
432     LengthBox clip() const { return visual->clip; }
433     bool hasClip() const { return visual->hasClip; }
434
435     EUnicodeBidi unicodeBidi() const { return static_cast<EUnicodeBidi>(noninherited_flags._unicodeBidi); }
436
437     EClear clear() const { return static_cast<EClear>(noninherited_flags._clear); }
438     ETableLayout tableLayout() const { return static_cast<ETableLayout>(noninherited_flags._table_layout); }
439
440     const Font& font() const { return inherited->font; }
441     const FontDescription& fontDescription() const { return inherited->font.fontDescription(); }
442     int fontSize() const { return inherited->font.pixelSize(); }
443
444     const Color& color() const { return inherited->color; }
445     Length textIndent() const { return inherited->indent; }
446     ETextAlign textAlign() const { return static_cast<ETextAlign>(inherited_flags._text_align); }
447     ETextTransform textTransform() const { return static_cast<ETextTransform>(inherited_flags._text_transform); }
448     int textDecorationsInEffect() const { return inherited_flags._text_decorations; }
449     int textDecoration() const { return visual->textDecoration; }
450     int wordSpacing() const { return inherited->font.wordSpacing(); }
451     int letterSpacing() const { return inherited->font.letterSpacing(); }
452
453     float zoom() const { return visual->m_zoom; }
454     float effectiveZoom() const { return inherited->m_effectiveZoom; }
455
456     TextDirection direction() const { return static_cast<TextDirection>(inherited_flags._direction); }
457     Length lineHeight() const { return inherited->line_height; }
458     int computedLineHeight() const
459     {
460         Length lh = lineHeight();
461
462         // Negative value means the line height is not set.  Use the font's built-in spacing.
463         if (lh.isNegative())
464             return font().lineSpacing();
465
466         if (lh.isPercent())
467             return lh.calcMinValue(fontSize());
468
469         return lh.value();
470     }
471
472     EWhiteSpace whiteSpace() const { return static_cast<EWhiteSpace>(inherited_flags._white_space); }
473     static bool autoWrap(EWhiteSpace ws)
474     {
475         // Nowrap and pre don't automatically wrap.
476         return ws != NOWRAP && ws != PRE;
477     }
478
479     bool autoWrap() const
480     {
481         return autoWrap(whiteSpace());
482     }
483
484     static bool preserveNewline(EWhiteSpace ws)
485     {
486         // Normal and nowrap do not preserve newlines.
487         return ws != NORMAL && ws != NOWRAP;
488     }
489
490     bool preserveNewline() const
491     {
492         return preserveNewline(whiteSpace());
493     }
494
495     static bool collapseWhiteSpace(EWhiteSpace ws)
496     {
497         // Pre and prewrap do not collapse whitespace.
498         return ws != PRE && ws != PRE_WRAP;
499     }
500
501     bool collapseWhiteSpace() const
502     {
503         return collapseWhiteSpace(whiteSpace());
504     }
505
506     bool isCollapsibleWhiteSpace(UChar c) const
507     {
508         switch (c) {
509             case ' ':
510             case '\t':
511                 return collapseWhiteSpace();
512             case '\n':
513                 return !preserveNewline();
514         }
515         return false;
516     }
517
518     bool breakOnlyAfterWhiteSpace() const
519     {
520         return whiteSpace() == PRE_WRAP || khtmlLineBreak() == AFTER_WHITE_SPACE;
521     }
522
523     bool breakWords() const
524     {
525         return wordBreak() == BreakWordBreak || wordWrap() == BreakWordWrap;
526     }
527
528     const Color& backgroundColor() const { return background->m_color; }
529     StyleImage* backgroundImage() const { return background->m_background.m_image.get(); }
530     EFillRepeat backgroundRepeatX() const { return static_cast<EFillRepeat>(background->m_background.m_repeatX); }
531     EFillRepeat backgroundRepeatY() const { return static_cast<EFillRepeat>(background->m_background.m_repeatY); }
532     CompositeOperator backgroundComposite() const { return static_cast<CompositeOperator>(background->m_background.m_composite); }
533     EFillAttachment backgroundAttachment() const { return static_cast<EFillAttachment>(background->m_background.m_attachment); }
534     EFillBox backgroundClip() const { return static_cast<EFillBox>(background->m_background.m_clip); }
535     EFillBox backgroundOrigin() const { return static_cast<EFillBox>(background->m_background.m_origin); }
536     Length backgroundXPosition() const { return background->m_background.m_xPosition; }
537     Length backgroundYPosition() const { return background->m_background.m_yPosition; }
538     EFillSizeType backgroundSizeType() const { return static_cast<EFillSizeType>(background->m_background.m_sizeType); }
539     LengthSize backgroundSizeLength() const { return background->m_background.m_sizeLength; }
540     FillLayer* accessBackgroundLayers() { return &(background.access()->m_background); }
541     const FillLayer* backgroundLayers() const { return &(background->m_background); }
542
543     StyleImage* maskImage() const { return rareNonInheritedData->m_mask.m_image.get(); }
544     EFillRepeat maskRepeatX() const { return static_cast<EFillRepeat>(rareNonInheritedData->m_mask.m_repeatX); }
545     EFillRepeat maskRepeatY() const { return static_cast<EFillRepeat>(rareNonInheritedData->m_mask.m_repeatY); }
546     CompositeOperator maskComposite() const { return static_cast<CompositeOperator>(rareNonInheritedData->m_mask.m_composite); }
547     EFillAttachment maskAttachment() const { return static_cast<EFillAttachment>(rareNonInheritedData->m_mask.m_attachment); }
548     EFillBox maskClip() const { return static_cast<EFillBox>(rareNonInheritedData->m_mask.m_clip); }
549     EFillBox maskOrigin() const { return static_cast<EFillBox>(rareNonInheritedData->m_mask.m_origin); }
550     Length maskXPosition() const { return rareNonInheritedData->m_mask.m_xPosition; }
551     Length maskYPosition() const { return rareNonInheritedData->m_mask.m_yPosition; }
552     LengthSize maskSize() const { return rareNonInheritedData->m_mask.m_sizeLength; }
553     FillLayer* accessMaskLayers() { return &(rareNonInheritedData.access()->m_mask); }
554     const FillLayer* maskLayers() const { return &(rareNonInheritedData->m_mask); }
555     const NinePieceImage& maskBoxImage() const { return rareNonInheritedData->m_maskBoxImage; }
556
557     // returns true for collapsing borders, false for separate borders
558     bool borderCollapse() const { return inherited_flags._border_collapse; }
559     short horizontalBorderSpacing() const { return inherited->horizontal_border_spacing; }
560     short verticalBorderSpacing() const { return inherited->vertical_border_spacing; }
561     EEmptyCell emptyCells() const { return static_cast<EEmptyCell>(inherited_flags._empty_cells); }
562     ECaptionSide captionSide() const { return static_cast<ECaptionSide>(inherited_flags._caption_side); }
563
564     short counterIncrement() const { return visual->counterIncrement; }
565     short counterReset() const { return visual->counterReset; }
566
567     EListStyleType listStyleType() const { return static_cast<EListStyleType>(inherited_flags._list_style_type); }
568     StyleImage* listStyleImage() const { return inherited->list_style_image.get(); }
569     EListStylePosition listStylePosition() const { return static_cast<EListStylePosition>(inherited_flags._list_style_position); }
570
571     Length marginTop() const { return surround->margin.top(); }
572     Length marginBottom() const { return surround->margin.bottom(); }
573     Length marginLeft() const { return surround->margin.left(); }
574     Length marginRight() const { return surround->margin.right(); }
575
576     LengthBox paddingBox() const { return surround->padding; }
577     Length paddingTop() const { return surround->padding.top(); }
578     Length paddingBottom() const { return surround->padding.bottom(); }
579     Length paddingLeft() const { return surround->padding.left(); }
580     Length paddingRight() const { return surround->padding.right(); }
581
582     ECursor cursor() const { return static_cast<ECursor>(inherited_flags._cursor_style); }
583
584     CursorList* cursors() const { return inherited->cursorData.get(); }
585
586     short widows() const { return inherited->widows; }
587     short orphans() const { return inherited->orphans; }
588     EPageBreak pageBreakInside() const { return static_cast<EPageBreak>(inherited->page_break_inside); }
589     EPageBreak pageBreakBefore() const { return static_cast<EPageBreak>(noninherited_flags._page_break_before); }
590     EPageBreak pageBreakAfter() const { return static_cast<EPageBreak>(noninherited_flags._page_break_after); }
591
592     // CSS3 Getter Methods
593 #if ENABLE(XBL)
594     BindingURI* bindingURIs() const { return rareNonInheritedData->bindingURI; }
595 #endif
596
597     int outlineOffset() const
598     {
599         if (background->m_outline.style() == BNONE)
600             return 0;
601         return background->m_outline._offset;
602     }
603
604     ShadowData* textShadow() const { return rareInheritedData->textShadow; }
605     const Color& textStrokeColor() const { return rareInheritedData->textStrokeColor; }
606     float textStrokeWidth() const { return rareInheritedData->textStrokeWidth; }
607     const Color& textFillColor() const { return rareInheritedData->textFillColor; }
608     ColorSpace colorSpace() const { return static_cast<ColorSpace>(rareInheritedData->colorSpace); }
609     float opacity() const { return rareNonInheritedData->opacity; }
610     ControlPart appearance() const { return static_cast<ControlPart>(rareNonInheritedData->m_appearance); }
611     EBoxAlignment boxAlign() const { return static_cast<EBoxAlignment>(rareNonInheritedData->flexibleBox->align); }
612     EBoxDirection boxDirection() const { return static_cast<EBoxDirection>(inherited_flags._box_direction); }
613     float boxFlex() { return rareNonInheritedData->flexibleBox->flex; }
614     unsigned int boxFlexGroup() const { return rareNonInheritedData->flexibleBox->flex_group; }
615     EBoxLines boxLines() { return static_cast<EBoxLines>(rareNonInheritedData->flexibleBox->lines); }
616     unsigned int boxOrdinalGroup() const { return rareNonInheritedData->flexibleBox->ordinal_group; }
617     EBoxOrient boxOrient() const { return static_cast<EBoxOrient>(rareNonInheritedData->flexibleBox->orient); }
618     EBoxAlignment boxPack() const { return static_cast<EBoxAlignment>(rareNonInheritedData->flexibleBox->pack); }
619
620     ShadowData* boxShadow() const { return rareNonInheritedData->m_boxShadow.get(); }
621     void getBoxShadowExtent(int &top, int &right, int &bottom, int &left) const;
622     void getBoxShadowHorizontalExtent(int &left, int &right) const;
623     void getBoxShadowVerticalExtent(int &top, int &bottom) const;
624
625     StyleReflection* boxReflect() const { return rareNonInheritedData->m_boxReflect.get(); }
626     EBoxSizing boxSizing() const { return static_cast<EBoxSizing>(box->boxSizing); }
627     Length marqueeIncrement() const { return rareNonInheritedData->marquee->increment; }
628     int marqueeSpeed() const { return rareNonInheritedData->marquee->speed; }
629     int marqueeLoopCount() const { return rareNonInheritedData->marquee->loops; }
630     EMarqueeBehavior marqueeBehavior() const { return static_cast<EMarqueeBehavior>(rareNonInheritedData->marquee->behavior); }
631     EMarqueeDirection marqueeDirection() const { return static_cast<EMarqueeDirection>(rareNonInheritedData->marquee->direction); }
632     EUserModify userModify() const { return static_cast<EUserModify>(rareInheritedData->userModify); }
633     EUserDrag userDrag() const { return static_cast<EUserDrag>(rareNonInheritedData->userDrag); }
634     EUserSelect userSelect() const { return static_cast<EUserSelect>(rareInheritedData->userSelect); }
635     bool textOverflow() const { return rareNonInheritedData->textOverflow; }
636     EMarginCollapse marginTopCollapse() const { return static_cast<EMarginCollapse>(rareNonInheritedData->marginTopCollapse); }
637     EMarginCollapse marginBottomCollapse() const { return static_cast<EMarginCollapse>(rareNonInheritedData->marginBottomCollapse); }
638     EWordBreak wordBreak() const { return static_cast<EWordBreak>(rareInheritedData->wordBreak); }
639     EWordWrap wordWrap() const { return static_cast<EWordWrap>(rareInheritedData->wordWrap); }
640     ENBSPMode nbspMode() const { return static_cast<ENBSPMode>(rareInheritedData->nbspMode); }
641     EKHTMLLineBreak khtmlLineBreak() const { return static_cast<EKHTMLLineBreak>(rareInheritedData->khtmlLineBreak); }
642     EMatchNearestMailBlockquoteColor matchNearestMailBlockquoteColor() const { return static_cast<EMatchNearestMailBlockquoteColor>(rareNonInheritedData->matchNearestMailBlockquoteColor); }
643     const AtomicString& highlight() const { return rareInheritedData->highlight; }
644     EBorderFit borderFit() const { return static_cast<EBorderFit>(rareNonInheritedData->m_borderFit); }
645     EResize resize() const { return static_cast<EResize>(rareInheritedData->resize); }
646     float columnWidth() const { return rareNonInheritedData->m_multiCol->m_width; }
647     bool hasAutoColumnWidth() const { return rareNonInheritedData->m_multiCol->m_autoWidth; }
648     unsigned short columnCount() const { return rareNonInheritedData->m_multiCol->m_count; }
649     bool hasAutoColumnCount() const { return rareNonInheritedData->m_multiCol->m_autoCount; }
650     float columnGap() const { return rareNonInheritedData->m_multiCol->m_gap; }
651     bool hasNormalColumnGap() const { return rareNonInheritedData->m_multiCol->m_normalGap; }
652     const Color& columnRuleColor() const { return rareNonInheritedData->m_multiCol->m_rule.color; }
653     EBorderStyle columnRuleStyle() const { return rareNonInheritedData->m_multiCol->m_rule.style(); }
654     unsigned short columnRuleWidth() const { return rareNonInheritedData->m_multiCol->ruleWidth(); }
655     bool columnRuleIsTransparent() const { return rareNonInheritedData->m_multiCol->m_rule.isTransparent(); }
656     EPageBreak columnBreakBefore() const { return static_cast<EPageBreak>(rareNonInheritedData->m_multiCol->m_breakBefore); }
657     EPageBreak columnBreakInside() const { return static_cast<EPageBreak>(rareNonInheritedData->m_multiCol->m_breakInside); }
658     EPageBreak columnBreakAfter() const { return static_cast<EPageBreak>(rareNonInheritedData->m_multiCol->m_breakAfter); }
659     const TransformOperations& transform() const { return rareNonInheritedData->m_transform->m_operations; }
660     Length transformOriginX() const { return rareNonInheritedData->m_transform->m_x; }
661     Length transformOriginY() const { return rareNonInheritedData->m_transform->m_y; }
662     float transformOriginZ() const { return rareNonInheritedData->m_transform->m_z; }
663     bool hasTransform() const { return !rareNonInheritedData->m_transform->m_operations.operations().isEmpty(); }
664     
665     // Return true if any transform related property (currently transform, transformStyle3D or perspective) 
666     // indicates that we are transforming
667     bool hasTransformRelatedProperty() const { return hasTransform() || preserves3D() || hasPerspective(); }
668
669     enum ApplyTransformOrigin { IncludeTransformOrigin, ExcludeTransformOrigin };
670     void applyTransform(TransformationMatrix&, const IntSize& borderBoxSize, ApplyTransformOrigin = IncludeTransformOrigin) const;
671
672     bool hasMask() const { return rareNonInheritedData->m_mask.hasImage() || rareNonInheritedData->m_maskBoxImage.hasImage(); }
673     // End CSS3 Getters
674
675     // Apple-specific property getter methods
676     EPointerEvents pointerEvents() const { return static_cast<EPointerEvents>(inherited_flags._pointerEvents); }
677     const AnimationList* animations() const { return rareNonInheritedData->m_animations.get(); }
678     const AnimationList* transitions() const { return rareNonInheritedData->m_transitions.get(); }
679
680     AnimationList* accessAnimations();
681     AnimationList* accessTransitions();
682
683     bool hasAnimations() const { return rareNonInheritedData->m_animations && rareNonInheritedData->m_animations->size() > 0; }
684     bool hasTransitions() const { return rareNonInheritedData->m_transitions && rareNonInheritedData->m_transitions->size() > 0; }
685
686     // return the first found Animation (including 'all' transitions)
687     const Animation* transitionForProperty(int property) const;
688
689     ETransformStyle3D transformStyle3D() const { return rareNonInheritedData->m_transformStyle3D; }
690     bool preserves3D() const { return rareNonInheritedData->m_transformStyle3D == TransformStyle3DPreserve3D; }
691
692     EBackfaceVisibility backfaceVisibility() const { return rareNonInheritedData->m_backfaceVisibility; }
693     float perspective() const { return rareNonInheritedData->m_perspective; }
694     bool hasPerspective() const { return rareNonInheritedData->m_perspective > 0; }
695     Length perspectiveOriginX() const { return rareNonInheritedData->m_perspectiveOriginX; }
696     Length perspectiveOriginY() const { return rareNonInheritedData->m_perspectiveOriginY; }
697     
698 #if USE(ACCELERATED_COMPOSITING)
699     // When set, this ensures that styles compare as different. Used during accelerated animations.
700     bool isRunningAcceleratedAnimation() const { return rareNonInheritedData->m_runningAcceleratedAnimation; }
701 #endif
702
703     const LineClampValue& lineClamp() const { return rareNonInheritedData->lineClamp; }
704     bool textSizeAdjust() const { return rareInheritedData->textSizeAdjust; }
705     ETextSecurity textSecurity() const { return static_cast<ETextSecurity>(rareInheritedData->textSecurity); }
706
707 // attribute setter methods
708
709     void setDisplay(EDisplay v) { noninherited_flags._effectiveDisplay = v; }
710     void setOriginalDisplay(EDisplay v) { noninherited_flags._originalDisplay = v; }
711     void setPosition(EPosition v) { noninherited_flags._position = v; }
712     void setFloating(EFloat v) { noninherited_flags._floating = v; }
713
714     void setLeft(Length v) { SET_VAR(surround, offset.m_left, v) }
715     void setRight(Length v) { SET_VAR(surround, offset.m_right, v) }
716     void setTop(Length v) { SET_VAR(surround, offset.m_top, v) }
717     void setBottom(Length v) { SET_VAR(surround, offset.m_bottom, v) }
718
719     void setWidth(Length v) { SET_VAR(box, width, v) }
720     void setHeight(Length v) { SET_VAR(box, height, v) }
721
722     void setMinWidth(Length v) { SET_VAR(box, min_width, v) }
723     void setMaxWidth(Length v) { SET_VAR(box, max_width, v) }
724     void setMinHeight(Length v) { SET_VAR(box, min_height, v) }
725     void setMaxHeight(Length v) { SET_VAR(box, max_height, v) }
726
727 #if ENABLE(DASHBOARD_SUPPORT)
728     Vector<StyleDashboardRegion> dashboardRegions() const { return rareNonInheritedData->m_dashboardRegions; }
729     void setDashboardRegions(Vector<StyleDashboardRegion> regions) { SET_VAR(rareNonInheritedData, m_dashboardRegions, regions); }
730
731     void setDashboardRegion(int type, const String& label, Length t, Length r, Length b, Length l, bool append)
732     {
733         StyleDashboardRegion region;
734         region.label = label;
735         region.offset.m_top = t;
736         region.offset.m_right = r;
737         region.offset.m_bottom = b;
738         region.offset.m_left = l;
739         region.type = type;
740         if (!append)
741             rareNonInheritedData.access()->m_dashboardRegions.clear();
742         rareNonInheritedData.access()->m_dashboardRegions.append(region);
743     }
744 #endif
745
746     void resetBorder() { resetBorderImage(); resetBorderTop(); resetBorderRight(); resetBorderBottom(); resetBorderLeft(); resetBorderRadius(); }
747     void resetBorderTop() { SET_VAR(surround, border.top, BorderValue()) }
748     void resetBorderRight() { SET_VAR(surround, border.right, BorderValue()) }
749     void resetBorderBottom() { SET_VAR(surround, border.bottom, BorderValue()) }
750     void resetBorderLeft() { SET_VAR(surround, border.left, BorderValue()) }
751     void resetBorderImage() { SET_VAR(surround, border.image, NinePieceImage()) }
752     void resetBorderRadius() { resetBorderTopLeftRadius(); resetBorderTopRightRadius(); resetBorderBottomLeftRadius(); resetBorderBottomRightRadius(); }
753     void resetBorderTopLeftRadius() { SET_VAR(surround, border.topLeft, initialBorderRadius()) }
754     void resetBorderTopRightRadius() { SET_VAR(surround, border.topRight, initialBorderRadius()) }
755     void resetBorderBottomLeftRadius() { SET_VAR(surround, border.bottomLeft, initialBorderRadius()) }
756     void resetBorderBottomRightRadius() { SET_VAR(surround, border.bottomRight, initialBorderRadius()) }
757
758     void resetOutline() { SET_VAR(background, m_outline, OutlineValue()) }
759
760     void setBackgroundColor(const Color& v) { SET_VAR(background, m_color, v) }
761
762     void setBackgroundXPosition(Length l) { SET_VAR(background, m_background.m_xPosition, l) }
763     void setBackgroundYPosition(Length l) { SET_VAR(background, m_background.m_yPosition, l) }
764     void setBackgroundSize(EFillSizeType b) { SET_VAR(background, m_background.m_sizeType, b) }
765     void setBackgroundSizeLength(LengthSize l) { SET_VAR(background, m_background.m_sizeLength, l) }
766     
767     void setBorderImage(const NinePieceImage& b) { SET_VAR(surround, border.image, b) }
768
769     void setBorderTopLeftRadius(const IntSize& s) { SET_VAR(surround, border.topLeft, s) }
770     void setBorderTopRightRadius(const IntSize& s) { SET_VAR(surround, border.topRight, s) }
771     void setBorderBottomLeftRadius(const IntSize& s) { SET_VAR(surround, border.bottomLeft, s) }
772     void setBorderBottomRightRadius(const IntSize& s) { SET_VAR(surround, border.bottomRight, s) }
773
774     void setBorderRadius(const IntSize& s)
775     {
776         setBorderTopLeftRadius(s);
777         setBorderTopRightRadius(s);
778         setBorderBottomLeftRadius(s);
779         setBorderBottomRightRadius(s);
780     }
781     
782     void getBorderRadiiForRect(const IntRect&, IntSize& topLeft, IntSize& topRight, IntSize& bottomLeft, IntSize& bottomRight) const;
783
784     void setBorderLeftWidth(unsigned short v) { SET_VAR(surround, border.left.width, v) }
785     void setBorderLeftStyle(EBorderStyle v) { SET_VAR(surround, border.left.m_style, v) }
786     void setBorderLeftColor(const Color& v) { SET_VAR(surround, border.left.color, v) }
787     void setBorderRightWidth(unsigned short v) { SET_VAR(surround, border.right.width, v) }
788     void setBorderRightStyle(EBorderStyle v) { SET_VAR(surround, border.right.m_style, v) }
789     void setBorderRightColor(const Color& v) { SET_VAR(surround, border.right.color, v) }
790     void setBorderTopWidth(unsigned short v) { SET_VAR(surround, border.top.width, v) }
791     void setBorderTopStyle(EBorderStyle v) { SET_VAR(surround, border.top.m_style, v) }
792     void setBorderTopColor(const Color& v) { SET_VAR(surround, border.top.color, v) }
793     void setBorderBottomWidth(unsigned short v) { SET_VAR(surround, border.bottom.width, v) }
794     void setBorderBottomStyle(EBorderStyle v) { SET_VAR(surround, border.bottom.m_style, v) }
795     void setBorderBottomColor(const Color& v) { SET_VAR(surround, border.bottom.color, v) }
796     void setOutlineWidth(unsigned short v) { SET_VAR(background, m_outline.width, v) }
797
798     void setOutlineStyle(EBorderStyle v, bool isAuto = false)
799     {
800         SET_VAR(background, m_outline.m_style, v)
801         SET_VAR(background, m_outline._auto, isAuto)
802     }
803
804     void setOutlineColor(const Color& v) { SET_VAR(background, m_outline.color, v) }
805
806     void setOverflowX(EOverflow v) { noninherited_flags._overflowX = v; }
807     void setOverflowY(EOverflow v) { noninherited_flags._overflowY = v; }
808     void setVisibility(EVisibility v) { inherited_flags._visibility = v; }
809     void setVerticalAlign(EVerticalAlign v) { noninherited_flags._vertical_align = v; }
810     void setVerticalAlignLength(Length l) { SET_VAR(box, vertical_align, l) }
811
812     void setHasClip(bool b = true) { SET_VAR(visual, hasClip, b) }
813     void setClipLeft(Length v) { SET_VAR(visual, clip.m_left, v) }
814     void setClipRight(Length v) { SET_VAR(visual, clip.m_right, v) }
815     void setClipTop(Length v) { SET_VAR(visual, clip.m_top, v) }
816     void setClipBottom(Length v) { SET_VAR(visual, clip.m_bottom, v) }
817     void setClip(Length top, Length right, Length bottom, Length left);
818
819     void setUnicodeBidi(EUnicodeBidi b) { noninherited_flags._unicodeBidi = b; }
820
821     void setClear(EClear v) { noninherited_flags._clear = v; }
822     void setTableLayout(ETableLayout v) { noninherited_flags._table_layout = v; }
823
824     bool setFontDescription(const FontDescription& v)
825     {
826         if (inherited->font.fontDescription() != v) {
827             inherited.access()->font = Font(v, inherited->font.letterSpacing(), inherited->font.wordSpacing());
828             return true;
829         }
830         return false;
831     }
832
833     // Only used for blending font sizes when animating.
834     void setBlendedFontSize(int);
835
836     void setColor(const Color& v) { SET_VAR(inherited, color, v) }
837     void setTextIndent(Length v) { SET_VAR(inherited, indent, v) }
838     void setTextAlign(ETextAlign v) { inherited_flags._text_align = v; }
839     void setTextTransform(ETextTransform v) { inherited_flags._text_transform = v; }
840     void addToTextDecorationsInEffect(int v) { inherited_flags._text_decorations |= v; }
841     void setTextDecorationsInEffect(int v) { inherited_flags._text_decorations = v; }
842     void setTextDecoration(int v) { SET_VAR(visual, textDecoration, v); }
843     void setDirection(TextDirection v) { inherited_flags._direction = v; }
844     void setLineHeight(Length v) { SET_VAR(inherited, line_height, v) }
845     void setZoom(float f) { SET_VAR(visual, m_zoom, f); setEffectiveZoom(effectiveZoom() * zoom()); }
846     void setEffectiveZoom(float f) { SET_VAR(inherited, m_effectiveZoom, f) }
847
848     void setWhiteSpace(EWhiteSpace v) { inherited_flags._white_space = v; }
849
850     void setWordSpacing(int v) { inherited.access()->font.setWordSpacing(v); }
851     void setLetterSpacing(int v) { inherited.access()->font.setLetterSpacing(v); }
852
853     void clearBackgroundLayers() { background.access()->m_background = FillLayer(BackgroundFillLayer); }
854     void inheritBackgroundLayers(const FillLayer& parent) { background.access()->m_background = parent; }
855
856     void adjustBackgroundLayers()
857     {
858         if (backgroundLayers()->next()) {
859             accessBackgroundLayers()->cullEmptyLayers();
860             accessBackgroundLayers()->fillUnsetProperties();
861         }
862     }
863
864     void clearMaskLayers() { rareNonInheritedData.access()->m_mask = FillLayer(MaskFillLayer); }
865     void inheritMaskLayers(const FillLayer& parent) { rareNonInheritedData.access()->m_mask = parent; }
866
867     void adjustMaskLayers()
868     {
869         if (maskLayers()->next()) {
870             accessMaskLayers()->cullEmptyLayers();
871             accessMaskLayers()->fillUnsetProperties();
872         }
873     }
874
875     void setMaskBoxImage(const NinePieceImage& b) { SET_VAR(rareNonInheritedData, m_maskBoxImage, b) }
876     void setMaskXPosition(Length l) { SET_VAR(rareNonInheritedData, m_mask.m_xPosition, l) }
877     void setMaskYPosition(Length l) { SET_VAR(rareNonInheritedData, m_mask.m_yPosition, l) }
878     void setMaskSize(LengthSize l) { SET_VAR(rareNonInheritedData, m_mask.m_sizeLength, l) }
879
880     void setBorderCollapse(bool collapse) { inherited_flags._border_collapse = collapse; }
881     void setHorizontalBorderSpacing(short v) { SET_VAR(inherited, horizontal_border_spacing, v) }
882     void setVerticalBorderSpacing(short v) { SET_VAR(inherited, vertical_border_spacing, v) }
883     void setEmptyCells(EEmptyCell v) { inherited_flags._empty_cells = v; }
884     void setCaptionSide(ECaptionSide v) { inherited_flags._caption_side = v; }
885
886     void setCounterIncrement(short v) { SET_VAR(visual, counterIncrement, v) }
887     void setCounterReset(short v) { SET_VAR(visual, counterReset, v) }
888
889     void setListStyleType(EListStyleType v) { inherited_flags._list_style_type = v; }
890     void setListStyleImage(StyleImage* v) { if (inherited->list_style_image != v) inherited.access()->list_style_image = v; }
891     void setListStylePosition(EListStylePosition v) { inherited_flags._list_style_position = v; }
892
893     void resetMargin() { SET_VAR(surround, margin, LengthBox(Fixed)) }
894     void setMarginTop(Length v) { SET_VAR(surround, margin.m_top, v) }
895     void setMarginBottom(Length v) { SET_VAR(surround, margin.m_bottom, v) }
896     void setMarginLeft(Length v) { SET_VAR(surround, margin.m_left, v) }
897     void setMarginRight(Length v) { SET_VAR(surround, margin.m_right, v) }
898
899     void resetPadding() { SET_VAR(surround, padding, LengthBox(Auto)) }
900     void setPaddingBox(const LengthBox& b) { SET_VAR(surround, padding, b) }
901     void setPaddingTop(Length v) { SET_VAR(surround, padding.m_top, v) }
902     void setPaddingBottom(Length v) { SET_VAR(surround, padding.m_bottom, v) }
903     void setPaddingLeft(Length v) { SET_VAR(surround, padding.m_left, v) }
904     void setPaddingRight(Length v) { SET_VAR(surround, padding.m_right, v) }
905
906     void setCursor(ECursor c) { inherited_flags._cursor_style = c; }
907     void addCursor(CachedImage*, const IntPoint& = IntPoint());
908     void setCursorList(PassRefPtr<CursorList>);
909     void clearCursorList();
910
911     bool forceBackgroundsToWhite() const { return inherited_flags._force_backgrounds_to_white; }
912     void setForceBackgroundsToWhite(bool b=true) { inherited_flags._force_backgrounds_to_white = b; }
913
914     bool htmlHacks() const { return inherited_flags._htmlHacks; }
915     void setHtmlHacks(bool b=true) { inherited_flags._htmlHacks = b; }
916
917     bool hasAutoZIndex() const { return box->z_auto; }
918     void setHasAutoZIndex() { SET_VAR(box, z_auto, true); SET_VAR(box, z_index, 0) }
919     int zIndex() const { return box->z_index; }
920     void setZIndex(int v) { SET_VAR(box, z_auto, false); SET_VAR(box, z_index, v) }
921
922     void setWidows(short w) { SET_VAR(inherited, widows, w); }
923     void setOrphans(short o) { SET_VAR(inherited, orphans, o); }
924     void setPageBreakInside(EPageBreak b) { SET_VAR(inherited, page_break_inside, b); }
925     void setPageBreakBefore(EPageBreak b) { noninherited_flags._page_break_before = b; }
926     void setPageBreakAfter(EPageBreak b) { noninherited_flags._page_break_after = b; }
927
928     // CSS3 Setters
929 #if ENABLE(XBL)
930     void deleteBindingURIs() { SET_VAR(rareNonInheritedData, bindingURI, static_cast<BindingURI*>(0)); }
931     void inheritBindingURIs(BindingURI* other) { SET_VAR(rareNonInheritedData, bindingURI, other->copy()); }
932     void addBindingURI(StringImpl* uri);
933 #endif
934
935     void setOutlineOffset(int v) { SET_VAR(background, m_outline._offset, v) }
936     void setTextShadow(ShadowData* val, bool add=false);
937     void setTextStrokeColor(const Color& c) { SET_VAR(rareInheritedData, textStrokeColor, c) }
938     void setTextStrokeWidth(float w) { SET_VAR(rareInheritedData, textStrokeWidth, w) }
939     void setTextFillColor(const Color& c) { SET_VAR(rareInheritedData, textFillColor, c) }
940     void setColorSpace(ColorSpace space) { SET_VAR(rareInheritedData, colorSpace, space) }
941     void setOpacity(float f) { SET_VAR(rareNonInheritedData, opacity, f); }
942     void setAppearance(ControlPart a) { SET_VAR(rareNonInheritedData, m_appearance, a); }
943     void setBoxAlign(EBoxAlignment a) { SET_VAR(rareNonInheritedData.access()->flexibleBox, align, a); }
944     void setBoxDirection(EBoxDirection d) { inherited_flags._box_direction = d; }
945     void setBoxFlex(float f) { SET_VAR(rareNonInheritedData.access()->flexibleBox, flex, f); }
946     void setBoxFlexGroup(unsigned int fg) { SET_VAR(rareNonInheritedData.access()->flexibleBox, flex_group, fg); }
947     void setBoxLines(EBoxLines l) { SET_VAR(rareNonInheritedData.access()->flexibleBox, lines, l); }
948     void setBoxOrdinalGroup(unsigned int og) { SET_VAR(rareNonInheritedData.access()->flexibleBox, ordinal_group, og); }
949     void setBoxOrient(EBoxOrient o) { SET_VAR(rareNonInheritedData.access()->flexibleBox, orient, o); }
950     void setBoxPack(EBoxAlignment p) { SET_VAR(rareNonInheritedData.access()->flexibleBox, pack, p); }
951     void setBoxShadow(ShadowData* val, bool add=false);
952     void setBoxReflect(PassRefPtr<StyleReflection> reflect) { if (rareNonInheritedData->m_boxReflect != reflect) rareNonInheritedData.access()->m_boxReflect = reflect; }
953     void setBoxSizing(EBoxSizing s) { SET_VAR(box, boxSizing, s); }
954     void setMarqueeIncrement(const Length& f) { SET_VAR(rareNonInheritedData.access()->marquee, increment, f); }
955     void setMarqueeSpeed(int f) { SET_VAR(rareNonInheritedData.access()->marquee, speed, f); }
956     void setMarqueeDirection(EMarqueeDirection d) { SET_VAR(rareNonInheritedData.access()->marquee, direction, d); }
957     void setMarqueeBehavior(EMarqueeBehavior b) { SET_VAR(rareNonInheritedData.access()->marquee, behavior, b); }
958     void setMarqueeLoopCount(int i) { SET_VAR(rareNonInheritedData.access()->marquee, loops, i); }
959     void setUserModify(EUserModify u) { SET_VAR(rareInheritedData, userModify, u); }
960     void setUserDrag(EUserDrag d) { SET_VAR(rareNonInheritedData, userDrag, d); }
961     void setUserSelect(EUserSelect s) { SET_VAR(rareInheritedData, userSelect, s); }
962     void setTextOverflow(bool b) { SET_VAR(rareNonInheritedData, textOverflow, b); }
963     void setMarginTopCollapse(EMarginCollapse c) { SET_VAR(rareNonInheritedData, marginTopCollapse, c); }
964     void setMarginBottomCollapse(EMarginCollapse c) { SET_VAR(rareNonInheritedData, marginBottomCollapse, c); }
965     void setWordBreak(EWordBreak b) { SET_VAR(rareInheritedData, wordBreak, b); }
966     void setWordWrap(EWordWrap b) { SET_VAR(rareInheritedData, wordWrap, b); }
967     void setNBSPMode(ENBSPMode b) { SET_VAR(rareInheritedData, nbspMode, b); }
968     void setKHTMLLineBreak(EKHTMLLineBreak b) { SET_VAR(rareInheritedData, khtmlLineBreak, b); }
969     void setMatchNearestMailBlockquoteColor(EMatchNearestMailBlockquoteColor c) { SET_VAR(rareNonInheritedData, matchNearestMailBlockquoteColor, c); }
970     void setHighlight(const AtomicString& h) { SET_VAR(rareInheritedData, highlight, h); }
971     void setBorderFit(EBorderFit b) { SET_VAR(rareNonInheritedData, m_borderFit, b); }
972     void setResize(EResize r) { SET_VAR(rareInheritedData, resize, r); }
973     void setColumnWidth(float f) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_autoWidth, false); SET_VAR(rareNonInheritedData.access()->m_multiCol, m_width, f); }
974     void setHasAutoColumnWidth() { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_autoWidth, true); SET_VAR(rareNonInheritedData.access()->m_multiCol, m_width, 0); }
975     void setColumnCount(unsigned short c) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_autoCount, false); SET_VAR(rareNonInheritedData.access()->m_multiCol, m_count, c); }
976     void setHasAutoColumnCount() { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_autoCount, true); SET_VAR(rareNonInheritedData.access()->m_multiCol, m_count, 0); }
977     void setColumnGap(float f) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_normalGap, false); SET_VAR(rareNonInheritedData.access()->m_multiCol, m_gap, f); }
978     void setHasNormalColumnGap() { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_normalGap, true); SET_VAR(rareNonInheritedData.access()->m_multiCol, m_gap, 0); }
979     void setColumnRuleColor(const Color& c) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_rule.color, c); }
980     void setColumnRuleStyle(EBorderStyle b) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_rule.m_style, b); }
981     void setColumnRuleWidth(unsigned short w) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_rule.width, w); }
982     void resetColumnRule() { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_rule, BorderValue()) }
983     void setColumnBreakBefore(EPageBreak p) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_breakBefore, p); }
984     void setColumnBreakInside(EPageBreak p) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_breakInside, p); }
985     void setColumnBreakAfter(EPageBreak p) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_breakAfter, p); }
986     void setTransform(const TransformOperations& ops) { SET_VAR(rareNonInheritedData.access()->m_transform, m_operations, ops); }
987     void setTransformOriginX(Length l) { SET_VAR(rareNonInheritedData.access()->m_transform, m_x, l); }
988     void setTransformOriginY(Length l) { SET_VAR(rareNonInheritedData.access()->m_transform, m_y, l); }
989     void setTransformOriginZ(float f) { SET_VAR(rareNonInheritedData.access()->m_transform, m_z, f); }
990     // End CSS3 Setters
991
992     // Apple-specific property setters
993     void setPointerEvents(EPointerEvents p) { inherited_flags._pointerEvents = p; }
994
995     void clearAnimations()
996     {
997         rareNonInheritedData.access()->m_animations.clear();
998     }
999
1000     void clearTransitions()
1001     {
1002         rareNonInheritedData.access()->m_transitions.clear();
1003     }
1004
1005     void inheritAnimations(const AnimationList* parent) { rareNonInheritedData.access()->m_animations.set(parent ? new AnimationList(*parent) : 0); }
1006     void inheritTransitions(const AnimationList* parent) { rareNonInheritedData.access()->m_transitions.set(parent ? new AnimationList(*parent) : 0); }
1007     void adjustAnimations();
1008     void adjustTransitions();
1009
1010     void setTransformStyle3D(ETransformStyle3D b) { SET_VAR(rareNonInheritedData, m_transformStyle3D, b); }
1011     void setBackfaceVisibility(EBackfaceVisibility b) { SET_VAR(rareNonInheritedData, m_backfaceVisibility, b); }
1012     void setPerspective(float p) { SET_VAR(rareNonInheritedData, m_perspective, p); }
1013     void setPerspectiveOriginX(Length l) { SET_VAR(rareNonInheritedData, m_perspectiveOriginX, l); }
1014     void setPerspectiveOriginY(Length l) { SET_VAR(rareNonInheritedData, m_perspectiveOriginY, l); }
1015
1016 #if USE(ACCELERATED_COMPOSITING)
1017     void setIsRunningAcceleratedAnimation(bool b = true) { SET_VAR(rareNonInheritedData, m_runningAcceleratedAnimation, b); }
1018 #endif
1019
1020     void setLineClamp(LineClampValue c) { SET_VAR(rareNonInheritedData, lineClamp, c); }
1021     void setTextSizeAdjust(bool b) { SET_VAR(rareInheritedData, textSizeAdjust, b); }
1022     void setTextSecurity(ETextSecurity aTextSecurity) { SET_VAR(rareInheritedData, textSecurity, aTextSecurity); }
1023
1024 #if ENABLE(SVG)
1025     const SVGRenderStyle* svgStyle() const { return m_svgStyle.get(); }
1026     SVGRenderStyle* accessSVGStyle() { return m_svgStyle.access(); }
1027     
1028     float fillOpacity() const { return svgStyle()->fillOpacity(); }
1029     void setFillOpacity(float f) { accessSVGStyle()->setFillOpacity(f); }
1030     
1031     float strokeOpacity() const { return svgStyle()->strokeOpacity(); }
1032     void setStrokeOpacity(float f) { accessSVGStyle()->setStrokeOpacity(f); }
1033     
1034     float floodOpacity() const { return svgStyle()->floodOpacity(); }
1035     void setFloodOpacity(float f) { accessSVGStyle()->setFloodOpacity(f); }
1036 #endif
1037
1038     const ContentData* contentData() const { return rareNonInheritedData->m_content.get(); }
1039     bool contentDataEquivalent(const RenderStyle* otherStyle) const { return const_cast<RenderStyle*>(this)->rareNonInheritedData->contentDataEquivalent(*const_cast<RenderStyle*>(otherStyle)->rareNonInheritedData); }
1040     void clearContent();
1041     void setContent(PassRefPtr<StringImpl>, bool add = false);
1042     void setContent(PassRefPtr<StyleImage>, bool add = false);
1043     void setContent(CounterContent*, bool add = false);
1044
1045     const CounterDirectiveMap* counterDirectives() const;
1046     CounterDirectiveMap& accessCounterDirectives();
1047
1048     bool inheritedNotEqual(const RenderStyle*) const;
1049
1050     StyleDifference diff(const RenderStyle*, unsigned& changedContextSensitiveProperties) const;
1051
1052     bool isDisplayReplacedType() const
1053     {
1054         return display() == INLINE_BLOCK || display() == INLINE_BOX || display() == INLINE_TABLE;
1055     }
1056
1057     bool isDisplayInlineType() const
1058     {
1059         return display() == INLINE || isDisplayReplacedType();
1060     }
1061
1062     bool isOriginalDisplayInlineType() const
1063     {
1064         return originalDisplay() == INLINE || originalDisplay() == INLINE_BLOCK ||
1065                originalDisplay() == INLINE_BOX || originalDisplay() == INLINE_TABLE;
1066     }
1067
1068     // To obtain at any time the pseudo state for a given link.
1069     PseudoState pseudoState() const { return static_cast<PseudoState>(m_pseudoState); }
1070     void setPseudoState(PseudoState s) { m_pseudoState = s; }
1071
1072     // To tell if this style matched attribute selectors. This makes it impossible to share.
1073     bool affectedByAttributeSelectors() const { return m_affectedByAttributeSelectors; }
1074     void setAffectedByAttributeSelectors() { m_affectedByAttributeSelectors = true; }
1075
1076     bool unique() const { return m_unique; }
1077     void setUnique() { m_unique = true; }
1078
1079     // Methods for indicating the style is affected by dynamic updates (e.g., children changing, our position changing in our sibling list, etc.)
1080     bool affectedByEmpty() const { return m_affectedByEmpty; }
1081     bool emptyState() const { return m_emptyState; }
1082     void setEmptyState(bool b) { m_affectedByEmpty = true; m_unique = true; m_emptyState = b; }
1083     bool childrenAffectedByPositionalRules() const { return childrenAffectedByForwardPositionalRules() || childrenAffectedByBackwardPositionalRules(); }
1084     bool childrenAffectedByFirstChildRules() const { return m_childrenAffectedByFirstChildRules; }
1085     void setChildrenAffectedByFirstChildRules() { m_childrenAffectedByFirstChildRules = true; }
1086     bool childrenAffectedByLastChildRules() const { return m_childrenAffectedByLastChildRules; }
1087     void setChildrenAffectedByLastChildRules() { m_childrenAffectedByLastChildRules = true; }
1088     bool childrenAffectedByDirectAdjacentRules() const { return m_childrenAffectedByDirectAdjacentRules; }
1089     void setChildrenAffectedByDirectAdjacentRules() { m_childrenAffectedByDirectAdjacentRules = true; }
1090     bool childrenAffectedByForwardPositionalRules() const { return m_childrenAffectedByForwardPositionalRules; }
1091     void setChildrenAffectedByForwardPositionalRules() { m_childrenAffectedByForwardPositionalRules = true; }
1092     bool childrenAffectedByBackwardPositionalRules() const { return m_childrenAffectedByBackwardPositionalRules; }
1093     void setChildrenAffectedByBackwardPositionalRules() { m_childrenAffectedByBackwardPositionalRules = true; }
1094     bool firstChildState() const { return m_firstChildState; }
1095     void setFirstChildState() { m_firstChildState = true; }
1096     bool lastChildState() const { return m_lastChildState; }
1097     void setLastChildState() { m_lastChildState = true; }
1098     unsigned childIndex() const { return m_childIndex; }
1099     void setChildIndex(unsigned index) { m_childIndex = index; }
1100
1101     // Initial values for all the properties
1102     static bool initialBorderCollapse() { return false; }
1103     static EBorderStyle initialBorderStyle() { return BNONE; }
1104     static NinePieceImage initialNinePieceImage() { return NinePieceImage(); }
1105     static IntSize initialBorderRadius() { return IntSize(0, 0); }
1106     static ECaptionSide initialCaptionSide() { return CAPTOP; }
1107     static EClear initialClear() { return CNONE; }
1108     static TextDirection initialDirection() { return LTR; }
1109     static EDisplay initialDisplay() { return INLINE; }
1110     static EEmptyCell initialEmptyCells() { return SHOW; }
1111     static EFloat initialFloating() { return FNONE; }
1112     static EListStylePosition initialListStylePosition() { return OUTSIDE; }
1113     static EListStyleType initialListStyleType() { return Disc; }
1114     static EOverflow initialOverflowX() { return OVISIBLE; }
1115     static EOverflow initialOverflowY() { return OVISIBLE; }
1116     static EPageBreak initialPageBreak() { return PBAUTO; }
1117     static EPosition initialPosition() { return StaticPosition; }
1118     static ETableLayout initialTableLayout() { return TAUTO; }
1119     static EUnicodeBidi initialUnicodeBidi() { return UBNormal; }
1120     static ETextTransform initialTextTransform() { return TTNONE; }
1121     static EVisibility initialVisibility() { return VISIBLE; }
1122     static EWhiteSpace initialWhiteSpace() { return NORMAL; }
1123     static short initialHorizontalBorderSpacing() { return 0; }
1124     static short initialVerticalBorderSpacing() { return 0; }
1125     static ECursor initialCursor() { return CURSOR_AUTO; }
1126     static Color initialColor() { return Color::black; }
1127     static StyleImage* initialListStyleImage() { return 0; }
1128     static unsigned short initialBorderWidth() { return 3; }
1129     static int initialLetterWordSpacing() { return 0; }
1130     static Length initialSize() { return Length(); }
1131     static Length initialMinSize() { return Length(0, Fixed); }
1132     static Length initialMaxSize() { return Length(undefinedLength, Fixed); }
1133     static Length initialOffset() { return Length(); }
1134     static Length initialMargin() { return Length(Fixed); }
1135     static Length initialPadding() { return Length(Fixed); }
1136     static Length initialTextIndent() { return Length(Fixed); }
1137     static EVerticalAlign initialVerticalAlign() { return BASELINE; }
1138     static int initialWidows() { return 2; }
1139     static int initialOrphans() { return 2; }
1140     static Length initialLineHeight() { return Length(-100.0, Percent); }
1141     static ETextAlign initialTextAlign() { return TAAUTO; }
1142     static ETextDecoration initialTextDecoration() { return TDNONE; }
1143     static float initialZoom() { return 1.0f; }
1144     static int initialOutlineOffset() { return 0; }
1145     static float initialOpacity() { return 1.0f; }
1146     static EBoxAlignment initialBoxAlign() { return BSTRETCH; }
1147     static EBoxDirection initialBoxDirection() { return BNORMAL; }
1148     static EBoxLines initialBoxLines() { return SINGLE; }
1149     static EBoxOrient initialBoxOrient() { return HORIZONTAL; }
1150     static EBoxAlignment initialBoxPack() { return BSTART; }
1151     static float initialBoxFlex() { return 0.0f; }
1152     static int initialBoxFlexGroup() { return 1; }
1153     static int initialBoxOrdinalGroup() { return 1; }
1154     static EBoxSizing initialBoxSizing() { return CONTENT_BOX; }
1155     static StyleReflection* initialBoxReflect() { return 0; }
1156     static int initialMarqueeLoopCount() { return -1; }
1157     static int initialMarqueeSpeed() { return 85; }
1158     static Length initialMarqueeIncrement() { return Length(6, Fixed); }
1159     static EMarqueeBehavior initialMarqueeBehavior() { return MSCROLL; }
1160     static EMarqueeDirection initialMarqueeDirection() { return MAUTO; }
1161     static EUserModify initialUserModify() { return READ_ONLY; }
1162     static EUserDrag initialUserDrag() { return DRAG_AUTO; }
1163     static EUserSelect initialUserSelect() { return SELECT_TEXT; }
1164     static bool initialTextOverflow() { return false; }
1165     static EMarginCollapse initialMarginTopCollapse() { return MCOLLAPSE; }
1166     static EMarginCollapse initialMarginBottomCollapse() { return MCOLLAPSE; }
1167     static EWordBreak initialWordBreak() { return NormalWordBreak; }
1168     static EWordWrap initialWordWrap() { return NormalWordWrap; }
1169     static ENBSPMode initialNBSPMode() { return NBNORMAL; }
1170     static EKHTMLLineBreak initialKHTMLLineBreak() { return LBNORMAL; }
1171     static EMatchNearestMailBlockquoteColor initialMatchNearestMailBlockquoteColor() { return BCNORMAL; }
1172     static const AtomicString& initialHighlight() { return nullAtom; }
1173     static EBorderFit initialBorderFit() { return BorderFitBorder; }
1174     static EResize initialResize() { return RESIZE_NONE; }
1175     static ControlPart initialAppearance() { return NoControlPart; }
1176     static bool initialVisuallyOrdered() { return false; }
1177     static float initialTextStrokeWidth() { return 0; }
1178     static unsigned short initialColumnCount() { return 1; }
1179     static const TransformOperations& initialTransform() { DEFINE_STATIC_LOCAL(TransformOperations, ops, ()); return ops; }
1180     static Length initialTransformOriginX() { return Length(50.0, Percent); }
1181     static Length initialTransformOriginY() { return Length(50.0, Percent); }
1182     static EPointerEvents initialPointerEvents() { return PE_AUTO; }
1183     static float initialTransformOriginZ() { return 0; }
1184     static ETransformStyle3D initialTransformStyle3D() { return TransformStyle3DFlat; }
1185     static EBackfaceVisibility initialBackfaceVisibility() { return BackfaceVisibilityVisible; }
1186     static float initialPerspective() { return 0; }
1187     static Length initialPerspectiveOriginX() { return Length(50.0, Percent); }
1188     static Length initialPerspectiveOriginY() { return Length(50.0, Percent); }
1189     static Color initialBackgroundColor() { return Color::transparent; }
1190
1191     // Keep these at the end.
1192     static LineClampValue initialLineClamp() { return LineClampValue(); }
1193     static bool initialTextSizeAdjust() { return true; }
1194     static ETextSecurity initialTextSecurity() { return TSNONE; }
1195 #if ENABLE(DASHBOARD_SUPPORT)
1196     static const Vector<StyleDashboardRegion>& initialDashboardRegions();
1197     static const Vector<StyleDashboardRegion>& noneDashboardRegions();
1198 #endif
1199 };
1200
1201 } // namespace WebCore
1202
1203 #endif // RenderStyle_h