/*

 * (C) 1999-2003 Lars Knoll (knoll@kde.org)

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

 *

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

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

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

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

#include "config.h"

#include "CSSPrimitiveValue.h"

#include "CSSHelper.h"

#include "CSSParser.h"

#include "CSSPropertyNames.h"

#include "CSSStyleSheet.h"

#include "CSSValueKeywords.h"

#include "Color.h"

#include "Counter.h"

#include "ExceptionCode.h"

#include "Node.h"

#include "Pair.h"

#include "RGBColor.h"

#include "Rect.h"

#include "RenderStyle.h"

#include <wtf/ASCIICType.h>

#include <wtf/StdLibExtras.h>

#if ENABLE(DASHBOARD_SUPPORT)

#include "DashboardRegion.h"

#endif

using namespace WTF;

namespace WebCore {

typedef HashMap<const CSSPrimitiveValue*, String> CSSTextCache;

static CSSTextCache& cssTextCache()

{

    DEFINE_STATIC_LOCAL(CSSTextCache, cache, ());

    return cache;

}

// A more stylish solution than sharing would be to turn CSSPrimitiveValue (or CSSValues in general) into non-virtual,

// non-refcounted simple type with value semantics. In practice these sharing tricks get similar memory benefits 

// with less need for refactoring.

inline PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValue::createUncachedIdentifier(int identifier)

{

    return adoptRef(new CSSPrimitiveValue(identifier));

}

inline PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValue::createUncachedColor(unsigned rgbValue)

{

    return adoptRef(new CSSPrimitiveValue(rgbValue));

}

inline PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValue::createUncached(double value, UnitTypes type)

{

    return adoptRef(new CSSPrimitiveValue(value, type));

}

PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValue::createIdentifier(int ident)

{

    static RefPtr<CSSPrimitiveValue>* identValueCache = new RefPtr<CSSPrimitiveValue>[numCSSValueKeywords];

    if (ident >= 0 && ident < numCSSValueKeywords) {

        RefPtr<CSSPrimitiveValue> primitiveValue = identValueCache[ident];

        if (!primitiveValue) {

            primitiveValue = createUncachedIdentifier(ident);

            identValueCache[ident] = primitiveValue;

        }

        return primitiveValue.release();

    } 

    return createUncachedIdentifier(ident);

}

PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValue::createColor(unsigned rgbValue)

{

    typedef HashMap<unsigned, RefPtr<CSSPrimitiveValue> > ColorValueCache;

    static ColorValueCache* colorValueCache = new ColorValueCache;

    // These are the empty and deleted values of the hash table.

    if (rgbValue == Color::transparent) {

        static CSSPrimitiveValue* colorTransparent = createUncachedColor(Color::transparent).releaseRef();

        return colorTransparent;

    }

    if (rgbValue == Color::white) {

        static CSSPrimitiveValue* colorWhite = createUncachedColor(Color::white).releaseRef();

        return colorWhite;

    }

    RefPtr<CSSPrimitiveValue> primitiveValue = colorValueCache->get(rgbValue);

    if (primitiveValue)

        return primitiveValue.release();

    primitiveValue = createUncachedColor(rgbValue);

    // Just wipe out the cache and start rebuilding when it gets too big.

    const int maxColorCacheSize = 512;

    if (colorValueCache->size() >= maxColorCacheSize)

        colorValueCache->clear();

    colorValueCache->add(rgbValue, primitiveValue);

    return primitiveValue.release();

}

PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValue::create(double value, UnitTypes type)

{

    // Small integers are very common. Try to share them.

    const int cachedIntegerCount = 128;

    // Other common primitive types have UnitTypes smaller than this.

    const int maxCachedUnitType = CSS_PX;

    typedef RefPtr<CSSPrimitiveValue>(* IntegerValueCache)[maxCachedUnitType + 1];

    static IntegerValueCache integerValueCache = new RefPtr<CSSPrimitiveValue>[cachedIntegerCount][maxCachedUnitType + 1];

    if (type <= maxCachedUnitType && value >= 0 && value < cachedIntegerCount) {

        int intValue = static_cast<int>(value);

        if (value == intValue) {

            RefPtr<CSSPrimitiveValue> primitiveValue = integerValueCache[intValue][type];

            if (!primitiveValue) {

                primitiveValue = createUncached(value, type);

                integerValueCache[intValue][type] = primitiveValue;

            }

            return primitiveValue.release();

        }

    }

    return createUncached(value, type);

}

PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValue::create(const String& value, UnitTypes type)

{

    return adoptRef(new CSSPrimitiveValue(value, type));

}

static const AtomicString& valueOrPropertyName(int valueOrPropertyID)

{

    ASSERT_ARG(valueOrPropertyID, valueOrPropertyID >= 0);

    ASSERT_ARG(valueOrPropertyID, valueOrPropertyID < numCSSValueKeywords || (valueOrPropertyID >= firstCSSProperty && valueOrPropertyID < firstCSSProperty + numCSSProperties));

    if (valueOrPropertyID < 0)

        return nullAtom;

    if (valueOrPropertyID < numCSSValueKeywords) {

        static AtomicString* cssValueKeywordStrings[numCSSValueKeywords];

        if (!cssValueKeywordStrings[valueOrPropertyID])

            cssValueKeywordStrings[valueOrPropertyID] = new AtomicString(getValueName(valueOrPropertyID));

        return *cssValueKeywordStrings[valueOrPropertyID];

    }

    if (valueOrPropertyID >= firstCSSProperty && valueOrPropertyID < firstCSSProperty + numCSSProperties) {

        static AtomicString* cssPropertyStrings[numCSSProperties];

        int propertyIndex = valueOrPropertyID - firstCSSProperty;

        if (!cssPropertyStrings[propertyIndex])

            cssPropertyStrings[propertyIndex] = new AtomicString(getPropertyName(static_cast<CSSPropertyID>(valueOrPropertyID)));

        return *cssPropertyStrings[propertyIndex];

    }

    return nullAtom;

}

CSSPrimitiveValue::CSSPrimitiveValue()

    : m_type(0)

    , m_hasCachedCSSText(false)

{

}

CSSPrimitiveValue::CSSPrimitiveValue(int ident)

    : m_type(CSS_IDENT)

    , m_hasCachedCSSText(false)

{

    m_value.ident = ident;

}

CSSPrimitiveValue::CSSPrimitiveValue(double num, UnitTypes type)

    : m_type(type)

    , m_hasCachedCSSText(false)

{

    m_value.num = num;

}

CSSPrimitiveValue::CSSPrimitiveValue(const String& str, UnitTypes type)

    : m_type(type)

    , m_hasCachedCSSText(false)

{

    if ((m_value.string = str.impl()))

        m_value.string->ref();

}

CSSPrimitiveValue::CSSPrimitiveValue(RGBA32 color)

    : m_type(CSS_RGBCOLOR)

    , m_hasCachedCSSText(false)

{

    m_value.rgbcolor = color;

}

CSSPrimitiveValue::CSSPrimitiveValue(const Length& length)

    : m_hasCachedCSSText(false)

{

    switch (length.type()) {

        case Auto:

            m_type = CSS_IDENT;

            m_value.ident = CSSValueAuto;

            break;

        case WebCore::Fixed:

            m_type = CSS_PX;

            m_value.num = length.value();

            break;

        case Intrinsic:

            m_type = CSS_IDENT;

            m_value.ident = CSSValueIntrinsic;

            break;

        case MinIntrinsic:

            m_type = CSS_IDENT;

            m_value.ident = CSSValueMinIntrinsic;

            break;

        case Percent:

            m_type = CSS_PERCENTAGE;

            m_value.num = length.percent();

            break;

        case Relative:

        case Static:

            ASSERT_NOT_REACHED();

            break;

    }

}

void CSSPrimitiveValue::init(PassRefPtr<Counter> c)

{

    m_type = CSS_COUNTER;

    m_hasCachedCSSText = false;

    m_value.counter = c.releaseRef();

}

void CSSPrimitiveValue::init(PassRefPtr<Rect> r)

{

    m_type = CSS_RECT;

    m_hasCachedCSSText = false;

    m_value.rect = r.releaseRef();

}

#if ENABLE(DASHBOARD_SUPPORT)

void CSSPrimitiveValue::init(PassRefPtr<DashboardRegion> r)

{

    m_type = CSS_DASHBOARD_REGION;

    m_hasCachedCSSText = false;

    m_value.region = r.releaseRef();

}

#endif

void CSSPrimitiveValue::init(PassRefPtr<Pair> p)

{

    m_type = CSS_PAIR;

    m_hasCachedCSSText = false;

    m_value.pair = p.releaseRef();

}

CSSPrimitiveValue::~CSSPrimitiveValue()

{

    cleanup();

}

void CSSPrimitiveValue::cleanup()

{

    switch (m_type) {

        case CSS_STRING:

        case CSS_URI:

        case CSS_ATTR:

        case CSS_PARSER_VARIABLE_FUNCTION_SYNTAX:

        case CSS_PARSER_HEXCOLOR:

            if (m_value.string)

                m_value.string->deref();

            break;

        case CSS_COUNTER:

            m_value.counter->deref();

            break;

        case CSS_RECT:

            m_value.rect->deref();

            break;

        case CSS_PAIR:

            m_value.pair->deref();

            break;

#if ENABLE(DASHBOARD_SUPPORT)

        case CSS_DASHBOARD_REGION:

            if (m_value.region)

                m_value.region->deref();

            break;

#endif

        default:

            break;

    }

    m_type = 0;

    if (m_hasCachedCSSText) {

        cssTextCache().remove(this);

        m_hasCachedCSSText = false;

    }

}

int CSSPrimitiveValue::computeLengthInt(RenderStyle* style, RenderStyle* rootStyle)

{

    double result = computeLengthDouble(style, rootStyle);

    // This conversion is imprecise, often resulting in values of, e.g., 44.99998.  We

    // need to go ahead and round if we're really close to the next integer value.

    result += result < 0 ? -0.01 : +0.01;

    if (result > INT_MAX || result < INT_MIN)

        return 0;

    return static_cast<int>(result);

}

int CSSPrimitiveValue::computeLengthInt(RenderStyle* style, RenderStyle* rootStyle, double multiplier)

{

    double result = computeLengthDouble(style, rootStyle, multiplier);

    // This conversion is imprecise, often resulting in values of, e.g., 44.99998.  We

    // need to go ahead and round if we're really close to the next integer value.

    result += result < 0 ? -0.01 : +0.01;

    if (result > INT_MAX || result < INT_MIN)

        return 0;

    return static_cast<int>(result);

}

const int intMaxForLength = 0x7ffffff; // max value for a 28-bit int

const int intMinForLength = (-0x7ffffff - 1); // min value for a 28-bit int

// Lengths expect an int that is only 28-bits, so we have to check for a different overflow.

int CSSPrimitiveValue::computeLengthIntForLength(RenderStyle* style, RenderStyle* rootStyle)

{

    double result = computeLengthDouble(style, rootStyle);

    // This conversion is imprecise, often resulting in values of, e.g., 44.99998.  We

    // need to go ahead and round if we're really close to the next integer value.

    result += result < 0 ? -0.01 : +0.01;

    if (result > intMaxForLength || result < intMinForLength)

        return 0;

    return static_cast<int>(result);

}

// Lengths expect an int that is only 28-bits, so we have to check for a different overflow.

int CSSPrimitiveValue::computeLengthIntForLength(RenderStyle* style, RenderStyle* rootStyle, double multiplier)

{

    double result = computeLengthDouble(style, rootStyle, multiplier);

    // This conversion is imprecise, often resulting in values of, e.g., 44.99998.  We

    // need to go ahead and round if we're really close to the next integer value.

    result += result < 0 ? -0.01 : +0.01;

    if (result > intMaxForLength || result < intMinForLength)

        return 0;

    return static_cast<int>(result);

}

short CSSPrimitiveValue::computeLengthShort(RenderStyle* style, RenderStyle* rootStyle)

{

    double result = computeLengthDouble(style, rootStyle);

    // This conversion is imprecise, often resulting in values of, e.g., 44.99998.  We

    // need to go ahead and round if we're really close to the next integer value.

    result += result < 0 ? -0.01 : +0.01;

    if (result > SHRT_MAX || result < SHRT_MIN)

        return 0;

    return static_cast<short>(result);

}

short CSSPrimitiveValue::computeLengthShort(RenderStyle* style, RenderStyle* rootStyle, double multiplier)

{

    double result = computeLengthDouble(style, rootStyle, multiplier);

    // This conversion is imprecise, often resulting in values of, e.g., 44.99998.  We

    // need to go ahead and round if we're really close to the next integer value.

    result += result < 0 ? -0.01 : +0.01;

    if (result > SHRT_MAX || result < SHRT_MIN)

        return 0;

    return static_cast<short>(result);

}

float CSSPrimitiveValue::computeLengthFloat(RenderStyle* style, RenderStyle* rootStyle, bool computingFontSize)

{

    return static_cast<float>(computeLengthDouble(style, rootStyle, 1.0, computingFontSize));

}

float CSSPrimitiveValue::computeLengthFloat(RenderStyle* style, RenderStyle* rootStyle, double multiplier, bool computingFontSize)

{

    return static_cast<float>(computeLengthDouble(style, rootStyle, multiplier, computingFontSize));

}

double CSSPrimitiveValue::computeLengthDouble(RenderStyle* style, RenderStyle* rootStyle, double multiplier, bool computingFontSize)

{

    unsigned short type = primitiveType();

    // We do not apply the zoom factor when we are computing the value of the font-size property.  The zooming

    // for font sizes is much more complicated, since we have to worry about enforcing the minimum font size preference

    // as well as enforcing the implicit "smart minimum."  In addition the CSS property text-size-adjust is used to

    // prevent text from zooming at all.  Therefore we will not apply the zoom here if we are computing font-size.

    bool applyZoomMultiplier = !computingFontSize;

    double factor = 1.0;

    switch (type) {

        case CSS_EMS:

            applyZoomMultiplier = false;

            factor = computingFontSize ? style->fontDescription().specifiedSize() : style->fontDescription().computedSize();

            break;

        case CSS_EXS:

            // FIXME: We have a bug right now where the zoom will be applied twice to EX units.

            // We really need to compute EX using fontMetrics for the original specifiedSize and not use

            // our actual constructed rendering font.

            applyZoomMultiplier = false;

            factor = style->font().xHeight();

            break;

        case CSS_REMS:

            applyZoomMultiplier = false;

            factor = computingFontSize ? rootStyle->fontDescription().specifiedSize() : rootStyle->fontDescription().computedSize();

            break;

        case CSS_PX:

            break;

        case CSS_CM:

            factor = cssPixelsPerInch / 2.54; // (2.54 cm/in)

            break;

        case CSS_MM:

            factor = cssPixelsPerInch / 25.4;

            break;

        case CSS_IN:

            factor = cssPixelsPerInch;

            break;

        case CSS_PT:

            factor = cssPixelsPerInch / 72.0;

            break;

        case CSS_PC:

            // 1 pc == 12 pt

            factor = cssPixelsPerInch * 12.0 / 72.0;

            break;

        default:

            return -1.0;

    }

    double result = getDoubleValue() * factor;

    if (!applyZoomMultiplier || multiplier == 1.0)

        return result;

    // Any original result that was >= 1 should not be allowed to fall below 1.  This keeps border lines from

    // vanishing.

    double zoomedResult = result * multiplier;

    if (result >= 1.0)

        zoomedResult = max(1.0, zoomedResult);

    return zoomedResult;

}

void CSSPrimitiveValue::setFloatValue(unsigned short unitType, double floatValue, ExceptionCode& ec)

{

    ec = 0;

    if (m_type < CSS_NUMBER || m_type > CSS_DIMENSION || unitType < CSS_NUMBER || unitType > CSS_DIMENSION) {

        ec = INVALID_ACCESS_ERR;

        return;

    }

    cleanup();

    m_value.num = floatValue;

    m_type = unitType;

}

static double scaleFactorForConversion(unsigned short unitType)

{

    double factor = 1.0;

    switch (unitType) {

        case CSSPrimitiveValue::CSS_PX:

            break;

        case CSSPrimitiveValue::CSS_CM:

            factor = cssPixelsPerInch / 2.54; // (2.54 cm/in)

            break;

        case CSSPrimitiveValue::CSS_MM:

            factor = cssPixelsPerInch / 25.4;

            break;

        case CSSPrimitiveValue::CSS_IN:

            factor = cssPixelsPerInch;

            break;

        case CSSPrimitiveValue::CSS_PT:

            factor = cssPixelsPerInch / 72.0;

            break;

        case CSSPrimitiveValue::CSS_PC:

            factor = cssPixelsPerInch * 12.0 / 72.0; // 1 pc == 12 pt

            break;

        default:

            break;

    }

    return factor;

}

double CSSPrimitiveValue::getDoubleValue(unsigned short unitType, ExceptionCode& ec)

{

    ec = 0;

    if (m_type < CSS_NUMBER || m_type > CSS_DIMENSION || unitType < CSS_NUMBER || unitType > CSS_DIMENSION) {

        ec = INVALID_ACCESS_ERR;

        return 0.0;

    }

    if (unitType == m_type || unitType < CSS_PX || unitType > CSS_PC)

        return m_value.num;

    double convertedValue = m_value.num;

    // First convert the value from m_type into CSSPixels

    double factor = scaleFactorForConversion(m_type);

    convertedValue *= factor;

    // Now convert from CSSPixels to the specified unitType

    factor = scaleFactorForConversion(unitType);

    convertedValue /= factor;

    return convertedValue;

}

double CSSPrimitiveValue::getDoubleValue(unsigned short unitType)

{