/*

 * Copyright (C) 1999 Antti Koivisto (koivisto@kde.org)

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

 *

 * 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.

 *

 */

#include "RenderStyle.h"

#include "RenderArena.h"

namespace WebCore {

static RenderStyle* defaultStyle;

StyleSurroundData::StyleSurroundData()

    : margin(Fixed), padding(Auto)

{

}

StyleSurroundData::StyleSurroundData(const StyleSurroundData& o)

    : Shared<StyleSurroundData>()

    , offset(o.offset)

    , margin(o.margin)

    , padding(o.padding)

    , border(o.border)

{

}

bool StyleSurroundData::operator==(const StyleSurroundData& o) const

{

    return offset == o.offset && margin == o.margin && padding == o.padding && border == o.border;

}

StyleBoxData::StyleBoxData()

    : z_index(0), z_auto(true), boxSizing(CONTENT_BOX)

{

    // Initialize our min/max widths/heights.

    min_width = min_height = RenderStyle::initialMinSize();

    max_width = max_height = RenderStyle::initialMaxSize();

}

StyleBoxData::StyleBoxData(const StyleBoxData& o)

    : Shared<StyleBoxData>()

    , width(o.width)

    , height(o.height)

    , min_width(o.min_width)

    , max_width(o.max_width)

    , min_height(o.min_height)

    , max_height(o.max_height)

    , z_index(o.z_index)

    , z_auto(o.z_auto)

    , boxSizing(o.boxSizing)

{

}

bool StyleBoxData::operator==(const StyleBoxData& o) const

{

    return width == o.width &&

           height == o.height &&

           min_width == o.min_width &&

           max_width == o.max_width &&

           min_height == o.min_height &&

           max_height == o.max_height &&

           z_index == o.z_index &&

           z_auto == o.z_auto &&

           boxSizing == o.boxSizing;

}

StyleVisualData::StyleVisualData()

    : hasClip(false)

    , textDecoration(RenderStyle::initialTextDecoration())

    , counterIncrement(0)

    , counterReset(0)

{

}

StyleVisualData::~StyleVisualData()

{

}

StyleVisualData::StyleVisualData(const StyleVisualData& o)

    : Shared<StyleVisualData>()

    , clip(o.clip)

    , hasClip(o.hasClip)

    , textDecoration(o.textDecoration)

    , counterIncrement(o.counterIncrement)

    , counterReset(o.counterReset)

{

}

BackgroundLayer::BackgroundLayer()

    : m_image(RenderStyle::initialBackgroundImage())

    , m_xPosition(RenderStyle::initialBackgroundXPosition())

    , m_yPosition(RenderStyle::initialBackgroundYPosition())

    , m_bgAttachment(RenderStyle::initialBackgroundAttachment())

    , m_bgClip(RenderStyle::initialBackgroundClip())

    , m_bgOrigin(RenderStyle::initialBackgroundOrigin())

    , m_bgRepeat(RenderStyle::initialBackgroundRepeat())

    , m_bgComposite(RenderStyle::initialBackgroundComposite())

    , m_backgroundSize(RenderStyle::initialBackgroundSize())

    , m_imageSet(false)

    , m_attachmentSet(false)

    , m_clipSet(false)

    , m_originSet(false)

    , m_repeatSet(false)

    , m_xPosSet(false)

    , m_yPosSet(false)

    , m_compositeSet(false)

    , m_backgroundSizeSet(false)

    , m_next(0)

{

}

BackgroundLayer::BackgroundLayer(const BackgroundLayer& o)

    : m_image(o.m_image)

    , m_xPosition(o.m_xPosition)

    , m_yPosition(o.m_yPosition)

    , m_bgAttachment(o.m_bgAttachment)

    , m_bgClip(o.m_bgClip)

    , m_bgOrigin(o.m_bgOrigin)

    , m_bgRepeat(o.m_bgRepeat)

