You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1525 lines
54 KiB
1525 lines
54 KiB
/*
|
|
* 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/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
|
|
};
|
|
|
|
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() && 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; }
|
|
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, 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;
|
|
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;
|
|
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 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 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 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
|
|
|