/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qtextformat.h"

#include "qtextformat_p.h"

#include <qvariant.h>

#include <qdatastream.h>

#include <qdebug.h>

#include <qmap.h>

#include <qhash.h>

QT_BEGIN_NAMESPACE

/*!

    \class QTextLength

    \reentrant

    \brief The QTextLength class encapsulates the different types of length

    used in a QTextDocument.

    \ingroup richtext-processing

    When we specify a value for the length of an element in a text document,

    we often need to provide some other information so that the length is

    used in the way we expect. For example, when we specify a table width,

    the value can represent a fixed number of pixels, or it can be a percentage

    value. This information changes both the meaning of the value and the way

    it is used.

    Generally, this class is used to specify table widths. These can be

    specified either as a fixed amount of pixels, as a percentage of the

    containing frame's width, or by a variable width that allows it to take

    up just the space it requires.

    \sa QTextTable

*/

/*!

    \fn explicit QTextLength::QTextLength()

    Constructs a new length object which represents a variable size.

*/

/*!

    \fn QTextLength::QTextLength(Type type, qreal value)

    Constructs a new length object of the given \a type and \a value.

*/

/*!

    \fn Type QTextLength::type() const

    Returns the type of this length object.

    \sa QTextLength::Type

*/

/*!

    \fn qreal QTextLength::value(qreal maximumLength) const

    Returns the effective length, constrained by the type of the length object

    and the specified \a maximumLength.

    \sa type()

*/

/*!

    \fn qreal QTextLength::rawValue() const

    Returns the constraint value that is specific for the type of the length.

    If the length is QTextLength::PercentageLength then the raw value is in

    percent, in the range of 0 to 100. If the length is QTextLength::FixedLength

    then that fixed amount is returned. For variable lengths, zero is returned.

*/

/*!

    \fn bool QTextLength::operator==(const QTextLength &other) const

    Returns true if this text length is the same as the \a other text

    length.

*/

/*!

    \fn bool QTextLength::operator!=(const QTextLength &other) const

    Returns true if this text length is different from the \a other text

    length.

*/

/*!

    \enum QTextLength::Type

    This enum describes the different types a length object can

    have.

    \value VariableLength The width of the object is variable

    \value FixedLength The width of the object is fixed

    \value PercentageLength The width of the object is in

                            percentage of the maximum width

    \sa type()

*/

/*!

   Returns the text length as a QVariant

*/

QTextLength::operator QVariant() const

{

    return QVariant(QVariant::TextLength, this);

}

#ifndef QT_NO_DATASTREAM

QDataStream &operator<<(QDataStream &stream, const QTextLength &length)

{

    return stream << qint32(length.lengthType) << double(length.fixedValueOrPercentage);

}

QDataStream &operator>>(QDataStream &stream, QTextLength &length)

{

    qint32 type;

    double fixedValueOrPercentage;

    stream >> type >> fixedValueOrPercentage;

    length.fixedValueOrPercentage = fixedValueOrPercentage;

    length.lengthType = QTextLength::Type(type);

    return stream;

}

#endif // QT_NO_DATASTREAM

class QTextFormatPrivate : public QSharedData

{

public:

    QTextFormatPrivate() : hashDirty(true), fontDirty(true), hashValue(0) {}

    struct Property

    {

        inline Property(qint32 k, const QVariant &v) : key(k), value(v) {}

        inline Property() {}

        qint32 key;

        QVariant value;

        inline bool operator==(const Property &other) const

        { return key == other.key && value == other.value; }

        inline bool operator!=(const Property &other) const

        { return key != other.key || value != other.value; }

    };

    inline uint hash() const

    {

        if (!hashDirty)

            return hashValue;

        return recalcHash();

    }

    inline bool operator==(const QTextFormatPrivate &rhs) const {

        if (hash() != rhs.hash())

            return false;

        return props == rhs.props;

    }

    inline void insertProperty(qint32 key, const QVariant &value)

    {

        hashDirty = true;

        if (key >= QTextFormat::FirstFontProperty && key <= QTextFormat::LastFontProperty)

            fontDirty = true;

        for (int i = 0; i < props.count(); ++i)

            if (props.at(i).key == key) {

                props[i].value = value;

                return;

            }

        props.append(Property(key, value));

    }

    inline void clearProperty(qint32 key)

    {

        for (int i = 0; i < props.count(); ++i)

            if (props.at(i).key == key) {

                hashDirty = true;

                if (key >= QTextFormat::FirstFontProperty && key <= QTextFormat::LastFontProperty)

                    fontDirty = true;

                props.remove(i);

                return;

            }

    }

    inline int propertyIndex(qint32 key) const

    {

        for (int i = 0; i < props.count(); ++i)

            if (props.at(i).key == key)

                return i;

        return -1;

    }

    inline QVariant property(qint32 key) const

    {

        const int idx = propertyIndex(key);

        if (idx < 0)

            return QVariant();

        return props.at(idx).value;

    }

