/*

 * This file is part of the DOM implementation for KDE.

 *

 * Copyright (C) 2000 Lars Knoll (knoll@kde.org)

 *           (C) 2000 Antti Koivisto (koivisto@kde.org)

 *           (C) 2000 Dirk Mueller (mueller@kde.org)

 * Copyright (C) 2003, 2005, 2006, 2007 Apple Inc. All rights reserved.

 * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.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 CSSValueKeywords.in, otherwise some optimizations in the parser will fail,

 * and produce invaliud results.

 */

#include "CSSPrimitiveValue.h"

#include "CSSValueList.h"

#include "Color.h"

#include "CSSCursorImageValue.h"

#include "DataRef.h"

#include "Font.h"

#include "GraphicsTypes.h"

#include "IntRect.h"

#include "Length.h"

#include "Pair.h"

#include "Shared.h"

#include "TextDirection.h"

#include <wtf/HashMap.h>

#include <wtf/Vector.h>

#if ENABLE(SVG)

#include "SVGRenderStyle.h"

#endif

#if PLATFORM(SYMBIAN)

//fixme CW has problems with references to bool, enum types

#define compareEqual(a,b) ((a)==(b))

#else

template<typename T, typename U> inline bool compareEqual(const T& t, const U& u) { return t == static_cast<T>(u); }

#endif

#define SET_VAR(group, variable, value) \

    if (!compareEqual(group->variable, value)) \

        group.access()->variable = value;

namespace WebCore {

using std::max;

class CSSStyleSelector;

class CSSValueList;

class CachedImage;

class CachedResource;

class CursorList;

class Pair;

class RenderArena;

class ShadowValue;

class StringImpl;

struct CursorData;

enum PseudoState { PseudoUnknown, PseudoNone, PseudoAnyLink, PseudoLink, PseudoVisited};

//------------------------------------------------

//------------------------------------------------

// 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;

    LengthBox& operator=(const Length& len)

    {

        left = len;

        right = len;

        top = len;

        bottom = len;

        return *this;

    }

    bool operator==(const LengthBox& o) const

    {

        return left == o.left && right == o.right && top == o.top && bottom == o.bottom;

    }

    bool operator!=(const LengthBox& o) const

    {

        return !(*this == o);

    }

    bool nonZero() const { return !(left.isZero() && right.isZero() && top.isZero() && bottom.isZero()); }

};

enum EPosition {

    StaticPosition, RelativePosition, AbsolutePosition, FixedPosition

};

enum EFloat {

    FNONE = 0, FLEFT, FRIGHT

};

//------------------------------------------------

// Border attributes. Not inherited.

// These have been defined in the order of their precedence for border-collapsing. Do

// not change this order!

enum EBorderStyle {

    BNONE, BHIDDEN, INSET, GROOVE, RIDGE, OUTSET, DOTTED, DASHED, SOLID, DOUBLE

};

class BorderValue {

public:

    BorderValue() {

        width = 3; // medium is default value

        m_style = BNONE;

    }

    Color color;

    unsigned width : 12;

    unsigned m_style : 4; // EBorderStyle 

    EBorderStyle style() const { return static_cast<EBorderStyle>(m_style); }

    bool nonZero(bool checkStyle = true) const {

        return width != 0 && (!checkStyle || m_style != BNONE);

    }

    bool isTransparent() const {

        return color.isValid() && color.alpha() == 0;

    }

    bool isVisible(bool checkStyle = true) const {

        return nonZero(checkStyle) && !isTransparent() && (!checkStyle || m_style != BHIDDEN);

    }

    bool operator==(const BorderValue& o) const

    {

        return width == o.width && m_style == o.m_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 && m_style == o.m_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; }

    Color color() const { return border ? border->color : Color(); }

    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;    

};

enum EBorderImageRule {

    BI_STRETCH, BI_ROUND, BI_REPEAT

};

class BorderImage {

public:

    BorderImage() :m_image(0), m_horizontalRule(BI_STRETCH), m_verticalRule(BI_STRETCH) {}

    BorderImage(CachedImage* image, LengthBox slices, EBorderImageRule h, EBorderImageRule v) 

      :m_image(image), m_slices(slices), m_horizontalRule(h), m_verticalRule(v) {}

    bool operator==(const BorderImage& o) const

    {

        return m_image == o.m_image && m_slices == o.m_slices && m_horizontalRule == o.m_horizontalRule &&

               m_verticalRule == o.m_verticalRule;

    }

    bool hasImage() const { return m_image != 0; }

    CachedImage* image() const { return m_image; }

    EBorderImageRule horizontalRule() const { return static_cast<EBorderImageRule>(m_horizontalRule); }

    EBorderImageRule verticalRule() const { return static_cast<EBorderImageRule>(m_verticalRule); }

    CachedImage* m_image;

    LengthBox m_slices;

    unsigned m_horizontalRule : 2; // EBorderImageRule

    unsigned m_verticalRule : 2; // EBorderImageRule

};

