a1bd5cc75a4e5a6a2d46b45da0c00741b35f79be
[WebKit-https.git] / WebCore / rendering / RenderStyle.h
1 /*
2  * This file is part of the DOM implementation for KDE.
3  *
4  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
5  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
6  *           (C) 2000 Dirk Mueller (mueller@kde.org)
7  * Copyright (C) 2003, 2005, 2006, 2007 Apple Inc. All rights reserved.
8  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
9  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Library General Public
12  * License as published by the Free Software Foundation; either
13  * version 2 of the License, or (at your option) any later version.
14  *
15  * This library is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Library General Public License for more details.
19  *
20  * You should have received a copy of the GNU Library General Public License
21  * along with this library; see the file COPYING.LIB.  If not, write to
22  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
23  * Boston, MA 02110-1301, USA.
24  *
25  */
26
27 #ifndef RenderStyle_h
28 #define RenderStyle_h
29
30 /*
31  * WARNING:
32  * --------
33  *
34  * The order of the values in the enums have to agree with the order specified
35  * in CSSValueKeywords.in, otherwise some optimizations in the parser will fail,
36  * and produce invaliud results.
37  */
38
39 #include "AffineTransform.h"
40 #include "CSSHelper.h"
41 #include "CSSPrimitiveValue.h"
42 #include "CSSValueList.h"
43 #include "Color.h"
44 #include "CSSCursorImageValue.h"
45 #include "CSSTransformValue.h"
46 #include "DataRef.h"
47 #include "Font.h"
48 #include "FloatPoint.h"
49 #include "GraphicsTypes.h"
50 #include "IntRect.h"
51 #include "Length.h"
52 #include "Pair.h"
53 #include <wtf/RefCounted.h>
54 #include "TextDirection.h"
55 #include <wtf/HashMap.h>
56 #include <wtf/Vector.h>
57
58 #if ENABLE(SVG)
59 #include "SVGRenderStyle.h"
60 #endif
61
62 template<typename T, typename U> inline bool compareEqual(const T& t, const U& u) { return t == static_cast<T>(u); }
63
64 #define SET_VAR(group, variable, value) \
65     if (!compareEqual(group->variable, value)) \
66         group.access()->variable = value;
67
68 namespace WebCore {
69
70 using std::max;
71
72 class CSSStyleSelector;
73 class CSSValueList;
74 class CachedImage;
75 class CachedResource;
76 class CursorList;
77 class Pair;
78 class RenderArena;
79 class ShadowValue;
80 class StringImpl;
81
82 struct CursorData;
83
84 enum PseudoState { PseudoUnknown, PseudoNone, PseudoAnyLink, PseudoLink, PseudoVisited};
85
86 //------------------------------------------------
87
88 //------------------------------------------------
89 // Box model attributes. Not inherited.
90
91 struct LengthBox {
92     LengthBox() { }
93     LengthBox(LengthType t)
94         : left(t), right(t), top(t), bottom(t) { }
95
96     Length left;
97     Length right;
98     Length top;
99     Length bottom;
100
101     LengthBox& operator=(const Length& len)
102     {
103         left = len;
104         right = len;
105         top = len;
106         bottom = len;
107         return *this;
108     }
109
110     bool operator==(const LengthBox& o) const
111     {
112         return left == o.left && right == o.right && top == o.top && bottom == o.bottom;
113     }
114
115     bool operator!=(const LengthBox& o) const
116     {
117         return !(*this == o);
118     }
119
120     bool nonZero() const { return !(left.isZero() && right.isZero() && top.isZero() && bottom.isZero()); }
121 };
122
123 enum EPosition {
124     StaticPosition, RelativePosition, AbsolutePosition, FixedPosition
125 };
126
127 enum EFloat {
128     FNONE = 0, FLEFT, FRIGHT
129 };
130
131 //------------------------------------------------
132 // Border attributes. Not inherited.
133
134 // These have been defined in the order of their precedence for border-collapsing. Do
135 // not change this order!
136 enum EBorderStyle {
137     BNONE, BHIDDEN, INSET, GROOVE, RIDGE, OUTSET, DOTTED, DASHED, SOLID, DOUBLE
138 };
139
140 class BorderValue {
141 public:
142     BorderValue() {
143         width = 3; // medium is default value
144         m_style = BNONE;
145     }
146
147     Color color;
148     unsigned width : 12;
149     unsigned m_style : 4; // EBorderStyle 
150
151     EBorderStyle style() const { return static_cast<EBorderStyle>(m_style); }
152     
153     bool nonZero(bool checkStyle = true) const {
154         return width != 0 && (!checkStyle || m_style != BNONE);
155     }
156
157     bool isTransparent() const {
158         return color.isValid() && color.alpha() == 0;
159     }
160
161     bool isVisible(bool checkStyle = true) const {
162         return nonZero(checkStyle) && !isTransparent() && (!checkStyle || m_style != BHIDDEN);
163     }
164
165     bool operator==(const BorderValue& o) const
166     {
167         return width == o.width && m_style == o.m_style && color == o.color;
168     }
169
170     bool operator!=(const BorderValue& o) const
171     {
172         return !(*this == o);
173     }
174 };
175
176 class OutlineValue : public BorderValue {
177 public:
178     OutlineValue()
179     {
180         _offset = 0;
181         _auto = false;
182     }
183     
184     bool operator==(const OutlineValue& o) const
185     {
186         return width == o.width && m_style == o.m_style && color == o.color && _offset == o._offset && _auto == o._auto;
187     }
188     
189     bool operator!=(const OutlineValue& o) const
190     {
191         return !(*this == o);
192     }
193     
194     int _offset;
195     bool _auto;
196 };
197
198 enum EBorderPrecedence { BOFF, BTABLE, BCOLGROUP, BCOL, BROWGROUP, BROW, BCELL };
199
200 struct CollapsedBorderValue {
201     CollapsedBorderValue() : border(0), precedence(BOFF) {}
202     CollapsedBorderValue(const BorderValue* b, EBorderPrecedence p) :border(b), precedence(p) {}
203     
204     int width() const { return border && border->nonZero() ? border->width : 0; }
205     EBorderStyle style() const { return border ? border->style() : BHIDDEN; }
206     bool exists() const { return border; }
207     Color color() const { return border ? border->color : Color(); }
208     bool isTransparent() const { return border ? border->isTransparent() : true; }
209     
210     bool operator==(const CollapsedBorderValue& o) const
211     {
212         if (!border) return !o.border;
213         if (!o.border) return false;
214         return *border == *o.border && precedence == o.precedence;
215     }
216     
217     const BorderValue* border;
218     EBorderPrecedence precedence;    
219 };
220
221 enum EBorderImageRule {
222     BI_STRETCH, BI_ROUND, BI_REPEAT
223 };
224
225 class BorderImage {
226 public:
227     BorderImage() :m_image(0), m_horizontalRule(BI_STRETCH), m_verticalRule(BI_STRETCH) {}
228     BorderImage(CachedImage* image, LengthBox slices, EBorderImageRule h, EBorderImageRule v) 
229       :m_image(image), m_slices(slices), m_horizontalRule(h), m_verticalRule(v) {}
230
231     bool operator==(const BorderImage& o) const
232     {
233         return m_image == o.m_image && m_slices == o.m_slices && m_horizontalRule == o.m_horizontalRule &&
234                m_verticalRule == o.m_verticalRule;
235     }
236
237     bool hasImage() const { return m_image != 0; }
238     CachedImage* image() const { return m_image; }
239     
240     EBorderImageRule horizontalRule() const { return static_cast<EBorderImageRule>(m_horizontalRule); }
241     EBorderImageRule verticalRule() const { return static_cast<EBorderImageRule>(m_verticalRule); }
242     
243     CachedImage* m_image;
244     LengthBox m_slices;
245     unsigned m_horizontalRule : 2; // EBorderImageRule
246     unsigned m_verticalRule : 2; // EBorderImageRule
247 };
248
249 class BorderData {
250 public:
251     BorderValue left;
252     BorderValue right;
253     BorderValue top;
254     BorderValue bottom;
255     
256     BorderImage image;
257
258     IntSize topLeft;
259     IntSize topRight;
260     IntSize bottomLeft;
261     IntSize bottomRight;
262
263     bool hasBorder() const
264     {
265         bool haveImage = image.hasImage();
266         return left.nonZero(!haveImage) || right.nonZero(!haveImage) || top.nonZero(!haveImage) || bottom.nonZero(!haveImage);
267     }
268
269     bool hasBorderRadius() const {
270         if (topLeft.width() > 0)
271             return true;
272         if (topRight.width() > 0)
273             return true;
274         if (bottomLeft.width() > 0)
275             return true;
276         if (bottomRight.width() > 0)
277             return true;
278         return false;
279     }
280     
281     unsigned short borderLeftWidth() const {
282         if (!image.hasImage() && (left.style() == BNONE || left.style() == BHIDDEN))
283             return 0; 
284         return left.width;
285     }
286     
287     unsigned short borderRightWidth() const {
288         if (!image.hasImage() && (right.style() == BNONE || right.style() == BHIDDEN))
289             return 0;
290         return right.width;
291     }
292     
293     unsigned short borderTopWidth() const {
294         if (!image.hasImage() && (top.style() == BNONE || top.style() == BHIDDEN))
295             return 0;
296         return top.width;
297     }
298     
299     unsigned short borderBottomWidth() const {
300         if (!image.hasImage() && (bottom.style() == BNONE || bottom.style() == BHIDDEN))
301             return 0;
302         return bottom.width;
303     }
304     
305     bool operator==(const BorderData& o) const
306     {
307         return left == o.left && right == o.right && top == o.top && bottom == o.bottom && image == o.image &&
308                topLeft == o.topLeft && topRight == o.topRight && bottomLeft == o.bottomLeft && bottomRight == o.bottomRight;
309     }
310     
311     bool operator!=(const BorderData& o) const {
312         return !(*this == o);
313     }
314 };
315
316 enum EMarginCollapse { MCOLLAPSE, MSEPARATE, MDISCARD };
317
318 class StyleSurroundData : public RefCounted<StyleSurroundData> {
319 public:
320     StyleSurroundData();
321     StyleSurroundData(const StyleSurroundData& o);
322     
323     bool operator==(const StyleSurroundData& o) const;
324     bool operator!=(const StyleSurroundData& o) const {
325         return !(*this == o);
326     }
327
328     LengthBox offset;
329     LengthBox margin;
330     LengthBox padding;
331     BorderData border;
332 };
333
334
335 //------------------------------------------------
336 // Box attributes. Not inherited.
337
338 enum EBoxSizing { CONTENT_BOX, BORDER_BOX };
339
340 class StyleBoxData : public RefCounted<StyleBoxData> {
341 public:
342     StyleBoxData();
343     StyleBoxData(const StyleBoxData& o);
344
345     // copy and assignment
346 //    StyleBoxData(const StyleBoxData &other);
347 //    const StyleBoxData &operator = (const StyleBoxData &other);
348
349     bool operator==(const StyleBoxData& o) const;
350     bool operator!=(const StyleBoxData& o) const {
351         return !(*this == o);
352     }
353
354     Length width;
355     Length height;
356
357     Length min_width;
358     Length max_width;
359
360     Length min_height;
361     Length max_height;
362
363     Length vertical_align;
364
365     int z_index;
366     bool z_auto : 1;
367     unsigned boxSizing : 1; // EBoxSizing
368 };
369
370 //------------------------------------------------
371 // Dashboard region attributes. Not inherited.
372
373 struct StyleDashboardRegion {
374     String label;
375     LengthBox offset;
376     int type;
377     
378     enum {
379         None,
380         Circle,
381         Rectangle
382     };
383
384     bool operator==(const StyleDashboardRegion& o) const
385     {
386         return type == o.type && offset == o.offset && label == o.label;
387     }
388
389    bool operator!=(const StyleDashboardRegion& o) const
390    {
391        return !(*this == o);
392    }
393 };
394
395 //------------------------------------------------
396 // Random visual rendering model attributes. Not inherited.
397
398 enum EOverflow {
399     OVISIBLE, OHIDDEN, OSCROLL, OAUTO, OOVERLAY, OMARQUEE
400 };
401
402 enum EVerticalAlign {
403     BASELINE, MIDDLE, SUB, SUPER, TEXT_TOP,
404     TEXT_BOTTOM, TOP, BOTTOM, BASELINE_MIDDLE, LENGTH
405 };
406
407 enum EClear{
408     CNONE = 0, CLEFT = 1, CRIGHT = 2, CBOTH = 3
409 };
410
411 enum ETableLayout {
412     TAUTO, TFIXED
413 };
414
415 enum EUnicodeBidi {
416     UBNormal, Embed, Override
417 };
418
419 class StyleVisualData : public RefCounted<StyleVisualData> {
420 public:
421     StyleVisualData();
422     ~StyleVisualData();
423     StyleVisualData(const StyleVisualData&);
424
425     bool operator==(const StyleVisualData& o) const {
426         return ( clip == o.clip &&
427                  hasClip == o.hasClip &&
428                  counterIncrement == o.counterIncrement &&
429                  counterReset == o.counterReset &&
430                  textDecoration == o.textDecoration);
431     }
432     bool operator!=(const StyleVisualData& o) const { return !(*this == o); }
433
434     LengthBox clip;
435     bool hasClip : 1;
436     unsigned textDecoration : 4; // Text decorations defined *only* by this element.
437
438     short counterIncrement; // ok, so these are not visual mode specific
439     short counterReset;     // can't go to inherited, since these are not inherited
440
441 };
442
443 //------------------------------------------------
444 enum EBackgroundBox {
445     BGBORDER, BGPADDING, BGCONTENT
446 };
447
448 enum EBackgroundRepeat {
449     REPEAT, REPEAT_X, REPEAT_Y, NO_REPEAT
450 };
451
452 struct LengthSize {
453     Length width;
454     Length height;
455 };
456
457 struct BackgroundLayer {
458 public:
459     BackgroundLayer();
460     ~BackgroundLayer();
461
462     CachedImage* backgroundImage() const { return m_image; }
463     Length backgroundXPosition() const { return m_xPosition; }
464     Length backgroundYPosition() const { return m_yPosition; }
465     bool backgroundAttachment() const { return m_bgAttachment; }
466     EBackgroundBox backgroundClip() const { return static_cast<EBackgroundBox>(m_bgClip); }
467     EBackgroundBox backgroundOrigin() const { return static_cast<EBackgroundBox>(m_bgOrigin); }
468     EBackgroundRepeat backgroundRepeat() const { return static_cast<EBackgroundRepeat>(m_bgRepeat); }
469     CompositeOperator backgroundComposite() const { return static_cast<CompositeOperator>(m_bgComposite); }
470     LengthSize backgroundSize() const { return m_backgroundSize; }
471
472     const BackgroundLayer* next() const { return m_next; }
473     BackgroundLayer* next() { return m_next; }
474
475     bool isBackgroundImageSet() const { return m_imageSet; }
476     bool isBackgroundXPositionSet() const { return m_xPosSet; }
477     bool isBackgroundYPositionSet() const { return m_yPosSet; }
478     bool isBackgroundAttachmentSet() const { return m_attachmentSet; }
479     bool isBackgroundClipSet() const { return m_clipSet; }
480     bool isBackgroundOriginSet() const { return m_originSet; }
481     bool isBackgroundRepeatSet() const { return m_repeatSet; }
482     bool isBackgroundCompositeSet() const { return m_compositeSet; }
483     bool isBackgroundSizeSet() const { return m_backgroundSizeSet; }
484     
485     void setBackgroundImage(CachedImage* i) { m_image = i; m_imageSet = true; }
486     void setBackgroundXPosition(const Length& l) { m_xPosition = l; m_xPosSet = true; }
487     void setBackgroundYPosition(const Length& l) { m_yPosition = l; m_yPosSet = true; }
488     void setBackgroundAttachment(bool b) { m_bgAttachment = b; m_attachmentSet = true; }
489     void setBackgroundClip(EBackgroundBox b) { m_bgClip = b; m_clipSet = true; }
490     void setBackgroundOrigin(EBackgroundBox b) { m_bgOrigin = b; m_originSet = true; }
491     void setBackgroundRepeat(EBackgroundRepeat r) { m_bgRepeat = r; m_repeatSet = true; }
492     void setBackgroundComposite(CompositeOperator c) { m_bgComposite = c; m_compositeSet = true; }
493     void setBackgroundSize(const LengthSize& b) { m_backgroundSize = b; m_backgroundSizeSet = true; }
494     
495     void clearBackgroundImage() { m_imageSet = false; }
496     void clearBackgroundXPosition() { m_xPosSet = false; }
497     void clearBackgroundYPosition() { m_yPosSet = false; }
498     void clearBackgroundAttachment() { m_attachmentSet = false; }
499     void clearBackgroundClip() { m_clipSet = false; }
500     void clearBackgroundOrigin() { m_originSet = false; }
501     void clearBackgroundRepeat() { m_repeatSet = false; }
502     void clearBackgroundComposite() { m_compositeSet = false; }
503     void clearBackgroundSize() { m_backgroundSizeSet = false; }
504
505     void setNext(BackgroundLayer* n) { if (m_next != n) { delete m_next; m_next = n; } }
506
507     BackgroundLayer& operator=(const BackgroundLayer& o);    
508     BackgroundLayer(const BackgroundLayer& o);
509
510     bool operator==(const BackgroundLayer& o) const;
511     bool operator!=(const BackgroundLayer& o) const {
512         return !(*this == o);
513     }
514
515     bool containsImage(CachedImage* c) const { if (c == m_image) return true; if (m_next) return m_next->containsImage(c); return false; }
516     
517     bool hasImage() const {
518         if (m_image)
519             return true;
520         return m_next ? m_next->hasImage() : false;
521     }
522     bool hasFixedImage() const {
523         if (m_image && !m_bgAttachment)
524             return true;
525         return m_next ? m_next->hasFixedImage() : false;
526     }
527
528     void fillUnsetProperties();
529     void cullEmptyLayers();
530
531     CachedImage* m_image;
532
533     Length m_xPosition;
534     Length m_yPosition;
535
536     bool m_bgAttachment : 1;
537     unsigned m_bgClip : 2; // EBackgroundBox
538     unsigned m_bgOrigin : 2; // EBackgroundBox
539     unsigned m_bgRepeat : 2; // EBackgroundRepeat
540     unsigned m_bgComposite : 2; // CompositeOperator
541
542     LengthSize m_backgroundSize;
543
544     bool m_imageSet : 1;
545     bool m_attachmentSet : 1;
546     bool m_clipSet : 1;
547     bool m_originSet : 1;
548     bool m_repeatSet : 1;
549     bool m_xPosSet : 1;
550     bool m_yPosSet : 1;
551     bool m_compositeSet : 1;
552     bool m_backgroundSizeSet : 1;
553
554     BackgroundLayer* m_next;
555 };
556
557 class StyleBackgroundData : public RefCounted<StyleBackgroundData> {
558 public:
559     StyleBackgroundData();
560     ~StyleBackgroundData() {}
561     StyleBackgroundData(const StyleBackgroundData& o );
562
563     bool operator==(const StyleBackgroundData& o) const;
564     bool operator!=(const StyleBackgroundData &o) const {
565         return !(*this == o);
566     }
567
568     BackgroundLayer m_background;
569     Color m_color;
570     OutlineValue m_outline;
571 };
572
573 //------------------------------------------------
574 // CSS3 Marquee Properties
575
576 enum EMarqueeBehavior { MNONE, MSCROLL, MSLIDE, MALTERNATE };
577 enum EMarqueeDirection { MAUTO = 0, MLEFT = 1, MRIGHT = -1, MUP = 2, MDOWN = -2, MFORWARD = 3, MBACKWARD = -3 };
578
579 class StyleMarqueeData : public RefCounted<StyleMarqueeData> {
580 public:
581     StyleMarqueeData();
582     StyleMarqueeData(const StyleMarqueeData& o);
583     
584     bool operator==(const StyleMarqueeData& o) const;
585     bool operator!=(const StyleMarqueeData& o) const {
586         return !(*this == o);
587     }
588     
589     Length increment;
590     int speed;
591     
592     int loops; // -1 means infinite.
593     
594     unsigned behavior : 3; // EMarqueeBehavior 
595     EMarqueeDirection direction : 3; // not unsigned because EMarqueeDirection has negative values
596 };
597   
598 // CSS3 Multi Column Layout
599
600 class StyleMultiColData : public RefCounted<StyleMultiColData> {
601 public:
602     StyleMultiColData();
603     StyleMultiColData(const StyleMultiColData& o);
604
605     bool operator==(const StyleMultiColData& o) const;
606     bool operator!=(const StyleMultiColData &o) const {
607         return !(*this == o);
608     }
609
610     unsigned short ruleWidth() const {
611         if (m_rule.style() == BNONE || m_rule.style() == BHIDDEN)
612             return 0; 
613         return m_rule.width;
614     }
615
616     float m_width;
617     unsigned short m_count;
618     float m_gap;
619     BorderValue m_rule;
620     
621     bool m_autoWidth : 1;
622     bool m_autoCount : 1;
623     bool m_normalGap : 1;
624     unsigned m_breakBefore : 2; // EPageBreak
625     unsigned m_breakAfter : 2; // EPageBreak
626     unsigned m_breakInside : 2; // EPageBreak
627 };
628
629 // CSS Transforms (may become part of CSS3)
630
631 class TransformOperation : public RefCounted<TransformOperation>
632 {
633 public:
634     virtual ~TransformOperation() {}
635     
636     virtual bool operator==(const TransformOperation&) const = 0;
637     bool operator!=(const TransformOperation& o) const { return !(*this == o); }
638
639     virtual void apply(AffineTransform&, const IntSize& borderBoxSize) = 0;
640     
641     virtual TransformOperation* blend(const TransformOperation* from, double progress, bool blendToIdentity = false) = 0;
642     
643     virtual bool isScaleOperation() const { return false; }
644     virtual bool isRotateOperation() const { return false; }
645     virtual bool isSkewOperation() const { return false; }
646     virtual bool isTranslateOperation() const { return false; }
647     virtual bool isMatrixOperation() const { return false; }
648 };
649
650 class ScaleTransformOperation : public TransformOperation
651 {
652 public:
653     ScaleTransformOperation(double sx, double sy)
654     : m_x(sx), m_y(sy)
655     {}
656         
657     virtual bool isScaleOperation() const { return true; }
658
659     virtual bool operator==(const TransformOperation& o) const
660     {
661         if (o.isScaleOperation()) {
662             const ScaleTransformOperation* s = static_cast<const ScaleTransformOperation*>(&o);
663             return m_x == s->m_x && m_y == s->m_y;
664         }
665         return false;
666     }
667
668     virtual void apply(AffineTransform& transform, const IntSize& borderBoxSize)
669     {
670         transform.scale(m_x, m_y);
671     }
672
673     virtual TransformOperation* blend(const TransformOperation* from, double progress, bool blendToIdentity = false);
674
675 private:
676     double m_x;
677     double m_y;
678 };
679
680 class RotateTransformOperation : public TransformOperation
681 {
682 public:
683     RotateTransformOperation(double angle)
684     : m_angle(angle)
685     {}
686
687     virtual bool isRotateOperation() const { return true; }
688
689     virtual bool operator==(const TransformOperation& o) const
690     {
691         if (o.isRotateOperation()) {
692             const RotateTransformOperation* r = static_cast<const RotateTransformOperation*>(&o);
693             return m_angle == r->m_angle;
694         }
695         return false;
696     }
697     
698     virtual void apply(AffineTransform& transform, const IntSize& borderBoxSize)
699     {
700         transform.rotate(m_angle);
701     }
702
703     virtual TransformOperation* blend(const TransformOperation* from, double progress, bool blendToIdentity = false);
704     
705 private:
706     double m_angle;
707 };
708
709 class SkewTransformOperation : public TransformOperation
710 {
711 public:
712     SkewTransformOperation(double angleX, double angleY)
713     : m_angleX(angleX), m_angleY(angleY)
714     {}
715     
716     virtual bool isSkewOperation() const { return true; }
717
718     virtual bool operator==(const TransformOperation& o) const
719     {
720         if (o.isSkewOperation()) {
721             const SkewTransformOperation* s = static_cast<const SkewTransformOperation*>(&o);
722             return m_angleX == s->m_angleX && m_angleY == s->m_angleY;
723         }
724         return false;
725     }
726
727     virtual void apply(AffineTransform& transform, const IntSize& borderBoxSize)
728     {
729         transform.skew(m_angleX, m_angleY);
730     }
731
732     virtual TransformOperation* blend(const TransformOperation* from, double progress, bool blendToIdentity = false);
733     
734 private:
735     double m_angleX;
736     double m_angleY;
737 };
738
739 class TranslateTransformOperation : public TransformOperation
740 {
741 public:
742     TranslateTransformOperation(const Length& tx, const Length& ty)
743     : m_x(tx), m_y(ty)
744     {}
745     
746     virtual bool isTranslateOperation() const { return true; }
747
748     virtual bool operator==(const TransformOperation& o) const
749     {
750         if (o.isTranslateOperation()) {
751             const TranslateTransformOperation* t = static_cast<const TranslateTransformOperation*>(&o);
752             return m_x == t->m_x && m_y == t->m_y;
753         }
754         return false;
755     }
756
757     virtual void apply(AffineTransform& transform, const IntSize& borderBoxSize)
758     {
759         transform.translate(m_x.calcValue(borderBoxSize.width()), m_y.calcValue(borderBoxSize.height()));
760     }
761
762     virtual TransformOperation* blend(const TransformOperation* from, double progress, bool blendToIdentity = false);
763
764 private:
765     Length m_x;
766     Length m_y;
767 };
768
769 class MatrixTransformOperation : public TransformOperation
770 {
771 public:
772     MatrixTransformOperation(double a, double b, double c, double d, double e, double f)
773     : m_a(a), m_b(b), m_c(c), m_d(d), m_e(e), m_f(f)
774     {}
775     
776     virtual bool isMatrixOperation() const { return true; }
777
778     virtual bool operator==(const TransformOperation& o) const
779     {
780         if (o.isMatrixOperation()) {
781             const MatrixTransformOperation* m = static_cast<const MatrixTransformOperation*>(&o);
782             return m_a == m->m_a && m_b == m->m_b && m_c == m->m_c && m_d == m->m_d && m_e == m->m_e && m_f == m->m_f;
783         }
784         return false;
785     }
786
787     virtual void apply(AffineTransform& transform, const IntSize& borderBoxSize)
788     {
789         AffineTransform matrix(m_a, m_b, m_c, m_d, m_e, m_f);
790         transform.multiply(matrix);
791     }
792
793     virtual TransformOperation* blend(const TransformOperation* from, double progress, bool blendToIdentity = false);
794     
795 private:
796     double m_a;
797     double m_b;
798     double m_c;
799     double m_d;
800     double m_e;
801     double m_f;
802 };
803
804 class TransformOperations
805 {
806 public:
807     bool operator==(const TransformOperations&) const;
808     bool operator!=(const TransformOperations& o) const {
809         return !(*this == o);
810     }
811     
812     bool isEmpty() const { return m_operations.isEmpty(); }
813     unsigned size() const { return m_operations.size(); }
814     const RefPtr<TransformOperation>& operator[](size_t i) const { return m_operations.at(i); }
815
816     void append(const RefPtr<TransformOperation>& op) { return m_operations.append(op); }
817
818 private:
819     Vector<RefPtr<TransformOperation> > m_operations;
820 };
821
822 class StyleTransformData : public RefCounted<StyleTransformData> {
823 public:
824     StyleTransformData();
825     StyleTransformData(const StyleTransformData&);
826
827     bool operator==(const StyleTransformData&) const;
828     bool operator!=(const StyleTransformData& o) const {
829         return !(*this == o);
830     }
831
832     TransformOperations m_operations;
833     Length m_x;
834     Length m_y;
835 };
836
837 //------------------------------------------------
838 // CSS3 Flexible Box Properties
839
840 enum EBoxAlignment { BSTRETCH, BSTART, BCENTER, BEND, BJUSTIFY, BBASELINE };
841 enum EBoxOrient { HORIZONTAL, VERTICAL };
842 enum EBoxLines { SINGLE, MULTIPLE };
843 enum EBoxDirection { BNORMAL, BREVERSE };
844
845 class StyleFlexibleBoxData : public RefCounted<StyleFlexibleBoxData> {
846 public:
847     StyleFlexibleBoxData();
848     StyleFlexibleBoxData(const StyleFlexibleBoxData& o);
849
850     bool operator==(const StyleFlexibleBoxData& o) const;
851     bool operator!=(const StyleFlexibleBoxData &o) const {
852         return !(*this == o);
853     }
854
855     float flex;
856     unsigned int flex_group;
857     unsigned int ordinal_group;
858
859     unsigned align : 3; // EBoxAlignment
860     unsigned pack: 3; // EBoxAlignment
861     unsigned orient: 1; // EBoxOrient
862     unsigned lines : 1; // EBoxLines
863 };
864
865 // This struct holds information about shadows for the text-shadow and box-shadow properties.
866 struct ShadowData {
867     ShadowData(int _x, int _y, int _blur, const Color& _color)
868     :x(_x), y(_y), blur(_blur), color(_color), next(0) {}
869     ShadowData(const ShadowData& o);
870     
871     ~ShadowData() { delete next; }
872
873     bool operator==(const ShadowData& o) const;
874     bool operator!=(const ShadowData &o) const {
875         return !(*this == o);
876     }
877     
878     int x;
879     int y;
880     int blur;
881     Color color;
882     ShadowData* next;
883 };
884
885 #if ENABLE(XBL)
886 struct BindingURI {
887     BindingURI(StringImpl*);
888     ~BindingURI();
889
890     BindingURI* copy();
891
892     bool operator==(const BindingURI& o) const;
893     bool operator!=(const BindingURI& o) const {
894         return !(*this == o);
895     }
896     
897     BindingURI* next() { return m_next; }
898     void setNext(BindingURI* n) { m_next = n; }
899     
900     StringImpl* uri() { return m_uri; }
901     
902     BindingURI* m_next;
903     StringImpl* m_uri;
904 };
905 #endif
906
907 //------------------------------------------------
908
909 enum ETextSecurity {
910     TSNONE, TSDISC, TSCIRCLE, TSSQUARE
911 };
912
913 // CSS3 User Modify Properties
914
915 enum EUserModify {
916     READ_ONLY, READ_WRITE, READ_WRITE_PLAINTEXT_ONLY
917 };
918
919 // CSS3 User Drag Values
920
921 enum EUserDrag {
922     DRAG_AUTO, DRAG_NONE, DRAG_ELEMENT
923 };
924
925 // CSS3 User Select Values
926
927 enum EUserSelect {
928     SELECT_NONE, SELECT_TEXT
929 };
930
931 // Word Break Values. Matches WinIE, rather than CSS3
932
933 enum EWordBreak {
934     NormalWordBreak, BreakAllWordBreak, BreakWordBreak
935 };
936
937 enum EWordWrap {
938     NormalWordWrap, BreakWordWrap
939 };
940
941 enum ENBSPMode {
942     NBNORMAL, SPACE
943 };
944
945 enum EKHTMLLineBreak {
946     LBNORMAL, AFTER_WHITE_SPACE
947 };
948
949 enum EMatchNearestMailBlockquoteColor {
950     BCNORMAL, MATCH
951 };
952
953 enum EResize {
954     RESIZE_NONE, RESIZE_BOTH, RESIZE_HORIZONTAL, RESIZE_VERTICAL
955 };
956
957 enum EAppearance {
958     NoAppearance, CheckboxAppearance, RadioAppearance, PushButtonAppearance, SquareButtonAppearance, ButtonAppearance,
959     ButtonBevelAppearance, ListboxAppearance, ListItemAppearance, MenulistAppearance,
960     MenulistButtonAppearance, MenulistTextAppearance, MenulistTextFieldAppearance,
961     ScrollbarButtonUpAppearance, ScrollbarButtonDownAppearance, 
962     ScrollbarButtonLeftAppearance, ScrollbarButtonRightAppearance,
963     ScrollbarTrackHorizontalAppearance, ScrollbarTrackVerticalAppearance,
964     ScrollbarThumbHorizontalAppearance, ScrollbarThumbVerticalAppearance,
965     ScrollbarGripperHorizontalAppearance, ScrollbarGripperVerticalAppearance,
966     SliderHorizontalAppearance, SliderVerticalAppearance, SliderThumbHorizontalAppearance,
967     SliderThumbVerticalAppearance, CaretAppearance, SearchFieldAppearance, SearchFieldDecorationAppearance,
968     SearchFieldResultsDecorationAppearance, SearchFieldResultsButtonAppearance,
969     SearchFieldCancelButtonAppearance, TextFieldAppearance, TextAreaAppearance
970 };
971
972 enum EListStyleType {
973      DISC, CIRCLE, SQUARE, LDECIMAL, DECIMAL_LEADING_ZERO,
974      LOWER_ROMAN, UPPER_ROMAN, LOWER_GREEK,
975      LOWER_ALPHA, LOWER_LATIN, UPPER_ALPHA, UPPER_LATIN,
976      HEBREW, ARMENIAN, GEORGIAN, CJK_IDEOGRAPHIC,
977      HIRAGANA, KATAKANA, HIRAGANA_IROHA, KATAKANA_IROHA, LNONE
978 };
979
980 struct CounterDirectives {
981     CounterDirectives() : m_reset(false), m_increment(false) { }
982
983     bool m_reset;
984     int m_resetValue;
985     bool m_increment;
986     int m_incrementValue;
987 };
988
989 bool operator==(const CounterDirectives&, const CounterDirectives&);
990 inline bool operator!=(const CounterDirectives& a, const CounterDirectives& b) { return !(a == b); }
991
992 typedef HashMap<RefPtr<AtomicStringImpl>, CounterDirectives> CounterDirectiveMap;
993
994 class CounterContent {
995 public:
996     CounterContent(const AtomicString& identifier, EListStyleType style, const AtomicString& separator)
997         : m_identifier(identifier), m_listStyle(style), m_separator(separator)
998     {
999     }
1000
1001     const AtomicString& identifier() const { return m_identifier; }
1002     EListStyleType listStyle() const { return m_listStyle; }
1003     const AtomicString& separator() const { return m_separator; }
1004
1005 private:
1006     AtomicString m_identifier;
1007     EListStyleType m_listStyle;
1008     AtomicString m_separator;
1009 };
1010
1011 enum ContentType {
1012     CONTENT_NONE, CONTENT_OBJECT, CONTENT_TEXT, CONTENT_COUNTER
1013 };
1014
1015 struct ContentData : Noncopyable {
1016     ContentData() : m_type(CONTENT_NONE), m_next(0) { }
1017     ~ContentData() { clear(); }
1018
1019     void clear();
1020
1021     ContentType m_type;
1022     union {
1023         CachedResource* m_object;
1024         StringImpl* m_text;
1025         CounterContent* m_counter;
1026     } m_content;
1027     ContentData* m_next;
1028 };
1029
1030 enum EBorderFit { BorderFitBorder, BorderFitLines };
1031
1032 enum ETimingFunctionType { LinearTimingFunction, CubicBezierTimingFunction };
1033
1034 struct TimingFunction
1035 {
1036     TimingFunction()
1037     : m_type(CubicBezierTimingFunction)
1038     , m_x1(.25)
1039     , m_y1(.1)
1040     , m_x2(.25)
1041     , m_y2(1.0)
1042     {}
1043
1044     TimingFunction(ETimingFunctionType timingFunction, double x1 = .0, double y1 = .0, double x2 = .0, double y2 = .0)
1045     : m_type(timingFunction)
1046     , m_x1(x1)
1047     , m_y1(y1)
1048     , m_x2(x2)
1049     , m_y2(y2)
1050     {
1051     }
1052
1053     bool operator==(const TimingFunction& o) const { return m_type == o.m_type && m_x1 == o.m_x1 && m_y1 == o.m_y1 && m_x2 == o.m_x2 && m_y2 == o.m_y2; }
1054
1055     double x1() const { return m_x1; }
1056     double y1() const { return m_y1; }
1057     double x2() const { return m_x2; }
1058     double y2() const { return m_y2; }
1059
1060     ETimingFunctionType type() const { return m_type; }
1061
1062 private:
1063     ETimingFunctionType m_type;
1064
1065     double m_x1;
1066     double m_y1;
1067     double m_x2;
1068     double m_y2;
1069 };
1070
1071 struct Transition {
1072 public:
1073     Transition();
1074     ~Transition();
1075
1076     Transition* next() const { return m_next; }
1077     Transition* next() { return m_next; }
1078
1079     bool isTransitionDurationSet() const { return m_durationSet; }
1080     bool isTransitionRepeatCountSet() const { return m_repeatCountSet; }
1081     bool isTransitionTimingFunctionSet() const { return m_timingFunctionSet; }
1082     bool isTransitionPropertySet() const { return m_propertySet; }
1083     
1084     bool isEmpty() const { return !m_durationSet && !m_repeatCountSet && !m_timingFunctionSet && !m_propertySet; }
1085     void clearTransitionDuration() { m_durationSet = false; }
1086     void clearTransitionRepeatCount() { m_repeatCountSet = false; }
1087     void clearTransitionTimingFunction() { m_timingFunctionSet = false; }
1088     void clearTransitionProperty() { m_propertySet = false; }
1089
1090     int transitionDuration() const { return m_duration; }
1091     int transitionRepeatCount() const { return m_repeatCount; }
1092     const TimingFunction& transitionTimingFunction() const { return m_timingFunction; }
1093     int transitionProperty() const { return m_property; }
1094     
1095     void setTransitionDuration(int d) { m_duration = d; m_durationSet = true; }
1096     void setTransitionRepeatCount(int c) { m_repeatCount = c; m_repeatCountSet = true; }
1097     void setTransitionTimingFunction(const TimingFunction& f) { m_timingFunction = f; m_timingFunctionSet = true; }
1098     void setTransitionProperty(int t) { m_property = t; m_propertySet = true; }
1099
1100     void setNext(Transition* n) { if (m_next != n) { delete m_next; m_next = n; } }
1101
1102     Transition& operator=(const Transition& o);    
1103     Transition(const Transition& o);
1104
1105     bool operator==(const Transition& o) const;
1106     bool operator!=(const Transition& o) const {
1107         return !(*this == o);
1108     }
1109
1110     void fillUnsetProperties();
1111
1112     int m_duration;
1113     int m_repeatCount;
1114     TimingFunction m_timingFunction;
1115     int m_property;
1116
1117     bool m_durationSet;
1118     bool m_repeatCountSet;
1119     bool m_timingFunctionSet;
1120     bool m_propertySet;
1121
1122     Transition* m_next;
1123 };
1124
1125 // This struct is for rarely used non-inherited CSS3, CSS2, and WebKit-specific properties.
1126 // By grouping them together, we save space, and only allocate this object when someone
1127 // actually uses one of these properties.
1128 class StyleRareNonInheritedData : public RefCounted<StyleRareNonInheritedData> {
1129 public:
1130     StyleRareNonInheritedData();
1131     ~StyleRareNonInheritedData();
1132     StyleRareNonInheritedData(const StyleRareNonInheritedData&);
1133
1134 #if ENABLE(XBL)
1135     bool bindingsEquivalent(const StyleRareNonInheritedData&) const;
1136 #endif
1137
1138     bool operator==(const StyleRareNonInheritedData&) const;
1139     bool operator!=(const StyleRareNonInheritedData& o) const { return !(*this == o); }
1140  
1141     bool shadowDataEquivalent(const StyleRareNonInheritedData& o) const;
1142     bool transitionDataEquivalent(const StyleRareNonInheritedData&) const;
1143
1144     int lineClamp; // An Apple extension.
1145     Vector<StyleDashboardRegion> m_dashboardRegions;
1146     float opacity; // Whether or not we're transparent.
1147
1148     DataRef<StyleFlexibleBoxData> flexibleBox; // Flexible box properties 
1149     DataRef<StyleMarqueeData> marquee; // Marquee properties
1150     DataRef<StyleMultiColData> m_multiCol; //  CSS3 multicol properties
1151     DataRef<StyleTransformData> m_transform; // Transform properties (rotate, scale, skew, etc.)
1152
1153     ContentData* m_content;
1154     CounterDirectiveMap* m_counterDirectives;
1155
1156     unsigned userDrag : 2; // EUserDrag
1157     bool textOverflow : 1; // Whether or not lines that spill out should be truncated with "..."
1158     unsigned marginTopCollapse : 2; // EMarginCollapse
1159     unsigned marginBottomCollapse : 2; // EMarginCollapse
1160     unsigned matchNearestMailBlockquoteColor : 1; // EMatchNearestMailBlockquoteColor, FIXME: This property needs to be eliminated. It should never have been added.
1161     unsigned m_appearance : 6; // EAppearance
1162     unsigned m_borderFit : 1; // EBorderFit
1163     ShadowData* m_boxShadow;  // For box-shadow decorations.
1164     
1165     Transition* m_transition;
1166
1167 #if ENABLE(XBL)
1168     BindingURI* bindingURI; // The XBL binding URI list.
1169 #endif
1170 };
1171
1172 // This struct is for rarely used inherited CSS3, CSS2, and WebKit-specific properties.
1173 // By grouping them together, we save space, and only allocate this object when someone
1174 // actually uses one of these properties.
1175 class StyleRareInheritedData : public RefCounted<StyleRareInheritedData> {
1176 public:
1177     StyleRareInheritedData();
1178     ~StyleRareInheritedData();
1179     StyleRareInheritedData(const StyleRareInheritedData& o);
1180
1181     bool operator==(const StyleRareInheritedData& o) const;
1182     bool operator!=(const StyleRareInheritedData &o) const {
1183         return !(*this == o);
1184     }
1185     bool shadowDataEquivalent(const StyleRareInheritedData&) const;
1186
1187     Color textStrokeColor;
1188     float textStrokeWidth;
1189     Color textFillColor;
1190
1191     ShadowData* textShadow; // Our text shadow information for shadowed text drawing.
1192     AtomicString highlight; // Apple-specific extension for custom highlight rendering.
1193     unsigned textSecurity : 2; // ETextSecurity
1194     unsigned userModify : 2; // EUserModify (editing)
1195     unsigned wordBreak : 2; // EWordBreak
1196     unsigned wordWrap : 1; // EWordWrap 
1197     unsigned nbspMode : 1; // ENBSPMode
1198     unsigned khtmlLineBreak : 1; // EKHTMLLineBreak
1199     bool textSizeAdjust : 1; // An Apple extension.
1200     unsigned resize : 2; // EResize
1201     unsigned userSelect : 1;  // EUserSelect
1202 };
1203
1204 //------------------------------------------------
1205 // Inherited attributes.
1206 //
1207
1208 enum EWhiteSpace {
1209     NORMAL, PRE, PRE_WRAP, PRE_LINE, NOWRAP, KHTML_NOWRAP
1210 };
1211
1212 enum ETextAlign {
1213     TAAUTO, LEFT, RIGHT, CENTER, JUSTIFY, WEBKIT_LEFT, WEBKIT_RIGHT, WEBKIT_CENTER
1214 };
1215
1216 enum ETextTransform {
1217     CAPITALIZE, UPPERCASE, LOWERCASE, TTNONE
1218 };
1219
1220 enum ETextDecoration {
1221     TDNONE = 0x0 , UNDERLINE = 0x1, OVERLINE = 0x2, LINE_THROUGH= 0x4, BLINK = 0x8
1222 };
1223
1224 enum EPageBreak {
1225     PBAUTO, PBALWAYS, PBAVOID
1226 };
1227
1228 class StyleInheritedData : public RefCounted<StyleInheritedData> {
1229 public:
1230     StyleInheritedData();
1231     ~StyleInheritedData();
1232     StyleInheritedData(const StyleInheritedData& o );
1233
1234     bool operator==(const StyleInheritedData& o) const;
1235     bool operator != ( const StyleInheritedData &o ) const {
1236         return !(*this == o);
1237     }
1238
1239     Length indent;
1240     // could be packed in a short but doesn't
1241     // make a difference currently because of padding
1242     Length line_height;
1243
1244     CachedImage *style_image;
1245     RefPtr<CursorList> cursorData;
1246
1247     Font font;
1248     Color color;
1249     
1250     short horizontal_border_spacing;
1251     short vertical_border_spacing;
1252     
1253     // Paged media properties.
1254     short widows;
1255     short orphans;
1256     unsigned page_break_inside : 2; // EPageBreak
1257 };
1258
1259
1260 enum EEmptyCell {
1261     SHOW, HIDE
1262 };
1263
1264 enum ECaptionSide {
1265     CAPTOP, CAPBOTTOM, CAPLEFT, CAPRIGHT
1266 };
1267
1268 enum EListStylePosition { OUTSIDE, INSIDE };
1269
1270 enum EVisibility { VISIBLE, HIDDEN, COLLAPSE };
1271
1272 enum ECursor {
1273     CURSOR_AUTO, CURSOR_CROSS, CURSOR_DEFAULT, CURSOR_POINTER, CURSOR_MOVE, CURSOR_VERTICAL_TEXT, CURSOR_CELL, CURSOR_CONTEXT_MENU,
1274     CURSOR_ALIAS, CURSOR_PROGRESS, CURSOR_NO_DROP, CURSOR_NOT_ALLOWED, CURSOR_WEBKIT_ZOOM_IN, CURSOR_WEBKIT_ZOOM_OUT,
1275     CURSOR_E_RESIZE, CURSOR_NE_RESIZE, CURSOR_NW_RESIZE, CURSOR_N_RESIZE, CURSOR_SE_RESIZE, CURSOR_SW_RESIZE,
1276     CURSOR_S_RESIZE, CURSOR_W_RESIZE, CURSOR_EW_RESIZE, CURSOR_NS_RESIZE, CURSOR_NESW_RESIZE, CURSOR_NWSE_RESIZE,
1277     CURSOR_COL_RESIZE, CURSOR_ROW_RESIZE, CURSOR_TEXT, CURSOR_WAIT, CURSOR_HELP, CURSOR_ALL_SCROLL, 
1278     CURSOR_COPY, CURSOR_NONE
1279 };
1280
1281 struct CursorData {
1282     CursorData()
1283         : cursorImage(0)
1284     {}
1285     
1286     bool operator==(const CursorData& o) const {
1287         return hotSpot == o.hotSpot && cursorImage == o.cursorImage && cursorFragmentId == o.cursorFragmentId;
1288     }
1289     bool operator!=(const CursorData& o) const { return !(*this == o); }
1290
1291     IntPoint hotSpot; // for CSS3 support
1292     CachedImage* cursorImage; // weak pointer, the CSSValueImage takes care of deleting cursorImage
1293     String cursorFragmentId; // only used for SVGCursorElement, a direct pointer would get stale
1294 };
1295
1296 class CursorList : public RefCounted<CursorList> {
1297 public:
1298     const CursorData& operator[](int i) const {
1299         return m_vector[i];
1300     }
1301
1302     bool operator==(const CursorList&) const;
1303     bool operator!=(const CursorList& o) const { return !(*this == o); }
1304
1305     size_t size() const { return m_vector.size(); }
1306     void append(const CursorData& cursorData) { m_vector.append(cursorData); }
1307
1308 private:
1309     Vector<CursorData> m_vector;
1310 };
1311
1312 //------------------------------------------------
1313
1314 enum EDisplay {
1315     INLINE, BLOCK, LIST_ITEM, RUN_IN, COMPACT, INLINE_BLOCK,
1316     TABLE, INLINE_TABLE, TABLE_ROW_GROUP,
1317     TABLE_HEADER_GROUP, TABLE_FOOTER_GROUP, TABLE_ROW,
1318     TABLE_COLUMN_GROUP, TABLE_COLUMN, TABLE_CELL,
1319     TABLE_CAPTION, BOX, INLINE_BOX, NONE
1320 };
1321
1322 class RenderStyle {
1323     friend class CSSStyleSelector;
1324
1325 public:
1326     // static pseudo styles. Dynamic ones are produced on the fly.
1327     enum PseudoId { NOPSEUDO, FIRST_LINE, FIRST_LETTER, BEFORE, AFTER, SELECTION, FIRST_LINE_INHERITED, FILE_UPLOAD_BUTTON, SLIDER_THUMB, 
1328                     SEARCH_CANCEL_BUTTON, SEARCH_DECORATION, SEARCH_RESULTS_DECORATION, SEARCH_RESULTS_BUTTON };
1329
1330     void ref() { m_ref++;  }
1331     void deref(RenderArena* arena) { 
1332         if (m_ref) m_ref--; 
1333         if (!m_ref)
1334             arenaDelete(arena);
1335     }
1336     bool hasOneRef() { return m_ref==1; }
1337     int refCount() const { return m_ref; }
1338     
1339     // Overloaded new operator.  Derived classes must override operator new
1340     // in order to allocate out of the RenderArena.
1341     void* operator new(size_t sz, RenderArena* renderArena) throw();    
1342     
1343     // Overridden to prevent the normal delete from being called.
1344     void operator delete(void* ptr, size_t sz);
1345     
1346 private:
1347     void arenaDelete(RenderArena *arena);
1348
1349 protected:
1350
1351 // !START SYNC!: Keep this in sync with the copy constructor in RenderStyle.cpp
1352
1353     // inherit
1354     struct InheritedFlags {
1355         bool operator==( const InheritedFlags &other ) const {
1356             return (_empty_cells == other._empty_cells) &&
1357                    (_caption_side == other._caption_side) &&
1358                    (_list_style_type == other._list_style_type) &&
1359                    (_list_style_position == other._list_style_position) &&
1360                    (_visibility == other._visibility) &&
1361                    (_text_align == other._text_align) &&
1362                    (_text_transform == other._text_transform) &&
1363                    (_text_decorations == other._text_decorations) &&
1364                    (_text_transform == other._text_transform) &&
1365                    (_cursor_style == other._cursor_style) &&
1366                    (_direction == other._direction) &&
1367                    (_border_collapse == other._border_collapse) &&
1368                    (_white_space == other._white_space) &&
1369                    (_box_direction == other._box_direction) &&
1370                    (_visuallyOrdered == other._visuallyOrdered) &&
1371                    (_htmlHacks == other._htmlHacks) &&
1372                    (_force_backgrounds_to_white == other._force_backgrounds_to_white);
1373         }
1374         
1375         bool operator!=( const InheritedFlags &other ) const {
1376             return !(*this == other);
1377         }
1378
1379         unsigned _empty_cells : 1; // EEmptyCell 
1380         unsigned _caption_side : 2; // ECaptionSide
1381         unsigned _list_style_type : 5 ; // EListStyleType
1382         unsigned _list_style_position : 1; // EListStylePosition
1383         unsigned _visibility : 2; // EVisibility
1384         unsigned _text_align : 4; // ETextAlign
1385         unsigned _text_transform : 2; // ETextTransform
1386         unsigned _text_decorations : 4;
1387         unsigned _cursor_style : 5; // ECursor
1388         unsigned _direction : 1; // TextDirection
1389         bool _border_collapse : 1 ;
1390         unsigned _white_space : 3; // EWhiteSpace
1391         unsigned _box_direction : 1; // EBoxDirection (CSS3 box_direction property, flexible box layout module)
1392         
1393         // non CSS2 inherited
1394         bool _visuallyOrdered : 1;
1395         bool _htmlHacks :1;
1396         bool _force_backgrounds_to_white : 1;
1397     } inherited_flags;
1398
1399 // don't inherit
1400     struct NonInheritedFlags {
1401         bool operator==( const NonInheritedFlags &other ) const {
1402             return (_effectiveDisplay == other._effectiveDisplay) &&
1403             (_originalDisplay == other._originalDisplay) &&
1404             (_bg_repeat == other._bg_repeat) &&
1405             (_overflowX == other._overflowX) &&
1406             (_overflowY == other._overflowY) &&
1407             (_vertical_align == other._vertical_align) &&
1408             (_clear == other._clear) &&
1409             (_position == other._position) &&
1410             (_floating == other._floating) &&
1411             (_table_layout == other._table_layout) &&
1412             (_page_break_before == other._page_break_before) &&
1413             (_page_break_after == other._page_break_after) &&
1414             (_styleType == other._styleType) &&
1415             (_affectedByHover == other._affectedByHover) &&
1416             (_affectedByActive == other._affectedByActive) &&
1417             (_affectedByDrag == other._affectedByDrag) &&
1418             (_pseudoBits == other._pseudoBits) &&
1419             (_unicodeBidi == other._unicodeBidi);
1420         }
1421
1422         bool operator!=( const NonInheritedFlags &other ) const {
1423             return !(*this == other);
1424         }
1425         
1426         unsigned _effectiveDisplay : 5; // EDisplay
1427         unsigned _originalDisplay : 5; // EDisplay
1428         unsigned _bg_repeat : 2; // EBackgroundRepeat
1429         unsigned _overflowX : 4; // EOverflow
1430         unsigned _overflowY : 4; // EOverflow
1431         unsigned _vertical_align : 4; // EVerticalAlign
1432         unsigned _clear : 2; // EClear
1433         unsigned _position : 2; // EPosition
1434         unsigned _floating : 2; // EFloat
1435         unsigned _table_layout : 1; // ETableLayout
1436         
1437         unsigned _page_break_before : 2; // EPageBreak
1438         unsigned _page_break_after : 2; // EPageBreak
1439
1440         unsigned _styleType : 4; // PseudoId
1441         bool _affectedByHover : 1;
1442         bool _affectedByActive : 1;
1443         bool _affectedByDrag : 1;
1444         unsigned _pseudoBits : 12;
1445         unsigned _unicodeBidi : 2; // EUnicodeBidi
1446     } noninherited_flags;
1447
1448 // non-inherited attributes
1449     DataRef<StyleBoxData> box;
1450     DataRef<StyleVisualData> visual;
1451     DataRef<StyleBackgroundData> background;
1452     DataRef<StyleSurroundData> surround;
1453     DataRef<StyleRareNonInheritedData> rareNonInheritedData;
1454
1455 // inherited attributes
1456     DataRef<StyleRareInheritedData> rareInheritedData;
1457     DataRef<StyleInheritedData> inherited;
1458     
1459 // list of associated pseudo styles
1460     RenderStyle* pseudoStyle;
1461     
1462     unsigned m_pseudoState : 3; // PseudoState
1463     bool m_affectedByAttributeSelectors : 1;
1464     bool m_unique : 1;
1465     int m_ref;
1466     
1467 #if ENABLE(SVG)
1468     DataRef<SVGRenderStyle> m_svgStyle;
1469 #endif
1470     
1471 // !END SYNC!
1472
1473 protected:
1474     void setBitDefaults()
1475     {
1476         inherited_flags._empty_cells = initialEmptyCells();
1477         inherited_flags._caption_side = initialCaptionSide();
1478         inherited_flags._list_style_type = initialListStyleType();
1479         inherited_flags._list_style_position = initialListStylePosition();
1480         inherited_flags._visibility = initialVisibility();
1481         inherited_flags._text_align = initialTextAlign();
1482         inherited_flags._text_transform = initialTextTransform();
1483         inherited_flags._text_decorations = initialTextDecoration();
1484         inherited_flags._cursor_style = initialCursor();
1485         inherited_flags._direction = initialDirection();
1486         inherited_flags._border_collapse = initialBorderCollapse();
1487         inherited_flags._white_space = initialWhiteSpace();
1488         inherited_flags._visuallyOrdered = initialVisuallyOrdered();
1489         inherited_flags._htmlHacks=false;
1490         inherited_flags._box_direction = initialBoxDirection();
1491         inherited_flags._force_backgrounds_to_white = false;
1492         
1493         noninherited_flags._effectiveDisplay = noninherited_flags._originalDisplay = initialDisplay();
1494         noninherited_flags._bg_repeat = initialBackgroundRepeat();
1495         noninherited_flags._overflowX = initialOverflowX();
1496         noninherited_flags._overflowY = initialOverflowY();
1497         noninherited_flags._vertical_align = initialVerticalAlign();
1498         noninherited_flags._clear = initialClear();
1499         noninherited_flags._position = initialPosition();
1500         noninherited_flags._floating = initialFloating();
1501         noninherited_flags._table_layout = initialTableLayout();
1502         noninherited_flags._page_break_before = initialPageBreak();
1503         noninherited_flags._page_break_after = initialPageBreak();
1504         noninherited_flags._styleType = NOPSEUDO;
1505         noninherited_flags._affectedByHover = false;
1506         noninherited_flags._affectedByActive = false;
1507         noninherited_flags._affectedByDrag = false;
1508         noninherited_flags._pseudoBits = 0;
1509         noninherited_flags._unicodeBidi = initialUnicodeBidi();
1510     }
1511
1512 public:
1513
1514     RenderStyle();
1515     // used to create the default style.
1516     RenderStyle(bool);
1517     RenderStyle(const RenderStyle&);
1518
1519     ~RenderStyle();
1520
1521     void inheritFrom(const RenderStyle* inheritParent);
1522
1523     PseudoId styleType() { return  static_cast<PseudoId>(noninherited_flags._styleType); }
1524     void setStyleType(PseudoId styleType) { noninherited_flags._styleType = styleType; }
1525
1526     RenderStyle* getPseudoStyle(PseudoId pi);
1527     void addPseudoStyle(RenderStyle* pseudo);
1528
1529     bool affectedByHoverRules() const { return  noninherited_flags._affectedByHover; }
1530     bool affectedByActiveRules() const { return  noninherited_flags._affectedByActive; }
1531     bool affectedByDragRules() const { return  noninherited_flags._affectedByDrag; }
1532
1533     void setAffectedByHoverRules(bool b) {  noninherited_flags._affectedByHover = b; }
1534     void setAffectedByActiveRules(bool b) {  noninherited_flags._affectedByActive = b; }
1535     void setAffectedByDragRules(bool b) {  noninherited_flags._affectedByDrag = b; }
1536  
1537     bool operator==(const RenderStyle& other) const;
1538     bool        isFloating() const { return !(noninherited_flags._floating == FNONE); }
1539     bool        hasMargin() const { return surround->margin.nonZero(); }
1540     bool        hasBorder() const { return surround->border.hasBorder(); }
1541     bool        hasPadding() const { return surround->padding.nonZero(); }
1542     bool        hasOffset() const { return surround->offset.nonZero(); }
1543
1544     bool hasBackground() const { if (backgroundColor().isValid() && backgroundColor().alpha() > 0)
1545                                     return true;
1546                                  return background->m_background.hasImage(); }
1547     bool hasFixedBackgroundImage() const { return background->m_background.hasFixedImage(); }
1548     bool hasAppearance() const { return appearance() != NoAppearance; }
1549
1550     bool visuallyOrdered() const { return inherited_flags._visuallyOrdered; }
1551     void setVisuallyOrdered(bool b) {  inherited_flags._visuallyOrdered = b; }
1552
1553     bool isStyleAvailable() const;
1554     
1555     bool hasPseudoStyle(PseudoId pseudo) const;
1556     void setHasPseudoStyle(PseudoId pseudo);
1557     
1558 // attribute getter methods
1559
1560     EDisplay    display() const { return static_cast<EDisplay>(noninherited_flags._effectiveDisplay); }
1561     EDisplay    originalDisplay() const { return static_cast<EDisplay>(noninherited_flags._originalDisplay); }
1562     
1563     Length      left() const {  return surround->offset.left; }
1564     Length      right() const {  return surround->offset.right; }
1565     Length      top() const {  return surround->offset.top; }
1566     Length      bottom() const {  return surround->offset.bottom; }
1567
1568     EPosition   position() const { return  static_cast<EPosition>(noninherited_flags._position); }
1569     EFloat      floating() const { return  static_cast<EFloat>(noninherited_flags._floating); }
1570
1571     Length      width() const { return box->width; }
1572     Length      height() const { return box->height; }
1573     Length      minWidth() const { return box->min_width; }
1574     Length      maxWidth() const { return box->max_width; }
1575     Length      minHeight() const { return box->min_height; }
1576     Length      maxHeight() const { return box->max_height; }
1577
1578     const BorderData& border() const { return surround->border; }
1579     const BorderValue& borderLeft() const { return surround->border.left; }
1580     const BorderValue& borderRight() const { return surround->border.right; }
1581     const BorderValue& borderTop() const { return surround->border.top; }
1582     const BorderValue& borderBottom() const { return surround->border.bottom; }
1583
1584     const BorderImage& borderImage() const { return surround->border.image; }
1585
1586     IntSize borderTopLeftRadius() const { return surround->border.topLeft; }
1587     IntSize borderTopRightRadius() const { return surround->border.topRight; }
1588     IntSize borderBottomLeftRadius() const { return surround->border.bottomLeft; }
1589     IntSize borderBottomRightRadius() const { return surround->border.bottomRight; }
1590     bool hasBorderRadius() const { return surround->border.hasBorderRadius(); }
1591
1592     unsigned short  borderLeftWidth() const { return surround->border.borderLeftWidth(); }
1593     EBorderStyle    borderLeftStyle() const { return surround->border.left.style(); }
1594     const Color&  borderLeftColor() const { return surround->border.left.color; }
1595     bool borderLeftIsTransparent() const { return surround->border.left.isTransparent(); }
1596     unsigned short  borderRightWidth() const { return surround->border.borderRightWidth(); }
1597     EBorderStyle    borderRightStyle() const {  return surround->border.right.style(); }
1598     const Color&   borderRightColor() const {  return surround->border.right.color; }
1599     bool borderRightIsTransparent() const { return surround->border.right.isTransparent(); }
1600     unsigned short  borderTopWidth() const { return surround->border.borderTopWidth(); }
1601     EBorderStyle    borderTopStyle() const { return surround->border.top.style(); }
1602     const Color&  borderTopColor() const {  return surround->border.top.color; }
1603     bool borderTopIsTransparent() const { return surround->border.top.isTransparent(); }
1604     unsigned short  borderBottomWidth() const { return surround->border.borderBottomWidth(); }
1605     EBorderStyle    borderBottomStyle() const {  return surround->border.bottom.style(); }
1606     const Color&   borderBottomColor() const {  return surround->border.bottom.color; }
1607     bool borderBottomIsTransparent() const { return surround->border.bottom.isTransparent(); }
1608     
1609     unsigned short outlineSize() const { return max(0, outlineWidth() + outlineOffset()); }
1610     unsigned short outlineWidth() const {
1611         if (background->m_outline.style() == BNONE || background->m_outline.style() == BHIDDEN)
1612             return 0;
1613         return background->m_outline.width;
1614     }
1615     bool hasOutline() const { return outlineWidth() > 0 && outlineStyle() > BHIDDEN; }
1616     EBorderStyle   outlineStyle() const {  return background->m_outline.style(); }
1617     bool outlineStyleIsAuto() const { return background->m_outline._auto; }
1618     const Color &  outlineColor() const {  return background->m_outline.color; }
1619
1620     EOverflow overflowX() const { return static_cast<EOverflow>(noninherited_flags._overflowX); }
1621     EOverflow overflowY() const { return static_cast<EOverflow>(noninherited_flags._overflowY); }
1622
1623     EVisibility visibility() const { return static_cast<EVisibility>(inherited_flags._visibility); }
1624     EVerticalAlign verticalAlign() const { return  static_cast<EVerticalAlign>(noninherited_flags._vertical_align); }
1625     Length verticalAlignLength() const { return box->vertical_align; }
1626
1627     Length clipLeft() const { return visual->clip.left; }
1628     Length clipRight() const { return visual->clip.right; }
1629     Length clipTop() const { return visual->clip.top; }
1630     Length clipBottom() const { return visual->clip.bottom; }
1631     LengthBox clip() const { return visual->clip; }
1632     bool hasClip() const { return visual->hasClip; }
1633     
1634     EUnicodeBidi unicodeBidi() const { return static_cast<EUnicodeBidi>(noninherited_flags._unicodeBidi); }
1635
1636     EClear clear() const { return static_cast<EClear>(noninherited_flags._clear); }
1637     ETableLayout tableLayout() const { return static_cast<ETableLayout>(noninherited_flags._table_layout); }
1638
1639     const Font& font() { return inherited->font; }
1640     const FontDescription& fontDescription() { return inherited->font.fontDescription(); }
1641     int fontSize() const { return inherited->font.pixelSize(); }
1642
1643     const Color & color() const { return inherited->color; }
1644     Length textIndent() const { return inherited->indent; }
1645     ETextAlign textAlign() const { return static_cast<ETextAlign>(inherited_flags._text_align); }
1646     ETextTransform textTransform() const { return static_cast<ETextTransform>(inherited_flags._text_transform); }
1647     int textDecorationsInEffect() const { return inherited_flags._text_decorations; }
1648     int textDecoration() const { return visual->textDecoration; }
1649     int wordSpacing() const { return inherited->font.wordSpacing(); }
1650     int letterSpacing() const { return inherited->font.letterSpacing(); }
1651
1652     TextDirection direction() const { return static_cast<TextDirection>(inherited_flags._direction); }
1653     Length lineHeight() const { return inherited->line_height; }
1654
1655     EWhiteSpace whiteSpace() const { return static_cast<EWhiteSpace>(inherited_flags._white_space); }
1656     static bool autoWrap(EWhiteSpace ws) {
1657         // Nowrap and pre don't automatically wrap.
1658         return ws != NOWRAP && ws != PRE;
1659     }
1660     bool autoWrap() const {
1661         return autoWrap(whiteSpace());
1662     }
1663     static bool preserveNewline(EWhiteSpace ws) {
1664         // Normal and nowrap do not preserve newlines.
1665         return ws != NORMAL && ws != NOWRAP;
1666     }
1667     bool preserveNewline() const {
1668         return preserveNewline(whiteSpace());
1669     }
1670     static bool collapseWhiteSpace(EWhiteSpace ws) {
1671         // Pre and prewrap do not collapse whitespace.
1672         return ws != PRE && ws != PRE_WRAP;
1673     }
1674     bool collapseWhiteSpace() const {
1675         return collapseWhiteSpace(whiteSpace());
1676     }
1677     bool isCollapsibleWhiteSpace(UChar c) const {
1678         switch (c) {
1679             case ' ':
1680             case '\t':
1681                 return collapseWhiteSpace();
1682             case '\n':
1683                 return !preserveNewline();
1684         }
1685         return false;
1686     }
1687     bool breakOnlyAfterWhiteSpace() const {
1688         return whiteSpace() == PRE_WRAP || khtmlLineBreak() == AFTER_WHITE_SPACE;
1689     }
1690     bool breakWords() const {
1691         return wordBreak() == BreakWordBreak || wordWrap() == BreakWordWrap;
1692     }
1693
1694     const Color & backgroundColor() const { return background->m_color; }
1695     CachedImage *backgroundImage() const { return background->m_background.m_image; }
1696     EBackgroundRepeat backgroundRepeat() const { return static_cast<EBackgroundRepeat>(background->m_background.m_bgRepeat); }
1697     CompositeOperator backgroundComposite() const { return static_cast<CompositeOperator>(background->m_background.m_bgComposite); }
1698     bool backgroundAttachment() const { return background->m_background.m_bgAttachment; }
1699     EBackgroundBox backgroundClip() const { return static_cast<EBackgroundBox>(background->m_background.m_bgClip); }
1700     EBackgroundBox backgroundOrigin() const { return static_cast<EBackgroundBox>(background->m_background.m_bgOrigin); }
1701     Length backgroundXPosition() const { return background->m_background.m_xPosition; }
1702     Length backgroundYPosition() const { return background->m_background.m_yPosition; }
1703     LengthSize backgroundSize() const { return background->m_background.m_backgroundSize; }
1704     BackgroundLayer* accessBackgroundLayers() { return &(background.access()->m_background); }
1705     const BackgroundLayer* backgroundLayers() const { return &(background->m_background); }
1706
1707     // returns true for collapsing borders, false for separate borders
1708     bool borderCollapse() const { return inherited_flags._border_collapse; }
1709     short horizontalBorderSpacing() const { return inherited->horizontal_border_spacing; }
1710     short verticalBorderSpacing() const { return inherited->vertical_border_spacing; }
1711     EEmptyCell emptyCells() const { return static_cast<EEmptyCell>(inherited_flags._empty_cells); }
1712     ECaptionSide captionSide() const { return static_cast<ECaptionSide>(inherited_flags._caption_side); }
1713
1714     short counterIncrement() const { return visual->counterIncrement; }
1715     short counterReset() const { return visual->counterReset; }
1716
1717     EListStyleType listStyleType() const { return static_cast<EListStyleType>(inherited_flags._list_style_type); }
1718     CachedImage *listStyleImage() const { return inherited->style_image; }
1719     EListStylePosition listStylePosition() const { return static_cast<EListStylePosition>(inherited_flags._list_style_position); }
1720
1721     Length marginTop() const { return surround->margin.top; }
1722     Length marginBottom() const {  return surround->margin.bottom; }
1723     Length marginLeft() const {  return surround->margin.left; }
1724     Length marginRight() const {  return surround->margin.right; }
1725
1726     Length paddingTop() const {  return surround->padding.top; }
1727     Length paddingBottom() const {  return surround->padding.bottom; }
1728     Length paddingLeft() const { return surround->padding.left; }
1729     Length paddingRight() const {  return surround->padding.right; }
1730
1731     ECursor cursor() const { return static_cast<ECursor>(inherited_flags._cursor_style); }
1732     
1733     CursorList* cursors() const { return inherited->cursorData.get(); }
1734
1735     short widows() const { return inherited->widows; }
1736     short orphans() const { return inherited->orphans; }
1737     EPageBreak pageBreakInside() const { return static_cast<EPageBreak>(inherited->page_break_inside); }
1738     EPageBreak pageBreakBefore() const { return static_cast<EPageBreak>(noninherited_flags._page_break_before); }
1739     EPageBreak pageBreakAfter() const { return static_cast<EPageBreak>(noninherited_flags._page_break_after); }
1740     
1741     // CSS3 Getter Methods
1742 #if ENABLE(XBL)
1743     BindingURI* bindingURIs() const { return rareNonInheritedData->bindingURI; }
1744 #endif
1745     int outlineOffset() const { 
1746         if (background->m_outline.style() == BNONE || background->m_outline.style() == BHIDDEN)
1747             return 0;
1748         return background->m_outline._offset;
1749     }
1750     ShadowData* textShadow() const { return rareInheritedData->textShadow; }
1751     Color textStrokeColor() const { return rareInheritedData->textStrokeColor; }
1752     float textStrokeWidth() const { return rareInheritedData->textStrokeWidth; }
1753     Color textFillColor() const { return rareInheritedData->textFillColor; }
1754     float opacity() const { return rareNonInheritedData->opacity; }
1755     EAppearance appearance() const { return static_cast<EAppearance>(rareNonInheritedData->m_appearance); }
1756     EBoxAlignment boxAlign() const { return static_cast<EBoxAlignment>(rareNonInheritedData->flexibleBox->align); }
1757     EBoxDirection boxDirection() const { return static_cast<EBoxDirection>(inherited_flags._box_direction); }
1758     float boxFlex() { return rareNonInheritedData->flexibleBox->flex; }
1759     unsigned int boxFlexGroup() const { return rareNonInheritedData->flexibleBox->flex_group; }
1760     EBoxLines boxLines() { return static_cast<EBoxLines>(rareNonInheritedData->flexibleBox->lines); }
1761     unsigned int boxOrdinalGroup() const { return rareNonInheritedData->flexibleBox->ordinal_group; }
1762     EBoxOrient boxOrient() const { return static_cast<EBoxOrient>(rareNonInheritedData->flexibleBox->orient); }
1763     EBoxAlignment boxPack() const { return static_cast<EBoxAlignment>(rareNonInheritedData->flexibleBox->pack); }
1764     ShadowData* boxShadow() const { return rareNonInheritedData->m_boxShadow; }
1765     EBoxSizing boxSizing() const { return static_cast<EBoxSizing>(box->boxSizing); }
1766     Length marqueeIncrement() const { return rareNonInheritedData->marquee->increment; }
1767     int marqueeSpeed() const { return rareNonInheritedData->marquee->speed; }
1768     int marqueeLoopCount() const { return rareNonInheritedData->marquee->loops; }
1769     EMarqueeBehavior marqueeBehavior() const { return static_cast<EMarqueeBehavior>(rareNonInheritedData->marquee->behavior); }
1770     EMarqueeDirection marqueeDirection() const { return static_cast<EMarqueeDirection>(rareNonInheritedData->marquee->direction); }
1771     EUserModify userModify() const { return static_cast<EUserModify>(rareInheritedData->userModify); }
1772     EUserDrag userDrag() const { return static_cast<EUserDrag>(rareNonInheritedData->userDrag); }
1773     EUserSelect userSelect() const { return static_cast<EUserSelect>(rareInheritedData->userSelect); }
1774     bool textOverflow() const { return rareNonInheritedData->textOverflow; }
1775     EMarginCollapse marginTopCollapse() const { return static_cast<EMarginCollapse>(rareNonInheritedData->marginTopCollapse); }
1776     EMarginCollapse marginBottomCollapse() const { return static_cast<EMarginCollapse>(rareNonInheritedData->marginBottomCollapse); }
1777     EWordBreak wordBreak() const { return static_cast<EWordBreak>(rareInheritedData->wordBreak); }
1778     EWordWrap wordWrap() const { return static_cast<EWordWrap>(rareInheritedData->wordWrap); }
1779     ENBSPMode nbspMode() const { return static_cast<ENBSPMode>(rareInheritedData->nbspMode); }
1780     EKHTMLLineBreak khtmlLineBreak() const { return static_cast<EKHTMLLineBreak>(rareInheritedData->khtmlLineBreak); }
1781     EMatchNearestMailBlockquoteColor matchNearestMailBlockquoteColor() const { return static_cast<EMatchNearestMailBlockquoteColor>(rareNonInheritedData->matchNearestMailBlockquoteColor); }
1782     const AtomicString& highlight() const { return rareInheritedData->highlight; }
1783     EBorderFit borderFit() const { return static_cast<EBorderFit>(rareNonInheritedData->m_borderFit); }
1784     EResize resize() const { return static_cast<EResize>(rareInheritedData->resize); }
1785     float columnWidth() const { return rareNonInheritedData->m_multiCol->m_width; }
1786     bool hasAutoColumnWidth() const { return rareNonInheritedData->m_multiCol->m_autoWidth; }
1787     unsigned short columnCount() const { return rareNonInheritedData->m_multiCol->m_count; }
1788     bool hasAutoColumnCount() const { return rareNonInheritedData->m_multiCol->m_autoCount; }
1789     float columnGap() const { return rareNonInheritedData->m_multiCol->m_gap; }
1790     bool hasNormalColumnGap() const { return rareNonInheritedData->m_multiCol->m_normalGap; }
1791     const Color& columnRuleColor() const { return rareNonInheritedData->m_multiCol->m_rule.color; }
1792     EBorderStyle columnRuleStyle() const { return rareNonInheritedData->m_multiCol->m_rule.style(); }
1793     unsigned short columnRuleWidth() const { return rareNonInheritedData->m_multiCol->ruleWidth(); }
1794     bool columnRuleIsTransparent() const { return rareNonInheritedData->m_multiCol->m_rule.isTransparent(); }
1795     EPageBreak columnBreakBefore() const { return static_cast<EPageBreak>(rareNonInheritedData->m_multiCol->m_breakBefore); }
1796     EPageBreak columnBreakInside() const { return static_cast<EPageBreak>(rareNonInheritedData->m_multiCol->m_breakInside); }
1797     EPageBreak columnBreakAfter() const { return static_cast<EPageBreak>(rareNonInheritedData->m_multiCol->m_breakAfter); }
1798     const TransformOperations& transform() const { return rareNonInheritedData->m_transform->m_operations; }
1799     Length transformOriginX() const { return rareNonInheritedData->m_transform->m_x; }
1800     Length transformOriginY() const { return rareNonInheritedData->m_transform->m_y; }
1801     bool hasTransform() const { return !rareNonInheritedData->m_transform->m_operations.isEmpty(); }
1802     void applyTransform(AffineTransform&, const IntSize& borderBoxSize) const;
1803     // End CSS3 Getters
1804
1805     // Apple-specific property getter methods
1806     Transition* accessTransitions();
1807     const Transition* transitions() const { return rareNonInheritedData->m_transition; }
1808     int lineClamp() const { return rareNonInheritedData->lineClamp; }
1809     bool textSizeAdjust() const { return rareInheritedData->textSizeAdjust; }
1810     ETextSecurity textSecurity() const { return static_cast<ETextSecurity>(rareInheritedData->textSecurity); }
1811
1812 // attribute setter methods
1813
1814     void setDisplay(EDisplay v) {  noninherited_flags._effectiveDisplay = v; }
1815     void setOriginalDisplay(EDisplay v) {  noninherited_flags._originalDisplay = v; }
1816     void setPosition(EPosition v) {  noninherited_flags._position = v; }
1817     void setFloating(EFloat v) {  noninherited_flags._floating = v; }
1818
1819     void setLeft(Length v)  {  SET_VAR(surround,offset.left,v) }
1820     void setRight(Length v) {  SET_VAR(surround,offset.right,v) }
1821     void setTop(Length v)   {  SET_VAR(surround,offset.top,v) }
1822     void setBottom(Length v){  SET_VAR(surround,offset.bottom,v) }
1823
1824     void setWidth(Length v)  { SET_VAR(box,width,v) }
1825     void setHeight(Length v) { SET_VAR(box,height,v) }
1826
1827     void setMinWidth(Length v)  { SET_VAR(box,min_width,v) }
1828     void setMaxWidth(Length v)  { SET_VAR(box,max_width,v) }
1829     void setMinHeight(Length v) { SET_VAR(box,min_height,v) }
1830     void setMaxHeight(Length v) { SET_VAR(box,max_height,v) }
1831
1832     Vector<StyleDashboardRegion> dashboardRegions() const { return rareNonInheritedData->m_dashboardRegions; }
1833     void setDashboardRegions(Vector<StyleDashboardRegion> regions) { SET_VAR(rareNonInheritedData,m_dashboardRegions,regions); }
1834     void setDashboardRegion(int type, const String& label, Length t, Length r, Length b, Length l, bool append) {
1835         StyleDashboardRegion region;
1836         region.label = label;
1837         region.offset.top  = t;
1838         region.offset.right = r;
1839         region.offset.bottom = b;
1840         region.offset.left = l;
1841         region.type = type;
1842         if (!append)
1843             rareNonInheritedData.access()->m_dashboardRegions.clear();
1844         rareNonInheritedData.access()->m_dashboardRegions.append(region);
1845     }
1846
1847     void resetBorder() { resetBorderImage(); resetBorderTop(); resetBorderRight(); resetBorderBottom(); resetBorderLeft(); resetBorderRadius(); }
1848     void resetBorderTop() { SET_VAR(surround, border.top, BorderValue()) }
1849     void resetBorderRight() { SET_VAR(surround, border.right, BorderValue()) }
1850     void resetBorderBottom() { SET_VAR(surround, border.bottom, BorderValue()) }
1851     void resetBorderLeft() { SET_VAR(surround, border.left, BorderValue()) }
1852     void resetBorderImage() { SET_VAR(surround, border.image, BorderImage()) }
1853     void resetBorderRadius() { resetBorderTopLeftRadius(); resetBorderTopRightRadius(); resetBorderBottomLeftRadius(); resetBorderBottomRightRadius(); }
1854     void resetBorderTopLeftRadius() { SET_VAR(surround, border.topLeft, initialBorderRadius()) }
1855     void resetBorderTopRightRadius() { SET_VAR(surround, border.topRight, initialBorderRadius()) }
1856     void resetBorderBottomLeftRadius() { SET_VAR(surround, border.bottomLeft, initialBorderRadius()) }
1857     void resetBorderBottomRightRadius() { SET_VAR(surround, border.bottomRight, initialBorderRadius()) }
1858     
1859     void resetOutline() { SET_VAR(background, m_outline, OutlineValue()) }
1860     
1861     void setBackgroundColor(const Color& v)    { SET_VAR(background, m_color, v) }
1862
1863     void setBorderImage(const BorderImage& b)   { SET_VAR(surround, border.image, b) }
1864
1865     void setBorderTopLeftRadius(const IntSize& s) { SET_VAR(surround, border.topLeft, s) }
1866     void setBorderTopRightRadius(const IntSize& s) { SET_VAR(surround, border.topRight, s) }
1867     void setBorderBottomLeftRadius(const IntSize& s) { SET_VAR(surround, border.bottomLeft, s) }
1868     void setBorderBottomRightRadius(const IntSize& s) { SET_VAR(surround, border.bottomRight, s) }
1869     void setBorderRadius(const IntSize& s) { 
1870         setBorderTopLeftRadius(s); setBorderTopRightRadius(s); setBorderBottomLeftRadius(s); setBorderBottomRightRadius(s);
1871     }
1872
1873     void setBorderLeftWidth(unsigned short v)   {  SET_VAR(surround, border.left.width, v) }
1874     void setBorderLeftStyle(EBorderStyle v)     {  SET_VAR(surround, border.left.m_style, v) }
1875     void setBorderLeftColor(const Color & v)   {  SET_VAR(surround, border.left.color, v) }
1876     void setBorderRightWidth(unsigned short v)  {  SET_VAR(surround, border.right.width, v) }
1877     void setBorderRightStyle(EBorderStyle v)    {  SET_VAR(surround, border.right.m_style, v) }
1878     void setBorderRightColor(const Color & v)  {  SET_VAR(surround, border.right.color, v) }
1879     void setBorderTopWidth(unsigned short v)    {  SET_VAR(surround, border.top.width, v) }
1880     void setBorderTopStyle(EBorderStyle v)      {  SET_VAR(surround, border.top.m_style, v) }
1881     void setBorderTopColor(const Color & v)    {  SET_VAR(surround, border.top.color, v) }    
1882     void setBorderBottomWidth(unsigned short v) {  SET_VAR(surround, border.bottom.width, v) }
1883     void setBorderBottomStyle(EBorderStyle v)   {  SET_VAR(surround, border.bottom.m_style, v) }
1884     void setBorderBottomColor(const Color & v) {  SET_VAR(surround, border.bottom.color, v) }
1885     void setOutlineWidth(unsigned short v) {  SET_VAR(background, m_outline.width, v) }
1886     void setOutlineStyle(EBorderStyle v, bool isAuto = false)   
1887     {  
1888         SET_VAR(background, m_outline.m_style, v)
1889         SET_VAR(background, m_outline._auto, isAuto)
1890     }
1891     void setOutlineColor(const Color & v) {  SET_VAR(background,m_outline.color,v) }
1892
1893     void setOverflowX(EOverflow v) { noninherited_flags._overflowX = v; }
1894     void setOverflowY(EOverflow v) { noninherited_flags._overflowY = v; }
1895     void setVisibility(EVisibility v) { inherited_flags._visibility = v; }
1896     void setVerticalAlign(EVerticalAlign v) { noninherited_flags._vertical_align = v; }
1897     void setVerticalAlignLength(Length l) { SET_VAR(box, vertical_align, l ) }
1898
1899     void setHasClip(bool b = true) { SET_VAR(visual,hasClip,b) }
1900     void setClipLeft(Length v) { SET_VAR(visual,clip.left,v) }
1901     void setClipRight(Length v) { SET_VAR(visual,clip.right,v) }
1902     void setClipTop(Length v) { SET_VAR(visual,clip.top,v) }
1903     void setClipBottom(Length v) { SET_VAR(visual,clip.bottom,v) }
1904     void setClip( Length top, Length right, Length bottom, Length left );
1905     
1906     void setUnicodeBidi( EUnicodeBidi b ) { noninherited_flags._unicodeBidi = b; }
1907
1908     void setClear(EClear v) {  noninherited_flags._clear = v; }
1909     void setTableLayout(ETableLayout v) {  noninherited_flags._table_layout = v; }
1910
1911     bool setFontDescription(const FontDescription& v) {
1912         if (inherited->font.fontDescription() != v) {
1913             inherited.access()->font = Font(v, inherited->font.letterSpacing(), inherited->font.wordSpacing());
1914             return true;
1915         }
1916         return false;
1917     }
1918
1919     void setColor(const Color & v) { SET_VAR(inherited,color,v) }
1920     void setTextIndent(Length v) { SET_VAR(inherited,indent,v) }
1921     void setTextAlign(ETextAlign v) { inherited_flags._text_align = v; }
1922     void setTextTransform(ETextTransform v) { inherited_flags._text_transform = v; }
1923     void addToTextDecorationsInEffect(int v) { inherited_flags._text_decorations |= v; }
1924     void setTextDecorationsInEffect(int v) { inherited_flags._text_decorations = v; }
1925     void setTextDecoration(int v) { SET_VAR(visual, textDecoration, v); }
1926     void setDirection(TextDirection v) { inherited_flags._direction = v; }
1927     void setLineHeight(Length v) { SET_VAR(inherited,line_height,v) }
1928
1929     void setWhiteSpace(EWhiteSpace v) { inherited_flags._white_space = v; }
1930
1931     void setWordSpacing(int v) { inherited.access()->font.setWordSpacing(v); }
1932     void setLetterSpacing(int v) { inherited.access()->font.setLetterSpacing(v); }
1933
1934     void clearBackgroundLayers() { background.access()->m_background = BackgroundLayer(); }
1935     void inheritBackgroundLayers(const BackgroundLayer& parent) { background.access()->m_background = parent; }
1936     void adjustBackgroundLayers();
1937
1938     void setBorderCollapse(bool collapse) { inherited_flags._border_collapse = collapse; }
1939     void setHorizontalBorderSpacing(short v) { SET_VAR(inherited,horizontal_border_spacing,v) }
1940     void setVerticalBorderSpacing(short v) { SET_VAR(inherited,vertical_border_spacing,v) }
1941     void setEmptyCells(EEmptyCell v) { inherited_flags._empty_cells = v; }
1942     void setCaptionSide(ECaptionSide v) { inherited_flags._caption_side = v; }
1943
1944
1945     void setCounterIncrement(short v) {  SET_VAR(visual,counterIncrement,v) }
1946     void setCounterReset(short v) {  SET_VAR(visual,counterReset,v) }
1947
1948     void setListStyleType(EListStyleType v) { inherited_flags._list_style_type = v; }
1949     void setListStyleImage(CachedImage *v) {  SET_VAR(inherited,style_image,v)}
1950     void setListStylePosition(EListStylePosition v) { inherited_flags._list_style_position = v; }
1951
1952     void resetMargin() { SET_VAR(surround, margin, LengthBox(Fixed)) }
1953     void setMarginTop(Length v)     {  SET_VAR(surround,margin.top,v) }
1954     void setMarginBottom(Length v)  {  SET_VAR(surround,margin.bottom,v) }
1955     void setMarginLeft(Length v)    {  SET_VAR(surround,margin.left,v) }
1956     void setMarginRight(Length v)   {  SET_VAR(surround,margin.right,v) }
1957
1958     void resetPadding() { SET_VAR(surround, padding, LengthBox(Auto)) }
1959     void setPaddingTop(Length v)    {  SET_VAR(surround,padding.top,v) }
1960     void setPaddingBottom(Length v) {  SET_VAR(surround,padding.bottom,v) }
1961     void setPaddingLeft(Length v)   {  SET_VAR(surround,padding.left,v) }
1962     void setPaddingRight(Length v)  {  SET_VAR(surround,padding.right,v) }
1963
1964     void setCursor( ECursor c ) { inherited_flags._cursor_style = c; }
1965     void addCursor(CachedImage*, const IntPoint& = IntPoint());
1966     void addSVGCursor(const String&);
1967     void setCursorList(PassRefPtr<CursorList>);
1968     void clearCursorList();
1969
1970     bool forceBackgroundsToWhite() const { return inherited_flags._force_backgrounds_to_white; }
1971     void setForceBackgroundsToWhite(bool b=true) { inherited_flags._force_backgrounds_to_white = b; }
1972
1973     bool htmlHacks() const { return inherited_flags._htmlHacks; }
1974     void setHtmlHacks(bool b=true) { inherited_flags._htmlHacks = b; }
1975
1976     bool hasAutoZIndex() { return box->z_auto; }
1977     void setHasAutoZIndex() { SET_VAR(box, z_auto, true); SET_VAR(box, z_index, 0) }
1978     int zIndex() const { return box->z_index; }
1979     void setZIndex(int v) { SET_VAR(box, z_auto, false); SET_VAR(box, z_index, v) }
1980
1981     void setWidows(short w) { SET_VAR(inherited, widows, w); }
1982     void setOrphans(short o) { SET_VAR(inherited, orphans, o); }
1983     void setPageBreakInside(EPageBreak b) { SET_VAR(inherited, page_break_inside, b); }
1984     void setPageBreakBefore(EPageBreak b) { noninherited_flags._page_break_before = b; }
1985     void setPageBreakAfter(EPageBreak b) { noninherited_flags._page_break_after = b; }
1986     
1987     // CSS3 Setters
1988 #if ENABLE(XBL)
1989     void deleteBindingURIs() { 
1990         delete rareNonInheritedData->bindingURI; 
1991         SET_VAR(rareNonInheritedData, bindingURI, (BindingURI*) 0);
1992     }
1993     void inheritBindingURIs(BindingURI* other) {
1994         SET_VAR(rareNonInheritedData, bindingURI, other->copy());
1995     }
1996     void addBindingURI(StringImpl* uri);
1997 #endif
1998     void setOutlineOffset(int v) { SET_VAR(background, m_outline._offset, v) }
1999     void setTextShadow(ShadowData* val, bool add=false);
2000     void setTextStrokeColor(const Color& c) { SET_VAR(rareInheritedData, textStrokeColor, c) }
2001     void setTextStrokeWidth(float w) { SET_VAR(rareInheritedData, textStrokeWidth, w) }
2002     void setTextFillColor(const Color& c) { SET_VAR(rareInheritedData, textFillColor, c) }
2003     void setOpacity(float f) { SET_VAR(rareNonInheritedData, opacity, f); }
2004     void setAppearance(EAppearance a) { SET_VAR(rareNonInheritedData, m_appearance, a); }
2005     void setBoxAlign(EBoxAlignment a) { SET_VAR(rareNonInheritedData.access()->flexibleBox, align, a); }
2006     void setBoxDirection(EBoxDirection d) { inherited_flags._box_direction = d; }
2007     void setBoxFlex(float f) { SET_VAR(rareNonInheritedData.access()->flexibleBox, flex, f); }
2008     void setBoxFlexGroup(unsigned int fg) { SET_VAR(rareNonInheritedData.access()->flexibleBox, flex_group, fg); }
2009     void setBoxLines(EBoxLines l) { SET_VAR(rareNonInheritedData.access()->flexibleBox, lines, l); }
2010     void setBoxOrdinalGroup(unsigned int og) { SET_VAR(rareNonInheritedData.access()->flexibleBox, ordinal_group, og); }
2011     void setBoxOrient(EBoxOrient o) { SET_VAR(rareNonInheritedData.access()->flexibleBox, orient, o); }
2012     void setBoxPack(EBoxAlignment p) { SET_VAR(rareNonInheritedData.access()->flexibleBox, pack, p); }
2013     void setBoxShadow(ShadowData* val, bool add=false);
2014     void setBoxSizing(EBoxSizing s) { SET_VAR(box, boxSizing, s); }
2015     void setMarqueeIncrement(const Length& f) { SET_VAR(rareNonInheritedData.access()->marquee, increment, f); }
2016     void setMarqueeSpeed(int f) { SET_VAR(rareNonInheritedData.access()->marquee, speed, f); }
2017     void setMarqueeDirection(EMarqueeDirection d) { SET_VAR(rareNonInheritedData.access()->marquee, direction, d); }
2018     void setMarqueeBehavior(EMarqueeBehavior b) { SET_VAR(rareNonInheritedData.access()->marquee, behavior, b); }
2019     void setMarqueeLoopCount(int i) { SET_VAR(rareNonInheritedData.access()->marquee, loops, i); }
2020     void setUserModify(EUserModify u) { SET_VAR(rareInheritedData, userModify, u); }
2021     void setUserDrag(EUserDrag d) { SET_VAR(rareNonInheritedData, userDrag, d); }
2022     void setUserSelect(EUserSelect s) { SET_VAR(rareInheritedData, userSelect, s); }
2023     void setTextOverflow(bool b) { SET_VAR(rareNonInheritedData, textOverflow, b); }
2024     void setMarginTopCollapse(EMarginCollapse c) { SET_VAR(rareNonInheritedData, marginTopCollapse, c); }
2025     void setMarginBottomCollapse(EMarginCollapse c) { SET_VAR(rareNonInheritedData, marginBottomCollapse, c); }
2026     void setWordBreak(EWordBreak b) { SET_VAR(rareInheritedData, wordBreak, b); }
2027     void setWordWrap(EWordWrap b) { SET_VAR(rareInheritedData, wordWrap, b); }
2028     void setNBSPMode(ENBSPMode b) { SET_VAR(rareInheritedData, nbspMode, b); }
2029     void setKHTMLLineBreak(EKHTMLLineBreak b) { SET_VAR(rareInheritedData, khtmlLineBreak, b); }
2030     void setMatchNearestMailBlockquoteColor(EMatchNearestMailBlockquoteColor c)  { SET_VAR(rareNonInheritedData, matchNearestMailBlockquoteColor, c); }
2031     void setHighlight(const AtomicString& h) { SET_VAR(rareInheritedData, highlight, h); }
2032     void setBorderFit(EBorderFit b) { SET_VAR(rareNonInheritedData, m_borderFit, b); }
2033     void setResize(EResize r) { SET_VAR(rareInheritedData, resize, r); }
2034     void setColumnWidth(float f) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_autoWidth, false); SET_VAR(rareNonInheritedData.access()->m_multiCol, m_width, f); }
2035     void setHasAutoColumnWidth() { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_autoWidth, true); SET_VAR(rareNonInheritedData.access()->m_multiCol, m_width, 0); }
2036     void setColumnCount(unsigned short c) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_autoCount, false); SET_VAR(rareNonInheritedData.access()->m_multiCol, m_count, c); }
2037     void setHasAutoColumnCount() { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_autoCount, true); SET_VAR(rareNonInheritedData.access()->m_multiCol, m_count, 0); }
2038     void setColumnGap(float f) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_normalGap, false); SET_VAR(rareNonInheritedData.access()->m_multiCol, m_gap, f); }
2039     void setHasNormalColumnGap() { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_normalGap, true); SET_VAR(rareNonInheritedData.access()->m_multiCol, m_gap, 0); }
2040     void setColumnRuleColor(const Color& c) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_rule.color, c); }
2041     void setColumnRuleStyle(EBorderStyle b) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_rule.m_style, b); }
2042     void setColumnRuleWidth(unsigned short w) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_rule.width, w); }
2043     void resetColumnRule() { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_rule, BorderValue()) }
2044     void setColumnBreakBefore(EPageBreak p) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_breakBefore, p); }
2045     void setColumnBreakInside(EPageBreak p) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_breakInside, p); }
2046     void setColumnBreakAfter(EPageBreak p) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_breakAfter, p); }
2047     void setTransform(const TransformOperations& ops) { SET_VAR(rareNonInheritedData.access()->m_transform, m_operations, ops); }
2048     void setTransformOriginX(Length l) { SET_VAR(rareNonInheritedData.access()->m_transform, m_x, l); }
2049     void setTransformOriginY(Length l) { SET_VAR(rareNonInheritedData.access()->m_transform, m_y, l); }
2050     // End CSS3 Setters
2051    
2052     // Apple-specific property setters
2053     void clearTransitions() { delete rareNonInheritedData.access()->m_transition; rareNonInheritedData.access()->m_transition = 0; }
2054     void inheritTransitions(const Transition* parent) { clearTransitions(); if (parent) rareNonInheritedData.access()->m_transition = new Transition(*parent); }
2055     void adjustTransitions();
2056     void setLineClamp(int c) { SET_VAR(rareNonInheritedData, lineClamp, c); }
2057     void setTextSizeAdjust(bool b) { SET_VAR(rareInheritedData, textSizeAdjust, b); }
2058     void setTextSecurity(ETextSecurity aTextSecurity) { SET_VAR(rareInheritedData, textSecurity, aTextSecurity); } 
2059
2060 #if ENABLE(SVG)
2061     const SVGRenderStyle* svgStyle() const { return m_svgStyle.get(); }
2062     SVGRenderStyle* accessSVGStyle() { return m_svgStyle.access(); }
2063 #endif
2064
2065     const ContentData* contentData() const { return rareNonInheritedData->m_content; }
2066     bool contentDataEquivalent(const RenderStyle* otherStyle) const;
2067     void clearContent();
2068     void setContent(StringImpl*, bool add = false);
2069     void setContent(CachedResource*, bool add = false);
2070     void setContent(CounterContent*, bool add = false);
2071
2072     const CounterDirectiveMap* counterDirectives() const;
2073     CounterDirectiveMap& accessCounterDirectives();
2074
2075     bool inheritedNotEqual(RenderStyle* other) const;
2076
2077     // The difference between two styles.  The following values are used:
2078     // (1) Equal - The two styles are identical
2079     // (2) Repaint - The object just needs to be repainted.
2080     // (3) RepaintLayer - The layer and its descendant layers needs to be repainted.
2081     // (4) Layout - A layout is required.
2082     enum Diff { Equal, Repaint, RepaintLayer, Layout };
2083     Diff diff( const RenderStyle *other ) const;
2084
2085     bool isDisplayReplacedType() {
2086         return display() == INLINE_BLOCK || display() == INLINE_BOX || display() == INLINE_TABLE;
2087     }
2088     bool isDisplayInlineType() {
2089         return display() == INLINE || isDisplayReplacedType();
2090     }
2091     bool isOriginalDisplayInlineType() {
2092         return originalDisplay() == INLINE || originalDisplay() == INLINE_BLOCK ||
2093                originalDisplay() == INLINE_BOX || originalDisplay() == INLINE_TABLE;
2094     }
2095     
2096     // To obtain at any time the pseudo state for a given link.
2097     PseudoState pseudoState() const { return static_cast<PseudoState>(m_pseudoState); }
2098     void setPseudoState(PseudoState s) { m_pseudoState = s; }
2099     
2100     // To tell if this style matched attribute selectors. This makes it impossible to share.
2101     bool affectedByAttributeSelectors() const { return m_affectedByAttributeSelectors; }
2102     void setAffectedByAttributeSelectors() { m_affectedByAttributeSelectors = true; }
2103
2104     bool unique() const { return m_unique; }
2105     void setUnique() { m_unique = true; }
2106
2107     // Initial values for all the properties
2108     static bool initialBackgroundAttachment() { return true; }
2109     static EBackgroundBox initialBackgroundClip() { return BGBORDER; }
2110     static EBackgroundBox initialBackgroundOrigin() { return BGPADDING; }
2111     static EBackgroundRepeat initialBackgroundRepeat() { return REPEAT; }
2112     static CompositeOperator initialBackgroundComposite() { return CompositeSourceOver; }
2113     static LengthSize initialBackgroundSize() { return LengthSize(); }
2114     static bool initialBorderCollapse() { return false; }
2115     static EBorderStyle initialBorderStyle() { return BNONE; }
2116     static BorderImage initialBorderImage() { return BorderImage(); }
2117     static IntSize initialBorderRadius() { return IntSize(0,0); }
2118     static ECaptionSide initialCaptionSide() { return CAPTOP; }
2119     static EClear initialClear() { return CNONE; }
2120     static TextDirection initialDirection() { return LTR; }
2121     static EDisplay initialDisplay() { return INLINE; }
2122     static EEmptyCell initialEmptyCells() { return SHOW; }
2123     static EFloat initialFloating() { return FNONE; }
2124     static EListStylePosition initialListStylePosition() { return OUTSIDE; }
2125     static EListStyleType initialListStyleType() { return DISC; }
2126     static EOverflow initialOverflowX() { return OVISIBLE; }
2127     static EOverflow initialOverflowY() { return OVISIBLE; }
2128     static EPageBreak initialPageBreak() { return PBAUTO; }
2129     static EPosition initialPosition() { return StaticPosition; }
2130     static ETableLayout initialTableLayout() { return TAUTO; }
2131     static EUnicodeBidi initialUnicodeBidi() { return UBNormal; }
2132     static ETextTransform initialTextTransform() { return TTNONE; }
2133     static EVisibility initialVisibility() { return VISIBLE; }
2134     static EWhiteSpace initialWhiteSpace() { return NORMAL; }
2135     static Length initialBackgroundXPosition() { return Length(0.0, Percent); }
2136     static Length initialBackgroundYPosition() { return Length(0.0, Percent); }
2137     static short initialHorizontalBorderSpacing() { return 0; }
2138     static short initialVerticalBorderSpacing() { return 0; }
2139     static ECursor initialCursor() { return CURSOR_AUTO; }
2140     static Color initialColor() { return Color::black; }
2141     static CachedImage* initialBackgroundImage() { return 0; }
2142     static CachedImage* initialListStyleImage() { return 0; }
2143     static unsigned short initialBorderWidth() { return 3; }
2144     static int initialLetterWordSpacing() { return 0; }
2145     static Length initialSize() { return Length(); }
2146     static Length initialMinSize() { return Length(0, Fixed); }
2147     static Length initialMaxSize() { return Length(undefinedLength, Fixed); }
2148     static Length initialOffset() { return Length(); }
2149     static Length initialMargin() { return Length(Fixed); }
2150     static Length initialPadding() { return Length(Auto); }
2151     static Length initialTextIndent() { return Length(Fixed); }
2152     static EVerticalAlign initialVerticalAlign() { return BASELINE; }
2153     static int initialWidows() { return 2; }
2154     static int initialOrphans() { return 2; }
2155     static Length initialLineHeight() { return Length(-100.0, Percent); }
2156     static ETextAlign initialTextAlign() { return TAAUTO; }
2157     static ETextDecoration initialTextDecoration() { return TDNONE; }
2158     static int initialOutlineOffset() { return 0; }
2159     static float initialOpacity() { return 1.0f; }
2160     static EBoxAlignment initialBoxAlign() { return BSTRETCH; }
2161     static EBoxDirection initialBoxDirection() { return BNORMAL; }
2162     static EBoxLines initialBoxLines() { return SINGLE; }
2163     static EBoxOrient initialBoxOrient() { return HORIZONTAL; }
2164     static EBoxAlignment initialBoxPack() { return BSTART; }
2165     static float initialBoxFlex() { return 0.0f; }
2166     static int initialBoxFlexGroup() { return 1; }
2167     static int initialBoxOrdinalGroup() { return 1; }
2168     static EBoxSizing initialBoxSizing() { return CONTENT_BOX; }
2169     static int initialMarqueeLoopCount() { return -1; }
2170     static int initialMarqueeSpeed() { return 85; }
2171     static Length initialMarqueeIncrement() { return Length(6, Fixed); }
2172     static EMarqueeBehavior initialMarqueeBehavior() { return MSCROLL; }
2173     static EMarqueeDirection initialMarqueeDirection() { return MAUTO; }
2174     static EUserModify initialUserModify() { return READ_ONLY; }
2175     static EUserDrag initialUserDrag() { return DRAG_AUTO; }
2176     static EUserSelect initialUserSelect() { return SELECT_TEXT; }
2177     static bool initialTextOverflow() { return false; }
2178     static EMarginCollapse initialMarginTopCollapse() { return MCOLLAPSE; }
2179     static EMarginCollapse initialMarginBottomCollapse() { return MCOLLAPSE; }
2180     static EWordBreak initialWordBreak() { return NormalWordBreak; }
2181     static EWordWrap initialWordWrap() { return NormalWordWrap; }
2182     static ENBSPMode initialNBSPMode() { return NBNORMAL; }
2183     static EKHTMLLineBreak initialKHTMLLineBreak() { return LBNORMAL; }
2184     static EMatchNearestMailBlockquoteColor initialMatchNearestMailBlockquoteColor() { return BCNORMAL; }
2185     static const AtomicString& initialHighlight() { return nullAtom; }
2186     static EBorderFit initialBorderFit() { return BorderFitBorder; }
2187     static EResize initialResize() { return RESIZE_NONE; }
2188     static EAppearance initialAppearance() { return NoAppearance; }
2189     static bool initialVisuallyOrdered() { return false; }
2190     static float initialTextStrokeWidth() { return 0; }
2191     static unsigned short initialColumnCount() { return 1; }
2192     static const TransformOperations& initialTransform() { static TransformOperations ops; return ops; }
2193     static Length initialTransformOriginX() { return Length(50.0, Percent); }
2194     static Length initialTransformOriginY() { return Length(50.0, Percent); }
2195     
2196     // Keep these at the end.
2197     static int initialTransitionDuration() { return 0; }
2198     static int initialTransitionRepeatCount() { return 1; }
2199     static TimingFunction initialTransitionTimingFunction() { return TimingFunction(); }
2200     static int initialTransitionProperty() { return cAnimateAll; }
2201     static int initialLineClamp() { return -1; }
2202     static bool initialTextSizeAdjust() { return true; }
2203     static ETextSecurity initialTextSecurity() { return TSNONE; }
2204     static const Vector<StyleDashboardRegion>& initialDashboardRegions();
2205     static const Vector<StyleDashboardRegion>& noneDashboardRegions();
2206 };
2207
2208 } // namespace WebCore
2209
2210 #endif