qtextformat.cpp

Go to the documentation of this file.

// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qtextformat.h"
#include "qtextformat_p.h"
 
#include <qvariant.h>
#include <qdatastream.h>
#include <qdebug.h>
#include <qmap.h>
#include <qhashfunctions.h>
 
QT_BEGIN_NAMESPACE
 
QTextLength::operator QVariant() const
{
    return QVariant::fromValue(*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
 
namespace {
struct Property
{
    inline Property(qint32 k, const QVariant &v) : key(k), value(v) {}
    inline Property() {}
 
    qint32 key = -1;
    QVariant value;
 
    inline bool operator==(const Property &other) const
    { return key == other.key && value == other.value; }
};
}
Q_DECLARE_TYPEINFO(Property, Q_RELOCATABLE_TYPE);
 
class QTextFormatPrivate : public QSharedData
{
public:
    QTextFormatPrivate() : hashDirty(true), fontDirty(true), hashValue(0) {}
 
    inline size_t 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.size(); ++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.size(); ++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.size(); ++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;
    }
 
    QList<Property> props;
private:
 
    size_t recalcHash() const;
    void recalcFont() const;
 
    mutable bool hashDirty;
    mutable bool fontDirty;
    mutable size_t hashValue;
    mutable QFont fnt;
 
    friend QDataStream &operator<<(QDataStream &, const QTextFormat &);
    friend QDataStream &operator>>(QDataStream &, QTextFormat &);
};
 
static inline size_t hash(const QColor &color)
{
    return (color.isValid()) ? color.rgba() : 0x234109;
}
 
static inline size_t hash(const QPen &pen)
{
    return hash(pen.color()) + qHash(pen.widthF());
}
 
static inline size_t hash(const QBrush &brush)
{
    return hash(brush.color()) + (brush.style() << 3);
}
 
static inline size_t variantHash(const QVariant &variant)
{
    // simple and fast hash functions to differentiate between type and value
    switch (variant.userType()) { // sorted by occurrence frequency
    case QMetaType::QString: return qHash(variant.toString());
    case QMetaType::Double: return qHash(variant.toDouble());
    case QMetaType::Int: return 0x811890U + variant.toInt();
    case QMetaType::QBrush:
        return 0x01010101 + hash(qvariant_cast<QBrush>(variant));
    case QMetaType::Bool: return 0x371818 + variant.toBool();
    case QMetaType::QPen: return 0x02020202 + hash(qvariant_cast<QPen>(variant));
    case QMetaType::QVariantList:
        return 0x8377U + qvariant_cast<QVariantList>(variant).size();
    case QMetaType::QColor: return hash(qvariant_cast<QColor>(variant));
      case QMetaType::QTextLength:
        return 0x377 + hash(qvariant_cast<QTextLength>(variant).rawValue());
    case QMetaType::Float: return qHash(variant.toFloat());
    case QMetaType::UnknownType: return 0;
    default: break;
    }
    return qHash(variant.typeName());
}
 
static inline size_t getHash(const QTextFormatPrivate *d, int format)
{
    return (d ? d->hash() : 0) + format;
}
 
size_t QTextFormatPrivate::recalcHash() const
{
    hashValue = 0;
    const auto end = props.constEnd();
    for (auto it = props.constBegin(); it != end; ++it)
        hashValue += (static_cast<quint32>(it->key) << 16) + variantHash(it->value);
 
    hashDirty = false;
 
    return hashValue;
}
 
void QTextFormatPrivate::resolveFont(const QFont &defaultFont)
{
    recalcFont();
    const uint oldMask = fnt.resolveMask();
    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.setResolveMask(oldMask);
}
 
void QTextFormatPrivate::recalcFont() const
{
    // update cached font as well
    QFont f;
 
    bool hasSpacingInformation = false;
    QFont::SpacingType spacingType = QFont::PercentageSpacing;
    qreal letterSpacing = 0.0;
 
    for (int i = 0; i < props.size(); ++i) {
        switch (props.at(i).key) {
            case QTextFormat::FontFamilies:
                f.setFamilies(props.at(i).value.toStringList());
                break;
            case QTextFormat::FontStyleName:
                f.setStyleName(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: {
                const QVariant weightValue = props.at(i).value;
                int weight = weightValue.toInt();
                if (weight >= 0 && weightValue.isValid())
                    f.setWeight(QFont::Weight(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::FontLetterSpacingType:
                spacingType = static_cast<QFont::SpacingType>(props.at(i).value.toInt());
                hasSpacingInformation = true;
                break;
            case QTextFormat::FontLetterSpacing:
                letterSpacing = props.at(i).value.toReal();
                hasSpacingInformation = true;
                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::FontStretch:
                f.setStretch(props.at(i).value.toInt());
                break;
            case QTextFormat::FontStyleHint:
                f.setStyleHint(static_cast<QFont::StyleHint>(props.at(i).value.toInt()), f.styleStrategy());
                break;
            case QTextFormat::FontHintingPreference:
                f.setHintingPreference(static_cast<QFont::HintingPreference>(props.at(i).value.toInt()));
                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;
            }
    }
 
    if (hasSpacingInformation)
        f.setLetterSpacing(spacingType, letterSpacing);
 
    fnt = f;
    fontDirty = false;
}
 
#ifndef QT_NO_DATASTREAM
Q_GUI_EXPORT QDataStream &operator<<(QDataStream &stream, const QTextFormat &fmt)
{
    QMap<int, QVariant> properties = fmt.properties();
    if (stream.version() < QDataStream::Qt_6_0) {
        auto it = properties.find(QTextFormat::FontLetterSpacingType);
        if (it != properties.end()) {
            properties[QTextFormat::OldFontLetterSpacingType] = it.value();
            properties.erase(it);
        }
 
        it = properties.find(QTextFormat::FontStretch);
        if (it != properties.end()) {
            properties[QTextFormat::OldFontStretch] = it.value();
            properties.erase(it);
        }
 
        it = properties.find(QTextFormat::TextUnderlineColor);
        if (it != properties.end()) {
            properties[QTextFormat::OldTextUnderlineColor] = it.value();
            properties.erase(it);
        }
 
        it = properties.find(QTextFormat::FontFamilies);
        if (it != properties.end()) {
            properties[QTextFormat::OldFontFamily] = QVariant(it.value().toStringList().first());
            properties.erase(it);
        }
    }
 
    stream << fmt.format_type << 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) {
        qint32 key = it.key();
        if (key == QTextFormat::OldFontLetterSpacingType)
            key = QTextFormat::FontLetterSpacingType;
        else if (key == QTextFormat::OldFontStretch)
            key = QTextFormat::FontStretch;
        else if (key == QTextFormat::OldTextUnderlineColor)
            key = QTextFormat::TextUnderlineColor;
        else if (key == QTextFormat::OldFontFamily)
            key = QTextFormat::FontFamilies;
        fmt.d->insertProperty(key, it.value());
    }
 
    return stream;
}
 
Q_GUI_EXPORT QDataStream &operator<<(QDataStream &stream, const QTextCharFormat &fmt)
{
    return stream << static_cast<const QTextFormat &>(fmt);
}
 
Q_GUI_EXPORT QDataStream &operator>>(QDataStream &stream, QTextCharFormat &fmt)
{
    return stream >> static_cast<QTextFormat &>(fmt);
}
 
Q_GUI_EXPORT QDataStream &operator<<(QDataStream &stream, const QTextBlockFormat &fmt)
{
    return stream << static_cast<const QTextFormat &>(fmt);
}
 
Q_GUI_EXPORT QDataStream &operator>>(QDataStream &stream, QTextBlockFormat &fmt)
{
    return stream >> static_cast<QTextFormat &>(fmt);
}
 
Q_GUI_EXPORT QDataStream &operator<<(QDataStream &stream, const QTextListFormat &fmt)
{
    return stream << static_cast<const QTextFormat &>(fmt);
}
 
Q_GUI_EXPORT QDataStream &operator>>(QDataStream &stream, QTextListFormat &fmt)
{
    return stream >> static_cast<QTextFormat &>(fmt);
}
 
Q_GUI_EXPORT QDataStream &operator<<(QDataStream &stream, const QTextFrameFormat &fmt)
{
    return stream << static_cast<const QTextFormat &>(fmt);
}
 
Q_GUI_EXPORT QDataStream &operator>>(QDataStream &stream, QTextFrameFormat &fmt)
{
    return stream >> static_cast<QTextFormat &>(fmt);
}
 
Q_GUI_EXPORT QDataStream &operator<<(QDataStream &stream, const QTextTableCellFormat &fmt)
{
    return stream << static_cast<const QTextFormat &>(fmt);
}
 
Q_GUI_EXPORT QDataStream &operator>>(QDataStream &stream, QTextTableCellFormat &fmt)
{
    return stream >> static_cast<QTextFormat &>(fmt);
}
#endif // QT_NO_DATASTREAM
 
QTextFormat::QTextFormat()
    : format_type(InvalidFormat)
{
}
 
QTextFormat::QTextFormat(int type)
    : format_type(type)
{
}
 
 
QTextFormat::QTextFormat(const QTextFormat &rhs)
    : d(rhs.d), format_type(rhs.format_type)
{
}
 
QTextFormat &QTextFormat::operator=(const QTextFormat &rhs)
{
    d = rhs.d;
    format_type = rhs.format_type;
    return *this;
}
 
QTextFormat::~QTextFormat()
{
}
 
 
QTextFormat::operator QVariant() const
{
    return QVariant::fromValue(*this);
}
 
void QTextFormat::merge(const QTextFormat &other)
{
    if (format_type != other.format_type)
        return;
 
    if (!d) {
        d = other.d;
        return;
    }
 
    if (!other.d)
        return;
 
    QTextFormatPrivate *p = d.data();
 
    const QList<QT_PREPEND_NAMESPACE(Property)> &otherProps = other.d.constData()->props;
    p->props.reserve(p->props.size() + otherProps.size());
    for (int i = 0; i < otherProps.size(); ++i) {
        const QT_PREPEND_NAMESPACE(Property) &prop = otherProps.at(i);
        p->insertProperty(prop.key, prop.value);
    }
}
 
int QTextFormat::type() const
{
    return format_type;
}
 
QTextBlockFormat QTextFormat::toBlockFormat() const
{
    return QTextBlockFormat(*this);
}
 
QTextCharFormat QTextFormat::toCharFormat() const
{
    return QTextCharFormat(*this);
}
 
QTextListFormat QTextFormat::toListFormat() const
{
    return QTextListFormat(*this);
}
 
QTextTableFormat QTextFormat::toTableFormat() const
{
    return QTextTableFormat(*this);
}
 
QTextFrameFormat QTextFormat::toFrameFormat() const
{
    return QTextFrameFormat(*this);
}
 
QTextImageFormat QTextFormat::toImageFormat() const
{
    return QTextImageFormat(*this);
}
 
QTextTableCellFormat QTextFormat::toTableCellFormat() const
{
    return QTextTableCellFormat(*this);
}
 
bool QTextFormat::boolProperty(int propertyId) const
{
    if (!d)
        return false;
    const QVariant prop = d->property(propertyId);
    if (prop.userType() != QMetaType::Bool)
        return false;
    return prop.toBool();
}
 
int QTextFormat::intProperty(int propertyId) const
{
    // required, since the default layout direction has to be LayoutDirectionAuto, which is not integer 0
    int def = (propertyId == QTextFormat::LayoutDirection) ? int(Qt::LayoutDirectionAuto) : 0;
 
    if (!d)
        return def;
    const QVariant prop = d->property(propertyId);
    if (prop.userType() != QMetaType::Int)
        return def;
    return prop.toInt();
}
 
qreal QTextFormat::doubleProperty(int propertyId) const
{
    if (!d)
        return 0.;
    const QVariant prop = d->property(propertyId);
    if (prop.userType() != QMetaType::Double && prop.userType() != QMetaType::Float)
        return 0.;
    return qvariant_cast<qreal>(prop);
}
 
QString QTextFormat::stringProperty(int propertyId) const
{
    if (!d)
        return QString();
    const QVariant prop = d->property(propertyId);
    if (prop.userType() != QMetaType::QString)
        return QString();
    return prop.toString();
}
 
QColor QTextFormat::colorProperty(int propertyId) const
{
    if (!d)
        return QColor();
    const QVariant prop = d->property(propertyId);
    if (prop.userType() != QMetaType::QColor)
        return QColor();
    return qvariant_cast<QColor>(prop);
}
 
QPen QTextFormat::penProperty(int propertyId) const
{
    if (!d)
        return QPen(Qt::NoPen);
    const QVariant prop = d->property(propertyId);
    if (prop.userType() != QMetaType::QPen)
        return QPen(Qt::NoPen);
    return qvariant_cast<QPen>(prop);
}
 
QBrush QTextFormat::brushProperty(int propertyId) const
{
    if (!d)
        return QBrush(Qt::NoBrush);
    const QVariant prop = d->property(propertyId);
    if (prop.userType() != QMetaType::QBrush)
        return QBrush(Qt::NoBrush);
    return qvariant_cast<QBrush>(prop);
}
 
QTextLength QTextFormat::lengthProperty(int propertyId) const
{
    if (!d)
        return QTextLength();
    return qvariant_cast<QTextLength>(d->property(propertyId));
}
 
QList<QTextLength> QTextFormat::lengthVectorProperty(int propertyId) const
{
    QList<QTextLength> list;
    if (!d)
        return list;
    const QVariant prop = d->property(propertyId);
    if (prop.userType() != QMetaType::QVariantList)
        return list;
 
    const QList<QVariant> propertyList = prop.toList();
    for (const auto &var : propertyList) {
        if (var.userType() == QMetaType::QTextLength)
            list.append(qvariant_cast<QTextLength>(var));
    }
 
    return list;
}
 
QVariant QTextFormat::property(int propertyId) const
{
    return d ? d->property(propertyId) : QVariant();
}
 
void QTextFormat::setProperty(int propertyId, const QVariant &value)
{
    if (!d)
        d = new QTextFormatPrivate;
    if (!value.isValid())
        clearProperty(propertyId);
    else
        d->insertProperty(propertyId, value);
}
 
void QTextFormat::setProperty(int propertyId, const QList<QTextLength> &value)
{
    if (!d)
        d = new QTextFormatPrivate;
    QVariantList list;
    const int numValues = value.size();
    list.reserve(numValues);
    for (int i = 0; i < numValues; ++i)
        list << value.at(i);
    d->insertProperty(propertyId, list);
}
 
void QTextFormat::clearProperty(int propertyId)
{
    if (!d)
        return;
    d->clearProperty(propertyId);
}
 
 
int QTextFormat::objectIndex() const
{
    if (!d)
        return -1;
    const QVariant prop = d->property(ObjectIndex);
    if (prop.userType() != QMetaType::Int) // ####
        return -1;
    return prop.toInt();
}
 
void QTextFormat::setObjectIndex(int o)
{
    if (o == -1) {
        if (d.constData())
            d->clearProperty(ObjectIndex);
    } else {
        if (!d.constData())
            d = new QTextFormatPrivate;
        // ### type
        d->insertProperty(ObjectIndex, o);
    }
}
 
bool QTextFormat::hasProperty(int propertyId) const
{
    return d ? d->hasProperty(propertyId) : false;
}
 
/*
    Returns the property type for the given \a propertyId.
 
    \sa hasProperty(), allPropertyIds(), Property
*/
 
QMap<int, QVariant> QTextFormat::properties() const
{
    QMap<int, QVariant> map;
    if (d) {
        for (int i = 0; i < d->props.size(); ++i)
            map.insert(d->props.at(i).key, d->props.at(i).value);
    }
    return map;
}
 
int QTextFormat::propertyCount() const
{
    return d ? d->props.size() : 0;
}
 
bool QTextFormat::operator==(const QTextFormat &rhs) const
{
    if (format_type != rhs.format_type)
        return false;
 
    if (d == rhs.d)
        return true;
 
    if (d && d->props.isEmpty() && !rhs.d)
        return true;
 
    if (!d && rhs.d && rhs.d->props.isEmpty())
        return true;
 
    if (!d || !rhs.d)
        return false;
 
    return *d == *rhs.d;
}
 
QTextCharFormat::QTextCharFormat() : QTextFormat(CharFormat) {}
 
QTextCharFormat::QTextCharFormat(const QTextFormat &fmt)
 : QTextFormat(fmt)
{
}
 
#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)
#else
/* // Qt 7 documents this function
    \fn QStringList QTextCharFormat::fontFamilies() const
    \since 5.13
 
    Returns the text format's font families.
 
    \sa font()
*/
#endif
 
#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)
#else
/* // Qt 7 documents this function
    \fn QStringList QTextCharFormat::fontStyleName() const
    \since 5.13
 
    Returns the text format's font style name.
 
    \sa font(), QFont::styleName()
*/
#endif
 
bool QTextCharFormat::fontUnderline() const
{
    if (hasProperty(TextUnderlineStyle))
        return underlineStyle() == SingleUnderline;
    return boolProperty(FontUnderline);
}
 
void QTextCharFormat::setUnderlineStyle(UnderlineStyle style)
{
    setProperty(TextUnderlineStyle, style);
    // for compatibility
    setProperty(FontUnderline, style == SingleUnderline);
}
 
QStringList QTextCharFormat::anchorNames() const
{
    QVariant prop = property(AnchorName);
    if (prop.userType() == QMetaType::QStringList)
        return prop.toStringList();
    else if (prop.userType() != QMetaType::QString)
        return QStringList();
    return QStringList(prop.toString());
}
 
 
void QTextCharFormat::setFont(const QFont &font, FontPropertiesInheritanceBehavior behavior)
{
    const uint mask = behavior == FontPropertiesAll ? uint(QFont::AllPropertiesResolved)
                                                    : font.resolveMask();
 
    if (mask & QFont::FamiliesResolved)
        setFontFamilies(font.families());
    if (mask & QFont::StyleNameResolved)
        setFontStyleName(font.styleName());
 
    if (mask & QFont::SizeResolved) {
        const qreal pointSize = font.pointSizeF();
        if (pointSize > 0) {
            setFontPointSize(pointSize);
        } else {
            const int pixelSize = font.pixelSize();
            if (pixelSize > 0)
                setProperty(QTextFormat::FontPixelSize, pixelSize);
        }
    }
 
    if (mask & QFont::WeightResolved)
        setFontWeight(font.weight());
    if (mask & QFont::StyleResolved)
        setFontItalic(font.style() != QFont::StyleNormal);
    if (mask & QFont::UnderlineResolved)
        setUnderlineStyle(font.underline() ? SingleUnderline : NoUnderline);
    if (mask & QFont::OverlineResolved)
        setFontOverline(font.overline());
    if (mask & QFont::StrikeOutResolved)
        setFontStrikeOut(font.strikeOut());
    if (mask & QFont::FixedPitchResolved)
        setFontFixedPitch(font.fixedPitch());
    if (mask & QFont::CapitalizationResolved)
        setFontCapitalization(font.capitalization());
    if (mask & QFont::WordSpacingResolved)
        setFontWordSpacing(font.wordSpacing());
    if (mask & QFont::LetterSpacingResolved) {
        setFontLetterSpacingType(font.letterSpacingType());
        setFontLetterSpacing(font.letterSpacing());
    }
    if (mask & QFont::StretchResolved)
        setFontStretch(font.stretch());
    if (mask & QFont::StyleHintResolved)
        setFontStyleHint(font.styleHint());
    if (mask & QFont::StyleStrategyResolved)
        setFontStyleStrategy(font.styleStrategy());
    if (mask & QFont::HintingPreferenceResolved)
        setFontHintingPreference(font.hintingPreference());
    if (mask & QFont::KerningResolved)
        setFontKerning(font.kerning());
}
 
QFont QTextCharFormat::font() const
{
    return d ? d->font() : QFont();
}
 
QTextBlockFormat::QTextBlockFormat() : QTextFormat(BlockFormat) {}
 
QTextBlockFormat::QTextBlockFormat(const QTextFormat &fmt)
 : QTextFormat(fmt)
{
}
 
void QTextBlockFormat::setTabPositions(const QList<QTextOption::Tab> &tabs)
{
    QList<QVariant> list;
    list.reserve(tabs.size());
    QList<QTextOption::Tab>::ConstIterator iter = tabs.constBegin();
    while (iter != tabs.constEnd()) {
        QVariant v;
        v.setValue(*iter);
        list.append(v);
        ++iter;
    }
    setProperty(TabPositions, list);
}
 
QList<QTextOption::Tab> QTextBlockFormat::tabPositions() const
{
    QVariant variant = property(TabPositions);
    if (variant.isNull())
        return QList<QTextOption::Tab>();
    QList<QTextOption::Tab> answer;
    QList<QVariant> variantsList = qvariant_cast<QList<QVariant> >(variant);
    QList<QVariant>::Iterator iter = variantsList.begin();
    answer.reserve(variantsList.size());
    while(iter != variantsList.end()) {
        answer.append( qvariant_cast<QTextOption::Tab>(*iter));
        ++iter;
    }
    return answer;
}
 
QTextListFormat::QTextListFormat()
    : QTextFormat(ListFormat)
{
    setIndent(1);
    setStart(1);
}
 
QTextListFormat::QTextListFormat(const QTextFormat &fmt)
 : QTextFormat(fmt)
{
}
 
QTextFrameFormat::QTextFrameFormat() : QTextFormat(FrameFormat)
{
    setBorderStyle(BorderStyle_Outset);
    setBorderBrush(Qt::darkGray);
}
 
QTextFrameFormat::QTextFrameFormat(const QTextFormat &fmt)
 : QTextFormat(fmt)
{
}
 
void QTextFrameFormat::setMargin(qreal amargin)
{
    setProperty(FrameMargin, amargin);
    setProperty(FrameTopMargin, amargin);
    setProperty(FrameBottomMargin, amargin);
    setProperty(FrameLeftMargin, amargin);
    setProperty(FrameRightMargin, amargin);
}
 
 
qreal QTextFrameFormat::topMargin() const
{
    if (!hasProperty(FrameTopMargin))
        return margin();
    return doubleProperty(FrameTopMargin);
}
 
qreal QTextFrameFormat::bottomMargin() const
{
    if (!hasProperty(FrameBottomMargin))
        return margin();
    return doubleProperty(FrameBottomMargin);
}
 
qreal QTextFrameFormat::leftMargin() const
{
    if (!hasProperty(FrameLeftMargin))
        return margin();
    return doubleProperty(FrameLeftMargin);
}
 
qreal QTextFrameFormat::rightMargin() const
{
    if (!hasProperty(FrameRightMargin))
        return margin();
    return doubleProperty(FrameRightMargin);
}
 
QTextTableFormat::QTextTableFormat()
 : QTextFrameFormat()
{
    setObjectType(TableObject);
    setCellSpacing(2);
    setBorder(1);
}
 
QTextTableFormat::QTextTableFormat(const QTextFormat &fmt)
 : QTextFrameFormat(fmt)
{
}
 
QTextImageFormat::QTextImageFormat() : QTextCharFormat() { setObjectType(ImageObject); }
 
QTextImageFormat::QTextImageFormat(const QTextFormat &fmt)
 : QTextCharFormat(fmt)
{
}
 
QTextTableCellFormat::QTextTableCellFormat()
    : QTextCharFormat()
{
    setObjectType(TableCellObject);
}
 
QTextTableCellFormat::QTextTableCellFormat(const QTextFormat &fmt)
    : QTextCharFormat(fmt)
{
}
 
// ------------------------------------------------------
 
QTextFormatCollection::~QTextFormatCollection()
{
}
 
void QTextFormatCollection::clear()
{
    formats.clear();
    objFormats.clear();
    hashes.clear();
}
 
int QTextFormatCollection::indexForFormat(const QTextFormat &format)
{
    size_t hash = getHash(format.d, format.format_type);
    auto i = hashes.constFind(hash);
    while (i != hashes.constEnd() && i.key() == hash) {
        if (formats.value(i.value()) == format) {
            return i.value();
        }
        ++i;
    }
 
    int idx = formats.size();
    formats.append(format);
 
    QT_TRY{
        QTextFormat &f = formats.last();
        if (!f.d)
            f.d = new QTextFormatPrivate;
        f.d->resolveFont(defaultFnt);
 
        hashes.insert(hash, idx);
 
    } QT_CATCH(...) {
        formats.pop_back();
        QT_RETHROW;
    }
    return idx;
}
 
bool QTextFormatCollection::hasFormatCached(const QTextFormat &format) const
{
    size_t hash = getHash(format.d, format.format_type);
    auto i = hashes.constFind(hash);
    while (i != hashes.constEnd() && i.key() == hash) {
        if (formats.value(i.value()) == format) {
            return true;
        }
        ++i;
    }
    return false;
}
 
int QTextFormatCollection::objectFormatIndex(int objectIndex) const
{
    if (objectIndex == -1)
        return -1;
    return objFormats.at(objectIndex);
}
 
void QTextFormatCollection::setObjectFormatIndex(int objectIndex, int formatIndex)
{
    objFormats[objectIndex] = formatIndex;
}
 
int QTextFormatCollection::createObjectIndex(const QTextFormat &f)
{
    const int objectIndex = objFormats.size();
    objFormats.append(indexForFormat(f));
    return objectIndex;
}
 
QTextFormat QTextFormatCollection::format(int idx) const
{
    if (idx < 0 || idx >= formats.size())
        return QTextFormat();
 
    return formats.at(idx);
}
 
void QTextFormatCollection::setDefaultFont(const QFont &f)
{
    defaultFnt = f;
    for (int i = 0; i < formats.size(); ++i)
        if (formats.at(i).d)
            formats[i].d->resolveFont(defaultFnt);
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QTextLength &l)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QTextLength(QTextLength::Type(" << l.type() << "))";
    return dbg;
}
 
QDebug operator<<(QDebug dbg, const QTextFormat &f)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QTextFormat(QTextFormat::FormatType(" << f.type() << "))";
    return dbg;
}
 
#endif
 
QT_END_NAMESPACE
 
#include "moc_qtextformat.cpp"