CSSComputedStyleDeclaration.cpp   [plain text]

/**
 *
 * Copyright (C) 2004 Zack Rusin <zack@kde.org>
 * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
 * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
 *
 * 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 "CSSPrimitiveValueMappings.h"
#include "CSSPropertyNames.h"
#include "CSSValueList.h"
#include "CachedImage.h"
#include "Document.h"
#include "ExceptionCode.h"
#include "Pair.h"
#include "Rect.h"
#include "RenderLayer.h"
#include "RenderObject.h"
#include "ShadowValue.h"
#include "CSSTimingFunctionValue.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[] = {
    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_TAP_HIGHLIGHT_COLOR,
    CSS_PROP__WEBKIT_TOUCH_CALLOUT,
    CSS_PROP__WEBKIT_COMPOSITION_FILL_COLOR,
    CSS_PROP__WEBKIT_COMPOSITION_FRAME_COLOR,
    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,
#if ENABLE(DASHBOARD_SUPPORT)
    CSS_PROP__WEBKIT_DASHBOARD_REGION,
#endif
    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,
    CSS_PROP__WEBKIT_TRANSFORM,
    CSS_PROP__WEBKIT_PERSPECTIVE,
    CSS_PROP__WEBKIT_PERSPECTIVE_ORIGIN,
    CSS_PROP__WEBKIT_PERSPECTIVE_ORIGIN_X,
    CSS_PROP__WEBKIT_PERSPECTIVE_ORIGIN_Y,
    CSS_PROP__WEBKIT_TRANSFORM_ORIGIN,
    CSS_PROP__WEBKIT_TRANSFORM_ORIGIN_X,
    CSS_PROP__WEBKIT_TRANSFORM_ORIGIN_Y,
    CSS_PROP__WEBKIT_TRANSFORM_ORIGIN_Z,
    CSS_PROP__WEBKIT_BACKFACE_VISIBILITY,
    CSS_PROP__WEBKIT_TRANSFORM_STYLE,
    CSS_PROP__WEBKIT_ANIMATION_DELAY,
    CSS_PROP__WEBKIT_ANIMATION_DIRECTION,
    CSS_PROP__WEBKIT_ANIMATION_DURATION,
    CSS_PROP__WEBKIT_ANIMATION_NAME,
    CSS_PROP__WEBKIT_ANIMATION_PLAY_STATE,
    CSS_PROP__WEBKIT_ANIMATION_ITERATION_COUNT,
    CSS_PROP__WEBKIT_ANIMATION_TIMING_FUNCTION,
    CSS_PROP__WEBKIT_TRANSITION_DELAY,
    CSS_PROP__WEBKIT_TRANSITION_DURATION,
    CSS_PROP__WEBKIT_TRANSITION_NAME,
    CSS_PROP__WEBKIT_TRANSITION_PROPERTY,
    CSS_PROP__WEBKIT_TRANSITION_ITERATION_COUNT,
    CSS_PROP__WEBKIT_TRANSITION_TIMING_FUNCTION
    
#if ENABLE(SVG)
    ,
    CSS_PROP_CLIP_PATH,
    CSS_PROP_CLIP_RULE,
    CSS_PROP_MASK,
    CSS_PROP_FILTER,
    CSS_PROP_FLOOD_COLOR,
    CSS_PROP_FLOOD_OPACITY,
    CSS_PROP_LIGHTING_COLOR,
    CSS_PROP_STOP_COLOR,
    CSS_PROP_STOP_OPACITY,
    CSS_PROP_POINTER_EVENTS,
    CSS_PROP_COLOR_INTERPOLATION,
    CSS_PROP_COLOR_INTERPOLATION_FILTERS,
    CSS_PROP_COLOR_RENDERING,
    CSS_PROP_FILL,
    CSS_PROP_FILL_OPACITY,
    CSS_PROP_FILL_RULE,
    CSS_PROP_IMAGE_RENDERING,
    CSS_PROP_MARKER_END,
    CSS_PROP_MARKER_MID,
    CSS_PROP_MARKER_START,
    CSS_PROP_SHAPE_RENDERING,
    CSS_PROP_STROKE,
    CSS_PROP_STROKE_DASHARRAY,
    CSS_PROP_STROKE_DASHOFFSET,
    CSS_PROP_STROKE_LINECAP,
    CSS_PROP_STROKE_LINEJOIN,
    CSS_PROP_STROKE_MITERLIMIT,
    CSS_PROP_STROKE_OPACITY,
    CSS_PROP_STROKE_WIDTH,
    CSS_PROP_TEXT_RENDERING,
    CSS_PROP_ALIGNMENT_BASELINE,
    CSS_PROP_BASELINE_SHIFT,
    CSS_PROP_DOMINANT_BASELINE,
    CSS_PROP_KERNING,
    CSS_PROP_TEXT_ANCHOR,
    CSS_PROP_WRITING_MODE,
    CSS_PROP_GLYPH_ORIENTATION_HORIZONTAL,
    CSS_PROP_GLYPH_ORIENTATION_VERTICAL
#endif
};

const unsigned numComputedProperties = sizeof(computedProperties) / sizeof(computedProperties[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 new CSSPrimitiveValue(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 new CSSPrimitiveValue(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();
}

static PassRefPtr<CSSValueList> computedTransform(RenderObject* renderer)
{
    if (!renderer)
        return 0;

    IntRect box = sizingBox(renderer);

    Transform3D transform;
    
#if ENABLE(HW_COMP)
    // go to the layer to get the current (possibly hardware-animating) value of the transform
    if (renderer->layer())
        transform = renderer->layer()->currentTransform();
    else
        renderer->style()->applyTransform(transform, box.size(), false);
#else
    renderer->style()->applyTransform(transform, box.size(), false);
#endif
    
    RefPtr<WebKitCSSTransformValue>  transformVal = new WebKitCSSTransformValue(WebKitCSSTransformValue::Matrix3DTransformOperation);

    transformVal->append(new CSSPrimitiveValue(transform.m11(), CSSPrimitiveValue::CSS_NUMBER));
    transformVal->append(new CSSPrimitiveValue(transform.m12(), CSSPrimitiveValue::CSS_NUMBER));
    transformVal->append(new CSSPrimitiveValue(transform.m13(), CSSPrimitiveValue::CSS_NUMBER));
    transformVal->append(new CSSPrimitiveValue(transform.m14(), CSSPrimitiveValue::CSS_NUMBER));

    transformVal->append(new CSSPrimitiveValue(transform.m21(), CSSPrimitiveValue::CSS_NUMBER));
    transformVal->append(new CSSPrimitiveValue(transform.m22(), CSSPrimitiveValue::CSS_NUMBER));
    transformVal->append(new CSSPrimitiveValue(transform.m23(), CSSPrimitiveValue::CSS_NUMBER));
    transformVal->append(new CSSPrimitiveValue(transform.m24(), CSSPrimitiveValue::CSS_NUMBER));

    transformVal->append(new CSSPrimitiveValue(transform.m31(), CSSPrimitiveValue::CSS_NUMBER));
    transformVal->append(new CSSPrimitiveValue(transform.m32(), CSSPrimitiveValue::CSS_NUMBER));
    transformVal->append(new CSSPrimitiveValue(transform.m33(), CSSPrimitiveValue::CSS_NUMBER));
    transformVal->append(new CSSPrimitiveValue(transform.m34(), CSSPrimitiveValue::CSS_NUMBER));

    transformVal->append(new CSSPrimitiveValue(transform.m41(), CSSPrimitiveValue::CSS_NUMBER));
    transformVal->append(new CSSPrimitiveValue(transform.m42(), CSSPrimitiveValue::CSS_NUMBER));
    transformVal->append(new CSSPrimitiveValue(transform.m43(), CSSPrimitiveValue::CSS_NUMBER));
    transformVal->append(new CSSPrimitiveValue(transform.m44(), CSSPrimitiveValue::CSS_NUMBER));

    RefPtr<CSSValueList> list = new CSSValueList(true);
    list->append(transformVal);
        
    return list.release();
}

#pragma mark -

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

PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(int propertyID) const
{
    return getPropertyCSSValue(propertyID, UpdateLayout);
}

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

    RenderObject* renderer = node->renderer();

    RenderStyle* style = node->computedStyle();
    if (!style)
        return 0;
        
    CSSPropertyID propID = static_cast<CSSPropertyID>(propertyID);

    switch (propID) {
        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(new CSSPrimitiveValue(style->backgroundSize().width));
            list->append(new CSSPrimitiveValue(style->backgroundSize().height));
            return list.release();
        }  
        case CSS_PROP_BACKGROUND_REPEAT:
            return new CSSPrimitiveValue(style->backgroundRepeat());
        case CSS_PROP__WEBKIT_BACKGROUND_COMPOSITE:
            return new CSSPrimitiveValue(style->backgroundComposite());
        case CSS_PROP_BACKGROUND_ATTACHMENT:
            if (style->backgroundAttachment())
                return new CSSPrimitiveValue(CSS_VAL_SCROLL);
            return new CSSPrimitiveValue(CSS_VAL_FIXED);
        case CSS_PROP__WEBKIT_BACKGROUND_CLIP:
        case CSS_PROP__WEBKIT_BACKGROUND_ORIGIN: {
            EBackgroundBox box = (propID == CSS_PROP__WEBKIT_BACKGROUND_CLIP ? style->backgroundClip() : style->backgroundOrigin());
            return new CSSPrimitiveValue(box);
        }
        case CSS_PROP_BACKGROUND_POSITION: {
            RefPtr<CSSValueList> list = new CSSValueList(true);

            list->append(new CSSPrimitiveValue(style->backgroundXPosition()));
            list->append(new CSSPrimitiveValue(style->backgroundYPosition()));

            return list.release();
        }
        case CSS_PROP_BACKGROUND_POSITION_X:
            return new CSSPrimitiveValue(style->backgroundXPosition());
        case CSS_PROP_BACKGROUND_POSITION_Y:
            return new CSSPrimitiveValue(style->backgroundYPosition());
        case CSS_PROP_BORDER_COLLAPSE:
            if (style->borderCollapse())
                return new CSSPrimitiveValue(CSS_VAL_COLLAPSE);
            return new CSSPrimitiveValue(CSS_VAL_SEPARATE);
        case CSS_PROP_BORDER_SPACING: {
            RefPtr<CSSValueList> list = new CSSValueList(true);
            list->append(new CSSPrimitiveValue(style->horizontalBorderSpacing(), CSSPrimitiveValue::CSS_PX));
            list->append(new CSSPrimitiveValue(style->verticalBorderSpacing(), CSSPrimitiveValue::CSS_PX));
            return list.release();
        }  
        case CSS_PROP__WEBKIT_BORDER_HORIZONTAL_SPACING:
            return new CSSPrimitiveValue(style->horizontalBorderSpacing(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP__WEBKIT_BORDER_VERTICAL_SPACING:
            return new CSSPrimitiveValue(style->verticalBorderSpacing(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP_BORDER_TOP_COLOR:
            return currentColorOrValidColor(style, style->borderTopColor());
        case CSS_PROP_BORDER_RIGHT_COLOR:
            return currentColorOrValidColor(style, style->borderRightColor());
        case CSS_PROP_BORDER_BOTTOM_COLOR:
            return currentColorOrValidColor(style, style->borderBottomColor());
        case CSS_PROP_BORDER_LEFT_COLOR:
            return currentColorOrValidColor(style, style->borderLeftColor());
        case CSS_PROP_BORDER_TOP_STYLE:
            return new CSSPrimitiveValue(style->borderTopStyle());
        case CSS_PROP_BORDER_RIGHT_STYLE:
            return new CSSPrimitiveValue(style->borderRightStyle());
        case CSS_PROP_BORDER_BOTTOM_STYLE:
            return new CSSPrimitiveValue(style->borderBottomStyle());
        case CSS_PROP_BORDER_LEFT_STYLE:
            return new CSSPrimitiveValue(style->borderLeftStyle());
        case CSS_PROP_BORDER_TOP_WIDTH:
            return new CSSPrimitiveValue(style->borderTopWidth(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP_BORDER_RIGHT_WIDTH:
            return new CSSPrimitiveValue(style->borderRightWidth(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP_BORDER_BOTTOM_WIDTH:
            return new CSSPrimitiveValue(style->borderBottomWidth(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP_BORDER_LEFT_WIDTH:
            return new CSSPrimitiveValue(style->borderLeftWidth(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP_BOTTOM:
            return getPositionOffsetValue(style, CSS_PROP_BOTTOM);
        case CSS_PROP__WEBKIT_BOX_ALIGN:
            return new CSSPrimitiveValue(style->boxAlign());
        case CSS_PROP__WEBKIT_BOX_DIRECTION:
            return new CSSPrimitiveValue(style->boxDirection());
        case CSS_PROP__WEBKIT_BOX_FLEX:
            return new CSSPrimitiveValue(style->boxFlex(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP__WEBKIT_BOX_FLEX_GROUP:
            return new CSSPrimitiveValue(style->boxFlexGroup(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP__WEBKIT_BOX_LINES:
            return new CSSPrimitiveValue(style->boxLines());
        case CSS_PROP__WEBKIT_BOX_ORDINAL_GROUP:
            return new CSSPrimitiveValue(style->boxOrdinalGroup(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP__WEBKIT_BOX_ORIENT:
            return new CSSPrimitiveValue(style->boxOrient());
        case CSS_PROP__WEBKIT_BOX_PACK: {
            EBoxAlignment boxPack = style->boxPack();
            ASSERT(boxPack != BSTRETCH);
            ASSERT(boxPack != BBASELINE);
            if (boxPack == BJUSTIFY || boxPack== BBASELINE)
                return 0;
            return new CSSPrimitiveValue(boxPack);
        }
        case CSS_PROP__WEBKIT_BOX_SHADOW:
            return valueForShadow(style->boxShadow());
        case CSS_PROP_CAPTION_SIDE:
            return new CSSPrimitiveValue(style->captionSide());
        case CSS_PROP_CLEAR:
            return new CSSPrimitiveValue(style->clear());
        case CSS_PROP_COLOR:
            return new CSSPrimitiveValue(style->color().rgb());
        case CSS_PROP__WEBKIT_COLUMN_COUNT:
            if (style->hasAutoColumnCount())
                return new CSSPrimitiveValue(CSS_VAL_AUTO);
            return new CSSPrimitiveValue(style->columnCount(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP__WEBKIT_COLUMN_GAP:
            if (style->hasNormalColumnGap())
                return new CSSPrimitiveValue(CSS_VAL_NORMAL);
            return new CSSPrimitiveValue(style->columnGap(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP__WEBKIT_COLUMN_RULE_COLOR:
            return currentColorOrValidColor(style, style->columnRuleColor());
        case CSS_PROP__WEBKIT_COLUMN_RULE_STYLE:
            return new CSSPrimitiveValue(style->columnRuleStyle());
        case CSS_PROP__WEBKIT_COLUMN_RULE_WIDTH:
            return new CSSPrimitiveValue(style->columnRuleWidth(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP__WEBKIT_COLUMN_BREAK_AFTER:
            return new CSSPrimitiveValue(style->columnBreakAfter());
        case CSS_PROP__WEBKIT_COLUMN_BREAK_BEFORE:
            return new CSSPrimitiveValue(style->columnBreakBefore());
        case CSS_PROP__WEBKIT_COLUMN_BREAK_INSIDE:
            return new CSSPrimitiveValue(style->columnBreakInside());
        case CSS_PROP__WEBKIT_COLUMN_WIDTH:
            if (style->hasAutoColumnWidth())
                return new CSSPrimitiveValue(CSS_VAL_AUTO);
            return new CSSPrimitiveValue(style->columnWidth(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP_CURSOR: {
            RefPtr<CSSValueList> list;
            CursorList* cursors = style->cursors();
            if (cursors && cursors->size() > 0) {
                list = new CSSValueList;
                for (unsigned i = 0; i < cursors->size(); ++i)
                    list->append(new CSSPrimitiveValue((*cursors)[i].cursorImage->url(), CSSPrimitiveValue::CSS_URI));
            }
            RefPtr<CSSValue> value = new CSSPrimitiveValue(style->cursor());
            if (list) {
                list->append(value);
                return list.release();
            }
            return value.release();
        }
        case CSS_PROP_DIRECTION:
            return new CSSPrimitiveValue(style->direction());
        case CSS_PROP_DISPLAY:
            return new CSSPrimitiveValue(style->display());
        case CSS_PROP_EMPTY_CELLS:
            return new CSSPrimitiveValue(style->emptyCells());
        case CSS_PROP_FLOAT:
            return new CSSPrimitiveValue(style->floating());
        case CSS_PROP_FONT_FAMILY:
            // FIXME: This only returns the first family.
            return new CSSPrimitiveValue(style->fontDescription().family().family().domString(), CSSPrimitiveValue::CSS_STRING);
        case CSS_PROP_FONT_SIZE:
            return new CSSPrimitiveValue(style->fontDescription().computedPixelSize(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP__WEBKIT_BINDING:
            break;
        case CSS_PROP_FONT_STYLE:
            if (style->fontDescription().italic())
                return new CSSPrimitiveValue(CSS_VAL_ITALIC);
            return new CSSPrimitiveValue(CSS_VAL_NORMAL);
        case CSS_PROP_FONT_VARIANT:
            if (style->fontDescription().smallCaps())
                return new CSSPrimitiveValue(CSS_VAL_SMALL_CAPS);
            return new CSSPrimitiveValue(CSS_VAL_NORMAL);
        case CSS_PROP_FONT_WEIGHT:
            // FIXME: this does not reflect the full range of weights
            // that can be expressed with CSS
            if (style->fontDescription().weight() == cBoldWeight)
                return new CSSPrimitiveValue(CSS_VAL_BOLD);
            return new CSSPrimitiveValue(CSS_VAL_NORMAL);
        case CSS_PROP_HEIGHT:
            if (renderer)
                return new CSSPrimitiveValue(sizingBox(renderer).height(), CSSPrimitiveValue::CSS_PX);
            return new CSSPrimitiveValue(style->height());
        case CSS_PROP__WEBKIT_HIGHLIGHT:
            if (style->highlight() == nullAtom)
                return new CSSPrimitiveValue(CSS_VAL_NONE);
            return new CSSPrimitiveValue(style->highlight(), CSSPrimitiveValue::CSS_STRING);
        case CSS_PROP__WEBKIT_BORDER_FIT:
            if (style->borderFit() == BorderFitBorder)
                return new CSSPrimitiveValue(CSS_VAL_BORDER);
            return new CSSPrimitiveValue(CSS_VAL_LINES);
        case CSS_PROP_LEFT:
            return getPositionOffsetValue(style, CSS_PROP_LEFT);
        case CSS_PROP_LETTER_SPACING:
            if (!style->letterSpacing())
                return new CSSPrimitiveValue(CSS_VAL_NORMAL);
            return new CSSPrimitiveValue(style->letterSpacing(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP__WEBKIT_LINE_CLAMP:
            if (style->lineClamp() == -1)
                return new CSSPrimitiveValue(CSS_VAL_NONE);
            return new CSSPrimitiveValue(style->lineClamp(), CSSPrimitiveValue::CSS_PERCENTAGE);
        case CSS_PROP_LINE_HEIGHT: {
            Length length = style->lineHeight();
            if (length.isNegative())
                return new CSSPrimitiveValue(CSS_VAL_NORMAL);
            if (length.isPercent())
                // This is imperfect, because it doesn't include the zoom factor and the real computation
                // for how high to be in pixels does include things like minimum font size and the zoom factor.
                // On the other hand, since font-size doesn't include the zoom factor, we really can't do
                // that here either.
                return new CSSPrimitiveValue(static_cast<int>(length.percent() * style->fontDescription().specifiedSize()) / 100, CSSPrimitiveValue::CSS_PX);
            return new CSSPrimitiveValue(length.value(), CSSPrimitiveValue::CSS_PX);
        }
        case CSS_PROP_LIST_STYLE_IMAGE:
            if (style->listStyleImage())
                return new CSSPrimitiveValue(style->listStyleImage()->url(), CSSPrimitiveValue::CSS_URI);
            return new CSSPrimitiveValue(CSS_VAL_NONE);
        case CSS_PROP_LIST_STYLE_POSITION:
            return new CSSPrimitiveValue(style->listStylePosition());
        case CSS_PROP_LIST_STYLE_TYPE:
            return new CSSPrimitiveValue(style->listStyleType());
        case CSS_PROP_MARGIN_TOP:
            if (renderer)
                // FIXME: Supposed to return the percentage if percentage was specified.
                return new CSSPrimitiveValue(renderer->marginTop(), CSSPrimitiveValue::CSS_PX);
            return new CSSPrimitiveValue(style->marginTop());
        case CSS_PROP_MARGIN_RIGHT:
            if (renderer)
                // FIXME: Supposed to return the percentage if percentage was specified.
                return new CSSPrimitiveValue(renderer->marginRight(), CSSPrimitiveValue::CSS_PX);
            return new CSSPrimitiveValue(style->marginRight());
        case CSS_PROP_MARGIN_BOTTOM:
            if (renderer)
                // FIXME: Supposed to return the percentage if percentage was specified.
                return new CSSPrimitiveValue(renderer->marginBottom(), CSSPrimitiveValue::CSS_PX);
            return new CSSPrimitiveValue(style->marginBottom());
        case CSS_PROP_MARGIN_LEFT:
            if (renderer)
                // FIXME: Supposed to return the percentage if percentage was specified.
                return new CSSPrimitiveValue(renderer->marginLeft(), CSSPrimitiveValue::CSS_PX);
            return new CSSPrimitiveValue(style->marginLeft());
        case CSS_PROP__WEBKIT_MARQUEE_DIRECTION:
            return new CSSPrimitiveValue(style->marqueeDirection());
        case CSS_PROP__WEBKIT_MARQUEE_INCREMENT:
            return new CSSPrimitiveValue(style->marqueeIncrement());
        case CSS_PROP__WEBKIT_MARQUEE_REPETITION:
            if (style->marqueeLoopCount() < 0)
                return new CSSPrimitiveValue(CSS_VAL_INFINITE);
            return new CSSPrimitiveValue(style->marqueeLoopCount(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP__WEBKIT_MARQUEE_STYLE:
            return new CSSPrimitiveValue(style->marqueeBehavior());
        case CSS_PROP__WEBKIT_USER_MODIFY:
            return new CSSPrimitiveValue(style->userModify());
        case CSS_PROP_MAX_HEIGHT: {
            const Length& maxHeight = style->maxHeight();
            if (maxHeight.isFixed() && maxHeight.value() == undefinedLength)
                return new CSSPrimitiveValue(CSS_VAL_NONE);
            return new CSSPrimitiveValue(maxHeight);
        }
        case CSS_PROP_MAX_WIDTH: {
            const Length& maxWidth = style->maxHeight();
            if (maxWidth.isFixed() && maxWidth.value() == undefinedLength)
                return new CSSPrimitiveValue(CSS_VAL_NONE);
            return new CSSPrimitiveValue(maxWidth);
        }
        case CSS_PROP_MIN_HEIGHT:
            return new CSSPrimitiveValue(style->minHeight());
        case CSS_PROP_MIN_WIDTH:
            return new CSSPrimitiveValue(style->minWidth());
        case CSS_PROP_OPACITY: {
            float opacity = style->opacity();
#if ENABLE(HW_COMP)
            // go to the layer to get the current (possibly hardware-animating) value of opacity
            if (renderer && renderer->layer())
                opacity = renderer->layer()->currentOpacity();
#endif
            return new CSSPrimitiveValue(opacity, CSSPrimitiveValue::CSS_NUMBER);
        }
        
        case CSS_PROP_ORPHANS:
            return new CSSPrimitiveValue(style->orphans(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP_OUTLINE_COLOR:
            return currentColorOrValidColor(style, style->outlineColor());
        case CSS_PROP_OUTLINE_STYLE:
            if (style->outlineStyleIsAuto())
                return new CSSPrimitiveValue(CSS_VAL_AUTO);
            return new CSSPrimitiveValue(style->outlineStyle());
        case CSS_PROP_OUTLINE_WIDTH:
            return new CSSPrimitiveValue(style->outlineWidth(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP_OVERFLOW:
            return new CSSPrimitiveValue(max(style->overflowX(), style->overflowY()));
        case CSS_PROP_OVERFLOW_X:
            return new CSSPrimitiveValue(style->overflowX());
        case CSS_PROP_OVERFLOW_Y:
            return new CSSPrimitiveValue(style->overflowY());
        case CSS_PROP_PADDING_TOP:
            if (renderer)
                return new CSSPrimitiveValue(renderer->paddingTop(), CSSPrimitiveValue::CSS_PX);
            return new CSSPrimitiveValue(style->paddingTop());
        case CSS_PROP_PADDING_RIGHT:
            if (renderer)
                return new CSSPrimitiveValue(renderer->paddingRight(), CSSPrimitiveValue::CSS_PX);
            return new CSSPrimitiveValue(style->paddingRight());
        case CSS_PROP_PADDING_BOTTOM:
            if (renderer)
                return new CSSPrimitiveValue(renderer->paddingBottom(), CSSPrimitiveValue::CSS_PX);
            return new CSSPrimitiveValue(style->paddingBottom());
        case CSS_PROP_PADDING_LEFT:
            if (renderer)
                return new CSSPrimitiveValue(renderer->paddingLeft(), CSSPrimitiveValue::CSS_PX);
            return new CSSPrimitiveValue(style->paddingLeft());
        case CSS_PROP_PAGE_BREAK_AFTER:
            return new CSSPrimitiveValue(style->pageBreakAfter());
        case CSS_PROP_PAGE_BREAK_BEFORE:
            return new CSSPrimitiveValue(style->pageBreakBefore());
        case CSS_PROP_PAGE_BREAK_INSIDE: {
            EPageBreak pageBreak = style->pageBreakInside();
            ASSERT(pageBreak != PBALWAYS);
            if (pageBreak == PBALWAYS)
                return 0;
            return new CSSPrimitiveValue(style->pageBreakInside());
        }
        case CSS_PROP_POSITION:
            return new CSSPrimitiveValue(style->position());
        case CSS_PROP_RIGHT:
            return getPositionOffsetValue(style, CSS_PROP_RIGHT);
        case CSS_PROP_TABLE_LAYOUT:
            return new CSSPrimitiveValue(style->tableLayout());
        case CSS_PROP_TEXT_ALIGN:
            return new CSSPrimitiveValue(style->textAlign());
        case CSS_PROP_TEXT_DECORATION: {
            String string;
            if (style->textDecoration() & UNDERLINE)
                string += "underline";
            if (style->textDecoration() & OVERLINE) {
                if (string.length())
                    string += " ";
                string += "overline";
            }
            if (style->textDecoration() & LINE_THROUGH) {
                if (string.length())
                    string += " ";
                string += "line-through";
            }
            if (style->textDecoration() & BLINK) {
                if (string.length())
                    string += " ";
                string += "blink";
            }
            if (!string.length())
                return new CSSPrimitiveValue(CSS_VAL_NONE);
            return new CSSPrimitiveValue(string, CSSPrimitiveValue::CSS_STRING);
        }
        case CSS_PROP__WEBKIT_TEXT_DECORATIONS_IN_EFFECT: {
            String string;
            if (style->textDecorationsInEffect() & UNDERLINE)
                string += "underline";
            if (style->textDecorationsInEffect() & OVERLINE) {
                if (string.length())
                    string += " ";
                string += "overline";
            }
            if (style->textDecorationsInEffect() & LINE_THROUGH) {
                if (string.length())
                    string += " ";
                string += "line-through";
            }
            if (style->textDecorationsInEffect() & BLINK) {
                if (string.length())
                    string += " ";
                string += "blink";
            }
            if (!string.length())
                return new CSSPrimitiveValue(CSS_VAL_NONE);
            return new CSSPrimitiveValue(string, CSSPrimitiveValue::CSS_STRING);
        }
        case CSS_PROP__WEBKIT_TEXT_FILL_COLOR:
            return currentColorOrValidColor(style, style->textFillColor());
        case CSS_PROP_TEXT_INDENT:
            return new CSSPrimitiveValue(style->textIndent());
        case CSS_PROP_TEXT_SHADOW:
            return valueForShadow(style->textShadow());
        case CSS_PROP__WEBKIT_TEXT_SECURITY:
            return new CSSPrimitiveValue(style->textSecurity());
        case CSS_PROP__WEBKIT_TEXT_SIZE_ADJUST:
            if (style->textSizeAdjust().isAuto()) 
                return new CSSPrimitiveValue(CSS_VAL_AUTO);
            else if (style->textSizeAdjust().isNone())
                return new CSSPrimitiveValue(CSS_VAL_NONE);
            else
                return new CSSPrimitiveValue(style->textSizeAdjust().percentage(), CSSPrimitiveValue::CSS_PERCENTAGE);
        case CSS_PROP__WEBKIT_TEXT_STROKE_COLOR:
            return currentColorOrValidColor(style, style->textStrokeColor());
        case CSS_PROP__WEBKIT_TEXT_STROKE_WIDTH:
            return new CSSPrimitiveValue(style->textStrokeWidth(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP_TEXT_TRANSFORM:
            return new CSSPrimitiveValue(style->textTransform());
        case CSS_PROP_TOP:
            return getPositionOffsetValue(style, CSS_PROP_TOP);
        case CSS_PROP_UNICODE_BIDI:
            return new CSSPrimitiveValue(style->unicodeBidi());
        case CSS_PROP_VERTICAL_ALIGN:
            switch (style->verticalAlign()) {
                case BASELINE:
                    return new CSSPrimitiveValue(CSS_VAL_BASELINE);
                case MIDDLE:
                    return new CSSPrimitiveValue(CSS_VAL_MIDDLE);
                case SUB:
                    return new CSSPrimitiveValue(CSS_VAL_SUB);
                case SUPER:
                    return new CSSPrimitiveValue(CSS_VAL_SUPER);
                case TEXT_TOP:
                    return new CSSPrimitiveValue(CSS_VAL_TEXT_TOP);
                case TEXT_BOTTOM:
                    return new CSSPrimitiveValue(CSS_VAL_TEXT_BOTTOM);
                case TOP:
                    return new CSSPrimitiveValue(CSS_VAL_TOP);
                case BOTTOM:
                    return new CSSPrimitiveValue(CSS_VAL_BOTTOM);
                case BASELINE_MIDDLE:
                    return new CSSPrimitiveValue(CSS_VAL__WEBKIT_BASELINE_MIDDLE);
                case LENGTH:
                    return new CSSPrimitiveValue(style->verticalAlignLength());
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_VISIBILITY:
            return new CSSPrimitiveValue(style->visibility());
        case CSS_PROP_WHITE_SPACE:
            return new CSSPrimitiveValue(style->whiteSpace());
        case CSS_PROP_WIDOWS:
            return new CSSPrimitiveValue(style->widows(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP_WIDTH:
            if (renderer)
                return new CSSPrimitiveValue(sizingBox(renderer).width(), CSSPrimitiveValue::CSS_PX);
            return new CSSPrimitiveValue(style->width());
        case CSS_PROP_WORD_BREAK:
            return new CSSPrimitiveValue(style->wordBreak());
        case CSS_PROP_WORD_SPACING:
            return new CSSPrimitiveValue(style->wordSpacing(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP_WORD_WRAP:
            return new CSSPrimitiveValue(style->wordWrap());
        case CSS_PROP__WEBKIT_LINE_BREAK:
            return new CSSPrimitiveValue(style->khtmlLineBreak());
        case CSS_PROP__WEBKIT_NBSP_MODE:
            return new CSSPrimitiveValue(style->nbspMode());
        case CSS_PROP__WEBKIT_MATCH_NEAREST_MAIL_BLOCKQUOTE_COLOR:
            return new CSSPrimitiveValue(style->matchNearestMailBlockquoteColor());
        case CSS_PROP_RESIZE:
            return new CSSPrimitiveValue(style->resize());
        case CSS_PROP_Z_INDEX:
            if (style->hasAutoZIndex())
                return new CSSPrimitiveValue(CSS_VAL_AUTO);
            return new CSSPrimitiveValue(style->zIndex(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP__WEBKIT_BOX_SIZING:
            if (style->boxSizing() == CONTENT_BOX)
                return new CSSPrimitiveValue(CSS_VAL_CONTENT_BOX);
            return new CSSPrimitiveValue(CSS_VAL_BORDER_BOX);
#if ENABLE(DASHBOARD_SUPPORT)
        case CSS_PROP__WEBKIT_DASHBOARD_REGION:
        {
            const Vector<StyleDashboardRegion>& regions = style->dashboardRegions();
            unsigned count = regions.size();
            if (count == 1 && regions[0].type == StyleDashboardRegion::None)
                return new CSSPrimitiveValue(CSS_VAL_NONE);

            RefPtr<DashboardRegion> firstRegion;
            DashboardRegion* previousRegion = 0;
            for (unsigned i = 0; i < count; i++) {
                RefPtr<DashboardRegion> region = new DashboardRegion;
                StyleDashboardRegion styleRegion = regions[i];

                region->m_label = styleRegion.label;
                LengthBox offset = styleRegion.offset;
                region->setTop(new CSSPrimitiveValue(offset.top.value(), CSSPrimitiveValue::CSS_PX));
                region->setRight(new CSSPrimitiveValue(offset.right.value(), CSSPrimitiveValue::CSS_PX));
                region->setBottom(new CSSPrimitiveValue(offset.bottom.value(), CSSPrimitiveValue::CSS_PX));
                region->setLeft(new CSSPrimitiveValue(offset.left.value(), CSSPrimitiveValue::CSS_PX));
                region->m_isRectangle = (styleRegion.type == StyleDashboardRegion::Rectangle);
                region->m_isCircle = (styleRegion.type == StyleDashboardRegion::Circle);

                if (previousRegion)
                    previousRegion->m_next = region;
                else
                    firstRegion = region;
                previousRegion = region.get();
            }
            return new CSSPrimitiveValue(firstRegion.release());
        }
#endif
        case CSS_PROP__WEBKIT_APPEARANCE:
            return new CSSPrimitiveValue(style->appearance());
        case CSS_PROP__WEBKIT_FONT_SIZE_DELTA:
            // Not a real style property -- used by the editing engine -- so has no computed value.
            break;
        case CSS_PROP__WEBKIT_MARGIN_BOTTOM_COLLAPSE:
            return new CSSPrimitiveValue(style->marginBottomCollapse());
        case CSS_PROP__WEBKIT_MARGIN_TOP_COLLAPSE:
            return new CSSPrimitiveValue(style->marginTopCollapse());
        case CSS_PROP__WEBKIT_RTL_ORDERING:
            if (style->visuallyOrdered())
                return new CSSPrimitiveValue(CSS_VAL_VISUAL);
            return new CSSPrimitiveValue(CSS_VAL_LOGICAL);
        case CSS_PROP__WEBKIT_TAP_HIGHLIGHT_COLOR:
            return new CSSPrimitiveValue(style->tapHighlightColor().rgb());
        case CSS_PROP__WEBKIT_TOUCH_CALLOUT: {
            return style->touchCalloutEnabled() ? new CSSPrimitiveValue(CSS_VAL_DEFAULT) : new CSSPrimitiveValue(CSS_VAL_NONE);
        }
        case CSS_PROP__WEBKIT_COMPOSITION_FILL_COLOR:
            return new CSSPrimitiveValue(style->compositionFillColor().rgb());
        case CSS_PROP__WEBKIT_COMPOSITION_FRAME_COLOR:
            return new CSSPrimitiveValue(style->compositionFrameColor().rgb());
        case CSS_PROP__WEBKIT_USER_DRAG:
            return new CSSPrimitiveValue(style->userDrag());
        case CSS_PROP__WEBKIT_USER_SELECT:
            return new CSSPrimitiveValue(style->userSelect());
        case CSS_PROP__WEBKIT_BORDER_BOTTOM_LEFT_RADIUS:
            return getBorderRadiusCornerValue(style->borderBottomLeftRadius());
        case CSS_PROP__WEBKIT_BORDER_BOTTOM_RIGHT_RADIUS:
            return getBorderRadiusCornerValue(style->borderBottomRightRadius());
        case CSS_PROP__WEBKIT_BORDER_TOP_LEFT_RADIUS:
            return getBorderRadiusCornerValue(style->borderTopLeftRadius());
        case CSS_PROP__WEBKIT_BORDER_TOP_RIGHT_RADIUS:
            return getBorderRadiusCornerValue(style->borderTopRightRadius());
        case CSS_PROP__WEBKIT_IMAGE_LOADING_BORDER:
#ifndef NDEBUG
            fprintf(stderr, "PURPLE fixme: CSSComputedStyleDeclaration.cpp CSS_PROP__WEBKIT_IMAGE_LOADING_BORDER\n");
#endif
            break;
        case CSS_PROP__WEBKIT_TRANSFORM:
            return computedTransform(renderer);
        case CSS_PROP__WEBKIT_TRANSFORM_ORIGIN: {
            RefPtr<CSSValueList> list = new CSSValueList(true);
            if (renderer) {
                IntRect box = sizingBox(renderer);
                list->append(new CSSPrimitiveValue(style->transformOriginX().calcMinValue(box.width()), CSSPrimitiveValue::CSS_PX));
                list->append(new CSSPrimitiveValue(style->transformOriginY().calcMinValue(box.height()), CSSPrimitiveValue::CSS_PX));
            }
            else {
                list->append(new CSSPrimitiveValue(style->transformOriginX()));
                list->append(new CSSPrimitiveValue(style->transformOriginY()));
            }
			list->append(new CSSPrimitiveValue(style->transformOriginZ(), CSSPrimitiveValue::CSS_PX));
            return list.release();
        }
        case CSS_PROP__WEBKIT_TRANSFORM_ORIGIN_X:
            if (renderer) {
                IntRect box = sizingBox(renderer);
                return new CSSPrimitiveValue(style->transformOriginX().calcMinValue(box.width()), CSSPrimitiveValue::CSS_PX);
            }
            else
                return new CSSPrimitiveValue(style->transformOriginX());
        case CSS_PROP__WEBKIT_TRANSFORM_ORIGIN_Y:
            if (renderer) {
                IntRect box = sizingBox(renderer);
                return new CSSPrimitiveValue(style->transformOriginY().calcMinValue(box.height()), CSSPrimitiveValue::CSS_PX);
            }
            else
                return new CSSPrimitiveValue(style->transformOriginY());
        case CSS_PROP__WEBKIT_TRANSFORM_ORIGIN_Z:
            return new CSSPrimitiveValue(style->transformOriginZ(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP__WEBKIT_BACKFACE_VISIBILITY:
			return new CSSPrimitiveValue(style->backfaceVisibility() ? CSS_VAL_VISIBLE : CSS_VAL_HIDDEN);
        case CSS_PROP__WEBKIT_TRANSFORM_STYLE:
			return new CSSPrimitiveValue(style->transformStyle3D() ? CSS_VAL_PRESERVE_3D : CSS_VAL_FLAT);
        case CSS_PROP__WEBKIT_PERSPECTIVE:
            if (isnan(style->perspective()))
                return new CSSPrimitiveValue(CSS_VAL_NONE);
            return new CSSPrimitiveValue(style->perspective(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP__WEBKIT_PERSPECTIVE_ORIGIN: {
            RefPtr<CSSValueList> list = new CSSValueList(true);
            if (renderer) {
                IntRect box = sizingBox(renderer);
                list->append(new CSSPrimitiveValue(style->perspectiveOriginX().calcMinValue(box.width()), CSSPrimitiveValue::CSS_PX));
                list->append(new CSSPrimitiveValue(style->perspectiveOriginY().calcMinValue(box.height()), CSSPrimitiveValue::CSS_PX));
            }
            else {
                list->append(new CSSPrimitiveValue(style->perspectiveOriginX()));
                list->append(new CSSPrimitiveValue(style->perspectiveOriginY()));
            }
            return list.release();
        }
        case CSS_PROP__WEBKIT_PERSPECTIVE_ORIGIN_X:
            if (renderer) {
                IntRect box = sizingBox(renderer);
                return new CSSPrimitiveValue(style->perspectiveOriginX().calcMinValue(box.width()), CSSPrimitiveValue::CSS_PX);
            }
            else
                return new CSSPrimitiveValue(style->perspectiveOriginX());
        case CSS_PROP__WEBKIT_PERSPECTIVE_ORIGIN_Y:
            if (renderer) {
                IntRect box = sizingBox(renderer);
                return new CSSPrimitiveValue(style->perspectiveOriginY().calcMinValue(box.height()), CSSPrimitiveValue::CSS_PX);
            }
            else
                return new CSSPrimitiveValue(style->perspectiveOriginY());
        case CSS_PROP__WEBKIT_ANIMATION_DELAY:
        case CSS_PROP__WEBKIT_TRANSITION_DELAY: {
            RefPtr<CSSValueList> list = new CSSValueList(false);
            const Transition* t = (propID == CSS_PROP__WEBKIT_ANIMATION_DELAY) ? style->animations() : style->transitions();
            if (t) {
                for ( ; t; t = t->next())
                    list->append(new CSSPrimitiveValue(t->animationDelay(), CSSPrimitiveValue::CSS_S));
            }
            else
                list->append(new CSSPrimitiveValue(RenderStyle::initialAnimationDelay(), CSSPrimitiveValue::CSS_S));
            return list.release();
        }
        case CSS_PROP__WEBKIT_ANIMATION_DIRECTION: {
            RefPtr<CSSValueList> list = new CSSValueList(false);
            const Transition* t = style->animations();
            if (t) {
                for ( ; t; t = t->next())
                    list->append(new CSSPrimitiveValue(t->animationDirection() ? CSS_VAL_ALTERNATE : CSS_VAL_NORMAL));
            }
            else
                list->append(new CSSPrimitiveValue(RenderStyle::initialAnimationDirection() ? CSS_VAL_ALTERNATE : CSS_VAL_NORMAL));
            return list.release();
        }
        case CSS_PROP__WEBKIT_ANIMATION_DURATION:
        case CSS_PROP__WEBKIT_TRANSITION_DURATION: {
            RefPtr<CSSValueList> list = new CSSValueList(false);
            const Transition* t = (propID == CSS_PROP__WEBKIT_ANIMATION_DURATION) ? style->animations() : style->transitions();
            if (t) {
                for ( ; t; t = t->next())
                    list->append(new CSSPrimitiveValue(t->transitionDuration(), CSSPrimitiveValue::CSS_S));
            }
            else
                list->append(new CSSPrimitiveValue(RenderStyle::initialTransitionDuration(), CSSPrimitiveValue::CSS_S));
            return list.release();
        }
        case CSS_PROP__WEBKIT_ANIMATION_NAME:
        case CSS_PROP__WEBKIT_TRANSITION_NAME: {
            RefPtr<CSSValueList> list = new CSSValueList(false);
            const Transition* t = (propID == CSS_PROP__WEBKIT_ANIMATION_NAME) ? style->animations() : style->transitions();
            if (t) {
                for ( ; t; t = t->next()) {
                    const String& name = t->animationName();
                    list->append(new CSSPrimitiveValue(name.isEmpty() ? "none" : name, CSSPrimitiveValue::CSS_STRING));
                }
            }
            else {
                const String& name = RenderStyle::initialAnimationName();
                list->append(new CSSPrimitiveValue(name.isEmpty() ? "none" : name, CSSPrimitiveValue::CSS_STRING));
            }
            return list.release();
        }
        case CSS_PROP__WEBKIT_ANIMATION_PLAY_STATE: {
            RefPtr<CSSValueList> list = new CSSValueList(false);
            const Transition* t = style->animations();
            if (t) {
                for ( ; t; t = t->next())
                    list->append(new CSSPrimitiveValue((t->animationPlayState() == AnimPlayStatePlaying) ? CSS_VAL_RUNNING : CSS_VAL_PAUSED));
            }
            else
                list->append(new CSSPrimitiveValue((RenderStyle::initialAnimationPlayState() == AnimPlayStatePlaying) ? CSS_VAL_RUNNING : CSS_VAL_PAUSED));
            return list.release();
        }
        case CSS_PROP__WEBKIT_ANIMATION_ITERATION_COUNT:
        case CSS_PROP__WEBKIT_TRANSITION_ITERATION_COUNT: {
            RefPtr<CSSValueList> list = new CSSValueList(false);
            const Transition* t = (propID == CSS_PROP__WEBKIT_ANIMATION_ITERATION_COUNT) ? style->animations() : style->transitions();
            if (t) {
                for ( ; t; t = t->next())
                    list->append(new CSSPrimitiveValue(t->transitionIterationCount(), CSSPrimitiveValue::CSS_NUMBER));
            }
            else
                list->append(new CSSPrimitiveValue(RenderStyle::initialTransitionIterationCount(), CSSPrimitiveValue::CSS_NUMBER));
            return list.release();
        }
        case CSS_PROP__WEBKIT_ANIMATION_TIMING_FUNCTION:
        case CSS_PROP__WEBKIT_TRANSITION_TIMING_FUNCTION: {
            RefPtr<CSSValueList> list = new CSSValueList(false);
            const Transition* t = (propID == CSS_PROP__WEBKIT_ANIMATION_TIMING_FUNCTION) ? style->animations() : style->transitions();
            if (t) {
                for ( ; t; t = t->next()) {
                    const TimingFunction& tf = t->transitionTimingFunction();
                    list->append(new CSSTimingFunctionValue(tf.x1(), tf.y1(), tf.x2(), tf.y2()));
                }
            }
            else {
                const TimingFunction& tf = RenderStyle::initialTransitionTimingFunction();
                list->append(new CSSTimingFunctionValue(tf.x1(), tf.y1(), tf.x2(), tf.y2()));
            }
            return list.release();
        }
        case CSS_PROP__WEBKIT_TRANSITION_PROPERTY: {
            RefPtr<CSSValueList> list = new CSSValueList(false);
            const Transition* t = style->transitions();
            if (t) {
                for ( ; t; t = t->next()) {
                    int prop = t->transitionProperty();
                    const char* name;
                    if (prop == cAnimateNone)
                        name = "none";
                    else if (prop == cAnimateAll)
                        name = "all";
                    else
                        name = getPropertyName(static_cast<CSSPropertyID>(prop));
                    list->append(new CSSPrimitiveValue(name, CSSPrimitiveValue::CSS_STRING));
                }
            }
            else
                list->append(new CSSPrimitiveValue("all", CSSPrimitiveValue::CSS_STRING));
            return list.release();
        }
        case CSS_PROP_BACKGROUND:
        case CSS_PROP_BORDER:
        case CSS_PROP_BORDER_BOTTOM:
        case CSS_PROP_BORDER_COLOR:
        case CSS_PROP_BORDER_LEFT:
        case CSS_PROP_BORDER_RIGHT:
        case CSS_PROP_BORDER_STYLE:
        case CSS_PROP_BORDER_TOP:
        case CSS_PROP_BORDER_WIDTH:
        case CSS_PROP_CLIP:
        case CSS_PROP_CONTENT:
        case CSS_PROP_COUNTER_INCREMENT:
        case CSS_PROP_COUNTER_RESET:
        case CSS_PROP_FONT:
        case CSS_PROP_FONT_STRETCH:
        case CSS_PROP_LIST_STYLE:
        case CSS_PROP_MARGIN:
        case CSS_PROP_OUTLINE:
        case CSS_PROP_OUTLINE_OFFSET:
        case CSS_PROP_PADDING:
        case CSS_PROP_PAGE:
        case CSS_PROP_QUOTES:
        case CSS_PROP_SCROLLBAR_3DLIGHT_COLOR:
        case CSS_PROP_SCROLLBAR_ARROW_COLOR:
        case CSS_PROP_SCROLLBAR_DARKSHADOW_COLOR:
        case CSS_PROP_SCROLLBAR_FACE_COLOR:
        case CSS_PROP_SCROLLBAR_HIGHLIGHT_COLOR:
        case CSS_PROP_SCROLLBAR_SHADOW_COLOR:
        case CSS_PROP_SCROLLBAR_TRACK_COLOR:
        case CSS_PROP_SRC: // Only used in @font-face rules.
        case CSS_PROP_SIZE:
        case CSS_PROP_TEXT_LINE_THROUGH:
        case CSS_PROP_TEXT_LINE_THROUGH_COLOR:
        case CSS_PROP_TEXT_LINE_THROUGH_MODE:
        case CSS_PROP_TEXT_LINE_THROUGH_STYLE:
        case CSS_PROP_TEXT_LINE_THROUGH_WIDTH:
        case CSS_PROP_TEXT_OVERFLOW:
        case CSS_PROP_TEXT_OVERLINE:
        case CSS_PROP_TEXT_OVERLINE_COLOR:
        case CSS_PROP_TEXT_OVERLINE_MODE:
        case CSS_PROP_TEXT_OVERLINE_STYLE:
        case CSS_PROP_TEXT_OVERLINE_WIDTH:
        case CSS_PROP_TEXT_UNDERLINE:
        case CSS_PROP_TEXT_UNDERLINE_COLOR:
        case CSS_PROP_TEXT_UNDERLINE_MODE:
        case CSS_PROP_TEXT_UNDERLINE_STYLE:
        case CSS_PROP_TEXT_UNDERLINE_WIDTH:
        case CSS_PROP_UNICODE_RANGE: // Only used in @font-face rules.
        case CSS_PROP__WEBKIT_BORDER_IMAGE:
        case CSS_PROP__WEBKIT_BORDER_RADIUS:
        case CSS_PROP__WEBKIT_COLUMNS:
        case CSS_PROP__WEBKIT_COLUMN_RULE:
        case CSS_PROP__WEBKIT_MARGIN_COLLAPSE:
        case CSS_PROP__WEBKIT_MARGIN_START:
        case CSS_PROP__WEBKIT_MARQUEE:
        case CSS_PROP__WEBKIT_MARQUEE_SPEED:
        case CSS_PROP__WEBKIT_PADDING_START:
        case CSS_PROP__WEBKIT_TEXT_STROKE:
        case CSS_PROP__WEBKIT_ANIMATION:
        case CSS_PROP__WEBKIT_TRANSITION:
            // FIXME: The above are unimplemented.
            break;
#if ENABLE(SVG)
        default:
            return getSVGPropertyCSSValue(propertyID, DoNotUpdateLayout);
#endif
    }

    LOG_ERROR("unimplemented propertyID: %d", propertyID);
    return 0;
}

String CSSComputedStyleDeclaration::getPropertyValue(int propertyID) const
{
    RefPtr<CSSValue> value = getPropertyCSSValue(propertyID);
    if (value)
        return value->cssText();
    return "";
}

bool CSSComputedStyleDeclaration::getPropertyPriority(int /*propertyID*/) const
{
    // All computed styles have a priority of false (not "important").
    return false;
}