class BorderData {

public:

    BorderValue left;

    BorderValue right;

    BorderValue top;

    BorderValue bottom;

    BorderImage image;

    IntSize topLeft;

    IntSize topRight;

    IntSize bottomLeft;

    IntSize bottomRight;

    bool hasBorder() const

    {

        bool haveImage = image.hasImage();

        return left.nonZero(!haveImage) || right.nonZero(!haveImage) || top.nonZero(!haveImage) || bottom.nonZero(!haveImage);

    }

    bool hasBorderRadius() const {

        if (topLeft.width() > 0)

            return true;

        if (topRight.width() > 0)

            return true;

        if (bottomLeft.width() > 0)

            return true;

        if (bottomRight.width() > 0)

            return true;

        return false;

    }

    unsigned short borderLeftWidth() const {

        if (!image.hasImage() && (left.style() == BNONE || left.style() == BHIDDEN))

            return 0; 

        return left.width;

    }

    unsigned short borderRightWidth() const {

        if (!image.hasImage() && (right.style() == BNONE || right.style() == BHIDDEN))

            return 0;

        return right.width;

    }

    unsigned short borderTopWidth() const {

        if (!image.hasImage() && (top.style() == BNONE || top.style() == BHIDDEN))

            return 0;

        return top.width;

    }

    unsigned short borderBottomWidth() const {

        if (!image.hasImage() && (bottom.style() == BNONE || bottom.style() == BHIDDEN))

            return 0;

        return bottom.width;

    }

    bool operator==(const BorderData& o) const

    {

        return left == o.left && right == o.right && top == o.top && bottom == o.bottom && image == o.image &&

               topLeft == o.topLeft && topRight == o.topRight && bottomLeft == o.bottomLeft && bottomRight == o.bottomRight;

    }

    bool operator!=(const BorderData& o) const {

        return !(*this == o);

    }

};

enum EMarginCollapse { MCOLLAPSE, MSEPARATE, MDISCARD };

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);

    }

    LengthBox offset;

    LengthBox margin;

    LengthBox padding;

    BorderData border;

};

//------------------------------------------------

// Box attributes. Not inherited.

enum EBoxSizing { CONTENT_BOX, BORDER_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;

    int z_index;

    bool z_auto : 1;

    unsigned boxSizing : 1; // EBoxSizing

};

//------------------------------------------------

// Dashboard region attributes. Not inherited.

struct StyleDashboardRegion {

    String label;

    LengthBox offset;

    int type;

    enum {

        None,

        Circle,

        Rectangle

    };

    bool operator==(const StyleDashboardRegion& o) const

    {

        return type == o.type && offset == o.offset && label == o.label;

    }

   bool operator!=(const StyleDashboardRegion& o) const

   {

       return !(*this == o);

   }

};

#if PLATFORM(SYMBIAN)

//------------------------------------------------

// Wap input format.  Not inherited

class StyleWapInput : public Shared<StyleWapInput>

{

public:

    StyleWapInput() : required(false)   {}

    StyleWapInput(const StyleWapInput& o) : Shared<StyleWapInput>(), format(o.format), required(o.required)  {}

    ~StyleWapInput() {}

    bool operator==(const StyleWapInput& o) const{

        return format == o.format && required == o.required;

    }

    bool operator!=(const StyleWapInput &o) const {

        return !(*this == o);

    }

    AtomicString    format;

    bool            required;

};

#endif

//------------------------------------------------

// Random visual rendering model attributes. Not inherited.

enum EOverflow {

    OVISIBLE, OHIDDEN, OSCROLL, OAUTO, OOVERLAY, 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&);

    bool operator==(const StyleVisualData& o) const {

        return ( clip == o.clip &&

                 hasClip == o.hasClip &&

                 counterIncrement == o.counterIncrement &&

                 counterReset == o.counterReset &&

                 textDecoration == o.textDecoration);

    }

    bool operator!=(const StyleVisualData& o) const { return !(*this == o); }

    LengthBox clip;

    bool hasClip : 1;

    unsigned textDecoration : 4; // Text decorations defined *only* by this element.

    short counterIncrement; // ok, so these are not visual mode specific

    short counterReset;     // can't go to inherited, since these are not inherited

};

//------------------------------------------------

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 static_cast<EBackgroundBox>(m_bgClip); }

    EBackgroundBox backgroundOrigin() const { return static_cast<EBackgroundBox>(m_bgOrigin); }

    EBackgroundRepeat backgroundRepeat() const { return static_cast<EBackgroundRepeat>(m_bgRepeat); }

    CompositeOperator backgroundComposite() const { return static_cast<CompositeOperator>(m_bgComposite); }

    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 isBackgroundCompositeSet() const { return m_compositeSet; }

    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 setBackgroundComposite(CompositeOperator c) { m_bgComposite = c; m_compositeSet = 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 clearBackgroundComposite() { m_compositeSet = false; }

    void clearBackgroundSize() { m_backgroundSizeSet = false; }