summaryrefslogtreecommitdiffstats
path: root/khtml/rendering/render_style.h
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commitce4a32fe52ef09d8f5ff1dd22c001110902b60a2 (patch)
tree5ac38a06f3dde268dc7927dc155896926aaf7012 /khtml/rendering/render_style.h
downloadtdelibs-ce4a32fe52ef09d8f5ff1dd22c001110902b60a2.tar.gz
tdelibs-ce4a32fe52ef09d8f5ff1dd22c001110902b60a2.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdelibs@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'khtml/rendering/render_style.h')
-rw-r--r--khtml/rendering/render_style.h1517
1 files changed, 1517 insertions, 0 deletions
diff --git a/khtml/rendering/render_style.h b/khtml/rendering/render_style.h
new file mode 100644
index 000000000..f8c2affd7
--- /dev/null
+++ b/khtml/rendering/render_style.h
@@ -0,0 +1,1517 @@
+/*
+ * This file is part of the DOM implementation for KDE.
+ *
+ * Copyright (C) 2000-2003 Lars Knoll (knoll@kde.org)
+ * (C) 2000 Antti Koivisto (koivisto@kde.org)
+ * (C) 2000-2003 Dirk Mueller (mueller@kde.org)
+ * (C) 2003-2005 Apple Computer, Inc.
+ * (C) 2004-2006 Allan Sandfeld Jensen (kde@carewolf.com)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ */
+#ifndef RENDERSTYLE_H
+#define RENDERSTYLE_H
+
+/*
+ * WARNING:
+ * --------
+ *
+ * The order of the values in the enums have to agree with the order specified
+ * in cssvalues.in, otherwise some optimizations in the parser will fail,
+ * and produce invaliud results.
+ */
+
+#include <qcolor.h>
+#include <qfont.h>
+#include <qfontmetrics.h>
+#include <qptrlist.h>
+#include <qpalette.h>
+#include <qapplication.h>
+
+#include "dom/dom_misc.h"
+#include "dom/dom_string.h"
+#include "misc/khtmllayout.h"
+#include "misc/shared.h"
+#include "rendering/font.h"
+
+#include <assert.h>
+
+#define SET_VAR(group,variable,value) \
+ if (!(group->variable == value)) \
+ group.access()->variable = value;
+
+#ifndef ENABLE_DUMP
+#ifndef NDEBUG
+#define ENABLE_DUMP 1
+#endif
+#endif
+
+namespace DOM {
+ class DOMStringImpl;
+ class ShadowValueImpl;
+ class QuotesValueImpl;
+ class CounterImpl;
+ class CSSValueListImpl;
+ class CounterActImpl;
+}
+
+namespace khtml {
+
+ class CachedImage;
+ class CachedObject;
+
+template <class DATA>
+class DataRef
+{
+public:
+
+ DataRef()
+ {
+ data=0;
+ }
+ DataRef( const DataRef<DATA> &d )
+ {
+ data = d.data;
+ data->ref();
+ }
+
+ ~DataRef()
+ {
+ if(data) data->deref();
+ }
+
+ const DATA* operator->() const
+ {
+ return data;
+ }
+
+ const DATA* get() const
+ {
+ return data;
+ }
+
+
+ DATA* access()
+ {
+ if (!data->hasOneRef())
+ {
+ data->deref();
+ data = new DATA(*data);
+ data->ref();
+ }
+ return data;
+ }
+
+ void init()
+ {
+ data = new DATA;
+ data->ref();
+ }
+
+ DataRef<DATA>& operator=(const DataRef<DATA>& d)
+ {
+ if (data==d.data)
+ return *this;
+ if (data)
+ data->deref();
+ data = d.data;
+
+ data->ref();
+
+ return *this;
+ }
+
+ bool operator == ( const DataRef<DATA> &o ) const {
+ return (*data == *(o.data) );
+ }
+ bool operator != ( const DataRef<DATA> &o ) const {
+ return (*data != *(o.data) );
+ }
+
+private:
+ DATA* data;
+};
+
+
+//------------------------------------------------
+
+//------------------------------------------------
+// Box model attributes. Not inherited.
+
+struct LengthBox
+{
+ LengthBox()
+ {
+ }
+ LengthBox( LengthType t )
+ : left( t ), right ( t ), top( t ), bottom( t ) {}
+
+ Length left;
+ Length right;
+ Length top;
+ Length bottom;
+ Length& operator=(Length& len)
+ {
+ left=len;
+ right=len;
+ top=len;
+ bottom=len;
+ return len;
+ }
+
+ bool operator==(const LengthBox& o) const
+ {
+ return left==o.left && right==o.right && top==o.top && bottom==o.bottom;
+ }
+
+
+ bool nonZero() const { return left.value() || right.value() || top.value() || bottom.value(); }
+};
+
+
+
+enum EPosition {
+ STATIC, RELATIVE, ABSOLUTE, FIXED
+};
+
+enum EFloat {
+ FNONE = 0, FLEFT = 0x01, FRIGHT = 0x02, FLEFT_ALIGN = 0x05, FRIGHT_ALIGN = 0x06
+};
+
+
+//------------------------------------------------
+// Border attributes. Not inherited.
+
+
+// These have been defined in the order of their precedence for border-collapsing. Do
+// not change this order!
+enum EBorderStyle {
+ BNATIVE, BNONE, BHIDDEN, INSET, GROOVE, RIDGE, OUTSET, DOTTED, DASHED, SOLID, DOUBLE
+};
+
+class BorderValue
+{
+public:
+ BorderValue() : width( 3 ), style( BNONE ) {}
+
+ QColor color;
+ unsigned short width : 12;
+ EBorderStyle style : 6;
+
+ bool nonZero(bool checkStyle = true) const {
+ return width != 0 && !(checkStyle && style == BNONE);
+ }
+
+ bool isTransparent() const {
+ return color.isValid() && qAlpha(color.rgb()) == 0;
+ }
+
+ bool operator==(const BorderValue& o) const
+ {
+ return width==o.width && style==o.style && color==o.color;
+ }
+
+ bool operator!=(const BorderValue& o) const
+ {
+ return !(*this == o);
+ }
+};
+
+class OutlineValue : public BorderValue
+{
+ public:
+ OutlineValue()
+ {
+ _offset = 0;
+ _auto = false;
+ }
+
+ bool operator==(const OutlineValue& o) const
+ {
+ return width==o.width && style==o.style && color==o.color && _offset == o._offset && _auto == o._auto;
+ }
+
+ bool operator!=(const OutlineValue& o) const
+ {
+ return !(*this == o);
+ }
+
+ int _offset;
+ bool _auto;
+};
+
+enum EBorderPrecedence { BOFF, BTABLE, BCOLGROUP, BCOL, BROWGROUP, BROW, BCELL };
+
+struct CollapsedBorderValue
+{
+ CollapsedBorderValue() :border(0), precedence(BOFF) {}
+ CollapsedBorderValue(const BorderValue* b, EBorderPrecedence p) :border(b), precedence(p) {}
+
+ int width() const { return border && border->nonZero() ? border->width : 0; }
+ EBorderStyle style() const { return border ? border->style : BHIDDEN; }
+ bool exists() const { return border; }
+ QColor color() const { return border ? border->color : QColor(); }
+ bool isTransparent() const { return border ? border->isTransparent() : true; }
+
+ bool operator==(const CollapsedBorderValue& o) const
+ {
+ if (!border) return !o.border;
+ if (!o.border) return false;
+ return *border == *o.border && precedence == o.precedence;
+ }
+
+ const BorderValue* border;
+ EBorderPrecedence precedence;
+};
+
+class BorderData : public Shared<BorderData>
+{
+public:
+ BorderValue left;
+ BorderValue right;
+ BorderValue top;
+ BorderValue bottom;
+
+ bool hasBorder() const
+ {
+ return left.nonZero() || right.nonZero() || top.nonZero() || bottom.nonZero();
+ }
+
+ unsigned short borderLeftWidth() const {
+ if (left.style == BNONE || left.style == BHIDDEN || left.style == BNATIVE)
+ return 0;
+ return left.width;
+ }
+
+ unsigned short borderRightWidth() const {
+ if (right.style == BNONE || right.style == BHIDDEN || right.style == BNATIVE)
+ return 0;
+ return right.width;
+ }
+
+ unsigned short borderTopWidth() const {
+ if (top.style == BNONE || top.style == BHIDDEN || top.style == BNATIVE)
+ return 0;
+ return top.width;
+ }
+
+ unsigned short borderBottomWidth() const {
+ if (bottom.style == BNONE || bottom.style == BHIDDEN || bottom.style == BNATIVE)
+ return 0;
+ return bottom.width;
+ }
+
+ bool operator==(const BorderData& o) const
+ {
+ return left==o.left && right==o.right && top==o.top && bottom==o.bottom;
+ }
+
+};
+
+class StyleSurroundData : public Shared<StyleSurroundData>
+{
+public:
+ StyleSurroundData();
+
+ StyleSurroundData(const StyleSurroundData& o );
+ bool operator==(const StyleSurroundData& o) const;
+ bool operator!=(const StyleSurroundData& o) const {
+ return !(*this == o);
+ }
+ bool hasSamePBMData(const StyleSurroundData& o) const {
+ return (margin == o.margin) && (padding == o.padding) && (border == o.border);
+ }
+
+ LengthBox offset;
+ LengthBox margin;
+ LengthBox padding;
+ BorderData border;
+};
+
+
+//------------------------------------------------
+// Box attributes. Not inherited.
+
+enum EBoxSizing {
+ BORDER_BOX, CONTENT_BOX
+};
+
+class StyleBoxData : public Shared<StyleBoxData>
+{
+public:
+ StyleBoxData();
+
+ StyleBoxData(const StyleBoxData& o );
+
+
+ // copy and assignment
+// StyleBoxData(const StyleBoxData &other);
+// const StyleBoxData &operator = (const StyleBoxData &other);
+
+ bool operator==(const StyleBoxData& o) const;
+ bool operator!=(const StyleBoxData& o) const {
+ return !(*this == o);
+ }
+
+ Length width;
+ Length height;
+
+ Length min_width;
+ Length max_width;
+
+ Length min_height;
+ Length max_height;
+
+ Length vertical_align;
+
+ EBoxSizing box_sizing;
+
+ signed int z_index :31;
+ bool z_auto : 1;
+};
+
+//------------------------------------------------
+// Random visual rendering model attributes. Not inherited.
+
+enum EOverflow {
+ OVISIBLE, OHIDDEN, OSCROLL, OAUTO, OMARQUEE
+};
+
+enum EVerticalAlign {
+ BASELINE, MIDDLE, SUB, SUPER, TEXT_TOP,
+ TEXT_BOTTOM, TOP, BOTTOM, BASELINE_MIDDLE, LENGTH
+};
+
+enum EClear{
+ CNONE = 0, CLEFT = 1, CRIGHT = 2, CBOTH = 3
+};
+
+enum ETableLayout {
+ TAUTO, TFIXED
+};
+
+enum EUnicodeBidi {
+ UBNormal, Embed, Override
+};
+
+class StyleVisualData : public Shared<StyleVisualData>
+{
+public:
+ StyleVisualData();
+
+ ~StyleVisualData();
+
+ StyleVisualData(const StyleVisualData& o );
+
+ bool operator==( const StyleVisualData &o ) const {
+ return ( clip == o.clip &&
+ palette == o.palette );
+ }
+ bool operator!=( const StyleVisualData &o ) const {
+ return !(*this == o);
+ }
+
+ LengthBox clip;
+ unsigned textDecoration : 4; // Text decorations defined *only* by this element.
+
+ QPalette palette; //widget styling with IE attributes
+
+};
+
+//------------------------------------------------
+enum EBackgroundBox {
+ BGBORDER, BGPADDING, BGCONTENT
+};
+
+enum EBackgroundRepeat {
+ REPEAT, REPEAT_X, REPEAT_Y, NO_REPEAT
+};
+
+struct LengthSize {
+ Length width;
+ Length height;
+};
+
+struct BackgroundLayer {
+public:
+ BackgroundLayer();
+ ~BackgroundLayer();
+
+ CachedImage* backgroundImage() const { return m_image; }
+ Length backgroundXPosition() const { return m_xPosition; }
+ Length backgroundYPosition() const { return m_yPosition; }
+ bool backgroundAttachment() const { return m_bgAttachment; }
+ EBackgroundBox backgroundClip() const { return m_bgClip; }
+ EBackgroundBox backgroundOrigin() const { return m_bgOrigin; }
+ EBackgroundRepeat backgroundRepeat() const { return m_bgRepeat; }
+ LengthSize backgroundSize() const { return m_backgroundSize; }
+
+ BackgroundLayer* next() const { return m_next; }
+ BackgroundLayer* next() { return m_next; }
+
+ bool isBackgroundImageSet() const { return m_imageSet; }
+ bool isBackgroundXPositionSet() const { return m_xPosSet; }
+ bool isBackgroundYPositionSet() const { return m_yPosSet; }
+ bool isBackgroundAttachmentSet() const { return m_attachmentSet; }
+ bool isBackgroundClipSet() const { return m_clipSet; }
+ bool isBackgroundOriginSet() const { return m_originSet; }
+ bool isBackgroundRepeatSet() const { return m_repeatSet; }
+ bool isBackgroundSizeSet() const { return m_backgroundSizeSet; }
+
+ void setBackgroundImage(CachedImage* i) { m_image = i; m_imageSet = true; }
+ void setBackgroundXPosition(const Length& l) { m_xPosition = l; m_xPosSet = true; }
+ void setBackgroundYPosition(const Length& l) { m_yPosition = l; m_yPosSet = true; }
+ void setBackgroundAttachment(bool b) { m_bgAttachment = b; m_attachmentSet = true; }
+ void setBackgroundClip(EBackgroundBox b) { m_bgClip = b; m_clipSet = true; }
+ void setBackgroundOrigin(EBackgroundBox b) { m_bgOrigin = b; m_originSet = true; }
+ void setBackgroundRepeat(EBackgroundRepeat r) { m_bgRepeat = r; m_repeatSet = true; }
+ void setBackgroundSize(const LengthSize& b) { m_backgroundSize = b; m_backgroundSizeSet = true; }
+
+ void clearBackgroundImage() { m_imageSet = false; }
+ void clearBackgroundXPosition() { m_xPosSet = false; }
+ void clearBackgroundYPosition() { m_yPosSet = false; }
+ void clearBackgroundAttachment() { m_attachmentSet = false; }
+ void clearBackgroundClip() { m_clipSet = false; }
+ void clearBackgroundOrigin() { m_originSet = false; }
+ void clearBackgroundRepeat() { m_repeatSet = false; }
+ void clearBackgroundSize() { m_backgroundSizeSet = false; }
+
+ void setNext(BackgroundLayer* n) { if (m_next != n) { delete m_next; m_next = n; } }
+
+ BackgroundLayer& operator=(const BackgroundLayer& o);
+ BackgroundLayer(const BackgroundLayer& o);
+
+ bool operator==(const BackgroundLayer& o) const;
+ bool operator!=(const BackgroundLayer& o) const {
+ return !(*this == o);
+ }
+
+ bool containsImage(CachedImage* c) const { if (c == m_image) return true; if (m_next) return m_next->containsImage(c); return false; }
+
+ bool hasImage() const {
+ if (m_image)
+ return true;
+ return m_next ? m_next->hasImage() : false;
+ }
+ bool hasFixedImage() const {
+ if (m_image && !m_bgAttachment)
+ return true;
+ return m_next ? m_next->hasFixedImage() : false;
+ }
+
+ void fillUnsetProperties();
+ void cullEmptyLayers();
+
+ CachedImage* m_image;
+
+ Length m_xPosition;
+ Length m_yPosition;
+
+ bool m_bgAttachment : 1;
+ EBackgroundBox m_bgClip : 2;
+ EBackgroundBox m_bgOrigin : 2;
+ EBackgroundRepeat m_bgRepeat : 2;
+
+ LengthSize m_backgroundSize;
+
+ bool m_imageSet : 1;
+ bool m_attachmentSet : 1;
+ bool m_clipSet : 1;
+ bool m_originSet : 1;
+ bool m_repeatSet : 1;
+ bool m_xPosSet : 1;
+ bool m_yPosSet : 1;
+ bool m_backgroundSizeSet : 1;
+
+ BackgroundLayer* m_next;
+};
+
+class StyleBackgroundData : public Shared<StyleBackgroundData>
+{
+public:
+ StyleBackgroundData();
+ ~StyleBackgroundData() {}
+ StyleBackgroundData(const StyleBackgroundData& o );
+
+ bool operator==(const StyleBackgroundData& o) const;
+ bool operator!=(const StyleBackgroundData &o) const {
+ return !(*this == o);
+ }
+
+ BackgroundLayer m_background;
+ QColor m_color;
+ OutlineValue m_outline;
+};
+
+enum EQuoteContent {
+ NO_QUOTE = 0, OPEN_QUOTE, CLOSE_QUOTE, NO_OPEN_QUOTE, NO_CLOSE_QUOTE
+};
+
+enum ContentType {
+ CONTENT_NONE = 0, CONTENT_NORMAL, CONTENT_OBJECT,
+ CONTENT_TEXT, CONTENT_COUNTER, CONTENT_QUOTE
+};
+
+struct ContentData {
+ ContentData() : _contentType( CONTENT_NONE ), _nextContent(0) {}
+ ContentData(const ContentData& o);
+ ~ContentData();
+ void clearContent();
+
+ DOM::DOMStringImpl* contentText()
+ { if (_contentType == CONTENT_TEXT) return _content.text; return 0; }
+ CachedObject* contentObject()
+ { if (_contentType == CONTENT_OBJECT) return _content.object; return 0; }
+ DOM::CounterImpl* contentCounter()
+ { if (_contentType == CONTENT_COUNTER) return _content.counter; return 0; }
+ EQuoteContent contentQuote()
+ { if (_contentType == CONTENT_QUOTE) return _content.quote; return NO_QUOTE; }
+
+ ContentType _contentType;
+
+ union {
+ CachedObject* object;
+ DOM::DOMStringImpl* text;
+ DOM::CounterImpl* counter;
+ EQuoteContent quote;
+ } _content ;
+
+ ContentData* _nextContent;
+};
+
+class StyleGeneratedData : public Shared<StyleGeneratedData>
+{
+public:
+ StyleGeneratedData();
+ ~StyleGeneratedData();
+ StyleGeneratedData(const StyleGeneratedData& o );
+
+ bool operator==(const StyleGeneratedData& o) const;
+ bool operator!=(const StyleGeneratedData &o) const {
+ return !(*this == o);
+ }
+
+ bool contentDataEquivalent(const StyleGeneratedData* otherStyle) const;
+ bool counterDataEquivalent(const StyleGeneratedData* otherStyle) const;
+
+ ContentData *content;
+ DOM::CSSValueListImpl *counter_reset;
+ DOM::CSSValueListImpl *counter_increment;
+};
+
+//------------------------------------------------
+// CSS3 Marquee Properties
+
+enum EMarqueeBehavior { MNONE, MSCROLL, MSLIDE, MALTERNATE, MUNFURL };
+enum EMarqueeDirection { MAUTO = 0, MLEFT = 1, MRIGHT = -1, MUP = 2, MDOWN = -2, MFORWARD = 3, MBACKWARD = -3 };
+
+class StyleMarqueeData : public Shared<StyleMarqueeData>
+{
+public:
+ StyleMarqueeData();
+ StyleMarqueeData(const StyleMarqueeData& o);
+
+ bool operator==(const StyleMarqueeData& o) const;
+ bool operator!=(const StyleMarqueeData& o) const {
+ return !(*this == o);
+ }
+
+ Length increment;
+ int speed;
+
+ int loops; // -1 means infinite.
+
+ EMarqueeBehavior behavior : 3;
+ EMarqueeDirection direction : 3;
+};
+
+// This struct holds information about shadows for the text-shadow and box-shadow properties.
+struct ShadowData {
+ ShadowData(int _x, int _y, int _blur, const QColor& _color)
+ :x(_x), y(_y), blur(_blur), color(_color), next(0) {}
+ ShadowData(const ShadowData& o);
+
+ ~ShadowData() { delete next; }
+
+ bool operator==(const ShadowData& o) const;
+ bool operator!=(const ShadowData &o) const {
+ return !(*this == o);
+ }
+
+ int x;
+ int y;
+ int blur;
+ QColor color;
+ ShadowData* next;
+};
+
+// This struct is for rarely used non-inherited CSS3 properties. By grouping them together,
+// we save space, and only allocate this object when someone actually uses
+// a non-inherited CSS3 property.
+class StyleCSS3NonInheritedData : public Shared<StyleCSS3NonInheritedData>
+{
+public:
+ StyleCSS3NonInheritedData();
+ ~StyleCSS3NonInheritedData() {}
+ StyleCSS3NonInheritedData(const StyleCSS3NonInheritedData& o);
+
+ bool operator==(const StyleCSS3NonInheritedData& o) const;
+ bool operator!=(const StyleCSS3NonInheritedData &o) const {
+ return !(*this == o);
+ }
+
+ float opacity; // Whether or not we're transparent.
+#ifdef APPLE_CHANGES // ### we don't have those (yet)
+ DataRef<StyleFlexibleBoxData> flexibleBox; // Flexible box properties
+#endif
+ DataRef<StyleMarqueeData> marquee; // Marquee properties
+};
+
+// This struct is for rarely used inherited CSS3 properties. By grouping them together,
+// we save space, and only allocate this object when someone actually uses
+// an inherited CSS3 property.
+class StyleCSS3InheritedData : public Shared<StyleCSS3InheritedData>
+{
+ public:
+ StyleCSS3InheritedData();
+ ~StyleCSS3InheritedData();
+ StyleCSS3InheritedData(const StyleCSS3InheritedData& o);
+
+ bool operator==(const StyleCSS3InheritedData& o) const;
+ bool operator!=(const StyleCSS3InheritedData &o) const {
+ return !(*this == o);
+ }
+ bool shadowDataEquivalent(const StyleCSS3InheritedData& o) const;
+
+ ShadowData* textShadow; // Our text shadow information for shadowed text drawing.
+#ifdef APPLE_CHANGES
+ EUserModify userModify : 2; // Flag used for editing state
+ bool textSizeAdjust : 1; // An Apple extension. Not really CSS3 but not worth making a new struct over.
+#endif
+ private:
+ StyleCSS3InheritedData &operator=(const StyleCSS3InheritedData &);
+};
+
+//------------------------------------------------
+// Inherited attributes.
+//
+// the inherited-decoration and inherited-shadow attributes
+// are inherited from the
+// first parent which is block level
+//
+
+enum EWhiteSpace {
+ NORMAL, PRE, NOWRAP, PRE_WRAP, PRE_LINE, KHTML_NOWRAP
+};
+
+enum ETextAlign {
+ TAAUTO, LEFT, RIGHT, CENTER, JUSTIFY, KHTML_LEFT, KHTML_RIGHT, KHTML_CENTER
+};
+
+enum ETextTransform {
+ CAPITALIZE, UPPERCASE, LOWERCASE, TTNONE
+};
+
+enum EDirection {
+ LTR, RTL
+};
+
+enum ETextDecoration {
+ TDNONE = 0x0 , UNDERLINE = 0x1, OVERLINE = 0x2, LINE_THROUGH= 0x4, BLINK = 0x8
+};
+
+enum EPageBreak {
+ PBAUTO, PBALWAYS, PBAVOID,
+ /* reserved for later use: */
+ PBLEFT, PBRIGHT
+};
+
+class StyleInheritedData : public Shared<StyleInheritedData>
+{
+ StyleInheritedData& operator=(const StyleInheritedData&);
+public:
+ StyleInheritedData();
+ ~StyleInheritedData();
+ StyleInheritedData(const StyleInheritedData& o );
+
+ bool operator==(const StyleInheritedData& o) const;
+ bool operator != ( const StyleInheritedData &o ) const {
+ return !(*this == o);
+ }
+
+ Length indent;
+ // could be packed in a short but doesn't
+ // make a difference currently because of padding
+ Length line_height;
+
+ CachedImage *style_image;
+
+ khtml::Font font;
+ QColor color;
+
+ short border_hspacing;
+ short border_vspacing;
+
+ // Paged media properties.
+ short widows;
+ short orphans;
+
+ DOM::QuotesValueImpl* quotes;
+};
+
+
+enum EEmptyCell {
+ SHOW, HIDE
+};
+
+enum ECaptionSide {
+ CAPTOP, CAPBOTTOM, CAPLEFT, CAPRIGHT
+};
+
+
+enum EListStyleType {
+ // Symbols:
+ LDISC, LCIRCLE, LSQUARE, LBOX, LDIAMOND,
+ // Numeric:
+ LDECIMAL, DECIMAL_LEADING_ZERO, ARABIC_INDIC, LAO, PERSIAN, URDU, THAI, TIBETAN,
+ // Algorithmic:
+ LOWER_ROMAN, UPPER_ROMAN, HEBREW, ARMENIAN, GEORGIAN,
+ // Ideographic:
+ CJK_IDEOGRAPHIC, JAPANESE_FORMAL, JAPANESE_INFORMAL,
+ SIMP_CHINESE_FORMAL, SIMP_CHINESE_INFORMAL, TRAD_CHINESE_FORMAL, TRAD_CHINESE_INFORMAL,
+ // Alphabetic:
+ LOWER_GREEK, UPPER_GREEK, LOWER_ALPHA, LOWER_LATIN, UPPER_ALPHA, UPPER_LATIN,
+ HIRAGANA, KATAKANA, HIRAGANA_IROHA, KATAKANA_IROHA,
+ // Special:
+ LNONE
+};
+
+inline bool isListStyleCounted(EListStyleType type)
+{
+ switch(type) {
+ case LDISC: case LCIRCLE: case LSQUARE: case LBOX: case LDIAMOND:
+ case LNONE:
+ return false;
+ default:
+ return true;
+ }
+}
+
+enum EListStylePosition { OUTSIDE, INSIDE };
+
+enum EVisibility { VISIBLE, HIDDEN, COLLAPSE };
+
+enum ECursor {
+ CURSOR_AUTO, CURSOR_CROSS, CURSOR_DEFAULT, CURSOR_POINTER, CURSOR_PROGRESS, CURSOR_MOVE,
+ CURSOR_E_RESIZE, CURSOR_NE_RESIZE, CURSOR_NW_RESIZE, CURSOR_N_RESIZE, CURSOR_SE_RESIZE, CURSOR_SW_RESIZE,
+ CURSOR_S_RESIZE, CURSOR_W_RESIZE, CURSOR_TEXT, CURSOR_WAIT, CURSOR_HELP
+};
+
+enum EUserInput {
+ UI_ENABLED, UI_DISABLED, UI_NONE
+};
+
+//------------------------------------------------
+
+enum EDisplay {
+ INLINE, BLOCK, LIST_ITEM, RUN_IN,
+ COMPACT, INLINE_BLOCK, TABLE, INLINE_TABLE,
+ TABLE_ROW_GROUP, TABLE_HEADER_GROUP, TABLE_FOOTER_GROUP, TABLE_ROW,
+ TABLE_COLUMN_GROUP, TABLE_COLUMN, TABLE_CELL,
+ TABLE_CAPTION, NONE
+};
+
+class RenderStyle : public Shared<RenderStyle>
+{
+ friend class CSSStyleSelector;
+public:
+ KDE_EXPORT static void cleanup();
+
+ // pseudo elements
+ enum PseudoId {
+ NOPSEUDO, FIRST_LINE, FIRST_LETTER, SELECTION,
+ BEFORE, AFTER, REPLACED, MARKER
+ };
+
+protected:
+
+// !START SYNC!: Keep this in sync with the copy constructor in render_style.cpp
+
+ // inherit
+ struct InheritedFlags {
+ // 64 bit inherited, update unused when adding to the struct, or the operator will break.
+ bool operator==( const InheritedFlags &other ) const
+ { return _iflags ==other._iflags; }
+ bool operator!=( const InheritedFlags &other ) const
+ { return _iflags != other._iflags; }
+
+ union {
+ struct {
+ EEmptyCell _empty_cells : 1 ;
+ ECaptionSide _caption_side : 2;
+ EListStyleType _list_style_type : 6;
+ EListStylePosition _list_style_position :1;
+
+ EVisibility _visibility : 2;
+ ETextAlign _text_align : 4;
+ ETextTransform _text_transform : 2;
+ unsigned _text_decorations : 4;
+ ECursor _cursor_style : 5;
+
+ EDirection _direction : 1;
+ bool _border_collapse : 1 ;
+ EWhiteSpace _white_space : 3;
+ // non CSS2 inherited
+ bool _visuallyOrdered : 1;
+ bool _htmlHacks :1;
+ EUserInput _user_input : 2;
+
+ bool _page_break_inside : 1; // AUTO/AVOID
+
+ unsigned int unused : 27;
+ } f;
+ Q_UINT64 _iflags;
+ };
+ } inherited_flags;
+
+// don't inherit
+ struct NonInheritedFlags {
+ // 64 bit non-inherited, update unused when adding to the struct, or the operator will break.
+ bool operator==( const NonInheritedFlags &other ) const
+ { return _niflags == other._niflags; }
+ bool operator!=( const NonInheritedFlags &other ) const
+ { return _niflags != other._niflags; }
+
+ union {
+ struct {
+ EDisplay _display : 5;
+ EDisplay _originalDisplay: 5;
+ EOverflow _overflowX : 4 ;
+ EOverflow _overflowY : 4 ;
+ EVerticalAlign _vertical_align : 4;
+ EClear _clear : 2;
+ EPosition _position : 2;
+ EFloat _floating : 3;
+ ETableLayout _table_layout : 1;
+ bool _flowAroundFloats :1;
+
+ EPageBreak _page_break_before : 3;
+ EPageBreak _page_break_after : 3;
+
+ PseudoId _styleType : 4;
+ bool _hasClip : 1;
+ unsigned _pseudoBits : 8;
+ EUnicodeBidi _unicodeBidi : 2;
+
+ // non CSS2 non-inherited
+ bool _textOverflow : 1; // Whether or not lines that spill out should be truncated with "..."
+
+ unsigned int unused : 11;
+ } f;
+ Q_UINT64 _niflags;
+ };
+ } noninherited_flags;
+
+// non-inherited attributes
+ DataRef<StyleBoxData> box;
+ DataRef<StyleVisualData> visual;
+ DataRef<StyleBackgroundData> background;
+ DataRef<StyleSurroundData> surround;
+ DataRef<StyleGeneratedData> generated;
+ DataRef<StyleCSS3NonInheritedData> css3NonInheritedData;
+
+// inherited attributes
+ DataRef<StyleCSS3InheritedData> css3InheritedData;
+ DataRef<StyleInheritedData> inherited;
+
+// list of associated pseudo styles
+ RenderStyle* pseudoStyle;
+
+// !END SYNC!
+
+// static default style
+ static RenderStyle* _default;
+
+private:
+ RenderStyle(const RenderStyle*) {}
+
+protected:
+ void setBitDefaults()
+ {
+ inherited_flags.f._empty_cells = initialEmptyCells();
+ inherited_flags.f._caption_side = initialCaptionSide();
+ inherited_flags.f._list_style_type = initialListStyleType();
+ inherited_flags.f._list_style_position = initialListStylePosition();
+ inherited_flags.f._visibility = initialVisibility();
+ inherited_flags.f._text_align = initialTextAlign();
+ inherited_flags.f._text_transform = initialTextTransform();
+ inherited_flags.f._text_decorations = initialTextDecoration();
+ inherited_flags.f._cursor_style = initialCursor();
+ inherited_flags.f._direction = initialDirection();
+ inherited_flags.f._border_collapse = initialBorderCollapse();
+ inherited_flags.f._white_space = initialWhiteSpace();
+ inherited_flags.f._visuallyOrdered = false;
+ inherited_flags.f._htmlHacks=false;
+ inherited_flags.f._user_input = UI_NONE;
+ inherited_flags.f._page_break_inside = true;
+ inherited_flags.f.unused = 0;
+
+ noninherited_flags._niflags = 0L; // for safety: without this, the equality method sometimes
+ // makes use of uninitialised bits according to valgrind
+
+ noninherited_flags.f._display = noninherited_flags.f._originalDisplay = initialDisplay();
+ noninherited_flags.f._overflowX = initialOverflowX();
+ noninherited_flags.f._overflowY = initialOverflowY();
+ noninherited_flags.f._vertical_align = initialVerticalAlign();
+ noninherited_flags.f._clear = initialClear();
+ noninherited_flags.f._position = initialPosition();
+ noninherited_flags.f._floating = initialFloating();
+ noninherited_flags.f._table_layout = initialTableLayout();
+ noninherited_flags.f._flowAroundFloats= initialFlowAroundFloats();
+ noninherited_flags.f._page_break_before = initialPageBreak();
+ noninherited_flags.f._page_break_after = initialPageBreak();
+ noninherited_flags.f._styleType = NOPSEUDO;
+ noninherited_flags.f._hasClip = false;
+ noninherited_flags.f._pseudoBits = 0;
+ noninherited_flags.f._unicodeBidi = initialUnicodeBidi();
+ noninherited_flags.f._textOverflow = initialTextOverflow();
+ noninherited_flags.f.unused = 0;
+ }
+
+public:
+
+ RenderStyle();
+ // used to create the default style.
+ RenderStyle(bool);
+ RenderStyle(const RenderStyle&);
+
+ ~RenderStyle();
+
+ void inheritFrom(const RenderStyle* inheritParent);
+
+ PseudoId styleType() const { return noninherited_flags.f._styleType; }
+ void setStyleType(PseudoId pi) { noninherited_flags.f._styleType = pi; }
+ bool isGenerated() const {
+ if (styleType() == AFTER || styleType() == BEFORE || styleType() == MARKER || styleType() == REPLACED)
+ return true;
+ else
+ return false;
+ }
+
+ bool hasPseudoStyle(PseudoId pi) const;
+ void setHasPseudoStyle(PseudoId pi, bool b=true);
+ RenderStyle* getPseudoStyle(PseudoId pi) const;
+ RenderStyle* addPseudoStyle(PseudoId pi);
+ void removePseudoStyle(PseudoId pi);
+
+ bool operator==(const RenderStyle& other) const;
+ bool isFloating() const { return !(noninherited_flags.f._floating == FNONE); }
+ bool hasMargin() const { return surround->margin.nonZero(); }
+ bool hasBorder() const { return surround->border.hasBorder(); }
+ bool hasOffset() const { return surround->offset.nonZero(); }
+
+ bool hasBackground() const {
+ if (backgroundColor().isValid() && qAlpha(backgroundColor().rgb()) > 0)
+ return true;
+ else
+ return background->m_background.hasImage();
+ }
+ bool hasFixedBackgroundImage() const { return background->m_background.hasFixedImage(); }
+
+ bool visuallyOrdered() const { return inherited_flags.f._visuallyOrdered; }
+ void setVisuallyOrdered(bool b) { inherited_flags.f._visuallyOrdered = b; }
+
+// attribute getter methods
+
+ EDisplay display() const { return noninherited_flags.f._display; }
+ EDisplay originalDisplay() const { return noninherited_flags.f._originalDisplay; }
+
+ Length left() const { return surround->offset.left; }
+ Length right() const { return surround->offset.right; }
+ Length top() const { return surround->offset.top; }
+ Length bottom() const { return surround->offset.bottom; }
+
+ EPosition position() const { return noninherited_flags.f._position; }
+ EFloat floating() const { return noninherited_flags.f._floating; }
+
+ Length width() const { return box->width; }
+ Length height() const { return box->height; }
+ Length minWidth() const { return box->min_width; }
+ Length maxWidth() const { return box->max_width; }
+ Length minHeight() const { return box->min_height; }
+ Length maxHeight() const { return box->max_height; }
+
+ const BorderData& border() const { return surround->border; }
+ const BorderValue& borderLeft() const { return surround->border.left; }
+ const BorderValue& borderRight() const { return surround->border.right; }
+ const BorderValue& borderTop() const { return surround->border.top; }
+ const BorderValue& borderBottom() const { return surround->border.bottom; }
+
+ unsigned short borderLeftWidth() const { return surround->border.borderLeftWidth(); }
+ EBorderStyle borderLeftStyle() const { return surround->border.left.style; }
+ const QColor& borderLeftColor() const { return surround->border.left.color; }
+ bool borderLeftIsTransparent() const { return surround->border.left.isTransparent(); }
+ unsigned short borderRightWidth() const { return surround->border.borderRightWidth(); }
+ EBorderStyle borderRightStyle() const { return surround->border.right.style; }
+ const QColor& borderRightColor() const { return surround->border.right.color; }
+ bool borderRightIsTransparent() const { return surround->border.right.isTransparent(); }
+ unsigned short borderTopWidth() const { return surround->border.borderTopWidth(); }
+ EBorderStyle borderTopStyle() const { return surround->border.top.style; }
+ const QColor& borderTopColor() const { return surround->border.top.color; }
+ bool borderTopIsTransparent() const { return surround->border.top.isTransparent(); }
+ unsigned short borderBottomWidth() const { return surround->border.borderBottomWidth(); }
+ EBorderStyle borderBottomStyle() const { return surround->border.bottom.style; }
+ const QColor& borderBottomColor() const { return surround->border.bottom.color; }
+ bool borderBottomIsTransparent() const { return surround->border.bottom.isTransparent(); }
+
+ unsigned short outlineSize() const { return outlineWidth() + outlineOffset(); }
+ unsigned short outlineWidth() const
+ { if(background->m_outline.style == BNONE || background->m_outline.style == BHIDDEN) return 0;
+ else return background->m_outline.width; }
+ EBorderStyle outlineStyle() const { return background->m_outline.style; }
+ bool outlineStyleIsAuto() const { return background->m_outline._auto; }
+ const QColor & outlineColor() const { return background->m_outline.color; }
+
+ EOverflow overflowX() const { return noninherited_flags.f._overflowX; }
+ EOverflow overflowY() const { return noninherited_flags.f._overflowY; }
+ bool hidesOverflow() const {
+ // either both overflow are visible or none are
+ return overflowX() != OVISIBLE;
+ }
+
+ EVisibility visibility() const { return inherited_flags.f._visibility; }
+ EVerticalAlign verticalAlign() const { return noninherited_flags.f._vertical_align; }
+ Length verticalAlignLength() const { return box->vertical_align; }
+
+ Length clipLeft() const { return visual->clip.left; }
+ Length clipRight() const { return visual->clip.right; }
+ Length clipTop() const { return visual->clip.top; }
+ Length clipBottom() const { return visual->clip.bottom; }
+ LengthBox clip() const { return visual->clip; }
+ bool hasClip() const { return noninherited_flags.f._hasClip; }
+
+ EUnicodeBidi unicodeBidi() const { return noninherited_flags.f._unicodeBidi; }
+
+ EClear clear() const { return noninherited_flags.f._clear; }
+ ETableLayout tableLayout() const { return noninherited_flags.f._table_layout; }
+
+ const QFont & font() const { return inherited->font.f; }
+ // use with care. call font->update() after modifications
+ const Font &htmlFont() { return inherited->font; }
+ const QFontMetrics & fontMetrics() const { return inherited->font.fm; }
+
+ const QColor & color() const { return inherited->color; }
+ Length textIndent() const { return inherited->indent; }
+ ETextAlign textAlign() const { return inherited_flags.f._text_align; }
+ ETextTransform textTransform() const { return inherited_flags.f._text_transform; }
+ int textDecorationsInEffect() const { return inherited_flags.f._text_decorations; }
+ int textDecoration() const { return visual->textDecoration; }
+ int wordSpacing() const { return inherited->font.wordSpacing; }
+ int letterSpacing() const { return inherited->font.letterSpacing; }
+
+ EDirection direction() const { return inherited_flags.f._direction; }
+ Length lineHeight() const { return inherited->line_height; }
+
+ EWhiteSpace whiteSpace() const { return inherited_flags.f._white_space; }
+ bool autoWrap() const {
+ if (whiteSpace() == NORMAL || whiteSpace() == PRE_WRAP || whiteSpace() == PRE_LINE)
+ return true;
+ // nowrap | pre
+ return false;
+ }
+ bool preserveLF() const {
+ if (whiteSpace() == PRE || whiteSpace() == PRE_WRAP || whiteSpace() == PRE_LINE)
+ return true;
+ // normal | nowrap
+ return false;
+ }
+ bool preserveWS() const {
+ if (whiteSpace() == PRE || whiteSpace() == PRE_WRAP)
+ return true;
+ // normal | nowrap | pre-line
+ return false;
+ }
+
+ const QColor & backgroundColor() const { return background->m_color; }
+ CachedImage *backgroundImage() const { return background->m_background.m_image; }
+ EBackgroundRepeat backgroundRepeat() const { return background->m_background.m_bgRepeat; }
+ bool backgroundAttachment() const { return background->m_background.m_bgAttachment; }
+ Length backgroundXPosition() const { return background->m_background.m_xPosition; }
+ Length backgroundYPosition() const { return background->m_background.m_yPosition; }
+ BackgroundLayer* accessBackgroundLayers() { return &(background.access()->m_background); }
+ const BackgroundLayer* backgroundLayers() const { return &(background->m_background); }
+
+ // returns true for collapsing borders, false for separate borders
+ bool borderCollapse() const { return inherited_flags.f._border_collapse; }
+ short borderHorizontalSpacing() const { return inherited->border_hspacing; }
+ short borderVerticalSpacing() const { return inherited->border_vspacing; }
+ EEmptyCell emptyCells() const { return inherited_flags.f._empty_cells; }
+ ECaptionSide captionSide() const { return inherited_flags.f._caption_side; }
+
+ EListStyleType listStyleType() const { return inherited_flags.f._list_style_type; }
+ CachedImage *listStyleImage() const { return inherited->style_image; }
+ EListStylePosition listStylePosition() const { return inherited_flags.f._list_style_position; }
+
+ Length marginTop() const { return surround->margin.top; }
+ Length marginBottom() const { return surround->margin.bottom; }
+ Length marginLeft() const { return surround->margin.left; }
+ Length marginRight() const { return surround->margin.right; }
+
+ Length paddingTop() const { return surround->padding.top; }
+ Length paddingBottom() const { return surround->padding.bottom; }
+ Length paddingLeft() const { return surround->padding.left; }
+ Length paddingRight() const { return surround->padding.right; }
+
+ ECursor cursor() const { return inherited_flags.f._cursor_style; }
+
+ short widows() const { return inherited->widows; }
+ short orphans() const { return inherited->orphans; }
+ bool pageBreakInside() const { return inherited_flags.f._page_break_inside; }
+ EPageBreak pageBreakBefore() const { return noninherited_flags.f._page_break_before; }
+ EPageBreak pageBreakAfter() const { return noninherited_flags.f._page_break_after; }
+
+ DOM::QuotesValueImpl* quotes() const { return inherited->quotes; }
+ QString openQuote(int level) const;
+ QString closeQuote(int level) const;
+
+ // CSS3 Getter Methods
+ EBoxSizing boxSizing() const { return box->box_sizing; }
+ int outlineOffset() const {
+ if (background->m_outline.style == BNONE || background->m_outline.style == BHIDDEN) return 0;
+ return background->m_outline._offset;
+ }
+ ShadowData* textShadow() const { return css3InheritedData->textShadow; }
+ float opacity() { return css3NonInheritedData->opacity; }
+ EUserInput userInput() const { return inherited_flags.f._user_input; }
+
+ Length marqueeIncrement() { return css3NonInheritedData->marquee->increment; }
+ int marqueeSpeed() { return css3NonInheritedData->marquee->speed; }
+ int marqueeLoopCount() { return css3NonInheritedData->marquee->loops; }
+ EMarqueeBehavior marqueeBehavior() { return css3NonInheritedData->marquee->behavior; }
+ EMarqueeDirection marqueeDirection() { return css3NonInheritedData->marquee->direction; }
+ bool textOverflow() const { return noninherited_flags.f._textOverflow; }
+ // End CSS3 Getters
+
+// attribute setter methods
+
+ void setDisplay(EDisplay v) { noninherited_flags.f._display = v; }
+ void setOriginalDisplay(EDisplay v) { noninherited_flags.f._originalDisplay = v; }
+ void setPosition(EPosition v) { noninherited_flags.f._position = v; }
+ void setFloating(EFloat v) { noninherited_flags.f._floating = v; }
+
+ void setLeft(Length v) { SET_VAR(surround,offset.left,v) }
+ void setRight(Length v) { SET_VAR(surround,offset.right,v) }
+ void setTop(Length v) { SET_VAR(surround,offset.top,v) }
+ void setBottom(Length v){ SET_VAR(surround,offset.bottom,v) }
+
+ void setWidth(Length v) { SET_VAR(box,width,v) }
+ void setHeight(Length v) { SET_VAR(box,height,v) }
+
+ void setMinWidth(Length v) { SET_VAR(box,min_width,v) }
+ void setMaxWidth(Length v) { SET_VAR(box,max_width,v) }
+ void setMinHeight(Length v) { SET_VAR(box,min_height,v) }
+ void setMaxHeight(Length v) { SET_VAR(box,max_height,v) }
+
+ void resetBorderTop() { SET_VAR(surround, border.top, BorderValue()) }
+ void resetBorderRight() { SET_VAR(surround, border.right, BorderValue()) }
+ void resetBorderBottom() { SET_VAR(surround, border.bottom, BorderValue()) }
+ void resetBorderLeft() { SET_VAR(surround, border.left, BorderValue()) }
+ void resetOutline() { SET_VAR(background, m_outline, OutlineValue()) }
+
+ void setBackgroundColor(const QColor& v) { SET_VAR(background, m_color, v) }
+
+ void setBorderLeftWidth(unsigned short v) { SET_VAR(surround,border.left.width,v) }
+ void setBorderLeftStyle(EBorderStyle v) { SET_VAR(surround,border.left.style,v) }
+ void setBorderLeftColor(const QColor & v) { SET_VAR(surround,border.left.color,v) }
+ void setBorderRightWidth(unsigned short v) { SET_VAR(surround,border.right.width,v) }
+ void setBorderRightStyle(EBorderStyle v) { SET_VAR(surround,border.right.style,v) }
+ void setBorderRightColor(const QColor & v) { SET_VAR(surround,border.right.color,v) }
+ void setBorderTopWidth(unsigned short v) { SET_VAR(surround,border.top.width,v) }
+ void setBorderTopStyle(EBorderStyle v) { SET_VAR(surround,border.top.style,v) }
+ void setBorderTopColor(const QColor & v) { SET_VAR(surround,border.top.color,v) }
+ void setBorderBottomWidth(unsigned short v) { SET_VAR(surround,border.bottom.width,v) }
+ void setBorderBottomStyle(EBorderStyle v) { SET_VAR(surround,border.bottom.style,v) }
+ void setBorderBottomColor(const QColor & v) { SET_VAR(surround,border.bottom.color,v) }
+ void setOutlineWidth(unsigned short v) { SET_VAR(background,m_outline.width,v) }
+ void setOutlineStyle(EBorderStyle v, bool isAuto = false)
+ {
+ SET_VAR(background,m_outline.style,v)
+ SET_VAR(background,m_outline._auto, isAuto)
+ }
+ void setOutlineColor(const QColor & v) { SET_VAR(background,m_outline.color,v) }
+
+ void setOverflowX(EOverflow v) { noninherited_flags.f._overflowX = v; }
+ void setOverflowY(EOverflow v) { noninherited_flags.f._overflowY = v; }
+ void setVisibility(EVisibility v) { inherited_flags.f._visibility = v; }
+ void setVerticalAlign(EVerticalAlign v) { noninherited_flags.f._vertical_align = v; }
+ void setVerticalAlignLength(Length l) { SET_VAR(box, vertical_align, l ) }
+
+ void setClipLeft(Length v) { SET_VAR(visual,clip.left,v) }
+ void setClipRight(Length v) { SET_VAR(visual,clip.right,v) }
+ void setClipTop(Length v) { SET_VAR(visual,clip.top,v) }
+ void setClipBottom(Length v) { SET_VAR(visual,clip.bottom,v) }
+ void setClip( Length top, Length right, Length bottom, Length left );
+ void setHasClip( bool b ) { noninherited_flags.f._hasClip = b; }
+
+ void setUnicodeBidi( EUnicodeBidi b ) { noninherited_flags.f._unicodeBidi = b; }
+
+ void setClear(EClear v) { noninherited_flags.f._clear = v; }
+ void setTableLayout(ETableLayout v) { noninherited_flags.f._table_layout = v; }
+ bool setFontDef(const khtml::FontDef & v) {
+ // bah, this doesn't compare pointers. broken! (Dirk)
+ if (!(inherited->font.fontDef == v)) {
+ inherited.access()->font = Font( v );
+ return true;
+ }
+ return false;
+ }
+
+ void setColor(const QColor & v) { SET_VAR(inherited,color,v) }
+ void setTextIndent(Length v) { SET_VAR(inherited,indent,v) }
+ void setTextAlign(ETextAlign v) { inherited_flags.f._text_align = v; }
+ void setTextTransform(ETextTransform v) { inherited_flags.f._text_transform = v; }
+ void addToTextDecorationsInEffect(int v) { inherited_flags.f._text_decorations |= v; }
+ void setTextDecorationsInEffect(int v) { inherited_flags.f._text_decorations = v; }
+ void setTextDecoration(unsigned v) { SET_VAR(visual, textDecoration, v); }
+ void setDirection(EDirection v) { inherited_flags.f._direction = v; }
+ void setLineHeight(Length v) { SET_VAR(inherited,line_height,v) }
+
+ void setWhiteSpace(EWhiteSpace v) { inherited_flags.f._white_space = v; }
+
+ void setWordSpacing(int v) { SET_VAR(inherited,font.wordSpacing,v) }
+ void setLetterSpacing(int v) { SET_VAR(inherited,font.letterSpacing,v) }
+
+ void clearBackgroundLayers() { background.access()->m_background = BackgroundLayer(); }
+ void inheritBackgroundLayers(const BackgroundLayer& parent) { background.access()->m_background = parent; }
+ void adjustBackgroundLayers();
+
+ void setBorderCollapse(bool collapse) { inherited_flags.f._border_collapse = collapse; }
+ void setBorderHorizontalSpacing(short v) { SET_VAR(inherited,border_hspacing,v) }
+ void setBorderVerticalSpacing(short v) { SET_VAR(inherited,border_vspacing,v) }
+
+ void setEmptyCells(EEmptyCell v) { inherited_flags.f._empty_cells = v; }
+ void setCaptionSide(ECaptionSide v) { inherited_flags.f._caption_side = v; }
+
+ void setListStyleType(EListStyleType v) { inherited_flags.f._list_style_type = v; }
+ void setListStyleImage(CachedImage *v) { SET_VAR(inherited,style_image,v)}
+ void setListStylePosition(EListStylePosition v) { inherited_flags.f._list_style_position = v; }
+
+ void resetMargin() { SET_VAR(surround, margin, LengthBox(Fixed)) }
+ void setMarginTop(Length v) { SET_VAR(surround,margin.top,v) }
+ void setMarginBottom(Length v) { SET_VAR(surround,margin.bottom,v) }
+ void setMarginLeft(Length v) { SET_VAR(surround,margin.left,v) }
+ void setMarginRight(Length v) { SET_VAR(surround,margin.right,v) }
+
+ void resetPadding() { SET_VAR(surround, padding, LengthBox(Variable)) }
+ void setPaddingTop(Length v) { SET_VAR(surround,padding.top,v) }
+ void setPaddingBottom(Length v) { SET_VAR(surround,padding.bottom,v) }
+ void setPaddingLeft(Length v) { SET_VAR(surround,padding.left,v) }
+ void setPaddingRight(Length v) { SET_VAR(surround,padding.right,v) }
+
+ void setCursor( ECursor c ) { inherited_flags.f._cursor_style = c; }
+
+ bool htmlHacks() const { return inherited_flags.f._htmlHacks; }
+ void setHtmlHacks(bool b=true) { inherited_flags.f._htmlHacks = b; }
+
+ bool flowAroundFloats() const { return noninherited_flags.f._flowAroundFloats; }
+ void setFlowAroundFloats(bool b=true) { noninherited_flags.f._flowAroundFloats = b; }
+
+ int zIndex() const { return box->z_auto? 0 : box->z_index; }
+ void setZIndex(int v) { SET_VAR(box,z_auto,false ); SET_VAR(box, z_index, v); }
+ bool hasAutoZIndex() const { return box->z_auto; }
+ void setHasAutoZIndex() { SET_VAR(box, z_auto, true ); }
+
+ void setWidows(short w) { SET_VAR(inherited, widows, w); }
+ void setOrphans(short o) { SET_VAR(inherited, orphans, o); }
+ void setPageBreakInside(bool b) { inherited_flags.f._page_break_inside = b; }
+ void setPageBreakBefore(EPageBreak b) { noninherited_flags.f._page_break_before = b; }
+ void setPageBreakAfter(EPageBreak b) { noninherited_flags.f._page_break_after = b; }
+
+ void setQuotes(DOM::QuotesValueImpl* q);
+
+ // CSS3 Setters
+ void setBoxSizing( EBoxSizing b ) { SET_VAR(box,box_sizing,b); }
+ void setOutlineOffset(unsigned short v) { SET_VAR(background,m_outline._offset,v) }
+ void setTextShadow(ShadowData* val, bool add=false);
+ void setOpacity(float f) { SET_VAR(css3NonInheritedData, opacity, f); }
+ void setUserInput(EUserInput ui) { inherited_flags.f._user_input = ui; }
+
+ void setMarqueeIncrement(const Length& f) { SET_VAR(css3NonInheritedData.access()->marquee, increment, f); }
+ void setMarqueeSpeed(int f) { SET_VAR(css3NonInheritedData.access()->marquee, speed, f); }
+ void setMarqueeDirection(EMarqueeDirection d) { SET_VAR(css3NonInheritedData.access()->marquee, direction, d); }
+ void setMarqueeBehavior(EMarqueeBehavior b) { SET_VAR(css3NonInheritedData.access()->marquee, behavior, b); }
+ void setMarqueeLoopCount(int i) { SET_VAR(css3NonInheritedData.access()->marquee, loops, i); }
+ void setTextOverflow(bool b) { noninherited_flags.f._textOverflow = b; }
+ // End CSS3 Setters
+
+ QPalette palette() const { return visual->palette; }
+ void setPaletteColor(QPalette::ColorGroup g, QColorGroup::ColorRole r, const QColor& c);
+ void resetPalette() // Called when the desktop color scheme changes.
+ {
+ const_cast<StyleVisualData *>(visual.get())->palette = QApplication::palette();
+ }
+
+ bool useNormalContent() const { return generated->content == 0; }
+ ContentData* contentData() const { return generated->content; }
+ bool contentDataEquivalent(const RenderStyle* otherStyle) const
+ {
+ return generated->contentDataEquivalent(otherStyle->generated.get());
+ }
+ void addContent(DOM::DOMStringImpl* s);
+ void addContent(CachedObject* o);
+ void addContent(DOM::CounterImpl* c);
+ void addContent(EQuoteContent q);
+ void setContentNone();
+ void setContentNormal();
+ void setContentData(ContentData* content);
+
+ DOM::CSSValueListImpl* counterReset() const { return generated->counter_reset; }
+ DOM::CSSValueListImpl* counterIncrement() const { return generated->counter_increment; }
+ void setCounterReset(DOM::CSSValueListImpl* v);
+ void setCounterIncrement(DOM::CSSValueListImpl* v);
+ bool hasCounterReset(const DOM::DOMString& c) const;
+ bool hasCounterIncrement(const DOM::DOMString& c) const;
+ short counterReset(const DOM::DOMString& c) const;
+ short counterIncrement(const DOM::DOMString& c) const;
+
+
+ bool inheritedNotEqual( RenderStyle *other ) const;
+
+ enum Diff { Equal, NonVisible = Equal, Visible, Position, Layout, CbLayout };
+ Diff diff( const RenderStyle *other ) const;
+
+ bool isDisplayReplacedType() {
+ return display() == INLINE_BLOCK ||/* display() == INLINE_BOX ||*/ display() == INLINE_TABLE;
+ }
+ bool isDisplayInlineType() {
+ return display() == INLINE || isDisplayReplacedType();
+ }
+ bool isOriginalDisplayInlineType() {
+ return originalDisplay() == INLINE || originalDisplay() == INLINE_BLOCK ||
+ /*originalDisplay() == INLINE_BOX ||*/ originalDisplay() == INLINE_TABLE;
+ }
+
+
+#ifdef ENABLE_DUMP
+ QString createDiff( const RenderStyle &parent ) const;
+#endif
+
+ // Initial values for all the properties
+ static bool initialBackgroundAttachment() { return true; }
+ static EBackgroundBox initialBackgroundClip() { return BGBORDER; }
+ static EBackgroundBox initialBackgroundOrigin() { return BGPADDING; }
+ static EBackgroundRepeat initialBackgroundRepeat() { return REPEAT; }
+ static LengthSize initialBackgroundSize() { return LengthSize(); }
+ static bool initialBorderCollapse() { return false; }
+ static EBorderStyle initialBorderStyle() { return BNONE; }
+ static ECaptionSide initialCaptionSide() { return CAPTOP; }
+ static EClear initialClear() { return CNONE; }
+ static EDirection initialDirection() { return LTR; }
+ static EDisplay initialDisplay() { return INLINE; }
+ static EEmptyCell initialEmptyCells() { return SHOW; }
+ static EFloat initialFloating() { return FNONE; }
+ static EListStylePosition initialListStylePosition() { return OUTSIDE; }
+ static EListStyleType initialListStyleType() { return LDISC; }
+ static EOverflow initialOverflowX() { return OVISIBLE; }
+ static EOverflow initialOverflowY() { return OVISIBLE; }
+ static EPageBreak initialPageBreak() { return PBAUTO; }
+ static bool initialPageBreakInside() { return true; }
+ static EPosition initialPosition() { return STATIC; }
+ static ETableLayout initialTableLayout() { return TAUTO; }
+ static EUnicodeBidi initialUnicodeBidi() { return UBNormal; }
+ static DOM::QuotesValueImpl* initialQuotes() { return 0; }
+ static EBoxSizing initialBoxSizing() { return CONTENT_BOX; }
+ static ETextTransform initialTextTransform() { return TTNONE; }
+ static EVisibility initialVisibility() { return VISIBLE; }
+ static EWhiteSpace initialWhiteSpace() { return NORMAL; }
+ static Length initialBackgroundXPosition() { return Length(); }
+ static Length initialBackgroundYPosition() { return Length(); }
+ static short initialBorderHorizontalSpacing() { return 0; }
+ static short initialBorderVerticalSpacing() { return 0; }
+ static ECursor initialCursor() { return CURSOR_AUTO; }
+ static QColor initialColor() { return Qt::black; }
+ static CachedImage* initialBackgroundImage() { return 0; }
+ static CachedImage* initialListStyleImage() { return 0; }
+ static unsigned short initialBorderWidth() { return 3; }
+ static int initialLetterWordSpacing() { return 0; }
+ static Length initialSize() { return Length(); }
+ static Length initialMinSize() { return Length(0, Fixed); }
+ static Length initialMaxSize() { return Length(UNDEFINED, Fixed); }
+ static Length initialOffset() { return Length(); }
+ static Length initialMargin() { return Length(Fixed); }
+ static Length initialPadding() { return Length(Variable); }
+ static Length initialTextIndent() { return Length(Fixed); }
+ static EVerticalAlign initialVerticalAlign() { return BASELINE; }
+ static int initialWidows() { return 2; }
+ static int initialOrphans() { return 2; }
+ static Length initialLineHeight() { return Length(-100, Percent); }
+ static ETextAlign initialTextAlign() { return TAAUTO; }
+ static ETextDecoration initialTextDecoration() { return TDNONE; }
+ static bool initialFlowAroundFloats() { return false; }
+ static int initialOutlineOffset() { return 0; }
+ static float initialOpacity() { return 1.0f; }
+ static int initialMarqueeLoopCount() { return -1; }
+ static int initialMarqueeSpeed() { return 85; }
+ static Length initialMarqueeIncrement() { return Length(6, Fixed); }
+ static EMarqueeBehavior initialMarqueeBehavior() { return MSCROLL; }
+ static EMarqueeDirection initialMarqueeDirection() { return MAUTO; }
+ static bool initialTextOverflow() { return false; }
+};
+
+class RenderPageStyle {
+ friend class CSSStyleSelector;
+public:
+ enum PageType { NO_PAGE = 0, ANY_PAGE, FIRST_PAGE, LEFT_PAGES, RIGHT_PAGES };
+
+ RenderPageStyle();
+ ~RenderPageStyle();
+
+ PageType pageType() { return m_pageType; }
+
+ RenderPageStyle* getPageStyle(PageType type);
+ RenderPageStyle* addPageStyle(PageType type);
+ void removePageStyle(PageType type);
+
+ Length marginTop() const { return margin.top; }
+ Length marginBottom() const { return margin.bottom; }
+ Length marginLeft() const { return margin.left; }
+ Length marginRight() const { return margin.right; }
+
+ Length pageWidth() const { return m_pageWidth; }
+ Length pageHeight() const { return m_pageHeight; }
+
+ void setMarginTop(Length v) { margin.top = v; }
+ void setMarginBottom(Length v) { margin.bottom = v; }
+ void setMarginLeft(Length v) { margin.left = v; }
+ void setMarginRight(Length v) { margin.right = v; }
+
+ void setPageWidth(Length v) { m_pageWidth = v; }
+ void setPageHeight(Length v) { m_pageHeight = v; }
+
+protected:
+ RenderPageStyle *next;
+ PageType m_pageType;
+
+ LengthBox margin;
+ Length m_pageWidth;
+ Length m_pageHeight;
+};
+
+} // namespace
+
+#endif
+