String CSSComputedStyleDeclaration::removeProperty(int /*propertyID*/, ExceptionCode& ec)
{
    ec = NO_MODIFICATION_ALLOWED_ERR;
    return String();
}

void CSSComputedStyleDeclaration::setProperty(int /*propertyID*/, const String& /*value*/, bool /*important*/, ExceptionCode& ec)
{
    ec = NO_MODIFICATION_ALLOWED_ERR;
}

unsigned CSSComputedStyleDeclaration::length() const
{
    Node* node = m_node.get();
    if (!node)
        return 0;

    RenderStyle* style = node->computedStyle();
    if (!style)
        return 0;

    return numComputedProperties;
}

String CSSComputedStyleDeclaration::item(unsigned i) const
{
    if (i >= length())
        return String();

    return getPropertyName(static_cast<CSSPropertyID>(computedProperties[i]));
}

// This is the list of properties we want to copy in the copyInheritableProperties() function.
// It is the intersection of the list of inherited CSS properties and the
// properties for which we have a computed implementation in this file.
const int inheritableProperties[] = {
    CSS_PROP_BORDER_COLLAPSE,
    CSS_PROP_COLOR,
    CSS_PROP_FONT_FAMILY,
    CSS_PROP_FONT_SIZE,
    CSS_PROP_FONT_STYLE,
    CSS_PROP_FONT_VARIANT,
    CSS_PROP_FONT_WEIGHT,
    CSS_PROP_LETTER_SPACING,
    CSS_PROP_LINE_HEIGHT,
    CSS_PROP_ORPHANS,
    CSS_PROP_TEXT_ALIGN,
    CSS_PROP_TEXT_INDENT,
    CSS_PROP_TEXT_TRANSFORM,
    CSS_PROP_WHITE_SPACE,
    CSS_PROP_WIDOWS,
    CSS_PROP_WORD_SPACING,
    CSS_PROP__WEBKIT_BORDER_HORIZONTAL_SPACING,
    CSS_PROP__WEBKIT_BORDER_VERTICAL_SPACING,
    CSS_PROP__WEBKIT_TAP_HIGHLIGHT_COLOR,
    CSS_PROP__WEBKIT_COMPOSITION_FILL_COLOR,
    CSS_PROP__WEBKIT_COMPOSITION_FRAME_COLOR,
    CSS_PROP__WEBKIT_TEXT_DECORATIONS_IN_EFFECT,
    CSS_PROP__WEBKIT_TEXT_FILL_COLOR,
    CSS_PROP__WEBKIT_TEXT_SIZE_ADJUST,
    CSS_PROP__WEBKIT_TEXT_STROKE_COLOR,
    CSS_PROP__WEBKIT_TEXT_STROKE_WIDTH,
};