    , m_bgComposite(o.m_bgComposite)

    , m_backgroundSize(o.m_backgroundSize)

    , m_imageSet(o.m_imageSet)

    , m_attachmentSet(o.m_attachmentSet)

    , m_clipSet(o.m_clipSet)

    , m_originSet(o.m_originSet)

    , m_repeatSet(o.m_repeatSet)

    , m_xPosSet(o.m_xPosSet)

    , m_yPosSet(o.m_yPosSet)

    , m_compositeSet(o.m_compositeSet)

    , m_backgroundSizeSet(o.m_backgroundSizeSet)

    , m_next(o.m_next ? new BackgroundLayer(*o.m_next) : 0)

{

}

BackgroundLayer::~BackgroundLayer()

{

    delete m_next;

}

BackgroundLayer& BackgroundLayer::operator=(const BackgroundLayer& o)

{

    if (m_next != o.m_next) {

        delete m_next;

        m_next = o.m_next ? new BackgroundLayer(*o.m_next) : 0;

    }

    m_image = o.m_image;

    m_xPosition = o.m_xPosition;

    m_yPosition = o.m_yPosition;

    m_bgAttachment = o.m_bgAttachment;

    m_bgClip = o.m_bgClip;

    m_bgComposite = o.m_bgComposite;

    m_bgOrigin = o.m_bgOrigin;

    m_bgRepeat = o.m_bgRepeat;

    m_backgroundSize = o.m_backgroundSize;

    m_imageSet = o.m_imageSet;

    m_attachmentSet = o.m_attachmentSet;

    m_clipSet = o.m_clipSet;

    m_compositeSet = o.m_compositeSet;

    m_originSet = o.m_originSet;

    m_repeatSet = o.m_repeatSet;

    m_xPosSet = o.m_xPosSet;

    m_yPosSet = o.m_yPosSet;

    m_backgroundSizeSet = o.m_backgroundSizeSet;

    return *this;

}

bool BackgroundLayer::operator==(const BackgroundLayer& o) const

{

    // We do not check the "isSet" booleans for each property, since those are only used during initial construction

    // to propagate patterns into layers.  All layer comparisons happen after values have all been filled in anyway.

    return m_image == o.m_image && m_xPosition == o.m_xPosition && m_yPosition == o.m_yPosition &&

           m_bgAttachment == o.m_bgAttachment && m_bgClip == o.m_bgClip && 

           m_bgComposite == o.m_bgComposite && m_bgOrigin == o.m_bgOrigin && m_bgRepeat == o.m_bgRepeat &&

           m_backgroundSize.width == o.m_backgroundSize.width && m_backgroundSize.height == o.m_backgroundSize.height && 

           ((m_next && o.m_next) ? *m_next == *o.m_next : m_next == o.m_next);

}

void BackgroundLayer::fillUnsetProperties()

{

    BackgroundLayer* curr;

    for (curr = this; curr && curr->isBackgroundImageSet(); curr = curr->next());

    if (curr && curr != this) {

        // We need to fill in the remaining values with the pattern specified.

        for (BackgroundLayer* pattern = this; curr; curr = curr->next()) {

            curr->m_image = pattern->m_image;

            pattern = pattern->next();

            if (pattern == curr || !pattern)

                pattern = this;

        }

    }

    for (curr = this; curr && curr->isBackgroundXPositionSet(); curr = curr->next());

    if (curr && curr != this) {

        // We need to fill in the remaining values with the pattern specified.

        for (BackgroundLayer* pattern = this; curr; curr = curr->next()) {

            curr->m_xPosition = pattern->m_xPosition;

            pattern = pattern->next();

            if (pattern == curr || !pattern)

                pattern = this;

        }

    }

    for (curr = this; curr && curr->isBackgroundYPositionSet(); curr = curr->next());

    if (curr && curr != this) {

        // We need to fill in the remaining values with the pattern specified.

        for (BackgroundLayer* pattern = this; curr; curr = curr->next()) {

            curr->m_yPosition = pattern->m_yPosition;

            pattern = pattern->next();

            if (pattern == curr || !pattern)

                pattern = this;

        }

    }

    for (curr = this; curr && curr->isBackgroundAttachmentSet(); curr = curr->next());

    if (curr && curr != this) {

        // We need to fill in the remaining values with the pattern specified.

        for (BackgroundLayer* pattern = this; curr; curr = curr->next()) {

            curr->m_bgAttachment = pattern->m_bgAttachment;

            pattern = pattern->next();

            if (pattern == curr || !pattern)

                pattern = this;

        }

    }

    for (curr = this; curr && curr->isBackgroundClipSet(); curr = curr->next());

    if (curr && curr != this) {

        // We need to fill in the remaining values with the pattern specified.

        for (BackgroundLayer* pattern = this; curr; curr = curr->next()) {

            curr->m_bgClip = pattern->m_bgClip;

            pattern = pattern->next();

            if (pattern == curr || !pattern)

                pattern = this;

        }

    }

    for (curr = this; curr && curr->isBackgroundCompositeSet(); curr = curr->next());

    if (curr && curr != this) {

        // We need to fill in the remaining values with the pattern specified.

        for (BackgroundLayer* pattern = this; curr; curr = curr->next()) {

            curr->m_bgComposite = pattern->m_bgComposite;

            pattern = pattern->next();

            if (pattern == curr || !pattern)

                pattern = this;

        }

    }

    for (curr = this; curr && curr->isBackgroundOriginSet(); curr = curr->next());

    if (curr && curr != this) {

        // We need to fill in the remaining values with the pattern specified.

        for (BackgroundLayer* pattern = this; curr; curr = curr->next()) {

            curr->m_bgOrigin = pattern->m_bgOrigin;

            pattern = pattern->next();

            if (pattern == curr || !pattern)

                pattern = this;

        }

    }

    for (curr = this; curr && curr->isBackgroundRepeatSet(); curr = curr->next());

    if (curr && curr != this) {

        // We need to fill in the remaining values with the pattern specified.

        for (BackgroundLayer* pattern = this; curr; curr = curr->next()) {

            curr->m_bgRepeat = pattern->m_bgRepeat;

            pattern = pattern->next();

            if (pattern == curr || !pattern)

                pattern = this;

        }

    }

    for (curr = this; curr && curr->isBackgroundSizeSet(); curr = curr->next());

    if (curr && curr != this) {

        // We need to fill in the remaining values with the pattern specified.

        for (BackgroundLayer* pattern = this; curr; curr = curr->next()) {

            curr->m_backgroundSize = pattern->m_backgroundSize;

            pattern = pattern->next();

            if (pattern == curr || !pattern)

                pattern = this;

        }

    }

}

void BackgroundLayer::cullEmptyLayers()

{

    BackgroundLayer *next;

    for (BackgroundLayer *p = this; p; p = next) {

        next = p->m_next;

        if (next && !next->isBackgroundImageSet() &&

            !next->isBackgroundXPositionSet() && !next->isBackgroundYPositionSet() &&

            !next->isBackgroundAttachmentSet() && !next->isBackgroundClipSet() &&

            !next->isBackgroundCompositeSet() && !next->isBackgroundOriginSet() &&

            !next->isBackgroundRepeatSet() && !next->isBackgroundSizeSet()) {

            delete next;

            p->m_next = 0;

            break;

        }

    }

}

StyleBackgroundData::StyleBackgroundData()

{

}

StyleBackgroundData::StyleBackgroundData(const StyleBackgroundData& o)

