/**

 *

 * Copyright (C) 2004 Zack Rusin <zack@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 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 "CSSMutableStyleDeclaration.h"

#include "CSSPrimitiveValue.h"

#include "CSSPropertyNames.h"

#include "CSSValueKeywords.h"

#include "CSSValueList.h"

#include "CachedImage.h"

#include "DashboardRegion.h"

#include "Document.h"

#include "ExceptionCode.h"

#include "Pair.h"

#include "RenderObject.h"

#include "ShadowValue.h"

namespace WebCore {

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

static const int computedProperties[] = {

    CSS_PROP_BACKGROUND_ATTACHMENT,

    CSS_PROP_BACKGROUND_COLOR,

    CSS_PROP_BACKGROUND_IMAGE,

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

    CSS_PROP_BACKGROUND_POSITION,

    CSS_PROP_BACKGROUND_REPEAT,

    CSS_PROP_BORDER_BOTTOM_COLOR,

    CSS_PROP_BORDER_BOTTOM_STYLE,

    CSS_PROP_BORDER_BOTTOM_WIDTH,

    CSS_PROP_BORDER_COLLAPSE,

    CSS_PROP_BORDER_LEFT_COLOR,

    CSS_PROP_BORDER_LEFT_STYLE,

    CSS_PROP_BORDER_LEFT_WIDTH,

    CSS_PROP_BORDER_RIGHT_COLOR,

    CSS_PROP_BORDER_RIGHT_STYLE,

    CSS_PROP_BORDER_RIGHT_WIDTH,

    CSS_PROP_BORDER_TOP_COLOR,

    CSS_PROP_BORDER_TOP_STYLE,

    CSS_PROP_BORDER_TOP_WIDTH,

    CSS_PROP_BOTTOM,

    CSS_PROP_CAPTION_SIDE,

    CSS_PROP_CLEAR,

    CSS_PROP_COLOR,

    CSS_PROP_CURSOR,

    CSS_PROP_DIRECTION,

    CSS_PROP_DISPLAY,

    CSS_PROP_EMPTY_CELLS,

    CSS_PROP_FLOAT,

    CSS_PROP_FONT_FAMILY,

    CSS_PROP_FONT_SIZE,

    CSS_PROP_FONT_STYLE,

    CSS_PROP_FONT_VARIANT,

    CSS_PROP_FONT_WEIGHT,

    CSS_PROP_HEIGHT,

    CSS_PROP_LEFT,

    CSS_PROP_LETTER_SPACING,

    CSS_PROP_LINE_HEIGHT,

    CSS_PROP_LIST_STYLE_IMAGE,

    CSS_PROP_LIST_STYLE_POSITION,

    CSS_PROP_LIST_STYLE_TYPE,

    CSS_PROP_MARGIN_BOTTOM,

    CSS_PROP_MARGIN_LEFT,

    CSS_PROP_MARGIN_RIGHT,

    CSS_PROP_MARGIN_TOP,

    CSS_PROP_MAX_HEIGHT,

    CSS_PROP_MAX_WIDTH,

    CSS_PROP_MIN_HEIGHT,

    CSS_PROP_MIN_WIDTH,

    CSS_PROP_OPACITY,

    CSS_PROP_ORPHANS,

    CSS_PROP_OUTLINE_COLOR,

    CSS_PROP_OUTLINE_STYLE,

    CSS_PROP_OUTLINE_WIDTH,

    CSS_PROP_OVERFLOW_X,

    CSS_PROP_OVERFLOW_Y,

    CSS_PROP_PADDING_BOTTOM,

    CSS_PROP_PADDING_LEFT,

    CSS_PROP_PADDING_RIGHT,

    CSS_PROP_PADDING_TOP,

    CSS_PROP_PAGE_BREAK_AFTER,

    CSS_PROP_PAGE_BREAK_BEFORE,

    CSS_PROP_PAGE_BREAK_INSIDE,

    CSS_PROP_POSITION,

    CSS_PROP_RESIZE,

    CSS_PROP_RIGHT,

    CSS_PROP_TABLE_LAYOUT,

    CSS_PROP_TEXT_ALIGN,

    CSS_PROP_TEXT_DECORATION,

    CSS_PROP_TEXT_INDENT,

    CSS_PROP_TEXT_SHADOW,

    CSS_PROP_TEXT_TRANSFORM,

    CSS_PROP_TOP,

    CSS_PROP_UNICODE_BIDI,

    CSS_PROP_VERTICAL_ALIGN,

    CSS_PROP_VISIBILITY,

    CSS_PROP_WHITE_SPACE,

    CSS_PROP_WIDOWS,

    CSS_PROP_WIDTH,

    CSS_PROP_WORD_SPACING,

    CSS_PROP_WORD_WRAP,

    CSS_PROP_Z_INDEX,

    CSS_PROP__WEBKIT_APPEARANCE,

    CSS_PROP__WEBKIT_BACKGROUND_CLIP,

    CSS_PROP__WEBKIT_BACKGROUND_COMPOSITE,

    CSS_PROP__WEBKIT_BACKGROUND_ORIGIN,

    CSS_PROP__WEBKIT_BACKGROUND_SIZE,

    CSS_PROP__WEBKIT_BORDER_FIT,

    CSS_PROP__WEBKIT_BORDER_HORIZONTAL_SPACING,

    CSS_PROP__WEBKIT_BORDER_VERTICAL_SPACING,

    CSS_PROP__WEBKIT_BOX_ALIGN,

    CSS_PROP__WEBKIT_BOX_DIRECTION,

    CSS_PROP__WEBKIT_BOX_FLEX,

    CSS_PROP__WEBKIT_BOX_FLEX_GROUP,

    CSS_PROP__WEBKIT_BOX_LINES,

    CSS_PROP__WEBKIT_BOX_ORDINAL_GROUP,

    CSS_PROP__WEBKIT_BOX_ORIENT,

    CSS_PROP__WEBKIT_BOX_PACK,

    CSS_PROP__WEBKIT_BOX_SHADOW,

    CSS_PROP__WEBKIT_BOX_SIZING,

    CSS_PROP__WEBKIT_COLUMN_BREAK_AFTER,

    CSS_PROP__WEBKIT_COLUMN_BREAK_BEFORE,

    CSS_PROP__WEBKIT_COLUMN_BREAK_INSIDE,

    CSS_PROP__WEBKIT_COLUMN_COUNT,

    CSS_PROP__WEBKIT_COLUMN_GAP,

    CSS_PROP__WEBKIT_COLUMN_RULE_COLOR,

    CSS_PROP__WEBKIT_COLUMN_RULE_STYLE,

    CSS_PROP__WEBKIT_COLUMN_RULE_WIDTH,

    CSS_PROP__WEBKIT_COLUMN_WIDTH,

    CSS_PROP__WEBKIT_HIGHLIGHT,

    CSS_PROP__WEBKIT_LINE_BREAK,

    CSS_PROP__WEBKIT_LINE_CLAMP,

    CSS_PROP__WEBKIT_MARGIN_BOTTOM_COLLAPSE,

    CSS_PROP__WEBKIT_MARGIN_TOP_COLLAPSE,

    CSS_PROP__WEBKIT_MARQUEE_DIRECTION,

    CSS_PROP__WEBKIT_MARQUEE_INCREMENT,

    CSS_PROP__WEBKIT_MARQUEE_REPETITION,

    CSS_PROP__WEBKIT_MARQUEE_STYLE,

    CSS_PROP__WEBKIT_NBSP_MODE,

    CSS_PROP__WEBKIT_RTL_ORDERING,

    CSS_PROP__WEBKIT_TEXT_DECORATIONS_IN_EFFECT,

    CSS_PROP__WEBKIT_TEXT_FILL_COLOR,

    CSS_PROP__WEBKIT_TEXT_SECURITY,

    CSS_PROP__WEBKIT_TEXT_STROKE_COLOR,

    CSS_PROP__WEBKIT_TEXT_STROKE_WIDTH,

    CSS_PROP__WEBKIT_USER_DRAG,

    CSS_PROP__WEBKIT_USER_MODIFY,

    CSS_PROP__WEBKIT_USER_SELECT,

    CSS_PROP__WEBKIT_DASHBOARD_REGION,

    CSS_PROP__WEBKIT_BORDER_BOTTOM_LEFT_RADIUS,

    CSS_PROP__WEBKIT_BORDER_BOTTOM_RIGHT_RADIUS,

    CSS_PROP__WEBKIT_BORDER_TOP_LEFT_RADIUS,

    CSS_PROP__WEBKIT_BORDER_TOP_RIGHT_RADIUS

#if PLATFORM(SYMBIAN)

    ,CSS_PROP__WAP_MARQUEE_DIR,

    CSS_PROP__WAP_MARQUEE_LOOP,

    CSS_PROP__WAP_MARQUEE_SPEED,

    CSS_PROP__WAP_MARQUEE_STYLE

#endif

};

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

static PassRefPtr<CSSValue> valueForLength(const Length& length)

{

    switch (length.type()) {

        case Auto:

            return new CSSPrimitiveValue(CSS_VAL_AUTO);

        case WebCore::Fixed:

            return new CSSPrimitiveValue(length.value(), CSSPrimitiveValue::CSS_PX);

        case Intrinsic:

            return new CSSPrimitiveValue(CSS_VAL_INTRINSIC);

        case MinIntrinsic:

            return new CSSPrimitiveValue(CSS_VAL_MIN_INTRINSIC);

        case Percent:

            return new CSSPrimitiveValue(length.percent(), CSSPrimitiveValue::CSS_PERCENTAGE);

        case Relative:

        case Static:

            break;

    }

    ASSERT_NOT_REACHED();

    return 0;

}

// Handles special value for "none".

static PassRefPtr<CSSValue> valueForMaxLength(const Length& length)

{

    if (length.isFixed() && length.value() == undefinedLength)

        return new CSSPrimitiveValue(CSS_VAL_NONE);

    return valueForLength(length);

}

static PassRefPtr<CSSValue> valueForBorderStyle(EBorderStyle style)

{

    switch (style) {

        case BNONE:

            return new CSSPrimitiveValue(CSS_VAL_NONE);

        case BHIDDEN:

            return new CSSPrimitiveValue(CSS_VAL_HIDDEN);

        case INSET:

            return new CSSPrimitiveValue(CSS_VAL_INSET);

        case GROOVE:

            return new CSSPrimitiveValue(CSS_VAL_GROOVE);

        case RIDGE:

            return new CSSPrimitiveValue(CSS_VAL_RIDGE);

        case OUTSET:

            return new CSSPrimitiveValue(CSS_VAL_OUTSET);

        case DOTTED:

            return new CSSPrimitiveValue(CSS_VAL_DOTTED);

        case DASHED:

            return new CSSPrimitiveValue(CSS_VAL_DASHED);

        case SOLID:

            return new CSSPrimitiveValue(CSS_VAL_SOLID);

        case DOUBLE:

            return new CSSPrimitiveValue(CSS_VAL_DOUBLE);

    }

    ASSERT_NOT_REACHED();

    return 0;

}

static PassRefPtr<CSSValue> valueForTextAlign(ETextAlign align)

{

    switch (align) {

        case TAAUTO:

            return new CSSPrimitiveValue(CSS_VAL_AUTO);

        case LEFT:

            return new CSSPrimitiveValue(CSS_VAL_LEFT);

        case RIGHT:

            return new CSSPrimitiveValue(CSS_VAL_RIGHT);

        case CENTER:

            return new CSSPrimitiveValue(CSS_VAL_CENTER);

        case JUSTIFY:

            return new CSSPrimitiveValue(CSS_VAL_JUSTIFY);

        case WEBKIT_LEFT:

            return new CSSPrimitiveValue(CSS_VAL__WEBKIT_LEFT);

        case WEBKIT_RIGHT:

            return new CSSPrimitiveValue(CSS_VAL__WEBKIT_RIGHT);

        case WEBKIT_CENTER:

            return new CSSPrimitiveValue(CSS_VAL__WEBKIT_CENTER);

    }

    ASSERT_NOT_REACHED();

    return 0;

}

static PassRefPtr<CSSValue> valueForAppearance(EAppearance appearance)

{

    switch (appearance) {

        case NoAppearance:

            return new CSSPrimitiveValue(CSS_VAL_NONE);

        case CheckboxAppearance:

            return new CSSPrimitiveValue(CSS_VAL_CHECKBOX);

        case RadioAppearance:

            return new CSSPrimitiveValue(CSS_VAL_RADIO);

        case PushButtonAppearance:

            return new CSSPrimitiveValue(CSS_VAL_PUSH_BUTTON);

        case SquareButtonAppearance:

            return new CSSPrimitiveValue(CSS_VAL_SQUARE_BUTTON);

        case ButtonAppearance:

            return new CSSPrimitiveValue(CSS_VAL_BUTTON);

        case ButtonBevelAppearance:

            return new CSSPrimitiveValue(CSS_VAL_BUTTON_BEVEL);

        case ListboxAppearance:

            return new CSSPrimitiveValue(CSS_VAL_LISTBOX);

        case ListItemAppearance:

            return new CSSPrimitiveValue(CSS_VAL_LISTITEM);

        case MenulistAppearance:

            return new CSSPrimitiveValue(CSS_VAL_MENULIST);

        case MenulistButtonAppearance:

            return new CSSPrimitiveValue(CSS_VAL_MENULIST_BUTTON);

        case MenulistTextAppearance:

            return new CSSPrimitiveValue(CSS_VAL_MENULIST_TEXT);

        case MenulistTextFieldAppearance:

            return new CSSPrimitiveValue(CSS_VAL_MENULIST_TEXTFIELD);

        case ScrollbarButtonUpAppearance:

            return new CSSPrimitiveValue(CSS_VAL_SCROLLBARBUTTON_UP);

        case ScrollbarButtonDownAppearance:

            return new CSSPrimitiveValue(CSS_VAL_SCROLLBARBUTTON_DOWN);

        case ScrollbarButtonLeftAppearance:

            return new CSSPrimitiveValue(CSS_VAL_SCROLLBARBUTTON_LEFT);

        case ScrollbarButtonRightAppearance:

            return new CSSPrimitiveValue(CSS_VAL_SCROLLBARBUTTON_RIGHT);

        case ScrollbarTrackHorizontalAppearance:

            return new CSSPrimitiveValue(CSS_VAL_SCROLLBARTRACK_HORIZONTAL);

        case ScrollbarTrackVerticalAppearance:

            return new CSSPrimitiveValue(CSS_VAL_SCROLLBARTRACK_VERTICAL);

        case ScrollbarThumbHorizontalAppearance:

            return new CSSPrimitiveValue(CSS_VAL_SCROLLBARTHUMB_HORIZONTAL);

        case ScrollbarThumbVerticalAppearance:

            return new CSSPrimitiveValue(CSS_VAL_SCROLLBARTHUMB_VERTICAL);

        case ScrollbarGripperHorizontalAppearance:

            return new CSSPrimitiveValue(CSS_VAL_SCROLLBARGRIPPER_HORIZONTAL);

        case ScrollbarGripperVerticalAppearance:

            return new CSSPrimitiveValue(CSS_VAL_SCROLLBARGRIPPER_VERTICAL);

        case SliderHorizontalAppearance:

            return new CSSPrimitiveValue(CSS_VAL_SLIDER_HORIZONTAL);

        case SliderVerticalAppearance:

            return new CSSPrimitiveValue(CSS_VAL_SLIDER_VERTICAL);

        case SliderThumbHorizontalAppearance:

            return new CSSPrimitiveValue(CSS_VAL_SLIDERTHUMB_HORIZONTAL);

        case SliderThumbVerticalAppearance:

            return new CSSPrimitiveValue(CSS_VAL_SLIDERTHUMB_VERTICAL);

        case CaretAppearance:

            return new CSSPrimitiveValue(CSS_VAL_CARET);

        case SearchFieldAppearance:

            return new CSSPrimitiveValue(CSS_VAL_SEARCHFIELD);

        case SearchFieldDecorationAppearance:

            return new CSSPrimitiveValue(CSS_VAL_SEARCHFIELD_DECORATION);

        case SearchFieldResultsDecorationAppearance:

            return new CSSPrimitiveValue(CSS_VAL_SEARCHFIELD_RESULTS_DECORATION);

        case SearchFieldResultsButtonAppearance:

            return new CSSPrimitiveValue(CSS_VAL_SEARCHFIELD_RESULTS_BUTTON);

        case SearchFieldCancelButtonAppearance:

            return new CSSPrimitiveValue(CSS_VAL_SEARCHFIELD_CANCEL_BUTTON);

        case TextFieldAppearance:

            return new CSSPrimitiveValue(CSS_VAL_TEXTFIELD);

        case TextAreaAppearance:

            return new CSSPrimitiveValue(CSS_VAL_TEXTAREA);

    }

    ASSERT_NOT_REACHED();

    return 0;

}

static PassRefPtr<CSSValue> valueForMarginCollapse(EMarginCollapse collapse)

{

    switch (collapse) {

        case MCOLLAPSE:

            return new CSSPrimitiveValue(CSS_VAL_COLLAPSE);

        case MSEPARATE:

            return new CSSPrimitiveValue(CSS_VAL_SEPARATE);

        case MDISCARD:

            return new CSSPrimitiveValue(CSS_VAL_DISCARD);

    }

    ASSERT_NOT_REACHED();

    return 0;

}

static PassRefPtr<CSSValue> valueForShadow(const ShadowData* shadow)

{

    if (!shadow)

        return new CSSPrimitiveValue(CSS_VAL_NONE);

    RefPtr<CSSValueList> list = new CSSValueList;

    for (const ShadowData* s = shadow; s; s = s->next) {

        RefPtr<CSSPrimitiveValue> x = new CSSPrimitiveValue(s->x, CSSPrimitiveValue::CSS_PX);

        RefPtr<CSSPrimitiveValue> y = new CSSPrimitiveValue(s->y, CSSPrimitiveValue::CSS_PX);

        RefPtr<CSSPrimitiveValue> blur = new CSSPrimitiveValue(s->blur, CSSPrimitiveValue::CSS_PX);

        RefPtr<CSSPrimitiveValue> color = new CSSPrimitiveValue(s->color.rgb());

        list->append(new ShadowValue(x.release(), y.release(), blur.release(), color.release()));

    }

    return list.release();

}

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

{

    if (!style)

        return 0;

    Length l;

    switch (propertyID) {

        case CSS_PROP_LEFT:

            l = style->left();

            break;

        case CSS_PROP_RIGHT:

            l = style->right();

            break;

        case CSS_PROP_TOP:

            l = style->top();

            break;

        case CSS_PROP_BOTTOM:

            l = style->bottom();

            break;

        default:

            return 0;

    }

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

        return valueForLength(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 valueForLength(l);

    return new CSSPrimitiveValue(CSS_VAL_AUTO);

}

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

{

    if (!color.isValid())

        return new CSSPrimitiveValue(style->color().rgb());

    return new CSSPrimitiveValue(color.rgb());

}

static PassRefPtr<CSSValue> getBorderRadiusCornerValue(IntSize radius)

{

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

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

    RefPtr<CSSValueList> list = new CSSValueList(true);

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

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

    return list.release();

}

static IntRect sizingBox(RenderObject* renderer)

{

    return renderer->style()->boxSizing() == CONTENT_BOX ? renderer->contentBox() : renderer->borderBox();

}

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)

{

    ec = NO_MODIFICATION_ALLOWED_ERR;

}

// Display integers in integer format instead of "1.0".

static String numberAsString(double n)

{

    long i = static_cast<long>(n);

    return i == n ? String::number(i) : String::number(n);

}

PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(int propertyID) const

{

    return getPropertyCSSValue(propertyID, UpdateLayout);

}

PassRefPtr<CSSPrimitiveValue> primitiveValueFromLength(Length length)

{

    String string;

    switch (length.type()) {

        case Percent:

            string = numberAsString(length.percent()) + "%";

            break;

        case Fixed:

            string = numberAsString(length.calcMinValue(0));

            break;

        case Auto:

            string = "auto";

            break;

        default:

            break;

    }

    return new CSSPrimitiveValue(string, CSSPrimitiveValue::CSS_STRING);

}

PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(int propertyID, EUpdateLayout updateLayout) const

{

    Node* node = m_node.get();

    if (!node)

        return 0;

    // Make sure our layout is up to date before we allow a query on these attributes.

    if (updateLayout)

        node->document()->updateLayout();

    RenderObject* renderer = node->renderer();

    RenderStyle* style = node->computedStyle();

    if (!style)

        return 0;

    switch (static_cast<CSSPropertyID>(propertyID)) {

        case CSS_PROP_INVALID:

            break;

        case CSS_PROP_BACKGROUND_COLOR:

            return new CSSPrimitiveValue(style->backgroundColor().rgb());

        case CSS_PROP_BACKGROUND_IMAGE:

            if (style->backgroundImage())

                return new CSSPrimitiveValue(style->backgroundImage()->url(), CSSPrimitiveValue::CSS_URI);

            return new CSSPrimitiveValue(CSS_VAL_NONE);

        case CSS_PROP__WEBKIT_BACKGROUND_SIZE: {

            RefPtr<CSSValueList> list = new CSSValueList(true);

            list->append(valueForLength(style->backgroundSize().width));

            list->append(valueForLength(style->backgroundSize().height));

            return list.release();

        }  

        case CSS_PROP_BACKGROUND_REPEAT:

            switch (style->backgroundRepeat()) {

                case REPEAT:

                    return new CSSPrimitiveValue(CSS_VAL_REPEAT);