const unsigned numInheritableProperties = sizeof(inheritableProperties) / sizeof(inheritableProperties[0]);

void CSSComputedStyleDeclaration::removeComputedInheritablePropertiesFrom(CSSMutableStyleDeclaration* declaration)
{
    declaration->removePropertiesInSet(inheritableProperties, numInheritableProperties);
}

PassRefPtr<CSSMutableStyleDeclaration> CSSComputedStyleDeclaration::copyInheritableProperties() const
{
    RefPtr<CSSMutableStyleDeclaration> style = copyPropertiesInSet(inheritableProperties, numInheritableProperties);
    if (style && m_node && m_node->computedStyle()) {
        // If a node's text fill color is invalid, then its children use 
        // their font-color as their text fill color (they don't
        // inherit it).  Likewise for stroke color.
        ExceptionCode ec = 0;
        if (!m_node->computedStyle()->textFillColor().isValid())
            style->removeProperty(CSS_PROP__WEBKIT_TEXT_FILL_COLOR, ec);
        if (!m_node->computedStyle()->textStrokeColor().isValid())
            style->removeProperty(CSS_PROP__WEBKIT_TEXT_STROKE_COLOR, ec);
        ASSERT(ec == 0);
    }
    return style.release();
}

PassRefPtr<CSSMutableStyleDeclaration> CSSComputedStyleDeclaration::copy() const
{
    return copyPropertiesInSet(computedProperties, numComputedProperties);
}

PassRefPtr<CSSMutableStyleDeclaration> CSSComputedStyleDeclaration::makeMutable()
{
    return copy();
}

PassRefPtr<CSSComputedStyleDeclaration> computedStyle(Node* node)
{
    return new CSSComputedStyleDeclaration(node);
}

} // namespace WebCore