diff options
Diffstat (limited to 'tdehtml/rendering/render_style.h')
| -rw-r--r-- | tdehtml/rendering/render_style.h | 1524 |
1 files changed, 1524 insertions, 0 deletions
diff --git a/tdehtml/rendering/render_style.h b/tdehtml/rendering/render_style.h new file mode 100644 index 000000000..28b6b999d --- /dev/null +++ b/tdehtml/rendering/render_style.h @@ -0,0 +1,1524 @@ +/* + * 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 <tqcolor.h> +#include <tqfont.h> +#include <tqfontmetrics.h> +#include <tqptrlist.h> +#include <tqpalette.h> +#include <tqapplication.h> + +#include "dom/dom_misc.h" +#include "dom/dom_string.h" +#include "misc/tdehtmllayout.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 tdehtml { + + 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 +}; + +enum EWordWrap { + WWNORMAL = 0, WWBREAKWORD = 0x01 +}; + +//------------------------------------------------ +// 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 ) {} + + TQColor 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() && tqAlpha(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; } + TQColor color() const { return border ? border->color : TQColor(); } + 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. + + TQPalette 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; + TQColor 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 TQColor& _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; + TQColor 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 + EWordWrap wordWrap : 1; + 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, TDEHTML_NOWRAP +}; + +enum ETextAlign { + TAAUTO, LEFT, RIGHT, CENTER, JUSTIFY, TDEHTML_LEFT, TDEHTML_RIGHT, TDEHTML_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; + + tdehtml::Font font; + TQColor 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; + TQ_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; + TQ_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() && tqAlpha(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 TQColor& 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 TQColor& 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 TQColor& 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 TQColor& 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 TQColor & 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 TQFont & font() const { return inherited->font.f; } + // use with care. call font->update() after modifications + const Font &htmlFont() { return inherited->font; } + const TQFontMetrics & fontMetrics() const { return inherited->font.fm; } + + const TQColor & 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 TQColor & 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; } + TQString openQuote(int level) const; + TQString 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; } + EWordWrap wordWrap() const { return css3InheritedData->wordWrap; } + 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 TQColor& 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 TQColor & 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 TQColor & 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 TQColor & 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 TQColor & 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 TQColor & 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 tdehtml::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 TQColor & 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 setWordWrap(EWordWrap w) { SET_VAR(css3InheritedData, wordWrap, w); } + 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 + + TQPalette palette() const { return visual->palette; } + void setPaletteColor(TQPalette::ColorGroup g, TQColorGroup::ColorRole r, const TQColor& c); + void resetPalette() // Called when the desktop color scheme changes. + { + const_cast<StyleVisualData *>(visual.get())->palette = TQApplication::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 + TQString 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 EWordWrap initialWordWrap() { return WWNORMAL; } + 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 TQColor 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 + |