    : Shared<StyleBackgroundData>(), m_background(o.m_background), m_outline(o.m_outline)

{

}

bool StyleBackgroundData::operator==(const StyleBackgroundData& o) const

{

    return m_background == o.m_background && m_color == o.m_color && m_outline == o.m_outline;

}

StyleMarqueeData::StyleMarqueeData()

    : increment(RenderStyle::initialMarqueeIncrement())

    , speed(RenderStyle::initialMarqueeSpeed())

    , loops(RenderStyle::initialMarqueeLoopCount())

    , behavior(RenderStyle::initialMarqueeBehavior())

    , direction(RenderStyle::initialMarqueeDirection())

{

}

StyleMarqueeData::StyleMarqueeData(const StyleMarqueeData& o)

    : Shared<StyleMarqueeData>()

    , increment(o.increment)

    , speed(o.speed)

    , loops(o.loops)

    , behavior(o.behavior)

    , direction(o.direction) 

{

}

bool StyleMarqueeData::operator==(const StyleMarqueeData& o) const

{

    return increment == o.increment && speed == o.speed && direction == o.direction &&

           behavior == o.behavior && loops == o.loops;

}

StyleFlexibleBoxData::StyleFlexibleBoxData()

    : flex(RenderStyle::initialBoxFlex())