    inline bool hasProperty(qint32 key) const

    { return propertyIndex(key) != -1; }

    void resolveFont(const QFont &defaultFont);

    inline const QFont &font() const {

        if (fontDirty)

            recalcFont();

        return fnt;

    }

    QVector<Property> props;

private:

    uint recalcHash() const;

    void recalcFont() const;

    mutable bool hashDirty;

    mutable bool fontDirty;

    mutable uint hashValue;

    mutable QFont fnt;

    friend QDataStream &operator<<(QDataStream &, const QTextFormat &);

    friend QDataStream &operator>>(QDataStream &, QTextFormat &);

};

// this is only safe if sizeof(int) == sizeof(float)

static inline uint hash(float d)

{

    return reinterpret_cast<uint&>(d);

}

static inline uint hash(const QColor &color)

{

    return (color.isValid()) ? color.rgba() : 0x234109;

}

static inline uint hash(const QPen &pen)

{

    return hash(pen.color()) + hash(pen.widthF());

}

static inline uint hash(const QBrush &brush)

{

    return hash(brush.color()) + (brush.style() << 3);

}

static inline uint variantHash(const QVariant &variant)

{

    // simple and fast hash functions to differentiate between type and value

    switch (variant.userType()) { // sorted by occurrence frequency

    case QVariant::String: return qHash(variant.toString());

    case QVariant::Double: return hash(variant.toDouble());

    case QVariant::Int: return 0x811890 + variant.toInt();

    case QVariant::Brush:

        return 0x01010101 + hash(qvariant_cast<QBrush>(variant));

    case QVariant::Bool: return 0x371818 + variant.toBool();

    case QVariant::Pen: return 0x02020202 + hash(qvariant_cast<QPen>(variant));

    case QVariant::List:

        return 0x8377 + qvariant_cast<QVariantList>(variant).count();

    case QVariant::Color: return hash(qvariant_cast<QColor>(variant));

      case QVariant::TextLength:

        return 0x377 + hash(qvariant_cast<QTextLength>(variant).rawValue());

    case QMetaType::Float: return hash(variant.toFloat());

    case QVariant::Invalid: return 0;

    default: break;

    }

    return qHash(variant.typeName());

}

static inline int getHash(const QTextFormatPrivate *d, int format)

{

    return (d ? d->hash() : 0) + format;

}

uint QTextFormatPrivate::recalcHash() const

{

    hashValue = 0;

    for (QVector<Property>::ConstIterator it = props.constBegin(); it != props.constEnd(); ++it)

        hashValue += (it->key << 16) + variantHash(it->value);

    hashDirty = false;

    return hashValue;

}

void QTextFormatPrivate::resolveFont(const QFont &defaultFont)

{

    recalcFont();

    const uint oldMask = fnt.resolve();

    fnt = fnt.resolve(defaultFont);

    if (hasProperty(QTextFormat::FontSizeAdjustment)) {

        const qreal scaleFactors[7] = {qreal(0.7), qreal(0.8), qreal(1.0), qreal(1.2), qreal(1.5), qreal(2), qreal(2.4)};

        const int htmlFontSize = qBound(0, property(QTextFormat::FontSizeAdjustment).toInt() + 3 - 1, 6);

        if (defaultFont.pointSize() <= 0) {

            qreal pixelSize = scaleFactors[htmlFontSize] * defaultFont.pixelSize();

            fnt.setPixelSize(qRound(pixelSize));

        } else {

            qreal pointSize = scaleFactors[htmlFontSize] * defaultFont.pointSizeF();

            fnt.setPointSizeF(pointSize);

        }

    }

    fnt.resolve(oldMask);

}

void QTextFormatPrivate::recalcFont() const

