/*

 * Copyright (C) 2004 Zack Rusin <zack@kde.org>

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

 * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>

 * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

 * 02110-1301  USA

 */

#include "config.h"

#include "CSSComputedStyleDeclaration.h"

#include "AnimationController.h"

#include "CSSBorderImageValue.h"

#include "CSSMutableStyleDeclaration.h"

#include "CSSPrimitiveValue.h"

#include "CSSPrimitiveValueMappings.h"

#include "CSSProperty.h"

#include "CSSPropertyNames.h"

#include "CSSReflectValue.h"

#include "CSSTimingFunctionValue.h"

#include "CSSValueList.h"

#include "CachedImage.h"

#include "Document.h"

#include "ExceptionCode.h"

#include "Pair.h"

#include "Rect.h"

#include "RenderBox.h"

#include "RenderLayer.h"

#include "ShadowValue.h"

#include "WebKitCSSTransformValue.h"

#if ENABLE(DASHBOARD_SUPPORT)

#include "DashboardRegion.h"

#endif

namespace WebCore {

// List of all properties we know how to compute, omitting shorthands.

static const int computedProperties[] = {

    CSSPropertyBackgroundAttachment,

    CSSPropertyBackgroundClip,

    CSSPropertyBackgroundColor,

    CSSPropertyBackgroundImage,

    CSSPropertyBackgroundOrigin,

    CSSPropertyBackgroundPosition, // more-specific background-position-x/y are non-standard

    CSSPropertyBackgroundRepeat,

    CSSPropertyBackgroundSize,

    CSSPropertyBorderBottomColor,

    CSSPropertyBorderBottomLeftRadius,

    CSSPropertyBorderBottomRightRadius,

    CSSPropertyBorderBottomStyle,

    CSSPropertyBorderBottomWidth,

    CSSPropertyBorderCollapse,

    CSSPropertyBorderLeftColor,

    CSSPropertyBorderLeftStyle,

    CSSPropertyBorderLeftWidth,

    CSSPropertyBorderRightColor,

    CSSPropertyBorderRightStyle,

    CSSPropertyBorderRightWidth,

    CSSPropertyBorderTopColor,

    CSSPropertyBorderTopLeftRadius,

    CSSPropertyBorderTopRightRadius,

    CSSPropertyBorderTopStyle,

    CSSPropertyBorderTopWidth,

    CSSPropertyBottom,

    CSSPropertyCaptionSide,

    CSSPropertyClear,

    CSSPropertyClip,

    CSSPropertyColor,

    CSSPropertyCursor,

    CSSPropertyDirection,

    CSSPropertyDisplay,

    CSSPropertyEmptyCells,

    CSSPropertyFloat,

    CSSPropertyFontFamily,

    CSSPropertyFontSize,

    CSSPropertyFontStyle,

    CSSPropertyFontVariant,

    CSSPropertyFontWeight,

    CSSPropertyHeight,

    CSSPropertyLeft,

    CSSPropertyLetterSpacing,

    CSSPropertyLineHeight,

    CSSPropertyListStyleImage,

    CSSPropertyListStylePosition,

    CSSPropertyListStyleType,

    CSSPropertyMarginBottom,

    CSSPropertyMarginLeft,

    CSSPropertyMarginRight,

    CSSPropertyMarginTop,

    CSSPropertyMaxHeight,

    CSSPropertyMaxWidth,

    CSSPropertyMinHeight,

    CSSPropertyMinWidth,

    CSSPropertyOpacity,

    CSSPropertyOrphans,

    CSSPropertyOutlineColor,

    CSSPropertyOutlineStyle,

    CSSPropertyOutlineWidth,

    CSSPropertyOverflowX,

    CSSPropertyOverflowY,

    CSSPropertyPaddingBottom,

    CSSPropertyPaddingLeft,

    CSSPropertyPaddingRight,

    CSSPropertyPaddingTop,

    CSSPropertyPageBreakAfter,

    CSSPropertyPageBreakBefore,

    CSSPropertyPageBreakInside,

    CSSPropertyPointerEvents,

    CSSPropertyPosition,

    CSSPropertyResize,

    CSSPropertyRight,

    CSSPropertyTableLayout,

    CSSPropertyTextAlign,

    CSSPropertyTextDecoration,

    CSSPropertyTextIndent,

    CSSPropertyTextRendering,

    CSSPropertyTextShadow,

    CSSPropertyTextOverflow,

    CSSPropertyTextTransform,

    CSSPropertyTop,

    CSSPropertyUnicodeBidi,

    CSSPropertyVerticalAlign,

    CSSPropertyVisibility,

    CSSPropertyWhiteSpace,

    CSSPropertyWidows,

    CSSPropertyWidth,

    CSSPropertyWordBreak,

    CSSPropertyWordSpacing,

    CSSPropertyWordWrap,

    CSSPropertyZIndex,

    CSSPropertyZoom,

    CSSPropertyWebkitAnimationDelay,

    CSSPropertyWebkitAnimationDirection,

    CSSPropertyWebkitAnimationDuration,

    CSSPropertyWebkitAnimationIterationCount,

    CSSPropertyWebkitAnimationName,

    CSSPropertyWebkitAnimationPlayState,

    CSSPropertyWebkitAnimationTimingFunction,

    CSSPropertyWebkitAppearance,

    CSSPropertyWebkitBackfaceVisibility,

    CSSPropertyWebkitBackgroundClip,

    CSSPropertyWebkitBackgroundComposite,

    CSSPropertyWebkitBackgroundOrigin,

    CSSPropertyWebkitBackgroundSize,

    CSSPropertyWebkitBorderFit,

    CSSPropertyWebkitBorderHorizontalSpacing,

    CSSPropertyWebkitBorderImage,

    CSSPropertyWebkitBorderVerticalSpacing,

    CSSPropertyWebkitBoxAlign,

    CSSPropertyWebkitBoxDirection,

    CSSPropertyWebkitBoxFlex,

    CSSPropertyWebkitBoxFlexGroup,

    CSSPropertyWebkitBoxLines,

    CSSPropertyWebkitBoxOrdinalGroup,

    CSSPropertyWebkitBoxOrient,

    CSSPropertyWebkitBoxPack,

    CSSPropertyWebkitBoxReflect,

    CSSPropertyWebkitBoxShadow,

    CSSPropertyWebkitBoxSizing,

    CSSPropertyWebkitColumnBreakAfter,

    CSSPropertyWebkitColumnBreakBefore,

    CSSPropertyWebkitColumnBreakInside,

    CSSPropertyWebkitColumnCount,

    CSSPropertyWebkitColumnGap,

    CSSPropertyWebkitColumnRuleColor,

    CSSPropertyWebkitColumnRuleStyle,

    CSSPropertyWebkitColumnRuleWidth,

    CSSPropertyWebkitColumnWidth,

#if ENABLE(DASHBOARD_SUPPORT)

    CSSPropertyWebkitDashboardRegion,

#endif

    CSSPropertyWebkitFontSmoothing,

    CSSPropertyWebkitHighlight,

    CSSPropertyWebkitLineBreak,

    CSSPropertyWebkitLineClamp,

    CSSPropertyWebkitMarginBottomCollapse,

    CSSPropertyWebkitMarginTopCollapse,

    CSSPropertyWebkitMarqueeDirection,

    CSSPropertyWebkitMarqueeIncrement,

    CSSPropertyWebkitMarqueeRepetition,

    CSSPropertyWebkitMarqueeStyle,

    CSSPropertyWebkitMaskAttachment,

    CSSPropertyWebkitMaskBoxImage,

    CSSPropertyWebkitMaskClip,

    CSSPropertyWebkitMaskComposite,

    CSSPropertyWebkitMaskImage,

    CSSPropertyWebkitMaskOrigin,

    CSSPropertyWebkitMaskPosition,

    CSSPropertyWebkitMaskRepeat,

    CSSPropertyWebkitMaskSize,

    CSSPropertyWebkitNbspMode,

    CSSPropertyWebkitPerspective,

    CSSPropertyWebkitPerspectiveOrigin,

    CSSPropertyWebkitRtlOrdering,

    CSSPropertyWebkitTextDecorationsInEffect,

    CSSPropertyWebkitTextFillColor,

    CSSPropertyWebkitTextSecurity,

    CSSPropertyWebkitTextStrokeColor,

    CSSPropertyWebkitTextStrokeWidth,

    CSSPropertyWebkitTransform,

    CSSPropertyWebkitTransformOrigin,

    CSSPropertyWebkitTransformStyle,

    CSSPropertyWebkitTransitionDelay,

    CSSPropertyWebkitTransitionDuration,

    CSSPropertyWebkitTransitionProperty,

    CSSPropertyWebkitTransitionTimingFunction,

    CSSPropertyWebkitUserDrag,

    CSSPropertyWebkitUserModify,

    CSSPropertyWebkitUserSelect

#if ENABLE(SVG)

    ,

    CSSPropertyClipPath,

    CSSPropertyClipRule,

    CSSPropertyMask,

    CSSPropertyFilter,

    CSSPropertyFloodColor,

    CSSPropertyFloodOpacity,

    CSSPropertyLightingColor,

    CSSPropertyStopColor,

    CSSPropertyStopOpacity,

    CSSPropertyColorInterpolation,

    CSSPropertyColorInterpolationFilters,

    CSSPropertyColorRendering,

    CSSPropertyFill,

    CSSPropertyFillOpacity,

    CSSPropertyFillRule,

    CSSPropertyImageRendering,

    CSSPropertyMarkerEnd,

    CSSPropertyMarkerMid,

    CSSPropertyMarkerStart,

    CSSPropertyShapeRendering,

    CSSPropertyStroke,

    CSSPropertyStrokeDasharray,

    CSSPropertyStrokeDashoffset,

    CSSPropertyStrokeLinecap,

    CSSPropertyStrokeLinejoin,

    CSSPropertyStrokeMiterlimit,

    CSSPropertyStrokeOpacity,

    CSSPropertyStrokeWidth,

    CSSPropertyAlignmentBaseline,

    CSSPropertyBaselineShift,

    CSSPropertyDominantBaseline,

    CSSPropertyKerning,

    CSSPropertyTextAnchor,

    CSSPropertyWritingMode,

    CSSPropertyGlyphOrientationHorizontal,

    CSSPropertyGlyphOrientationVertical,

    CSSPropertyWebkitShadow

#endif

};

const unsigned numComputedProperties = sizeof(computedProperties) / sizeof(computedProperties[0]);

static int valueForRepeatRule(int rule)

{

    switch (rule) {

        case RepeatImageRule:

            return CSSValueRepeat;

        case RoundImageRule:

            return CSSValueRound;

        default:

            return CSSValueStretch;

    }

}

static PassRefPtr<CSSValue> valueForNinePieceImage(const NinePieceImage& image)

{

    if (!image.hasImage())

        return CSSPrimitiveValue::createIdentifier(CSSValueNone);

    // Image first.

    RefPtr<CSSValue> imageValue;

    if (image.image())

        imageValue = image.image()->cssValue();

    // Create the slices.

    RefPtr<CSSPrimitiveValue> top;

    if (image.m_slices.top().isPercent())

        top = CSSPrimitiveValue::create(image.m_slices.top().value(), CSSPrimitiveValue::CSS_PERCENTAGE);

    else

        top = CSSPrimitiveValue::create(image.m_slices.top().value(), CSSPrimitiveValue::CSS_NUMBER);

    RefPtr<CSSPrimitiveValue> right;

    if (image.m_slices.right().isPercent())

        right = CSSPrimitiveValue::create(image.m_slices.right().value(), CSSPrimitiveValue::CSS_PERCENTAGE);

    else

        right = CSSPrimitiveValue::create(image.m_slices.right().value(), CSSPrimitiveValue::CSS_NUMBER);

    RefPtr<CSSPrimitiveValue> bottom;

    if (image.m_slices.bottom().isPercent())

        bottom = CSSPrimitiveValue::create(image.m_slices.bottom().value(), CSSPrimitiveValue::CSS_PERCENTAGE);

    else

        bottom = CSSPrimitiveValue::create(image.m_slices.bottom().value(), CSSPrimitiveValue::CSS_NUMBER);

    RefPtr<CSSPrimitiveValue> left;

    if (image.m_slices.left().isPercent())

        left = CSSPrimitiveValue::create(image.m_slices.left().value(), CSSPrimitiveValue::CSS_PERCENTAGE);

    else

        left = CSSPrimitiveValue::create(image.m_slices.left().value(), CSSPrimitiveValue::CSS_NUMBER);

    RefPtr<Rect> rect = Rect::create();

    rect->setTop(top);

    rect->setRight(right);

    rect->setBottom(bottom);

    rect->setLeft(left);

    return CSSBorderImageValue::create(imageValue, rect, valueForRepeatRule(image.m_horizontalRule), valueForRepeatRule(image.m_verticalRule));

}

static PassRefPtr<CSSValue> valueForReflection(const StyleReflection* reflection)

{

    if (!reflection)

        return CSSPrimitiveValue::createIdentifier(CSSValueNone);

    RefPtr<CSSPrimitiveValue> offset;

    if (reflection->offset().isPercent())

        offset = CSSPrimitiveValue::create(reflection->offset().percent(), CSSPrimitiveValue::CSS_PERCENTAGE);

    else

        offset = CSSPrimitiveValue::create(reflection->offset().value(), CSSPrimitiveValue::CSS_PX);

    return CSSReflectValue::create(reflection->direction(), offset.release(), valueForNinePieceImage(reflection->mask()));

}

static PassRefPtr<CSSValue> getPositionOffsetValue(RenderStyle* style, int propertyID)

{

    if (!style)

        return 0;

    Length l;

    switch (propertyID) {

        case CSSPropertyLeft:

            l = style->left();

            break;

        case CSSPropertyRight:

            l = style->right();

            break;

        case CSSPropertyTop:

            l = style->top();

            break;

        case CSSPropertyBottom:

            l = style->bottom();

            break;

        default:

            return 0;

    }

    if (style->position() == AbsolutePosition || style->position() == FixedPosition)

        return CSSPrimitiveValue::create(l);

    if (style->position() == RelativePosition)

        // FIXME: It's not enough to simply return "auto" values for one offset if the other side is defined.

        // In other words if left is auto and right is not auto, then left's computed value is negative right().

        // So we should get the opposite length unit and see if it is auto.

        return CSSPrimitiveValue::create(l);

    return CSSPrimitiveValue::createIdentifier(CSSValueAuto);

}

static PassRefPtr<CSSPrimitiveValue> currentColorOrValidColor(RenderStyle* style, const Color& color)

{

    if (!color.isValid())

        return CSSPrimitiveValue::createColor(style->color().rgb());

    return CSSPrimitiveValue::createColor(color.rgb());

}

static PassRefPtr<CSSValue> getBorderRadiusCornerValue(IntSize radius)

{

    if (radius.width() == radius.height())

        return CSSPrimitiveValue::create(radius.width(), CSSPrimitiveValue::CSS_PX);

    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

    list->append(CSSPrimitiveValue::create(radius.width(), CSSPrimitiveValue::CSS_PX));

    list->append(CSSPrimitiveValue::create(radius.height(), CSSPrimitiveValue::CSS_PX));

    return list.release();

}

static IntRect sizingBox(RenderObject* renderer)

{

    if (!renderer->isBox())

        return IntRect();

    RenderBox* box = toRenderBox(renderer);

    return box->style()->boxSizing() == CONTENT_BOX ? box->contentBoxRect() : box->borderBoxRect();

}

static inline bool hasCompositedLayer(RenderObject* renderer)

{

    return renderer && renderer->hasLayer() && toRenderBoxModelObject(renderer)->layer()->isComposited();

}

static PassRefPtr<CSSValue> computedTransform(RenderObject* renderer, const RenderStyle* style)

{

    if (!renderer || style->transform().operations().isEmpty())

        return CSSPrimitiveValue::createIdentifier(CSSValueNone);

    IntRect box = sizingBox(renderer);

    TransformationMatrix transform;

    style->applyTransform(transform, box.size(), RenderStyle::ExcludeTransformOrigin);

    // Note that this does not flatten to an affine transform if ENABLE(3D_RENDERING) is off, by design.

    RefPtr<WebKitCSSTransformValue> transformVal;

    // FIXME: Need to print out individual functions (https://bugs.webkit.org/show_bug.cgi?id=23924)

    if (transform.isAffine()) {

        transformVal = WebKitCSSTransformValue::create(WebKitCSSTransformValue::MatrixTransformOperation);

        transformVal->append(CSSPrimitiveValue::create(transform.a(), CSSPrimitiveValue::CSS_NUMBER));

        transformVal->append(CSSPrimitiveValue::create(transform.b(), CSSPrimitiveValue::CSS_NUMBER));

        transformVal->append(CSSPrimitiveValue::create(transform.c(), CSSPrimitiveValue::CSS_NUMBER));

        transformVal->append(CSSPrimitiveValue::create(transform.d(), CSSPrimitiveValue::CSS_NUMBER));

        transformVal->append(CSSPrimitiveValue::create(transform.e(), CSSPrimitiveValue::CSS_NUMBER));

        transformVal->append(CSSPrimitiveValue::create(transform.f(), CSSPrimitiveValue::CSS_NUMBER));

    } else {

        transformVal = WebKitCSSTransformValue::create(WebKitCSSTransformValue::Matrix3DTransformOperation);

        transformVal->append(CSSPrimitiveValue::create(transform.m11(), CSSPrimitiveValue::CSS_NUMBER));

        transformVal->append(CSSPrimitiveValue::create(transform.m12(), CSSPrimitiveValue::CSS_NUMBER));

        transformVal->append(CSSPrimitiveValue::create(transform.m13(), CSSPrimitiveValue::CSS_NUMBER));

        transformVal->append(CSSPrimitiveValue::create(transform.m14(), CSSPrimitiveValue::CSS_NUMBER));

        transformVal->append(CSSPrimitiveValue::create(transform.m21(), CSSPrimitiveValue::CSS_NUMBER));

        transformVal->append(CSSPrimitiveValue::create(transform.m22(), CSSPrimitiveValue::CSS_NUMBER));

        transformVal->append(CSSPrimitiveValue::create(transform.m23(), CSSPrimitiveValue::CSS_NUMBER));

        transformVal->append(CSSPrimitiveValue::create(transform.m24(), CSSPrimitiveValue::CSS_NUMBER));

        transformVal->append(CSSPrimitiveValue::create(transform.m31(), CSSPrimitiveValue::CSS_NUMBER));

        transformVal->append(CSSPrimitiveValue::create(transform.m32(), CSSPrimitiveValue::CSS_NUMBER));

        transformVal->append(CSSPrimitiveValue::create(transform.m33(), CSSPrimitiveValue::CSS_NUMBER));

        transformVal->append(CSSPrimitiveValue::create(transform.m34(), CSSPrimitiveValue::CSS_NUMBER));

        transformVal->append(CSSPrimitiveValue::create(transform.m41(), CSSPrimitiveValue::CSS_NUMBER));

        transformVal->append(CSSPrimitiveValue::create(transform.m42(), CSSPrimitiveValue::CSS_NUMBER));

        transformVal->append(CSSPrimitiveValue::create(transform.m43(), CSSPrimitiveValue::CSS_NUMBER));

        transformVal->append(CSSPrimitiveValue::create(transform.m44(), CSSPrimitiveValue::CSS_NUMBER));

    }

    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

    list->append(transformVal);

    return list.release();

}

static PassRefPtr<CSSValue> getDelayValue(const AnimationList* animList)

{

    RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

    if (animList) {

        for (size_t i = 0; i < animList->size(); ++i)

            list->append(CSSPrimitiveValue::create(animList->animation(i)->delay(), CSSPrimitiveValue::CSS_S));

    } else {

        // Note that initialAnimationDelay() is used for both transitions and animations

        list->append(CSSPrimitiveValue::create(Animation::initialAnimationDelay(), CSSPrimitiveValue::CSS_S));

    }

    return list.release();

}

static PassRefPtr<CSSValue> getDurationValue(const AnimationList* animList)

{

    RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

    if (animList) {

        for (size_t i = 0; i < animList->size(); ++i)

            list->append(CSSPrimitiveValue::create(animList->animation(i)->duration(), CSSPrimitiveValue::CSS_S));

    } else {

        // Note that initialAnimationDuration() is used for both transitions and animations

        list->append(CSSPrimitiveValue::create(Animation::initialAnimationDuration(), CSSPrimitiveValue::CSS_S));

    }

    return list.release();

}

static PassRefPtr<CSSValue> getTimingFunctionValue(const AnimationList* animList)

{

    RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

    if (animList) {

        for (size_t i = 0; i < animList->size(); ++i) {

            const TimingFunction& tf = animList->animation(i)->timingFunction();

            list->append(CSSTimingFunctionValue::create(tf.x1(), tf.y1(), tf.x2(), tf.y2()));

        }

    } else {

        // Note that initialAnimationTimingFunction() is used for both transitions and animations

        const TimingFunction& tf = Animation::initialAnimationTimingFunction();

        list->append(CSSTimingFunctionValue::create(tf.x1(), tf.y1(), tf.x2(), tf.y2()));

    }

    return list.release();

}

CSSComputedStyleDeclaration::CSSComputedStyleDeclaration(PassRefPtr<Node> n)

    : m_node(n)

{

}

CSSComputedStyleDeclaration::~CSSComputedStyleDeclaration()

{

}

String CSSComputedStyleDeclaration::cssText() const

{

    String result("");

    for (unsigned i = 0; i < numComputedProperties; i++) {

        if (i)

            result += " ";

        result += getPropertyName(static_cast<CSSPropertyID>(computedProperties[i]));

        result += ": ";

        result += getPropertyValue(computedProperties[i]);

        result += ";";

    }

    return result;

}

void CSSComputedStyleDeclaration::setCssText(const String&, ExceptionCode& ec)