    , flex_group(RenderStyle::initialBoxFlexGroup())

    , ordinal_group(RenderStyle::initialBoxOrdinalGroup())

    , align(RenderStyle::initialBoxAlign())

    , pack(RenderStyle::initialBoxPack())

    , orient(RenderStyle::initialBoxOrient())

    , lines(RenderStyle::initialBoxLines())

{

}

StyleFlexibleBoxData::StyleFlexibleBoxData(const StyleFlexibleBoxData& o)

    : Shared<StyleFlexibleBoxData>()

    , flex(o.flex)

    , flex_group(o.flex_group)

    , ordinal_group(o.ordinal_group)

    , align(o.align)

    , pack(o.pack)

    , orient(o.orient)

    , lines(o.lines)

{

}

bool StyleFlexibleBoxData::operator==(const StyleFlexibleBoxData& o) const

{

    return flex == o.flex && flex_group == o.flex_group &&

           ordinal_group == o.ordinal_group && align == o.align &&

           pack == o.pack && orient == o.orient && lines == o.lines;

}

StyleMultiColData::StyleMultiColData()

    : m_width(0)

    , m_count(RenderStyle::initialColumnCount())

    , m_gap(0)

    , m_autoWidth(true)

    , m_autoCount(true)

    , m_normalGap(true)

    , m_breakBefore(RenderStyle::initialPageBreak())

    , m_breakAfter(RenderStyle::initialPageBreak())

    , m_breakInside(RenderStyle::initialPageBreak())

{}

StyleMultiColData::StyleMultiColData(const StyleMultiColData& o)

    : Shared<StyleMultiColData>()

    , m_width(o.m_width)

    , m_count(o.m_count)

    , m_gap(o.m_gap)

    , m_rule(o.m_rule)

    , m_autoWidth(o.m_autoWidth)

    , m_autoCount(o.m_autoCount)

    , m_normalGap(o.m_normalGap)

    , m_breakBefore(o.m_breakBefore)

    , m_breakAfter(o.m_breakAfter)

    , m_breakInside(o.m_breakInside)

{}

bool StyleMultiColData::operator==(const StyleMultiColData& o) const

{

    return m_width == o.m_width && m_count == o.m_count && m_gap == o.m_gap &&

           m_rule == o.m_rule && m_breakBefore == o.m_breakBefore && 

           m_autoWidth == o.m_autoWidth && m_autoCount == o.m_autoCount && m_normalGap == o.m_normalGap &&

           m_breakAfter == o.m_breakAfter && m_breakInside == o.m_breakInside;

}

StyleRareNonInheritedData::StyleRareNonInheritedData()

    : lineClamp(RenderStyle::initialLineClamp())

    , opacity(RenderStyle::initialOpacity())

    , m_content(0)

    , m_counterDirectives(0)

    , userDrag(RenderStyle::initialUserDrag())

    , textOverflow(RenderStyle::initialTextOverflow())