{

    // update cached font as well

    QFont f;

    for (int i = 0; i < props.count(); ++i) {

        switch (props.at(i).key) {

            case QTextFormat::FontFamily:

                f.setFamily(props.at(i).value.toString());

                break;

            case QTextFormat::FontPointSize:

                f.setPointSizeF(props.at(i).value.toReal());

                break;

            case  QTextFormat::FontPixelSize:

                f.setPixelSize(props.at(i).value.toInt());

                break;

            case QTextFormat::FontWeight: {

                int weight = props.at(i).value.toInt();

                if (weight == 0) weight = QFont::Normal;

                f.setWeight(weight);

                break; }

            case QTextFormat::FontItalic:

                f.setItalic(props.at(i).value.toBool());

                break;

            case QTextFormat::FontUnderline:

                if (! hasProperty(QTextFormat::TextUnderlineStyle)) // don't use the old one if the new one is there.

                    f.setUnderline(props.at(i).value.toBool());

                break;

            case QTextFormat::TextUnderlineStyle:

                f.setUnderline(static_cast<QTextCharFormat::UnderlineStyle>(props.at(i).value.toInt()) == QTextCharFormat::SingleUnderline);

                break;

            case QTextFormat::FontOverline:

                f.setOverline(props.at(i).value.toBool());

                break;

            case QTextFormat::FontStrikeOut:

                f.setStrikeOut(props.at(i).value.toBool());

                break;

            case QTextFormat::FontLetterSpacing:

                f.setLetterSpacing(QFont::PercentageSpacing, props.at(i).value.toReal());

                break;

            case QTextFormat::FontWordSpacing:

                f.setWordSpacing(props.at(i).value.toReal());

                break;

            case QTextFormat::FontCapitalization:

                f.setCapitalization(static_cast<QFont::Capitalization> (props.at(i).value.toInt()));

                break;

            case QTextFormat::FontFixedPitch: {

                const bool value = props.at(i).value.toBool();

                if (f.fixedPitch() != value)

                    f.setFixedPitch(value);

                break; }

            case QTextFormat::FontStyleHint:

                f.setStyleHint(static_cast<QFont::StyleHint>(props.at(i).value.toInt()), f.styleStrategy());

                break;

            case QTextFormat::FontStyleStrategy:

                f.setStyleStrategy(static_cast<QFont::StyleStrategy>(props.at(i).value.toInt()));

                break;

            case QTextFormat::FontKerning:

                f.setKerning(props.at(i).value.toBool());

                break;

            default:

                break;

            }

    }

    fnt = f;

    fontDirty = false;

}

#ifndef QT_NO_DATASTREAM

Q_GUI_EXPORT QDataStream &operator<<(QDataStream &stream, const QTextFormat &fmt)

{

    stream << fmt.format_type << fmt.properties();

    return stream;

}

Q_GUI_EXPORT QDataStream &operator>>(QDataStream &stream, QTextFormat &fmt)

{

    QMap<qint32, QVariant> properties;

    stream >> fmt.format_type >> properties;

    // QTextFormat's default constructor doesn't allocate the private structure, so

    // we have to do this, in case fmt is a default constructed value.

    if(!fmt.d)

        fmt.d = new QTextFormatPrivate();

    for (QMap<qint32, QVariant>::ConstIterator it = properties.constBegin();

         it != properties.constEnd(); ++it)

        fmt.d->insertProperty(it.key(), it.value());

    return stream;

}

#endif // QT_NO_DATASTREAM

/*!

    \class QTextFormat

    \reentrant

    \brief The QTextFormat class provides formatting information for a

    QTextDocument.

    \ingroup richtext-processing

    \ingroup shared

    A QTextFormat is a generic class used for describing the format of

    parts of a QTextDocument. The derived classes QTextCharFormat,

    QTextBlockFormat, QTextListFormat, and QTextTableFormat are usually

    more useful, and describe the formatting that is applied to

    specific parts of the document.

    A format has a \c FormatType which specifies the kinds of text item it

    can format; e.g. a block of text, a list, a table, etc. A format

    also has various properties (some specific to particular format

    types), as described by the Property enum. Every property has a

    corresponding Property.

    The format type is given by type(), and the format can be tested

    with isCharFormat(), isBlockFormat(), isListFormat(),

    isTableFormat(), isFrameFormat(), and isImageFormat(). If the

    type is determined, it can be retrieved with toCharFormat(),

    toBlockFormat(), toListFormat(), toTableFormat(), toFrameFormat(),

    and toImageFormat().

    A format's properties can be set with the setProperty() functions,

    and retrieved with boolProperty(), intProperty(), doubleProperty(),

    and stringProperty() as appropriate. All the property IDs used in

    the format can be retrieved with allPropertyIds(). One format can

    be merged into another using merge().

    A format's object index can be set with setObjectIndex(), and

    retrieved with objectIndex(). These methods can be used to

    associate the format with a QTextObject. It is used to represent

    lists, frames, and tables inside the document.

    \sa {Rich Text Processing}

*/

/*!

    \enum QTextFormat::FormatType

    This enum describes the text item a QTextFormat object is formatting.

    \value InvalidFormat An invalid format as created by the default

                         constructor

    \value BlockFormat The object formats a text block

    \value CharFormat The object formats a single character

    \value ListFormat The object formats a list

    \value TableFormat The object formats a table

    \value FrameFormat The object formats a frame

    \value UserFormat

    \sa QTextCharFormat, QTextBlockFormat, QTextListFormat,

    QTextTableFormat, type()

*/

/*!

    \enum QTextFormat::Property

    This enum describes the different properties a format can have.

    \value ObjectIndex The index of the formatted object. See objectIndex().

    Paragraph and character properties

    \value CssFloat How a frame is located relative to the surrounding text

    \value LayoutDirection  The layout direction of the text in the document

                            (Qt::LayoutDirection).

    \value OutlinePen

    \value ForegroundBrush

    \value BackgroundBrush

    \value BackgroundImageUrl

    Paragraph properties