/*

 * 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, 2008, 2009, 2010 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

#include "TransformationMatrix.h"

#include "AnimationList.h"

#include "BorderData.h"

#include "BorderValue.h"

#include "CSSHelper.h"

#include "CSSImageGeneratorValue.h"

#include "CSSPrimitiveValue.h"

#include "CSSPropertyNames.h"

#include "CSSReflectionDirection.h"

#include "CSSValueList.h"

#include "CachedImage.h"

#include "CollapsedBorderValue.h"

#include "Color.h"

#include "ColorSpace.h"

#include "ContentData.h"

#include "CounterDirectives.h"

#include "CursorList.h"

#include "DataRef.h"

#include "FillLayer.h"

#include "FloatPoint.h"

#include "Font.h"

#include "GraphicsTypes.h"

#include "IntRect.h"

#include "Length.h"

#include "LengthBox.h"

#include "LengthSize.h"

#include "LineClampValue.h"

#include "NinePieceImage.h"

#include "OutlineValue.h"

#include "Pair.h"

#include "RenderStyleConstants.h"

#include "ShadowData.h"

#include "StyleBackgroundData.h"

#include "StyleBoxData.h"

#include "StyleFlexibleBoxData.h"

#include "StyleInheritedData.h"

#include "StyleMarqueeData.h"

#include "StyleMultiColData.h"

#include "StyleRareInheritedData.h"

#include "StyleRareNonInheritedData.h"

#include "StyleReflection.h"

#include "StyleSurroundData.h"

#include "StyleTransformData.h"

#include "StyleVisualData.h"

#include "TextDirection.h"

#include "ThemeTypes.h"

#include "TimingFunction.h"

#include "TransformOperations.h"

#include <wtf/OwnPtr.h>

#include <wtf/RefCounted.h>

#include <wtf/StdLibExtras.h>

#include <wtf/Vector.h>

#if ENABLE(DASHBOARD_SUPPORT)

#include "StyleDashboardRegion.h"

#endif

#if ENABLE(SVG)

#include "SVGRenderStyle.h"

#endif

#if ENABLE(XBL)

#include "BindingURI.h"

#endif

#if COMPILER(WINSCW)

#define compareEqual(t, u)      ((t) == (u))

#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 Pair;

class StringImpl;

class StyleImage;

typedef Vector<RefPtr<RenderStyle>, 4> PseudoStyleCache;

class RenderStyle: public RefCounted<RenderStyle> {

    friend class AnimationBase; // Used by CSS animations. We can't allow them to animate based off visited colors.

    friend class ApplyStyleCommand; // Editing has to only reveal unvisited info.

    friend class CSSStyleSelector; // Sets members directly.

    friend class CSSComputedStyleDeclaration; // Ignores visited styles, so needs to be able to see unvisited info.

    friend class PropertyWrapperMaybeInvalidColor; // Used by CSS animations. We can't allow them to animate based off visited colors.

    friend class RenderSVGResource; // FIXME: Needs to alter the visited state by hand. Should clean the SVG code up and move it into RenderStyle perhaps.

    friend class RenderTreeAsText; // FIXME: Only needed so the render tree can keep lying and dump the wrong colors.  Rebaselining would allow this to be yanked.

protected:

    // The following bitfield is 32-bits long, which optimizes padding with the

    // int refCount in the base class. Beware when adding more bits.

    bool m_affectedByAttributeSelectors : 1;

    bool m_unique : 1;

    // Bits for dynamic child matching.

    bool m_affectedByEmpty : 1;

    bool m_emptyState : 1;

    // We optimize for :first-child and :last-child.  The other positional child selectors like nth-child or

    // *-child-of-type, we will just give up and re-evaluate whenever children change at all.

    bool m_childrenAffectedByFirstChildRules : 1;

    bool m_childrenAffectedByLastChildRules : 1;

    bool m_childrenAffectedByDirectAdjacentRules : 1;

    bool m_childrenAffectedByForwardPositionalRules : 1;

    bool m_childrenAffectedByBackwardPositionalRules : 1;

    bool m_firstChildState : 1;

    bool m_lastChildState : 1;

    unsigned m_childIndex : 21; // Plenty of bits to cache an index.

    // non-inherited attributes

    DataRef<StyleBoxData> m_box;

    DataRef<StyleVisualData> visual;

    DataRef<StyleBackgroundData> m_background;

    DataRef<StyleSurroundData> surround;

    DataRef<StyleRareNonInheritedData> rareNonInheritedData;

    // inherited attributes

    DataRef<StyleRareInheritedData> rareInheritedData;

    DataRef<StyleInheritedData> inherited;

    // list of associated pseudo styles

    OwnPtr<PseudoStyleCache> m_cachedPseudoStyles;

#if ENABLE(SVG)

    DataRef<SVGRenderStyle> m_svgStyle;

#endif

// !START SYNC!: Keep this in sync with the copy constructor in RenderStyle.cpp

    // inherit

    struct InheritedFlags {

        bool operator==(const InheritedFlags& other) const

        {

            return (_empty_cells == other._empty_cells) &&

                   (_caption_side == other._caption_side) &&

                   (_list_style_type == other._list_style_type) &&

                   (_list_style_position == other._list_style_position) &&

                   (_visibility == other._visibility) &&

                   (_text_align == other._text_align) &&

                   (_text_transform == other._text_transform) &&

                   (_text_decorations == other._text_decorations) &&

                   (_text_transform == other._text_transform) &&

                   (_cursor_style == other._cursor_style) &&

                   (_direction == other._direction) &&

                   (_border_collapse == other._border_collapse) &&

                   (_white_space == other._white_space) &&

                   (_box_direction == other._box_direction) &&

                   (_visuallyOrdered == other._visuallyOrdered) &&

                   (_htmlHacks == other._htmlHacks) &&

                   (_force_backgrounds_to_white == other._force_backgrounds_to_white) &&

                   (_pointerEvents == other._pointerEvents) &&

                   (_insideLink == other._insideLink);

        }

        bool operator!=(const InheritedFlags& other) const { return !(*this == other); }

        unsigned _empty_cells : 1; // EEmptyCell

        unsigned _caption_side : 2; // ECaptionSide

        unsigned _list_style_type : 7; // EListStyleType

        unsigned _list_style_position : 1; // EListStylePosition

        unsigned _visibility : 2; // EVisibility

        unsigned _text_align : 3; // ETextAlign

        unsigned _text_transform : 2; // ETextTransform

        unsigned _text_decorations : 4;

        unsigned _cursor_style : 6; // ECursor

        unsigned _direction : 1; // TextDirection

        bool _border_collapse : 1 ;

        unsigned _white_space : 3; // EWhiteSpace

        unsigned _box_direction : 1; // EBoxDirection (CSS3 box_direction property, flexible box layout module)

        // 34 bits

        // non CSS2 inherited

        bool _visuallyOrdered : 1;

        bool _htmlHacks : 1;

        bool _force_backgrounds_to_white : 1;

        unsigned _pointerEvents : 4; // EPointerEvents

        unsigned _insideLink : 2; // EInsideLink

        // 43 bits

    } inherited_flags;

// don't inherit

    struct NonInheritedFlags {

        bool operator==(const NonInheritedFlags& other) const

        {

            return _effectiveDisplay == other._effectiveDisplay

                && _originalDisplay == other._originalDisplay

                && _overflowX == other._overflowX

                && _overflowY == other._overflowY

                && _vertical_align == other._vertical_align

                && _clear == other._clear

                && _position == other._position

                && _floating == other._floating

                && _table_layout == other._table_layout

                && _page_break_before == other._page_break_before

                && _page_break_after == other._page_break_after

                && _page_break_inside == other._page_break_inside

                && _styleType == other._styleType

                && _affectedByHover == other._affectedByHover

                && _affectedByActive == other._affectedByActive

                && _affectedByDrag == other._affectedByDrag

                && _pseudoBits == other._pseudoBits

                && _unicodeBidi == other._unicodeBidi

                && _isLink == other._isLink;

        }

        bool operator!=(const NonInheritedFlags& other) const { return !(*this == other); }

        unsigned _effectiveDisplay : 5; // EDisplay

        unsigned _originalDisplay : 5; // EDisplay

        unsigned _overflowX : 3; // EOverflow

        unsigned _overflowY : 3; // EOverflow

        unsigned _vertical_align : 4; // EVerticalAlign

        unsigned _clear : 2; // EClear

        unsigned _position : 2; // EPosition

        unsigned _floating : 2; // EFloat

        unsigned _table_layout : 1; // ETableLayout

        unsigned _page_break_before : 2; // EPageBreak

        unsigned _page_break_after : 2; // EPageBreak

        unsigned _page_break_inside : 2; // EPageBreak

        unsigned _styleType : 6; // PseudoId

        bool _affectedByHover : 1;

        bool _affectedByActive : 1;

        bool _affectedByDrag : 1;

        unsigned _pseudoBits : 7;

        unsigned _unicodeBidi : 2; // EUnicodeBidi

        bool _isLink : 1;

        // 50 bits

    } noninherited_flags;

// !END SYNC!

protected:

    void setBitDefaults()

    {

        inherited_flags._empty_cells = initialEmptyCells();

        inherited_flags._caption_side = initialCaptionSide();

        inherited_flags._list_style_type = initialListStyleType();

        inherited_flags._list_style_position = initialListStylePosition();

        inherited_flags._visibility = initialVisibility();

        inherited_flags._text_align = initialTextAlign();

        inherited_flags._text_transform = initialTextTransform();

        inherited_flags._text_decorations = initialTextDecoration();

        inherited_flags._cursor_style = initialCursor();

        inherited_flags._direction = initialDirection();

        inherited_flags._border_collapse = initialBorderCollapse();

        inherited_flags._white_space = initialWhiteSpace();

        inherited_flags._visuallyOrdered = initialVisuallyOrdered();

        inherited_flags._htmlHacks=false;

        inherited_flags._box_direction = initialBoxDirection();

        inherited_flags._force_backgrounds_to_white = false;

        inherited_flags._pointerEvents = initialPointerEvents();

        inherited_flags._insideLink = NotInsideLink;

        noninherited_flags._effectiveDisplay = noninherited_flags._originalDisplay = initialDisplay();

        noninherited_flags._overflowX = initialOverflowX();

        noninherited_flags._overflowY = initialOverflowY();

        noninherited_flags._vertical_align = initialVerticalAlign();

        noninherited_flags._clear = initialClear();

        noninherited_flags._position = initialPosition();

        noninherited_flags._floating = initialFloating();

        noninherited_flags._table_layout = initialTableLayout();

        noninherited_flags._page_break_before = initialPageBreak();

        noninherited_flags._page_break_after = initialPageBreak();

        noninherited_flags._page_break_inside = initialPageBreak();

        noninherited_flags._styleType = NOPSEUDO;

        noninherited_flags._affectedByHover = false;

        noninherited_flags._affectedByActive = false;

        noninherited_flags._affectedByDrag = false;

        noninherited_flags._pseudoBits = 0;

        noninherited_flags._unicodeBidi = initialUnicodeBidi();

        noninherited_flags._isLink = false;

    }

private:

    RenderStyle();

    // used to create the default style.

    RenderStyle(bool);

    RenderStyle(const RenderStyle&);

public:

    static PassRefPtr<RenderStyle> create();

    static PassRefPtr<RenderStyle> createDefaultStyle();

    static PassRefPtr<RenderStyle> clone(const RenderStyle*);

    ~RenderStyle();

    void inheritFrom(const RenderStyle* inheritParent);

    PseudoId styleType() const { return static_cast<PseudoId>(noninherited_flags._styleType); }

    void setStyleType(PseudoId styleType) { noninherited_flags._styleType = styleType; }

    RenderStyle* getCachedPseudoStyle(PseudoId) const;

    RenderStyle* addCachedPseudoStyle(PassRefPtr<RenderStyle>);

    const PseudoStyleCache* cachedPseudoStyles() const { return m_cachedPseudoStyles.get(); }

    bool affectedByHoverRules() const { return noninherited_flags._affectedByHover; }

    bool affectedByActiveRules() const { return noninherited_flags._affectedByActive; }

    bool affectedByDragRules() const { return noninherited_flags._affectedByDrag; }

    void setAffectedByHoverRules(bool b) { noninherited_flags._affectedByHover = b; }

    void setAffectedByActiveRules(bool b) { noninherited_flags._affectedByActive = b; }

    void setAffectedByDragRules(bool b) { noninherited_flags._affectedByDrag = b; }

    bool operator==(const RenderStyle& other) const;

    bool operator!=(const RenderStyle& other) const { return !(*this == other); }

    bool isFloating() const { return !(noninherited_flags._floating == FNONE); }

    bool hasMargin() const { return surround->margin.nonZero(); }

    bool hasBorder() const { return surround->border.hasBorder(); }

    bool hasPadding() const { return surround->padding.nonZero(); }

    bool hasOffset() const { return surround->offset.nonZero(); }

    bool hasBackgroundImage() const { return m_background->background().hasImage(); }

    bool hasFixedBackgroundImage() const { return m_background->background().hasFixedImage(); }

    bool hasAppearance() const { return appearance() != NoControlPart; }

    bool visuallyOrdered() const { return inherited_flags._visuallyOrdered; }

    void setVisuallyOrdered(bool b) { inherited_flags._visuallyOrdered = b; }

    bool isStyleAvailable() const;

    bool hasAnyPublicPseudoStyles() const;

    bool hasPseudoStyle(PseudoId pseudo) const;

    void setHasPseudoStyle(PseudoId pseudo);

    // attribute getter methods

    EDisplay display() const { return static_cast<EDisplay>(noninherited_flags._effectiveDisplay); }

    EDisplay originalDisplay() const { return static_cast<EDisplay>(noninherited_flags._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(); }

    // Whether or not a positioned element requires normal flow x/y to be computed

    // to determine its position.

    bool hasStaticX() const { return (left().isAuto() && right().isAuto()) || left().isStatic() || right().isStatic(); }

    bool hasStaticY() const { return (top().isAuto() && bottom().isAuto()) || top().isStatic(); }

    EPosition position() const { return static_cast<EPosition>(noninherited_flags._position); }

    EFloat floating() const { return static_cast<EFloat>(noninherited_flags._floating); }

    Length width() const { return m_box->width(); }

    Length height() const { return m_box->height(); }

    Length minWidth() const { return m_box->minWidth(); }

    Length maxWidth() const { return m_box->maxWidth(); }

    Length minHeight() const { return m_box->minHeight(); }

    Length maxHeight() const { return m_box->maxHeight(); }

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

    const NinePieceImage& borderImage() const { return surround->border.image(); }

    const IntSize& borderTopLeftRadius() const { return surround->border.topLeft(); }

    const IntSize& borderTopRightRadius() const { return surround->border.topRight(); }

    const IntSize& borderBottomLeftRadius() const { return surround->border.bottomLeft(); }

    const IntSize& borderBottomRightRadius() const { return surround->border.bottomRight(); }

    bool hasBorderRadius() const { return surround->border.hasBorderRadius(); }

    unsigned short borderLeftWidth() const { return surround->border.borderLeftWidth(); }

    EBorderStyle borderLeftStyle() const { return surround->border.left().style(); }

    bool borderLeftIsTransparent() const { return surround->border.left().isTransparent(); }

    unsigned short borderRightWidth() const { return surround->border.borderRightWidth(); }

    EBorderStyle borderRightStyle() const { return surround->border.right().style(); }

    bool borderRightIsTransparent() const { return surround->border.right().isTransparent(); }

    unsigned short borderTopWidth() const { return surround->border.borderTopWidth(); }

    EBorderStyle borderTopStyle() const { return surround->border.top().style(); }

    bool borderTopIsTransparent() const { return surround->border.top().isTransparent(); }

    unsigned short borderBottomWidth() const { return surround->border.borderBottomWidth(); }

    EBorderStyle borderBottomStyle() const { return surround->border.bottom().style(); }

    bool borderBottomIsTransparent() const { return surround->border.bottom().isTransparent(); }

    unsigned short outlineSize() const { return max(0, outlineWidth() + outlineOffset()); }

    unsigned short outlineWidth() const

    {

        if (m_background->outline().style() == BNONE)

            return 0;

        return m_background->outline().width();

    }

    bool hasOutline() const { return outlineWidth() > 0 && outlineStyle() > BHIDDEN; }

    EBorderStyle outlineStyle() const { return m_background->outline().style(); }

    bool outlineStyleIsAuto() const { return m_background->outline().isAuto(); }

    EOverflow overflowX() const { return static_cast<EOverflow>(noninherited_flags._overflowX); }

    EOverflow overflowY() const { return static_cast<EOverflow>(noninherited_flags._overflowY); }

    EVisibility visibility() const { return static_cast<EVisibility>(inherited_flags._visibility); }

    EVerticalAlign verticalAlign() const { return static_cast<EVerticalAlign>(noninherited_flags._vertical_align); }

    Length verticalAlignLength() const { return m_box->verticalAlign(); }

    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 visual->hasClip; }

    EUnicodeBidi unicodeBidi() const { return static_cast<EUnicodeBidi>(noninherited_flags._unicodeBidi); }

    EClear clear() const { return static_cast<EClear>(noninherited_flags._clear); }

    ETableLayout tableLayout() const { return static_cast<ETableLayout>(noninherited_flags._table_layout); }

    const Font& font() const { return inherited->font; }

    const FontDescription& fontDescription() const { return inherited->font.fontDescription(); }

    int fontSize() const { return inherited->font.pixelSize(); }

    Length textIndent() const { return rareInheritedData->indent; }

    ETextAlign textAlign() const { return static_cast<ETextAlign>(inherited_flags._text_align); }

    ETextTransform textTransform() const { return static_cast<ETextTransform>(inherited_flags._text_transform); }

    int textDecorationsInEffect() const { return inherited_flags._text_decorations; }

    int textDecoration() const { return visual->textDecoration; }

    int wordSpacing() const { return inherited->font.wordSpacing(); }

    int letterSpacing() const { return inherited->font.letterSpacing(); }

    float zoom() const { return visual->m_zoom; }

    float effectiveZoom() const { return rareInheritedData->m_effectiveZoom; }

    TextDirection direction() const { return static_cast<TextDirection>(inherited_flags._direction); }

    Length lineHeight() const { return inherited->line_height; }

    int computedLineHeight() const

    {

        Length lh = lineHeight();

        // Negative value means the line height is not set.  Use the font's built-in spacing.

        if (lh.isNegative())

            return font().lineSpacing();

        if (lh.isPercent())

            return lh.calcMinValue(fontSize());

        return lh.value();

    }

    EWhiteSpace whiteSpace() const { return static_cast<EWhiteSpace>(inherited_flags._white_space); }

    static bool autoWrap(EWhiteSpace ws)

    {

        // Nowrap and pre don't automatically wrap.

        return ws != NOWRAP && ws != PRE;

    }

    bool autoWrap() const

    {

        return autoWrap(whiteSpace());

    }

    static bool preserveNewline(EWhiteSpace ws)

    {

        // Normal and nowrap do not preserve newlines.

        return ws != NORMAL && ws != NOWRAP;

    }

    bool preserveNewline() const

    {

        return preserveNewline(whiteSpace());

    }

    static bool collapseWhiteSpace(EWhiteSpace ws)

    {

        // Pre and prewrap do not collapse whitespace.

        return ws != PRE && ws != PRE_WRAP;

    }

    bool collapseWhiteSpace() const

    {

        return collapseWhiteSpace(whiteSpace());

    }

    bool isCollapsibleWhiteSpace(UChar c) const

    {

        switch (c) {

            case ' ':

            case '\t':

                return collapseWhiteSpace();

            case '\n':

                return !preserveNewline();

        }

        return false;

    }

    bool breakOnlyAfterWhiteSpace() const

    {

        return whiteSpace() == PRE_WRAP || khtmlLineBreak() == AFTER_WHITE_SPACE;

    }

    bool breakWords() const