--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/gui/text/qtextformat.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,3120 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** 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 &);
+};
+
+static uint variantHash(const QVariant &variant)
+{
+ switch (variant.userType()) {
+ case QVariant::Invalid: return 0;
+ case QVariant::Bool: return variant.toBool();
+ case QVariant::Int: return variant.toInt();
+ case QMetaType::Float: return static_cast<int>(variant.toFloat());
+ case QVariant::Double: return static_cast<int>(variant.toDouble());
+ case QVariant::String: return qHash(variant.toString());
+ case QVariant::Color: return qHash(qvariant_cast<QColor>(variant).rgb());
+ default: break;
+ }
+ return qHash(variant.typeName());
+}
+
+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
+
+ \value BlockAlignment
+ \value BlockTopMargin
+ \value BlockBottomMargin
+ \value BlockLeftMargin
+ \value BlockRightMargin
+ \value TextIndent
+ \value TabPositions Specifies the tab positions. The tab positions are structs of QTextOption::Tab which are stored in
+ a QList (internally, in a QList<QVariant>).
+ \value BlockIndent
+ \value BlockNonBreakableLines
+ \value BlockTrailingHorizontalRulerWidth The width of a horizontal ruler element.
+
+ Character properties
+
+ \value FontFamily
+ \value FontPointSize
+ \value FontPixelSize
+ \value FontSizeAdjustment Specifies the change in size given to the fontsize already set using
+ FontPointSize or FontPixelSize.
+ \value FontFixedPitch
+ \omitvalue FontSizeIncrement
+ \value FontWeight
+ \value FontItalic
+ \value FontUnderline \e{This property has been deprecated.} Use QTextFormat::TextUnderlineStyle instead.
+ \value FontOverline
+ \value FontStrikeOut
+ \value FontCapitalization Specifies the capitalization type that is to be applied to the text.
+ \value FontLetterSpacing Changes the default spacing between individual letters in the font. The value is
+ specified in percentage, with 100 as the default value.
+ \value FontWordSpacing Changes the default spacing between individual words. A positive value increases the word spacing
+ by the corresponding pixels; a negative value decreases the spacing.
+ \value FontStyleHint Corresponds to the QFont::StyleHint property
+ \value FontStyleStrategy Corresponds to the QFont::StyleStrategy property
+ \value FontKerning Specifies whether the font has kerning turned on.
+
+ \omitvalue FirstFontProperty
+ \omitvalue LastFontProperty
+
+ \value TextUnderlineColor
+ \value TextVerticalAlignment
+ \value TextOutline
+ \value TextUnderlineStyle
+ \value TextToolTip Specifies the (optional) tool tip to be displayed for a fragment of text.
+
+ \value IsAnchor
+ \value AnchorHref
+ \value AnchorName
+ \value ObjectType
+
+ List properties
+
+ \value ListStyle
+ \value ListIndent
+
+ Table and frame properties
+
+ \value FrameBorder
+ \value FrameBorderBrush
+ \value FrameBorderStyle See the \l{QTextFrameFormat::BorderStyle}{BorderStyle} enum.
+ \value FrameBottomMargin
+ \value FrameHeight
+ \value FrameLeftMargin
+ \value FrameMargin
+ \value FramePadding
+ \value FrameRightMargin
+ \value FrameTopMargin
+ \value FrameWidth
+ \value TableCellSpacing
+ \value TableCellPadding
+ \value TableColumns
+ \value TableColumnWidthConstraints
+ \value TableHeaderRowCount
+
+ Table cell properties
+
+ \value TableCellRowSpan
+ \value TableCellColumnSpan
+ \value TableCellLeftPadding
+ \value TableCellRightPadding
+ \value TableCellTopPadding
+ \value TableCellBottomPadding
+
+ Image properties
+
+ \value ImageName
+ \value ImageWidth
+ \value ImageHeight
+
+ Selection properties
+
+ \value FullWidthSelection When set on the characterFormat of a selection,
+ the whole width of the text will be shown selected.
+
+ Page break properties
+
+ \value PageBreakPolicy Specifies how pages are broken. See the PageBreakFlag enum.
+
+ \value UserProperty
+
+ \sa property(), setProperty()
+*/
+
+/*!
+ \enum QTextFormat::ObjectTypes
+
+ This enum describes what kind of QTextObject this format is associated with.
+
+ \value NoObject
+ \value ImageObject
+ \value TableObject
+ \value TableCellObject
+ \value UserObject The first object that can be used for application-specific purposes.
+
+ \sa QTextObject, QTextTable, QTextObject::format()
+*/
+
+/*!
+ \enum QTextFormat::PageBreakFlag
+ \since 4.2
+
+ This enum describes how page breaking is performed when printing. It maps to the
+ corresponding css properties.
+
+ \value PageBreak_Auto The page break is determined automatically depending on the
+ available space on the current page
+ \value PageBreak_AlwaysBefore The page is always broken before the paragraph/table
+ \value PageBreak_AlwaysAfter A new page is always started after the paragraph/table
+
+ \sa QTextBlockFormat::pageBreakPolicy(), QTextFrameFormat::pageBreakPolicy(),
+ PageBreakPolicy
+*/
+
+/*!
+ \fn bool QTextFormat::isValid() const
+
+ Returns true if the format is valid (i.e. is not
+ InvalidFormat); otherwise returns false.
+*/
+
+/*!
+ \fn bool QTextFormat::isCharFormat() const
+
+ Returns true if this text format is a \c CharFormat; otherwise
+ returns false.
+*/
+
+
+/*!
+ \fn bool QTextFormat::isBlockFormat() const
+
+ Returns true if this text format is a \c BlockFormat; otherwise
+ returns false.
+*/
+
+
+/*!
+ \fn bool QTextFormat::isListFormat() const
+
+ Returns true if this text format is a \c ListFormat; otherwise
+ returns false.
+*/
+
+
+/*!
+ \fn bool QTextFormat::isTableFormat() const
+
+ Returns true if this text format is a \c TableFormat; otherwise
+ returns false.
+*/
+
+
+/*!
+ \fn bool QTextFormat::isFrameFormat() const
+
+ Returns true if this text format is a \c FrameFormat; otherwise
+ returns false.
+*/
+
+
+/*!
+ \fn bool QTextFormat::isImageFormat() const
+
+ Returns true if this text format is an image format; otherwise
+ returns false.
+*/
+
+
+/*!
+ \fn bool QTextFormat::isTableCellFormat() const
+ \since 4.4
+
+ Returns true if this text format is a \c TableCellFormat; otherwise
+ returns false.
+*/
+
+
+/*!
+ Creates a new text format with an \c InvalidFormat.
+
+ \sa FormatType
+*/
+QTextFormat::QTextFormat()
+ : format_type(InvalidFormat)
+{
+}
+
+/*!
+ Creates a new text format of the given \a type.
+
+ \sa FormatType
+*/
+QTextFormat::QTextFormat(int type)
+ : format_type(type)
+{
+}
+
+
+/*!
+ \fn QTextFormat::QTextFormat(const QTextFormat &other)
+
+ Creates a new text format with the same attributes as the \a other
+ text format.
+*/
+QTextFormat::QTextFormat(const QTextFormat &rhs)
+ : d(rhs.d), format_type(rhs.format_type)
+{
+}
+
+/*!
+ \fn QTextFormat &QTextFormat::operator=(const QTextFormat &other)
+
+ Assigns the \a other text format to this text format, and returns a
+ reference to this text format.
+*/
+QTextFormat &QTextFormat::operator=(const QTextFormat &rhs)
+{
+ d = rhs.d;
+ format_type = rhs.format_type;
+ return *this;
+}
+
+/*!
+ Destroys this text format.
+*/
+QTextFormat::~QTextFormat()
+{
+}
+
+
+/*!
+ Returns the text format as a QVariant
+*/
+QTextFormat::operator QVariant() const
+{
+ return QVariant(QVariant::TextFormat, this);
+}
+
+/*!
+ Merges the \a other format with this format; where there are
+ conflicts the \a other format takes precedence.
+*/
+void QTextFormat::merge(const QTextFormat &other)
+{
+ if (format_type != other.format_type)
+ return;
+
+ if (!d) {
+ d = other.d;
+ return;
+ }
+
+ if (!other.d)
+ return;
+
+ QTextFormatPrivate *d = this->d;
+
+ const QVector<QTextFormatPrivate::Property> &otherProps = other.d->props;
+ d->props.reserve(d->props.size() + otherProps.size());
+ for (int i = 0; i < otherProps.count(); ++i) {
+ const QTextFormatPrivate::Property &p = otherProps.at(i);
+ d->insertProperty(p.key, p.value);
+ }
+}
+
+/*!
+ Returns the type of this format.
+
+ \sa FormatType
+*/
+int QTextFormat::type() const
+{
+ return format_type;
+}
+
+/*!
+ Returns this format as a block format.
+*/
+QTextBlockFormat QTextFormat::toBlockFormat() const
+{
+ return QTextBlockFormat(*this);
+}
+
+/*!
+ Returns this format as a character format.
+*/
+QTextCharFormat QTextFormat::toCharFormat() const
+{
+ return QTextCharFormat(*this);
+}
+
+/*!
+ Returns this format as a list format.
+*/
+QTextListFormat QTextFormat::toListFormat() const
+{
+ return QTextListFormat(*this);
+}
+
+/*!
+ Returns this format as a table format.
+*/
+QTextTableFormat QTextFormat::toTableFormat() const
+{
+ return QTextTableFormat(*this);
+}
+
+/*!
+ Returns this format as a frame format.
+*/
+QTextFrameFormat QTextFormat::toFrameFormat() const
+{
+ return QTextFrameFormat(*this);
+}
+
+/*!
+ Returns this format as an image format.
+*/
+QTextImageFormat QTextFormat::toImageFormat() const
+{
+ return QTextImageFormat(*this);
+}
+
+/*!
+ \since 4.4
+
+ Returns this format as a table cell format.
+*/
+QTextTableCellFormat QTextFormat::toTableCellFormat() const
+{
+ return QTextTableCellFormat(*this);
+}
+
+/*!
+ Returns the value of the property specified by \a propertyId. If the
+ property isn't of QTextFormat::Bool type, false is returned instead.
+
+ \sa setProperty() intProperty() doubleProperty() stringProperty() colorProperty() lengthProperty() lengthVectorProperty() Property
+*/
+bool QTextFormat::boolProperty(int propertyId) const
+{
+ if (!d)
+ return false;
+ const QVariant prop = d->property(propertyId);
+ if (prop.userType() != QVariant::Bool)
+ return false;
+ return prop.toBool();
+}
+
+/*!
+ Returns the value of the property specified by \a propertyId. If the
+ property is not of QTextFormat::Integer type, 0 is returned instead.
+
+ \sa setProperty() boolProperty() doubleProperty() stringProperty() colorProperty() lengthProperty() lengthVectorProperty() Property
+*/
+int QTextFormat::intProperty(int propertyId) const
+{
+ if (!d)
+ return 0;
+ const QVariant prop = d->property(propertyId);
+ if (prop.userType() != QVariant::Int)
+ return 0;
+ return prop.toInt();
+}
+
+/*!
+ Returns the value of the property specified by \a propertyId. If the
+ property isn't of QVariant::Double or QMetaType::Float type, 0 is
+ returned instead.
+
+ \sa setProperty() boolProperty() intProperty() stringProperty() colorProperty() lengthProperty() lengthVectorProperty() Property
+*/
+qreal QTextFormat::doubleProperty(int propertyId) const
+{
+ if (!d)
+ return 0.;
+ const QVariant prop = d->property(propertyId);
+ if (prop.userType() != QVariant::Double && prop.userType() != QMetaType::Float)
+ return 0.;
+ return qVariantValue<qreal>(prop);
+}
+
+/*!
+ Returns the value of the property given by \a propertyId; if the
+ property isn't of QVariant::String type, an empty string is
+ returned instead.
+
+ \sa setProperty() boolProperty() intProperty() doubleProperty() colorProperty() lengthProperty() lengthVectorProperty() Property
+*/
+QString QTextFormat::stringProperty(int propertyId) const
+{
+ if (!d)
+ return QString();
+ const QVariant prop = d->property(propertyId);
+ if (prop.userType() != QVariant::String)
+ return QString();
+ return prop.toString();
+}
+
+/*!
+ Returns the value of the property given by \a propertyId; if the
+ property isn't of QVariant::Color type, an invalid color is
+ returned instead.
+
+ \sa setProperty(), boolProperty(), intProperty(), doubleProperty(),
+ stringProperty(), lengthProperty(), lengthVectorProperty(), Property
+*/
+QColor QTextFormat::colorProperty(int propertyId) const
+{
+ if (!d)
+ return QColor();
+ const QVariant prop = d->property(propertyId);
+ if (prop.userType() != QVariant::Color)
+ return QColor();
+ return qvariant_cast<QColor>(prop);
+}
+
+/*!
+ Returns the value of the property given by \a propertyId; if the
+ property isn't of QVariant::Pen type, Qt::NoPen is
+ returned instead.
+
+ \sa setProperty() boolProperty() intProperty() doubleProperty() stringProperty() lengthProperty() lengthVectorProperty() Property
+*/
+QPen QTextFormat::penProperty(int propertyId) const
+{
+ if (!d)
+ return QPen(Qt::NoPen);
+ const QVariant prop = d->property(propertyId);
+ if (prop.userType() != QVariant::Pen)
+ return QPen(Qt::NoPen);
+ return qvariant_cast<QPen>(prop);
+}
+
+/*!
+ Returns the value of the property given by \a propertyId; if the
+ property isn't of QVariant::Brush type, Qt::NoBrush is
+ returned instead.
+
+ \sa setProperty() boolProperty() intProperty() doubleProperty() stringProperty() lengthProperty() lengthVectorProperty() Property
+*/
+QBrush QTextFormat::brushProperty(int propertyId) const
+{
+ if (!d)
+ return QBrush(Qt::NoBrush);
+ const QVariant prop = d->property(propertyId);
+ if (prop.userType() != QVariant::Brush)
+ return QBrush(Qt::NoBrush);
+ return qvariant_cast<QBrush>(prop);
+}
+
+/*!
+ Returns the value of the property given by \a propertyId.
+
+ \sa setProperty() boolProperty() intProperty() doubleProperty() stringProperty() colorProperty() lengthVectorProperty() Property
+*/
+QTextLength QTextFormat::lengthProperty(int propertyId) const
+{
+ if (!d)
+ return QTextLength();
+ return qvariant_cast<QTextLength>(d->property(propertyId));
+}
+
+/*!
+ Returns the value of the property given by \a propertyId. If the
+ property isn't of QTextFormat::LengthVector type, an empty length
+ vector is returned instead.
+
+ \sa setProperty() boolProperty() intProperty() doubleProperty() stringProperty() colorProperty() lengthProperty() Property
+*/
+QVector<QTextLength> QTextFormat::lengthVectorProperty(int propertyId) const
+{
+ QVector<QTextLength> vector;
+ if (!d)
+ return vector;
+ const QVariant prop = d->property(propertyId);
+ if (prop.userType() != QVariant::List)
+ return vector;
+
+ QList<QVariant> propertyList = prop.toList();
+ for (int i=0; i<propertyList.size(); ++i) {
+ QVariant var = propertyList.at(i);
+ if (var.userType() == QVariant::TextLength)
+ vector.append(qvariant_cast<QTextLength>(var));
+ }
+
+ return vector;
+}
+
+/*!
+ Returns the property specified by the given \a propertyId.
+
+ \sa Property
+*/
+QVariant QTextFormat::property(int propertyId) const
+{
+ return d ? d->property(propertyId) : QVariant();
+}
+
+/*!
+ Sets the property specified by the \a propertyId to the given \a value.
+
+ \sa Property
+*/
+void QTextFormat::setProperty(int propertyId, const QVariant &value)
+{
+ if (!d)
+ d = new QTextFormatPrivate;
+ if (!value.isValid())
+ clearProperty(propertyId);
+ else
+ d->insertProperty(propertyId, value);
+}
+
+/*!
+ Sets the value of the property given by \a propertyId to \a value.
+
+ \sa lengthVectorProperty() Property
+*/
+void QTextFormat::setProperty(int propertyId, const QVector<QTextLength> &value)
+{
+ if (!d)
+ d = new QTextFormatPrivate;
+ QVariantList list;
+ for (int i=0; i<value.size(); ++i)
+ list << value.at(i);
+ d->insertProperty(propertyId, list);
+}
+
+/*!
+ Clears the value of the property given by \a propertyId
+
+ \sa Property
+*/
+void QTextFormat::clearProperty(int propertyId)
+{
+ if (!d)
+ return;
+ d->clearProperty(propertyId);
+}
+
+
+/*!
+ \fn void QTextFormat::setObjectType(int type)
+
+ Sets the text format's object type to \a type.
+
+ \sa ObjectTypes, objectType()
+*/
+
+
+/*!
+ \fn int QTextFormat::objectType() const
+
+ Returns the text format's object type.
+
+ \sa ObjectTypes, setObjectType()
+*/
+
+
+/*!
+ Returns the index of the format object, or -1 if the format object is invalid.
+
+ \sa setObjectIndex()
+*/
+int QTextFormat::objectIndex() const
+{
+ if (!d)
+ return -1;
+ const QVariant prop = d->property(ObjectIndex);
+ if (prop.userType() != QVariant::Int) // ####
+ return -1;
+ return prop.toInt();
+}
+
+/*!
+ \fn void QTextFormat::setObjectIndex(int index)
+
+ Sets the format object's object \a index.
+
+ \sa objectIndex()
+*/
+void QTextFormat::setObjectIndex(int o)
+{
+ if (o == -1) {
+ if (d)
+ d->clearProperty(ObjectIndex);
+ } else {
+ if (!d)
+ d = new QTextFormatPrivate;
+ // ### type
+ d->insertProperty(ObjectIndex, o);
+ }
+}
+
+/*!
+ Returns true if the text format has a property with the given \a
+ propertyId; otherwise returns false.
+
+ \sa properties() Property
+*/
+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
+*/
+
+/*!
+ Returns a map with all properties of this text format.
+*/
+QMap<int, QVariant> QTextFormat::properties() const
+{
+ QMap<int, QVariant> map;
+ if (d) {
+ for (int i = 0; i < d->props.count(); ++i)
+ map.insert(d->props.at(i).key, d->props.at(i).value);
+ }
+ return map;
+}
+
+/*!
+ \since 4.3
+ Returns the number of properties stored in the format.
+*/
+int QTextFormat::propertyCount() const
+{
+ return d ? d->props.count() : 0;
+}
+
+/*!
+ \fn bool QTextFormat::operator!=(const QTextFormat &other) const
+
+ Returns true if this text format is different from the \a other text
+ format.
+*/
+
+
+/*!
+ \fn bool QTextFormat::operator==(const QTextFormat &other) const
+
+ Returns true if this text format is the same as the \a other text
+ format.
+*/
+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;
+}
+
+/*!
+ \class QTextCharFormat
+ \reentrant
+
+ \brief The QTextCharFormat class provides formatting information for
+ characters in a QTextDocument.
+
+ \ingroup richtext-processing
+
+ The character format of text in a document specifies the visual properties
+ of the text, as well as information about its role in a hypertext document.
+
+ The font used can be set by supplying a font to the setFont() function, and
+ each aspect of its appearance can be adjusted to give the desired effect.
+ setFontFamily() and setFontPointSize() define the font's family (e.g. Times)
+ and printed size; setFontWeight() and setFontItalic() provide control over
+ the style of the font. setFontUnderline(), setFontOverline(),
+ setFontStrikeOut(), and setFontFixedPitch() provide additional effects for
+ text.
+
+ The color is set with setForeground(). If the text is intended to be used
+ as an anchor (for hyperlinks), this can be enabled with setAnchor(). The
+ setAnchorHref() and setAnchorNames() functions are used to specify the
+ information about the hyperlink's destination and the anchor's name.
+
+ \sa QTextFormat QTextBlockFormat QTextTableFormat QTextListFormat
+*/
+
+/*!
+ \enum QTextCharFormat::VerticalAlignment
+
+ This enum describes the ways that adjacent characters can be vertically
+ aligned.
+
+ \value AlignNormal Adjacent characters are positioned in the standard
+ way for text in the writing system in use.
+ \value AlignSuperScript Characters are placed above the baseline for
+ normal text.
+ \value AlignSubScript Characters are placed below the baseline for
+ normal text.
+ \value AlignMiddle The center of the object is vertically aligned with the base line.
+ Currently, this is only implemented for inline objects.
+ \value AlignBottom The bottom edge of the object is vertically aligned with
+ the base line.
+ \value AlignTop The top edge of the object is vertically aligned with
+ the base line.
+*/
+
+/*!
+ \enum QTextCharFormat::UnderlineStyle
+
+ This enum describes the different ways drawing underlined text.
+
+ \value NoUnderline Text is draw without any underlining decoration.
+ \value SingleUnderline A line is drawn using Qt::SolidLine.
+ \value DashUnderline Dashes are drawn using Qt::DashLine.
+ \value DotLine Dots are drawn using Qt::DotLine;
+ \value DashDotLine Dashs and dots are drawn using Qt::DashDotLine.
+ \value DashDotDotLine Underlines draw drawn using Qt::DashDotDotLine.
+ \value WaveUnderline The text is underlined using a wave shaped line.
+ \value SpellCheckUnderline The underline is drawn depending on the QStyle::SH_SpellCeckUnderlineStyle
+ style hint of the QApplication style. By default this is mapped to
+ WaveUnderline, on Mac OS X it is mapped to DashDotLine.
+
+ \sa Qt::PenStyle
+*/
+
+/*!
+ \fn QTextCharFormat::QTextCharFormat()
+
+ Constructs a new character format object.
+*/
+QTextCharFormat::QTextCharFormat() : QTextFormat(CharFormat) {}
+
+/*!
+ \internal
+ \fn QTextCharFormat::QTextCharFormat(const QTextFormat &other)
+
+ Creates a new character format with the same attributes as the \a given
+ text format.
+*/
+QTextCharFormat::QTextCharFormat(const QTextFormat &fmt)
+ : QTextFormat(fmt)
+{
+}
+
+/*!
+ \fn bool QTextCharFormat::isValid() const
+
+ Returns true if this character format is valid; otherwise returns
+ false.
+*/
+
+
+/*!
+ \fn void QTextCharFormat::setFontFamily(const QString &family)
+
+ Sets the text format's font \a family.
+
+ \sa setFont()
+*/
+
+
+/*!
+ \fn QString QTextCharFormat::fontFamily() const
+
+ Returns the text format's font family.
+
+ \sa font()
+*/
+
+
+/*!
+ \fn void QTextCharFormat::setFontPointSize(qreal size)
+
+ Sets the text format's font \a size.
+
+ \sa setFont()
+*/
+
+
+/*!
+ \fn qreal QTextCharFormat::fontPointSize() const
+
+ Returns the font size used to display text in this format.
+
+ \sa font()
+*/
+
+
+/*!
+ \fn void QTextCharFormat::setFontWeight(int weight)
+
+ Sets the text format's font weight to \a weight.
+
+ \sa setFont(), QFont::Weight
+*/
+
+
+/*!
+ \fn int QTextCharFormat::fontWeight() const
+
+ Returns the text format's font weight.
+
+ \sa font(), QFont::Weight
+*/
+
+
+/*!
+ \fn void QTextCharFormat::setFontItalic(bool italic)
+
+ If \a italic is true, sets the text format's font to be italic; otherwise
+ the font will be non-italic.
+
+ \sa setFont()
+*/
+
+
+/*!
+ \fn bool QTextCharFormat::fontItalic() const
+
+ Returns true if the text format's font is italic; otherwise
+ returns false.
+
+ \sa font()
+*/
+
+
+/*!
+ \fn void QTextCharFormat::setFontUnderline(bool underline)
+
+ If \a underline is true, sets the text format's font to be underlined;
+ otherwise it is displayed non-underlined.
+
+ \sa setFont()
+*/
+
+
+/*!
+ \fn bool QTextCharFormat::fontUnderline() const
+
+ Returns true if the text format's font is underlined; otherwise
+ returns false.
+
+ \sa font()
+*/
+bool QTextCharFormat::fontUnderline() const
+{
+ if (hasProperty(TextUnderlineStyle))
+ return underlineStyle() == SingleUnderline;
+ return boolProperty(FontUnderline);
+}
+
+/*!
+ \fn UnderlineStyle QTextCharFormat::underlineStyle() const
+ \since 4.2
+
+ Returns the style of underlining the text.
+*/
+
+/*!
+ \fn void QTextCharFormat::setUnderlineStyle(UnderlineStyle style)
+ \since 4.2
+
+ Sets the style of underlining the text to \a style.
+*/
+void QTextCharFormat::setUnderlineStyle(UnderlineStyle style)
+{
+ setProperty(TextUnderlineStyle, style);
+ // for compatibility
+ setProperty(FontUnderline, style == SingleUnderline);
+}
+
+/*!
+ \fn void QTextCharFormat::setFontOverline(bool overline)
+
+ If \a overline is true, sets the text format's font to be overlined;
+ otherwise the font is displayed non-overlined.
+
+ \sa setFont()
+*/
+
+
+/*!
+ \fn bool QTextCharFormat::fontOverline() const
+
+ Returns true if the text format's font is overlined; otherwise
+ returns false.
+
+ \sa font()
+*/
+
+
+/*!
+ \fn void QTextCharFormat::setFontStrikeOut(bool strikeOut)
+
+ If \a strikeOut is true, sets the text format's font with strike-out
+ enabled (with a horizontal line through it); otherwise it is displayed
+ without strikeout.
+
+ \sa setFont()
+*/
+
+
+/*!
+ \fn bool QTextCharFormat::fontStrikeOut() const
+
+ Returns true if the text format's font is struck out (has a horizontal line
+ drawn through it); otherwise returns false.
+
+ \sa font()
+*/
+
+
+/*!
+ \since 4.5
+ \fn void QTextCharFormat::setFontStyleHint(QFont::StyleHint hint, QFont::StyleStrategy strategy)
+
+ Sets the font style \a hint and \a strategy.
+
+ Qt does not support style hints on X11 since this information is not provided by the window system.
+
+ \sa setFont()
+ \sa QFont::setStyleHint()
+*/
+
+
+/*!
+ \since 4.5
+ \fn void QTextCharFormat::setFontStyleStrategy(QFont::StyleStrategy strategy)
+
+ Sets the font style \a strategy.
+
+ \sa setFont()
+ \sa QFont::setStyleStrategy()
+*/
+
+
+/*!
+ \since 4.5
+ \fn void QTextCharFormat::setFontKerning(bool enable)
+ Enables kerning for this font if \a enable is true; otherwise disables it.
+
+ When kerning is enabled, glyph metrics do not add up anymore, even for
+ Latin text. In other words, the assumption that width('a') + width('b')
+ is equal to width("ab") is not neccesairly true.
+
+ \sa setFont()
+*/
+
+
+/*!
+ \fn QTextCharFormat::StyleHint QTextCharFormat::fontStyleHint() const
+ \since 4.5
+
+ Returns the font style hint.
+
+ \sa setFontStyleHint(), font()
+*/
+
+
+/*!
+ \since 4.5
+ \fn QTextCharFormat::StyleStrategy QTextCharFormat::fontStyleStrategy() const
+
+ Returns the current font style strategy.
+
+ \sa setFontStyleStrategy()
+ \sa font()
+*/
+
+
+/*!
+ \since 4.5
+ \fn bool QTextCharFormat::fontKerning() const
+ Returns true if the font kerning is enabled.
+
+ \sa setFontKerning()
+ \sa font()
+*/
+
+
+/*!
+ \fn void QTextCharFormat::setFontFixedPitch(bool fixedPitch)
+
+ If \a fixedPitch is true, sets the text format's font to be fixed pitch;
+ otherwise a non-fixed pitch font is used.
+
+ \sa setFont()
+*/
+
+
+/*!
+ \fn bool QTextCharFormat::fontFixedPitch() const
+
+ Returns true if the text format's font is fixed pitch; otherwise
+ returns false.
+
+ \sa font()
+*/
+
+
+/*!
+ \fn QPen QTextCharFormat::textOutline() const
+
+ Returns the pen used to draw the outlines of characters in this format.
+*/
+
+
+/*!
+ \fn void QTextCharFormat::setTextOutline(const QPen &pen)
+
+ Sets the pen used to draw the outlines of characters to the given \a pen.
+*/
+
+/*!
+ \fn void QTextCharFormat::setToolTip(const QString &text)
+ \since 4.3
+
+ Sets the tool tip for a fragment of text to the given \a text.
+*/
+
+/*!
+ \fn QString QTextCharFormat::toolTip() const
+ \since 4.3
+
+ Returns the tool tip that is displayed for a fragment of text.
+*/
+
+/*!
+ \fn void QTextFormat::setForeground(const QBrush &brush)
+
+ Sets the foreground brush to the specified \a brush. The foreground
+ brush is mostly used to render text.
+
+ \sa foreground() clearForeground() setBackground()
+*/
+
+
+/*!
+ \fn QBrush QTextFormat::foreground() const
+
+ Returns the brush used to render foreground details, such as text,
+ frame outlines, and table borders.
+
+ \sa setForeground() clearForeground() background()
+*/
+
+/*!
+ \fn void QTextFormat::clearForeground()
+
+ Clears the brush used to paint the document's foreground. The default
+ brush will be used.
+
+ \sa foreground() setForeground() clearBackground()
+*/
+
+
+/*!
+ \fn void QTextCharFormat::setAnchor(bool anchor)
+
+ If \a anchor is true, text with this format represents an anchor, and is
+ formatted in the appropriate way; otherwise the text is formatted normally.
+ (Anchors are hyperlinks which are often shown underlined and in a different
+ color from plain text.)
+
+ The way the text is rendered is independent of whether or not the format
+ has a valid anchor defined. Use setAnchorHref(), and optionally
+ setAnchorNames() to create a hypertext link.
+
+ \sa isAnchor()
+*/
+
+
+/*!
+ \fn bool QTextCharFormat::isAnchor() const
+
+ Returns true if the text is formatted as an anchor; otherwise
+ returns false.
+
+ \sa setAnchor() setAnchorHref() setAnchorNames()
+*/
+
+
+/*!
+ \fn void QTextCharFormat::setAnchorHref(const QString &value)
+
+ Sets the hypertext link for the text format to the given \a value.
+ This is typically a URL like "http://example.com/index.html".
+
+ The anchor will be displayed with the \a value as its display text;
+ if you want to display different text call setAnchorNames().
+
+ To format the text as a hypertext link use setAnchor().
+*/
+
+
+/*!
+ \fn QString QTextCharFormat::anchorHref() const
+
+ Returns the text format's hypertext link, or an empty string if
+ none has been set.
+*/
+
+
+/*!
+ \fn void QTextCharFormat::setAnchorName(const QString &name)
+ \obsolete
+
+ This function is deprecated. Use setAnchorNames() instead.
+
+ Sets the text format's anchor \a name. For the anchor to work as a
+ hyperlink, the destination must be set with setAnchorHref() and
+ the anchor must be enabled with setAnchor().
+*/
+
+/*!
+ \fn void QTextCharFormat::setAnchorNames(const QStringList &names)
+ \since 4.3
+
+ Sets the text format's anchor \a names. For the anchor to work as a
+ hyperlink, the destination must be set with setAnchorHref() and
+ the anchor must be enabled with setAnchor().
+*/
+
+/*!
+ \fn QString QTextCharFormat::anchorName() const
+ \obsolete
+
+ This function is deprecated. Use anchorNames() instead.
+
+ Returns the anchor name associated with this text format, or an empty
+ string if none has been set. If the anchor name is set, text with this
+ format can be the destination of a hypertext link.
+*/
+QString QTextCharFormat::anchorName() const
+{
+ QVariant prop = property(AnchorName);
+ if (prop.userType() == QVariant::StringList)
+ return prop.toStringList().value(0);
+ else if (prop.userType() != QVariant::String)
+ return QString();
+ return prop.toString();
+}
+
+/*!
+ \fn QStringList QTextCharFormat::anchorNames() const
+ \since 4.3
+
+ Returns the anchor names associated with this text format, or an empty
+ string list if none has been set. If the anchor names are set, text with this
+ format can be the destination of a hypertext link.
+*/
+QStringList QTextCharFormat::anchorNames() const
+{
+ QVariant prop = property(AnchorName);
+ if (prop.userType() == QVariant::StringList)
+ return prop.toStringList();
+ else if (prop.userType() != QVariant::String)
+ return QStringList();
+ return QStringList(prop.toString());
+}
+
+
+/*!
+ \fn void QTextCharFormat::setTableCellRowSpan(int tableCellRowSpan)
+ \internal
+
+ If this character format is applied to characters in a table cell,
+ the cell will span \a tableCellRowSpan rows.
+*/
+
+
+/*!
+ \fn int QTextCharFormat::tableCellRowSpan() const
+ \internal
+
+ If this character format is applied to characters in a table cell,
+ this function returns the number of rows spanned by the text (this may
+ be 1); otherwise it returns 1.
+*/
+
+/*!
+ \fn void QTextCharFormat::setTableCellColumnSpan(int tableCellColumnSpan)
+ \internal
+
+ If this character format is applied to characters in a table cell,
+ the cell will span \a tableCellColumnSpan columns.
+*/
+
+
+/*!
+ \fn int QTextCharFormat::tableCellColumnSpan() const
+ \internal
+
+ If this character format is applied to characters in a table cell,
+ this function returns the number of columns spanned by the text (this
+ may be 1); otherwise it returns 1.
+*/
+
+/*!
+ \fn void QTextCharFormat::setUnderlineColor(const QColor &color)
+
+ Sets the underline color used for the characters with this format to
+ the \a color specified.
+
+ \sa underlineColor()
+*/
+
+/*!
+ \fn QColor QTextCharFormat::underlineColor() const
+
+ Returns the color used to underline the characters with this format.
+
+ \sa setUnderlineColor()
+*/
+
+/*!
+ \fn void QTextCharFormat::setVerticalAlignment(VerticalAlignment alignment)
+
+ Sets the vertical alignment used for the characters with this format to
+ the \a alignment specified.
+
+ \sa verticalAlignment()
+*/
+
+/*!
+ \fn VerticalAlignment QTextCharFormat::verticalAlignment() const
+
+ Returns the vertical alignment used for characters with this format.
+
+ \sa setVerticalAlignment()
+*/
+
+/*!
+ Sets the text format's \a font.
+*/
+void QTextCharFormat::setFont(const QFont &font)
+{
+ setFontFamily(font.family());
+
+ const qreal pointSize = font.pointSizeF();
+ if (pointSize > 0) {
+ setFontPointSize(pointSize);
+ } else {
+ const int pixelSize = font.pixelSize();
+ if (pixelSize > 0)
+ setProperty(QTextFormat::FontPixelSize, pixelSize);
+ }
+
+ setFontWeight(font.weight());
+ setFontItalic(font.italic());
+ setUnderlineStyle(font.underline() ? SingleUnderline : NoUnderline);
+ setFontOverline(font.overline());
+ setFontStrikeOut(font.strikeOut());
+ setFontFixedPitch(font.fixedPitch());
+ setFontCapitalization(font.capitalization());
+ setFontWordSpacing(font.wordSpacing());
+ if (font.letterSpacingType() == QFont::PercentageSpacing)
+ setFontLetterSpacing(font.letterSpacing());
+ setFontStyleHint(font.styleHint());
+ setFontStyleStrategy(font.styleStrategy());
+ setFontKerning(font.kerning());
+}
+
+/*!
+ Returns the font for this character format.
+*/
+QFont QTextCharFormat::font() const
+{
+ return d ? d->font() : QFont();
+}
+
+/*!
+ \class QTextBlockFormat
+ \reentrant
+
+ \brief The QTextBlockFormat class provides formatting information for
+ blocks of text in a QTextDocument.
+
+ \ingroup richtext-processing
+
+ A document is composed of a list of blocks, represented by QTextBlock
+ objects. Each block can contain an item of some kind, such as a
+ paragraph of text, a table, a list, or an image. Every block has an
+ associated QTextBlockFormat that specifies its characteristics.
+
+ To cater for left-to-right and right-to-left languages you can set
+ a block's direction with setDirection(). Paragraph alignment is
+ set with setAlignment(). Margins are controlled by setTopMargin(),
+ setBottomMargin(), setLeftMargin(), setRightMargin(). Overall
+ indentation is set with setIndent(), the indentation of the first
+ line with setTextIndent().
+
+ Line breaking can be enabled and disabled with setNonBreakableLines().
+
+ The brush used to paint the paragraph's background
+ is set with \l{QTextFormat::setBackground()}{setBackground()}, and other
+ aspects of the text's appearance can be customized by using the
+ \l{QTextFormat::setProperty()}{setProperty()} function with the
+ \c OutlinePen, \c ForegroundBrush, and \c BackgroundBrush
+ \l{QTextFormat::Property} values.
+
+ If a text block is part of a list, it can also have a list format that
+ is accessible with the listFormat() function.
+
+ \sa QTextBlock, QTextCharFormat
+*/
+
+/*!
+ \fn QTextBlockFormat::QTextBlockFormat()
+
+ Constructs a new QTextBlockFormat.
+*/
+QTextBlockFormat::QTextBlockFormat() : QTextFormat(BlockFormat) {}
+
+/*!
+ \internal
+ \fn QTextBlockFormat::QTextBlockFormat(const QTextFormat &other)
+
+ Creates a new block format with the same attributes as the \a given
+ text format.
+*/
+QTextBlockFormat::QTextBlockFormat(const QTextFormat &fmt)
+ : QTextFormat(fmt)
+{
+}
+
+/*!
+ \since 4.4
+ Sets the tab positions for the text block to those specified by
+ \a tabs.
+
+ \sa tabPositions()
+*/
+void QTextBlockFormat::setTabPositions(const QList<QTextOption::Tab> &tabs)
+{
+ QList<QVariant> list;
+ QList<QTextOption::Tab>::ConstIterator iter = tabs.constBegin();
+ while (iter != tabs.constEnd()) {
+ QVariant v;
+ qVariantSetValue<QTextOption::Tab>(v, *iter);
+ list.append(v);
+ ++iter;
+ }
+ setProperty(TabPositions, list);
+}
+
+/*!
+ \since 4.4
+ Returns a list of tab positions defined for the text block.
+
+ \sa setTabPositions()
+*/
+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();
+ while(iter != variantsList.end()) {
+ answer.append( qVariantValue<QTextOption::Tab>(*iter));
+ ++iter;
+ }
+ return answer;
+}
+
+/*!
+ \fn QTextBlockFormat::isValid() const
+
+ Returns true if this block format is valid; otherwise returns
+ false.
+*/
+
+/*!
+ \fn void QTextFormat::setLayoutDirection(Qt::LayoutDirection direction)
+
+ Sets the document's layout direction to the specified \a direction.
+
+ \sa layoutDirection()
+*/
+
+
+/*!
+ \fn Qt::LayoutDirection QTextFormat::layoutDirection() const
+
+ Returns the document's layout direction.
+
+ \sa setLayoutDirection()
+*/
+
+
+/*!
+ \fn void QTextBlockFormat::setAlignment(Qt::Alignment alignment)
+
+ Sets the paragraph's \a alignment.
+
+ \sa alignment()
+*/
+
+
+/*!
+ \fn Qt::Alignment QTextBlockFormat::alignment() const
+
+ Returns the paragraph's alignment.
+
+ \sa setAlignment()
+*/
+
+
+/*!
+ \fn void QTextBlockFormat::setTopMargin(qreal margin)
+
+ Sets the paragraph's top \a margin.
+
+ \sa topMargin() setBottomMargin() setLeftMargin() setRightMargin()
+*/
+
+
+/*!
+ \fn qreal QTextBlockFormat::topMargin() const
+
+ Returns the paragraph's top margin.
+
+ \sa setTopMargin() bottomMargin()
+*/
+
+
+/*!
+ \fn void QTextBlockFormat::setBottomMargin(qreal margin)
+
+ Sets the paragraph's bottom \a margin.
+
+ \sa bottomMargin() setTopMargin() setLeftMargin() setRightMargin()
+*/
+
+
+/*!
+ \fn qreal QTextBlockFormat::bottomMargin() const
+
+ Returns the paragraph's bottom margin.
+
+ \sa setBottomMargin() topMargin()
+*/
+
+
+/*!
+ \fn void QTextBlockFormat::setLeftMargin(qreal margin)
+
+ Sets the paragraph's left \a margin. Indentation can be applied separately
+ with setIndent().
+
+ \sa leftMargin() setRightMargin() setTopMargin() setBottomMargin()
+*/
+
+
+/*!
+ \fn qreal QTextBlockFormat::leftMargin() const
+
+ Returns the paragraph's left margin.
+
+ \sa setLeftMargin() rightMargin() indent()
+*/
+
+
+/*!
+ \fn void QTextBlockFormat::setRightMargin(qreal margin)
+
+ Sets the paragraph's right \a margin.
+
+ \sa rightMargin() setLeftMargin() setTopMargin() setBottomMargin()
+*/
+
+
+/*!
+ \fn qreal QTextBlockFormat::rightMargin() const
+
+ Returns the paragraph's right margin.
+
+ \sa setRightMargin() leftMargin()
+*/
+
+
+/*!
+ \fn void QTextBlockFormat::setTextIndent(qreal indent)
+
+ Sets the \a indent for the first line in the block. This allows the first
+ line of a paragraph to be indented differently to the other lines,
+ enhancing the readability of the text.
+
+ \sa textIndent() setLeftMargin() setRightMargin() setTopMargin() setBottomMargin()
+*/
+
+
+/*!
+ \fn qreal QTextBlockFormat::textIndent() const
+
+ Returns the paragraph's text indent.
+
+ \sa setTextIndent()
+*/
+
+
+/*!
+ \fn void QTextBlockFormat::setIndent(int indentation)
+
+ Sets the paragraph's \a indentation. Margins are set independently of
+ indentation with setLeftMargin() and setTextIndent().
+ The \a indentation is an integer that is multiplied with the document-wide
+ standard indent, resulting in the actual indent of the paragraph.
+
+ \sa indent() QTextDocument::indentWidth()
+*/
+
+
+/*!
+ \fn int QTextBlockFormat::indent() const
+
+ Returns the paragraph's indent.
+
+ \sa setIndent()
+*/
+
+
+/*!
+ \fn void QTextBlockFormat::setNonBreakableLines(bool b)
+
+ If \a b is true, the lines in the paragraph are treated as
+ non-breakable; otherwise they are breakable.
+
+ \sa nonBreakableLines()
+*/
+
+
+/*!
+ \fn bool QTextBlockFormat::nonBreakableLines() const
+
+ Returns true if the lines in the paragraph are non-breakable;
+ otherwise returns false.
+
+ \sa setNonBreakableLines()
+*/
+
+/*!
+ \fn QTextFormat::PageBreakFlags QTextBlockFormat::pageBreakPolicy() const
+ \since 4.2
+
+ Returns the currently set page break policy for the paragraph. The default is
+ QTextFormat::PageBreak_Auto.
+
+ \sa setPageBreakPolicy()
+*/
+
+/*!
+ \fn void QTextBlockFormat::setPageBreakPolicy(PageBreakFlags policy)
+ \since 4.2
+
+ Sets the page break policy for the paragraph to \a policy.
+
+ \sa pageBreakPolicy()
+*/
+
+/*!
+ \class QTextListFormat
+ \reentrant
+
+ \brief The QTextListFormat class provides formatting information for
+ lists in a QTextDocument.
+
+ \ingroup richtext-processing
+
+ A list is composed of one or more items, represented as text blocks.
+ The list's format specifies the appearance of items in the list.
+ In particular, it determines the indentation and the style of each item.
+
+ The indentation of the items is an integer value that causes each item to
+ be offset from the left margin by a certain amount. This value is read with
+ indent() and set with setIndent().
+
+ The style used to decorate each item is set with setStyle() and can be read
+ with the style() function. The style controls the type of bullet points and
+ numbering scheme used for items in the list. Note that lists that use the
+ decimal numbering scheme begin counting at 1 rather than 0.
+
+ \sa QTextList
+*/
+
+/*!
+ \enum QTextListFormat::Style
+
+ This enum describes the symbols used to decorate list items:
+
+ \value ListDisc a filled circle
+ \value ListCircle an empty circle
+ \value ListSquare a filled square
+ \value ListDecimal decimal values in ascending order
+ \value ListLowerAlpha lower case Latin characters in alphabetical order
+ \value ListUpperAlpha upper case Latin characters in alphabetical order
+ \value ListLowerRoman lower case roman numerals (supports up to 4999 items only)
+ \value ListUpperRoman upper case roman numerals (supports up to 4999 items only)
+ \omitvalue ListStyleUndefined
+*/
+
+/*!
+ \fn QTextListFormat::QTextListFormat()
+
+ Constructs a new list format object.
+*/
+QTextListFormat::QTextListFormat()
+ : QTextFormat(ListFormat)
+{
+ setIndent(1);
+}
+
+/*!
+ \internal
+ \fn QTextListFormat::QTextListFormat(const QTextFormat &other)
+
+ Creates a new list format with the same attributes as the \a given
+ text format.
+*/
+QTextListFormat::QTextListFormat(const QTextFormat &fmt)
+ : QTextFormat(fmt)
+{
+}
+
+/*!
+ \fn bool QTextListFormat::isValid() const
+
+ Returns true if this list format is valid; otherwise
+ returns false.
+*/
+
+/*!
+ \fn void QTextListFormat::setStyle(Style style)
+
+ Sets the list format's \a style.
+
+ \sa style() Style
+*/
+
+/*!
+ \fn Style QTextListFormat::style() const
+
+ Returns the list format's style.
+
+ \sa setStyle() Style
+*/
+
+
+/*!
+ \fn void QTextListFormat::setIndent(int indentation)
+
+ Sets the list format's \a indentation.
+ The indentation is multiplied by the QTextDocument::indentWidth
+ property to get the effective indent in pixels.
+
+ \sa indent()
+*/
+
+
+/*!
+ \fn int QTextListFormat::indent() const
+
+ Returns the list format's indentation.
+ The indentation is multiplied by the QTextDocument::indentWidth
+ property to get the effective indent in pixels.
+
+ \sa setIndent()
+*/
+
+
+/*!
+ \class QTextFrameFormat
+ \reentrant
+
+ \brief The QTextFrameFormat class provides formatting information for
+ frames in a QTextDocument.
+
+ \ingroup richtext-processing
+
+ A text frame groups together one or more blocks of text, providing a layer
+ of structure larger than the paragraph. The format of a frame specifies
+ how it is rendered and positioned on the screen. It does not directly
+ specify the behavior of the text formatting within, but provides
+ constraints on the layout of its children.
+
+ The frame format defines the width() and height() of the frame on the
+ screen. Each frame can have a border() that surrounds its contents with
+ a rectangular box. The border is surrounded by a margin() around the frame,
+ and the contents of the frame are kept separate from the border by the
+ frame's padding(). This scheme is similar to the box model used by Cascading
+ Style Sheets for HTML pages.
+
+ \img qtextframe-style.png
+
+ The position() of a frame is set using setPosition() and determines how it
+ is located relative to the surrounding text.
+
+ The validity of a QTextFrameFormat object can be determined with the
+ isValid() function.
+
+ \sa QTextFrame QTextBlockFormat
+*/
+
+/*!
+ \enum QTextFrameFormat::Position
+
+ This enum describes how a frame is located relative to the surrounding text.
+
+ \value InFlow
+ \value FloatLeft
+ \value FloatRight
+
+ \sa position() CssFloat
+*/
+
+/*!
+ \enum QTextFrameFormat::BorderStyle
+ \since 4.3
+
+ This enum describes different border styles for the text frame.
+
+ \value BorderStyle_None
+ \value BorderStyle_Dotted
+ \value BorderStyle_Dashed
+ \value BorderStyle_Solid
+ \value BorderStyle_Double
+ \value BorderStyle_DotDash
+ \value BorderStyle_DotDotDash
+ \value BorderStyle_Groove
+ \value BorderStyle_Ridge
+ \value BorderStyle_Inset
+ \value BorderStyle_Outset
+
+ \sa borderStyle() FrameBorderStyle
+*/
+
+/*!
+ \fn QTextFrameFormat::QTextFrameFormat()
+
+ Constructs a text frame format object with the default properties.
+*/
+QTextFrameFormat::QTextFrameFormat() : QTextFormat(FrameFormat)
+{
+ setBorderStyle(BorderStyle_Outset);
+ setBorderBrush(Qt::darkGray);
+}
+
+/*!
+ \internal
+ \fn QTextFrameFormat::QTextFrameFormat(const QTextFormat &other)
+
+ Creates a new frame format with the same attributes as the \a given
+ text format.
+*/
+QTextFrameFormat::QTextFrameFormat(const QTextFormat &fmt)
+ : QTextFormat(fmt)
+{
+}
+
+/*!
+ \fn QTextFrameFormat::isValid() const
+
+ Returns true if the format description is valid; otherwise returns false.
+*/
+
+/*!
+ \fn QTextFrameFormat::setPosition(Position policy)
+
+ Sets the \a policy for positioning frames with this frame format.
+
+*/
+
+/*!
+ \fn Position QTextFrameFormat::position() const
+
+ Returns the positioning policy for frames with this frame format.
+*/
+
+/*!
+ \fn QTextFrameFormat::setBorder(qreal width)
+
+ Sets the \a width (in pixels) of the frame's border.
+*/
+
+/*!
+ \fn qreal QTextFrameFormat::border() const
+
+ Returns the width of the border in pixels.
+*/
+
+/*!
+ \fn QTextFrameFormat::setBorderBrush(const QBrush &brush)
+ \since 4.3
+
+ Sets the \a brush used for the frame's border.
+*/
+
+/*!
+ \fn QBrush QTextFrameFormat::borderBrush() const
+ \since 4.3
+
+ Returns the brush used for the frame's border.
+*/
+
+/*!
+ \fn QTextFrameFormat::setBorderStyle(BorderStyle style)
+ \since 4.3
+
+ Sets the \a style of the frame's border.
+*/
+
+/*!
+ \fn BorderStyle QTextFrameFormat::borderStyle() const
+ \since 4.3
+
+ Returns the style of the frame's border.
+*/
+
+/*!
+ \fn QTextFrameFormat::setMargin(qreal margin)
+
+ Sets the frame's \a margin in pixels.
+ This method also sets the left, right, top and bottom margins
+ of the frame to the same value. The individual margins override
+ the general margin.
+*/
+void QTextFrameFormat::setMargin(qreal amargin)
+{
+ setProperty(FrameMargin, amargin);
+ setProperty(FrameTopMargin, amargin);
+ setProperty(FrameBottomMargin, amargin);
+ setProperty(FrameLeftMargin, amargin);
+ setProperty(FrameRightMargin, amargin);
+}
+
+
+/*!
+ \fn qreal QTextFrameFormat::margin() const
+
+ Returns the width of the frame's external margin in pixels.
+*/
+
+/*!
+ \fn QTextFrameFormat::setTopMargin(qreal margin)
+ \since 4.3
+
+ Sets the frame's top \a margin in pixels.
+*/
+
+/*!
+ \fn qreal QTextFrameFormat::topMargin() const
+ \since 4.3
+
+ Returns the width of the frame's top margin in pixels.
+*/
+qreal QTextFrameFormat::topMargin() const
+{
+ if (!hasProperty(FrameTopMargin))
+ return margin();
+ return doubleProperty(FrameTopMargin);
+}
+
+/*!
+ \fn QTextFrameFormat::setBottomMargin(qreal margin)
+ \since 4.3
+
+ Sets the frame's bottom \a margin in pixels.
+*/
+
+/*!
+ \fn qreal QTextFrameFormat::bottomMargin() const
+ \since 4.3
+
+ Returns the width of the frame's bottom margin in pixels.
+*/
+qreal QTextFrameFormat::bottomMargin() const
+{
+ if (!hasProperty(FrameBottomMargin))
+ return margin();
+ return doubleProperty(FrameBottomMargin);
+}
+
+/*!
+ \fn QTextFrameFormat::setLeftMargin(qreal margin)
+ \since 4.3
+
+ Sets the frame's left \a margin in pixels.
+*/
+
+/*!
+ \fn qreal QTextFrameFormat::leftMargin() const
+ \since 4.3
+
+ Returns the width of the frame's left margin in pixels.
+*/
+qreal QTextFrameFormat::leftMargin() const
+{
+ if (!hasProperty(FrameLeftMargin))
+ return margin();
+ return doubleProperty(FrameLeftMargin);
+}
+
+/*!
+ \fn QTextFrameFormat::setRightMargin(qreal margin)
+ \since 4.3
+
+ Sets the frame's right \a margin in pixels.
+*/
+
+/*!
+ \fn qreal QTextFrameFormat::rightMargin() const
+ \since 4.3
+
+ Returns the width of the frame's right margin in pixels.
+*/
+qreal QTextFrameFormat::rightMargin() const
+{
+ if (!hasProperty(FrameRightMargin))
+ return margin();
+ return doubleProperty(FrameRightMargin);
+}
+
+/*!
+ \fn QTextFrameFormat::setPadding(qreal width)
+
+ Sets the \a width of the frame's internal padding in pixels.
+*/
+
+/*!
+ \fn qreal QTextFrameFormat::padding() const
+
+ Returns the width of the frame's internal padding in pixels.
+*/
+
+/*!
+ \fn QTextFrameFormat::setWidth(const QTextLength &width)
+
+ Sets the frame's border rectangle's \a width.
+
+ \sa QTextLength
+*/
+
+/*!
+ \fn QTextFrameFormat::setWidth(qreal width)
+ \overload
+
+ Convenience method that sets the width of the frame's border
+ rectangle's width to the specified fixed \a width.
+*/
+
+/*!
+ \fn QTextFormat::PageBreakFlags QTextFrameFormat::pageBreakPolicy() const
+ \since 4.2
+
+ Returns the currently set page break policy for the frame/table. The default is
+ QTextFormat::PageBreak_Auto.
+
+ \sa setPageBreakPolicy()
+*/
+
+/*!
+ \fn void QTextFrameFormat::setPageBreakPolicy(PageBreakFlags policy)
+ \since 4.2
+
+ Sets the page break policy for the frame/table to \a policy.
+
+ \sa pageBreakPolicy()
+*/
+
+/*!
+ \fn QTextLength QTextFrameFormat::width() const
+
+ Returns the width of the frame's border rectangle.
+
+ \sa QTextLength
+*/
+
+/*!
+ \fn void QTextFrameFormat::setHeight(const QTextLength &height)
+
+ Sets the frame's \a height.
+*/
+
+/*!
+ \fn void QTextFrameFormat::setHeight(qreal height)
+ \overload
+
+ Sets the frame's \a height.
+*/
+
+/*!
+ \fn qreal QTextFrameFormat::height() const
+
+ Returns the height of the frame's border rectangle.
+*/
+
+/*!
+ \class QTextTableFormat
+ \reentrant
+
+ \brief The QTextTableFormat class provides formatting information for
+ tables in a QTextDocument.
+
+ \ingroup richtext-processing
+
+ A table is a group of cells ordered into rows and columns. Each table
+ contains at least one row and one column. Each cell contains a block.
+ Tables in rich text documents are formatted using the properties
+ defined in this class.
+
+ Tables are horizontally justified within their parent frame according to the
+ table's alignment. This can be read with the alignment() function and set
+ with setAlignment().
+
+ Cells within the table are separated by cell spacing. The number of pixels
+ between cells is set with setCellSpacing() and read with cellSpacing().
+ The contents of each cell is surrounded by cell padding. The number of pixels
+ between each cell edge and its contents is set with setCellPadding() and read
+ with cellPadding().
+
+ \image qtexttableformat-cell.png
+
+ The table's background color can be read with the background() function,
+ and can be specified with setBackground(). The background color of each
+ cell can be set independently, and will control the color of the cell within
+ the padded area.
+
+ The table format also provides a way to constrain the widths of the columns
+ in the table. Columns can be assigned a fixed width, a variable width, or
+ a percentage of the available width (see QTextLength). The columns() function
+ returns the number of columns with constraints, and the
+ columnWidthConstraints() function returns the constraints defined for the
+ table. These quantities can also be set by calling setColumnWidthConstraints()
+ with a vector containing new constraints. If no constraints are
+ required, clearColumnWidthConstraints() can be used to remove them.
+
+ \sa QTextTable QTextTableCell QTextLength
+*/
+
+/*!
+ \fn QTextTableFormat::QTextTableFormat()
+
+ Constructs a new table format object.
+*/
+QTextTableFormat::QTextTableFormat()
+ : QTextFrameFormat()
+{
+ setObjectType(TableObject);
+ setCellSpacing(2);
+ setBorder(1);
+}
+
+/*!
+ \internal
+ \fn QTextTableFormat::QTextTableFormat(const QTextFormat &other)
+
+ Creates a new table format with the same attributes as the \a given
+ text format.
+*/
+QTextTableFormat::QTextTableFormat(const QTextFormat &fmt)
+ : QTextFrameFormat(fmt)
+{
+}
+
+/*!
+ \fn bool QTextTableFormat::isValid() const
+
+ Returns true if this table format is valid; otherwise
+ returns false.
+*/
+
+
+/*!
+ \fn int QTextTableFormat::columns() const
+
+ Returns the number of columns specified by the table format.
+*/
+
+
+/*!
+ \internal
+ \fn void QTextTableFormat::setColumns(int columns)
+
+ Sets the number of \a columns required by the table format.
+
+ \sa columns()
+*/
+
+/*!
+ \fn void QTextTableFormat::clearColumnWidthConstraints()
+
+ Clears the column width constraints for the table.
+
+ \sa columnWidthConstraints() setColumnWidthConstraints()
+*/
+
+/*!
+ \fn void QTextTableFormat::setColumnWidthConstraints(const QVector<QTextLength> &constraints)
+
+ Sets the column width \a constraints for the table.
+
+ \sa columnWidthConstraints() clearColumnWidthConstraints()
+*/
+
+/*!
+ \fn QVector<QTextLength> QTextTableFormat::columnWidthConstraints() const
+
+ Returns a list of constraints used by this table format to control the
+ appearance of columns in a table.
+
+ \sa setColumnWidthConstraints()
+*/
+
+/*!
+ \fn qreal QTextTableFormat::cellSpacing() const
+
+ Returns the table's cell spacing. This describes the distance between
+ adjacent cells.
+*/
+
+/*!
+ \fn void QTextTableFormat::setCellSpacing(qreal spacing)
+
+ Sets the cell \a spacing for the table. This determines the distance
+ between adjacent cells.
+*/
+
+/*!
+ \fn qreal QTextTableFormat::cellPadding() const
+
+ Returns the table's cell padding. This describes the distance between
+ the border of a cell and its contents.
+*/
+
+/*!
+ \fn void QTextTableFormat::setCellPadding(qreal padding)
+
+ Sets the cell \a padding for the table. This determines the distance
+ between the border of a cell and its contents.
+*/
+
+/*!
+ \fn void QTextTableFormat::setAlignment(Qt::Alignment alignment)
+
+ Sets the table's \a alignment.
+
+ \sa alignment()
+*/
+
+/*!
+ \fn Qt::Alignment QTextTableFormat::alignment() const
+
+ Returns the table's alignment.
+
+ \sa setAlignment()
+*/
+
+/*!
+ \fn void QTextTableFormat::setHeaderRowCount(int count)
+ \since 4.2
+
+ Declares the first \a count rows of the table as table header.
+ The table header rows get repeated when a table is broken
+ across a page boundary.
+*/
+
+/*!
+ \fn int QTextTableFormat::headerRowCount() const
+ \since 4.2
+
+ Returns the number of rows in the table that define the header.
+
+ \sa setHeaderRowCount()
+*/
+
+/*!
+ \fn void QTextFormat::setBackground(const QBrush &brush)
+
+ Sets the brush use to paint the document's background to the
+ \a brush specified.
+
+ \sa background() clearBackground() setForeground()
+*/
+
+/*!
+ \fn QColor QTextFormat::background() const
+
+ Returns the brush used to paint the document's background.
+
+ \sa setBackground() clearBackground() foreground()
+*/
+
+/*!
+ \fn void QTextFormat::clearBackground()
+
+ Clears the brush used to paint the document's background. The default
+ brush will be used.
+
+ \sa background() setBackground() clearForeground()
+*/
+
+
+/*!
+ \class QTextImageFormat
+ \reentrant
+
+ \brief The QTextImageFormat class provides formatting information for
+ images in a QTextDocument.
+
+ \ingroup richtext-processing
+
+ Inline images are represented by an object replacement character
+ (0xFFFC in Unicode) which has an associated QTextImageFormat. The
+ image format specifies a name with setName() that is used to
+ locate the image. The size of the rectangle that the image will
+ occupy is specified using setWidth() and setHeight().
+
+ Images can be supplied in any format for which Qt has an image
+ reader, so SVG drawings can be included alongside PNG, TIFF and
+ other bitmap formats.
+
+ \sa QImage, QImageReader
+*/
+
+/*!
+ \fn QTextImageFormat::QTextImageFormat()
+
+ Creates a new image format object.
+*/
+QTextImageFormat::QTextImageFormat() : QTextCharFormat() { setObjectType(ImageObject); }
+
+/*!
+ \internal
+ \fn QTextImageFormat::QTextImageFormat(const QTextFormat &other)
+
+ Creates a new image format with the same attributes as the \a given
+ text format.
+*/
+QTextImageFormat::QTextImageFormat(const QTextFormat &fmt)
+ : QTextCharFormat(fmt)
+{
+}
+
+/*!
+ \fn bool QTextImageFormat::isValid() const
+
+ Returns true if this image format is valid; otherwise returns false.
+*/
+
+
+/*!
+ \fn void QTextImageFormat::setName(const QString &name)
+
+ Sets the \a name of the image. The \a name is used to locate the image
+ in the application's resources.
+
+ \sa name()
+*/
+
+
+/*!
+ \fn QString QTextImageFormat::name() const
+
+ Returns the name of the image. The name refers to an entry in the
+ application's resources file.
+
+ \sa setName()
+*/
+
+/*!
+ \fn void QTextImageFormat::setWidth(qreal width)
+
+ Sets the \a width of the rectangle occupied by the image.
+
+ \sa width() setHeight()
+*/
+
+
+// ### Qt5 qreal replace with a QTextLength
+/*!
+ \fn qreal QTextImageFormat::width() const
+
+ Returns the width of the rectangle occupied by the image.
+
+ \sa height() setWidth()
+*/
+
+
+/*!
+ \fn void QTextImageFormat::setHeight(qreal height)
+
+ Sets the \a height of the rectangle occupied by the image.
+
+ \sa height() setWidth()
+*/
+
+
+// ### Qt5 qreal replace with a QTextLength
+/*!
+ \fn qreal QTextImageFormat::height() const
+
+ Returns the height of the rectangle occupied by the image.
+
+ \sa width() setHeight()
+*/
+
+/*!
+ \fn void QTextCharFormat::setFontCapitalization(QFont::Capitalization capitalization)
+ \since 4.4
+
+ Sets the capitalization of the text that apppears in this font to \a capitalization.
+
+ A font's capitalization makes the text appear in the selected capitalization mode.
+
+ \sa fontCapitalization()
+*/
+
+/*!
+ \fn Capitalization QTextCharFormat::fontCapitalization() const
+ \since 4.4
+
+ Returns the current capitalization type of the font.
+*/
+
+/*!
+ \fn void QTextCharFormat::setFontLetterSpacing(qreal spacing)
+ \since 4.4
+
+ Sets the letter spacing of this format to the given \a spacing, in percent.
+ A value of 100 indicates default spacing; a value of 200 doubles the amount
+ of space a letter takes.
+
+ \sa fontLetterSpacing()
+*/
+
+/*!
+ \fn qreal QTextCharFormat::fontLetterSpacing() const
+ \since 4.4
+
+ Returns the current letter spacing percentage.
+*/
+
+/*!
+ \fn void QTextCharFormat::setFontWordSpacing(qreal spacing)
+ \since 4.4
+
+ Sets the word spacing of this format to the given \a spacing, in pixels.
+
+ \sa fontWordSpacing()
+*/
+
+/*!
+ \fn qreal QTextCharFormat::fontWordSpacing() const
+ \since 4.4
+
+ Returns the current word spacing value.
+*/
+
+/*!
+ \fn qreal QTextTableCellFormat::topPadding() const
+ \since 4.4
+
+ Gets the top padding of the table cell.
+
+ \sa setTopPadding(), leftPadding(), rightPadding(), bottomPadding()
+*/
+
+/*!
+ \fn qreal QTextTableCellFormat::bottomPadding() const
+ \since 4.4
+
+ Gets the bottom padding of the table cell.
+
+ \sa setBottomPadding(), leftPadding(), rightPadding(), topPadding()
+*/
+
+/*!
+ \fn qreal QTextTableCellFormat::leftPadding() const
+ \since 4.4
+
+ Gets the left padding of the table cell.
+
+ \sa setLeftPadding(), rightPadding(), topPadding(), bottomPadding()
+*/
+
+/*!
+ \fn qreal QTextTableCellFormat::rightPadding() const
+ \since 4.4
+
+ Gets the right padding of the table cell.
+
+ \sa setRightPadding(), leftPadding(), topPadding(), bottomPadding()
+*/
+
+/*!
+ \fn void QTextTableCellFormat::setTopPadding(qreal padding)
+ \since 4.4
+
+ Sets the top \a padding of the table cell.
+
+ \sa topPadding(), setLeftPadding(), setRightPadding(), setBottomPadding()
+*/
+
+/*!
+ \fn void QTextTableCellFormat::setBottomPadding(qreal padding)
+ \since 4.4
+
+ Sets the bottom \a padding of the table cell.
+
+ \sa bottomPadding(), setLeftPadding(), setRightPadding(), setTopPadding()
+*/
+
+/*!
+ \fn void QTextTableCellFormat::setLeftPadding(qreal padding)
+ \since 4.4
+
+ Sets the left \a padding of the table cell.
+
+ \sa leftPadding(), setRightPadding(), setTopPadding(), setBottomPadding()
+*/
+
+/*!
+ \fn void QTextTableCellFormat::setRightPadding(qreal padding)
+ \since 4.4
+
+ Sets the right \a padding of the table cell.
+
+ \sa rightPadding(), setLeftPadding(), setTopPadding(), setBottomPadding()
+*/
+
+/*!
+ \fn void QTextTableCellFormat::setPadding(qreal padding)
+ \since 4.4
+
+ Sets the left, right, top, and bottom \a padding of the table cell.
+
+ \sa setLeftPadding(), setRightPadding(), setTopPadding(), setBottomPadding()
+*/
+
+/*!
+ \fn bool QTextTableCellFormat::isValid() const
+ \since 4.4
+
+ Returns true if this table cell format is valid; otherwise returns false.
+*/
+
+/*!
+ \fn QTextTableCellFormat::QTextTableCellFormat()
+ \since 4.4
+
+ Constructs a new table cell format object.
+*/
+QTextTableCellFormat::QTextTableCellFormat()
+ : QTextCharFormat()
+{
+ setObjectType(TableCellObject);
+}
+
+/*!
+ \internal
+ \fn QTextTableCellFormat::QTextTableCellFormat(const QTextFormat &other)
+
+ Creates a new table cell format with the same attributes as the \a given
+ text format.
+*/
+QTextTableCellFormat::QTextTableCellFormat(const QTextFormat &fmt)
+ : QTextCharFormat(fmt)
+{
+}
+
+/*!
+ \class QTextTableCellFormat
+ \reentrant
+ \since 4.4
+
+ \brief The QTextTableCellFormat class provides formatting information for
+ table cells in a QTextDocument.
+
+ \ingroup richtext-processing
+
+ The table cell format of a table cell in a document specifies the visual
+ properties of the table cell.
+
+ The padding properties of a table cell are controlled by setLeftPadding(),
+ setRightPadding(), setTopPadding(), and setBottomPadding(). All the paddings
+ can be set at once using setPadding().
+
+ \sa QTextFormat QTextBlockFormat QTextTableFormat QTextCharFormat
+*/
+
+// ------------------------------------------------------
+
+
+QTextFormatCollection::QTextFormatCollection(const QTextFormatCollection &rhs)
+{
+ formats = rhs.formats;
+ objFormats = rhs.objFormats;
+}
+
+QTextFormatCollection &QTextFormatCollection::operator=(const QTextFormatCollection &rhs)
+{
+ formats = rhs.formats;
+ objFormats = rhs.objFormats;
+ return *this;
+}
+
+QTextFormatCollection::~QTextFormatCollection()
+{
+}
+
+int QTextFormatCollection::indexForFormat(const QTextFormat &format)
+{
+ uint hash = format.d ? format.d->hash() : 0;
+ if (hashes.contains(hash)) {
+ for (int i = 0; i < formats.size(); ++i) {
+ if (formats.at(i) == format)
+ return 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);
+
+ } QT_CATCH(...) {
+ formats.pop_back();
+ QT_RETHROW;
+ }
+ return idx;
+}
+
+bool QTextFormatCollection::hasFormatCached(const QTextFormat &format) const
+{
+ uint hash = format.d ? format.d->hash() : 0;
+ if (hashes.contains(hash)) {
+ for (int i = 0; i < formats.size(); ++i)
+ if (formats.at(i) == format)
+ return true;
+ }
+ return false;
+}
+
+QTextFormat QTextFormatCollection::objectFormat(int objectIndex) const
+{
+ if (objectIndex == -1)
+ return QTextFormat();
+ return format(objFormats.at(objectIndex));
+}
+
+void QTextFormatCollection::setObjectFormat(int objectIndex, const QTextFormat &f)
+{
+ const int formatIndex = indexForFormat(f);
+ objFormats[objectIndex] = formatIndex;
+}
+
+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.count())
+ return QTextFormat();
+
+ return formats.at(idx);
+}
+
+void QTextFormatCollection::setDefaultFont(const QFont &f)
+{
+ defaultFnt = f;
+ for (int i = 0; i < formats.count(); ++i)
+ if (formats[i].d)
+ formats[i].d->resolveFont(defaultFnt);
+}
+
+QT_END_NAMESPACE