    , marginTopCollapse(MCOLLAPSE)

    , marginBottomCollapse(MCOLLAPSE)

    , matchNearestMailBlockquoteColor(RenderStyle::initialMatchNearestMailBlockquoteColor())

    , m_appearance(RenderStyle::initialAppearance())

    , m_borderFit(RenderStyle::initialBorderFit())

    , m_boxShadow(0)

#if ENABLE(XBL)

    , bindingURI(0)

#endif

{

}

StyleRareNonInheritedData::StyleRareNonInheritedData(const StyleRareNonInheritedData& o)

    : Shared<StyleRareNonInheritedData>()

    , lineClamp(o.lineClamp)

    , opacity(o.opacity)

    , flexibleBox(o.flexibleBox)

    , marquee(o.marquee)

#if PLATFORM(SYMBIAN)

    , wapInput(o.wapInput)

#endif

    , m_multiCol(o.m_multiCol)

    , m_content(0)

    , m_counterDirectives(0)

    , userDrag(o.userDrag)

    , textOverflow(o.textOverflow)

    , marginTopCollapse(o.marginTopCollapse)

    , marginBottomCollapse(o.marginBottomCollapse)

    , matchNearestMailBlockquoteColor(o.matchNearestMailBlockquoteColor)

    , m_appearance(o.m_appearance)

    , m_borderFit(o.m_borderFit)

    , m_boxShadow(o.m_boxShadow ? new ShadowData(*o.m_boxShadow) : 0)

#if ENABLE(XBL)

    , bindingURI(o.bindingURI ? o.bindingURI->copy() : 0)

#endif

{

}

StyleRareNonInheritedData::~StyleRareNonInheritedData()

{

    delete m_content;

    delete m_counterDirectives;

    delete m_boxShadow;

#if ENABLE(XBL)

    delete bindingURI;

#endif

}

#if ENABLE(XBL)

bool StyleRareNonInheritedData::bindingsEquivalent(const StyleRareNonInheritedData& o) const

{

    if (this == &o) return true;

    if (!bindingURI && o.bindingURI || bindingURI && !o.bindingURI)

        return false;

    if (bindingURI && o.bindingURI && (*bindingURI != *o.bindingURI))

        return false;

    return true;

}

#endif

bool StyleRareNonInheritedData::operator==(const StyleRareNonInheritedData& o) const

{

    return lineClamp == o.lineClamp

        && m_dashboardRegions == o.m_dashboardRegions

        && opacity == o.opacity

        && flexibleBox == o.flexibleBox

        && marquee == o.marquee

        && m_multiCol == o.m_multiCol

        && m_content == o.m_content

        && m_counterDirectives == o.m_counterDirectives

        && userDrag == o.userDrag

        && textOverflow == o.textOverflow

        && marginTopCollapse == o.marginTopCollapse

        && marginBottomCollapse == o.marginBottomCollapse

        && matchNearestMailBlockquoteColor == o.matchNearestMailBlockquoteColor

        && m_appearance == o.m_appearance

        && m_borderFit == o.m_borderFit

        && shadowDataEquivalent(o)

#if ENABLE(XBL)

        && bindingsEquivalent(o)

#endif

#if PLATFORM(SYMBIAN)

        && wapInput == o.wapInput

#endif

        ;

}

bool StyleRareNonInheritedData::shadowDataEquivalent(const StyleRareNonInheritedData& o) const

{

    if (!m_boxShadow && o.m_boxShadow || m_boxShadow && !o.m_boxShadow)

        return false;

    if (m_boxShadow && o.m_boxShadow && (*m_boxShadow != *o.m_boxShadow))

        return false;

    return true;

}

StyleRareInheritedData::StyleRareInheritedData()

    : textStrokeWidth(RenderStyle::initialTextStrokeWidth())

    , textShadow(0)

    , textSecurity(RenderStyle::initialTextSecurity())