1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

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

     6 **

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

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qtextformat.h"

    43 #include "qtextformat_p.h"

    44 

    45 #include <qvariant.h>

    46 #include <qdatastream.h>

    47 #include <qdebug.h>

    48 #include <qmap.h>

    49 #include <qhash.h>

    50 

    51 QT_BEGIN_NAMESPACE

    52 

    53 /*!

    54     \class QTextLength

    55     \reentrant

    56 

    57     \brief The QTextLength class encapsulates the different types of length

    58     used in a QTextDocument.

    59 

    60     \ingroup richtext-processing

    61 

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

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

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

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

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

    67     it is used.

    68 

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

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

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

    72     up just the space it requires.

    73 

    74     \sa QTextTable

    75 */

    76 

    77 /*!

    78     \fn explicit QTextLength::QTextLength()

    79 

    80     Constructs a new length object which represents a variable size.

    81 */

    82 

    83 /*!

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

    85 

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

    87 */

    88 

    89 /*!

    90     \fn Type QTextLength::type() const

    91 

    92     Returns the type of this length object.

    93 

    94     \sa QTextLength::Type

    95 */

    96 

    97 /*!

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

    99 

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

   101     and the specified \a maximumLength.

   102 

   103     \sa type()

   104 */

   105 

   106 /*!

   107     \fn qreal QTextLength::rawValue() const

   108 

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

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

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

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

   113 */

   114 

   115 /*!

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

   117 

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

   119     length.

   120 */

   121 

   122 /*!

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

   124 

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

   126     length.

   127 */

   128 

   129 /*!

   130     \enum QTextLength::Type

   131 

   132     This enum describes the different types a length object can

   133     have.

   134 

   135     \value VariableLength The width of the object is variable

   136     \value FixedLength The width of the object is fixed

   137     \value PercentageLength The width of the object is in

   138                             percentage of the maximum width

   139 

   140     \sa type()

   141 */

   142 

   143 /*!

   144    Returns the text length as a QVariant

   145 */

   146 QTextLength::operator QVariant() const

   147 {

   148     return QVariant(QVariant::TextLength, this);

   149 }

   150 

   151 #ifndef QT_NO_DATASTREAM

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

   153 {

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

   155 }

   156 

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

   158 {

   159     qint32 type;

   160     double fixedValueOrPercentage;

   161     stream >> type >> fixedValueOrPercentage;

   162     length.fixedValueOrPercentage = fixedValueOrPercentage;

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

   164     return stream;

   165 }

   166 #endif // QT_NO_DATASTREAM

   167 

   168 class QTextFormatPrivate : public QSharedData

   169 {

   170 public:

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

   172 

   173     struct Property

   174     {

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

   176         inline Property() {}

   177 

   178         qint32 key;

   179         QVariant value;

   180 

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

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

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

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

   185     };

   186 

   187     inline uint hash() const

   188     {

   189         if (!hashDirty)

   190             return hashValue;

   191         return recalcHash();

   192     }

   193 

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

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

   196             return false;

   197 

   198         return props == rhs.props;

   199     }

   200 

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

   202     {

   203         hashDirty = true;

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

   205             fontDirty = true;

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

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

   208                 props[i].value = value;

   209                 return;

   210             }

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

   212     }

   213 

   214     inline void clearProperty(qint32 key)

   215     {

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

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

   218                 hashDirty = true;

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

   220                     fontDirty = true;

   221                 props.remove(i);

   222                 return;

   223             }

   224     }

   225 

   226     inline int propertyIndex(qint32 key) const

   227     {

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

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

   230                 return i;

   231         return -1;

   232     }

   233 

   234     inline QVariant property(qint32 key) const

   235     {

   236         const int idx = propertyIndex(key);

   237         if (idx < 0)

   238             return QVariant();

   239         return props.at(idx).value;

   240     }

   241 

   242     inline bool hasProperty(qint32 key) const

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

   244 

   245     void resolveFont(const QFont &defaultFont);

   246 

   247     inline const QFont &font() const {

   248         if (fontDirty)

   249             recalcFont();

   250         return fnt;

   251     }

   252 

   253     QVector<Property> props;

   254 private:

   255 

   256     uint recalcHash() const;

   257     void recalcFont() const;

   258 

   259     mutable bool hashDirty;

   260     mutable bool fontDirty;

   261     mutable uint hashValue;

   262     mutable QFont fnt;

   263 

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

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

   266 };

   267 

   268 static uint variantHash(const QVariant &variant)

   269 {

   270     switch (variant.userType()) {

   271     case QVariant::Invalid: return 0;

   272     case QVariant::Bool: return variant.toBool();

   273     case QVariant::Int: return variant.toInt();

   274     case QMetaType::Float: return static_cast<int>(variant.toFloat());

   275     case QVariant::Double: return static_cast<int>(variant.toDouble());

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

   277     case QVariant::Color: return qHash(qvariant_cast<QColor>(variant).rgb());

   278     default: break;

   279     }

   280     return qHash(variant.typeName());

   281 }

   282 

   283 uint QTextFormatPrivate::recalcHash() const

   284 {

   285     hashValue = 0;

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

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

   288 

   289     hashDirty = false;

   290 

   291     return hashValue;

   292 }

   293 

   294 void QTextFormatPrivate::resolveFont(const QFont &defaultFont)

   295 {

   296     recalcFont();

   297     const uint oldMask = fnt.resolve();

   298     fnt = fnt.resolve(defaultFont);

   299 

   300     if (hasProperty(QTextFormat::FontSizeAdjustment)) {

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

   302 

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

   304 

   305 

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

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

   308             fnt.setPixelSize(qRound(pixelSize));

   309         } else {

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

   311             fnt.setPointSizeF(pointSize);

   312         }

   313     }

   314 

   315     fnt.resolve(oldMask);

   316 }

   317 

   318 void QTextFormatPrivate::recalcFont() const

   319 {

   320     // update cached font as well

   321     QFont f;

   322 

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

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

   325             case QTextFormat::FontFamily:

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

   327                 break;

   328             case QTextFormat::FontPointSize:

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

   330                 break;

   331             case  QTextFormat::FontPixelSize:

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

   333                 break;

   334             case QTextFormat::FontWeight: {

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

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

   337                 f.setWeight(weight);

   338                 break; }

   339             case QTextFormat::FontItalic:

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

   341                 break;

   342             case QTextFormat::FontUnderline:

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

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

   345                 break;

   346             case QTextFormat::TextUnderlineStyle:

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

   348                 break;

   349             case QTextFormat::FontOverline:

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

   351                 break;

   352             case QTextFormat::FontStrikeOut:

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

   354                 break;

   355             case QTextFormat::FontLetterSpacing:

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

   357                 break;

   358             case QTextFormat::FontWordSpacing:

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

   360                 break;

   361             case QTextFormat::FontCapitalization:

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

   363                 break;

   364             case QTextFormat::FontFixedPitch: {

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

   366                 if (f.fixedPitch() != value)

   367                     f.setFixedPitch(value);

   368                 break; }

   369             case QTextFormat::FontStyleHint:

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

   371                 break;

   372             case QTextFormat::FontStyleStrategy:

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

   374                 break;

   375             case QTextFormat::FontKerning:

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

   377                 break;

   378             default:

   379                 break;

   380             }

   381     }

   382     fnt = f;

   383     fontDirty = false;

   384 }

   385 

   386 #ifndef QT_NO_DATASTREAM

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

   388 {

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

   390     return stream;

   391 }

   392 

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

   394 {

   395     QMap<qint32, QVariant> properties;

   396     stream >> fmt.format_type >> properties;

   397 

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

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

   400     if(!fmt.d)

   401         fmt.d = new QTextFormatPrivate();

   402 

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

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

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

   406 

   407     return stream;

   408 }

   409 #endif // QT_NO_DATASTREAM

   410 

   411 /*!

   412     \class QTextFormat

   413     \reentrant

   414 

   415     \brief The QTextFormat class provides formatting information for a

   416     QTextDocument.

   417 

   418     \ingroup richtext-processing

   419     \ingroup shared

   420 

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

   422     parts of a QTextDocument. The derived classes QTextCharFormat,

   423     QTextBlockFormat, QTextListFormat, and QTextTableFormat are usually

   424     more useful, and describe the formatting that is applied to

   425     specific parts of the document.

   426 

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

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

   429     also has various properties (some specific to particular format

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

   431     corresponding Property.

   432 

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

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

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

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

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

   438     and toImageFormat().

   439 

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

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

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

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

   444     be merged into another using merge().

   445 

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

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

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

   449     lists, frames, and tables inside the document.

   450 

   451     \sa {Rich Text Processing}

   452 */

   453 

   454 /*!

   455     \enum QTextFormat::FormatType

   456 

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

   458 

   459     \value InvalidFormat An invalid format as created by the default

   460                          constructor

   461     \value BlockFormat The object formats a text block

   462     \value CharFormat The object formats a single character

   463     \value ListFormat The object formats a list

   464     \value TableFormat The object formats a table

   465     \value FrameFormat The object formats a frame

   466 

   467     \value UserFormat

   468 

   469     \sa QTextCharFormat, QTextBlockFormat, QTextListFormat,

   470     QTextTableFormat, type()

   471 */

   472 

   473 /*!

   474     \enum QTextFormat::Property

   475 

   476     This enum describes the different properties a format can have.

   477 

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

   479 

   480     Paragraph and character properties

   481 

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

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

   484                             (Qt::LayoutDirection).

   485 

   486     \value OutlinePen

   487     \value ForegroundBrush

   488     \value BackgroundBrush

   489     \value BackgroundImageUrl

   490 

   491     Paragraph properties

   492 

   493     \value BlockAlignment

   494     \value BlockTopMargin

   495     \value BlockBottomMargin

   496     \value BlockLeftMargin

   497     \value BlockRightMargin

   498     \value TextIndent

   499     \value TabPositions     Specifies the tab positions.  The tab positions are structs of QTextOption::Tab which are stored in

   500                             a QList (internally, in a QList<QVariant>).

   501     \value BlockIndent

   502     \value BlockNonBreakableLines

   503     \value BlockTrailingHorizontalRulerWidth The width of a horizontal ruler element.

   504 

   505     Character properties

   506 

   507     \value FontFamily

   508     \value FontPointSize

   509     \value FontPixelSize

   510     \value FontSizeAdjustment       Specifies the change in size given to the fontsize already set using

   511                                     FontPointSize or FontPixelSize.

   512     \value FontFixedPitch

   513     \omitvalue FontSizeIncrement

   514     \value FontWeight

   515     \value FontItalic

   516     \value FontUnderline \e{This property has been deprecated.} Use QTextFormat::TextUnderlineStyle instead.

   517     \value FontOverline

   518     \value FontStrikeOut

   519     \value FontCapitalization Specifies the capitalization type that is to be applied to the text.

   520     \value FontLetterSpacing Changes the default spacing between individual letters in the font. The value is

   521                                                 specified in percentage, with 100 as the default value.

   522     \value FontWordSpacing  Changes the default spacing between individual words. A positive value increases the word spacing

   523                                                  by the corresponding pixels; a negative value decreases the spacing.

   524     \value FontStyleHint        Corresponds to the QFont::StyleHint property

   525     \value FontStyleStrategy    Corresponds to the QFont::StyleStrategy property

   526     \value FontKerning          Specifies whether the font has kerning turned on.

   527 

   528     \omitvalue FirstFontProperty

   529     \omitvalue LastFontProperty

   530 

   531     \value TextUnderlineColor

   532     \value TextVerticalAlignment

   533     \value TextOutline

   534     \value TextUnderlineStyle

   535     \value TextToolTip Specifies the (optional) tool tip to be displayed for a fragment of text.

   536 

   537     \value IsAnchor

   538     \value AnchorHref

   539     \value AnchorName

   540     \value ObjectType

   541 

   542     List properties

   543 

   544     \value ListStyle

   545     \value ListIndent

   546 

   547     Table and frame properties

   548 

   549     \value FrameBorder

   550     \value FrameBorderBrush

   551     \value FrameBorderStyle See the \l{QTextFrameFormat::BorderStyle}{BorderStyle} enum.

   552     \value FrameBottomMargin

   553     \value FrameHeight

   554     \value FrameLeftMargin

   555     \value FrameMargin

   556     \value FramePadding

   557     \value FrameRightMargin

   558     \value FrameTopMargin

   559     \value FrameWidth

   560     \value TableCellSpacing

   561     \value TableCellPadding

   562     \value TableColumns

   563     \value TableColumnWidthConstraints

   564     \value TableHeaderRowCount

   565 

   566     Table cell properties

   567 

   568     \value TableCellRowSpan

   569     \value TableCellColumnSpan

   570     \value TableCellLeftPadding

   571     \value TableCellRightPadding

   572     \value TableCellTopPadding

   573     \value TableCellBottomPadding

   574 

   575     Image properties

   576 

   577     \value ImageName

   578     \value ImageWidth

   579     \value ImageHeight

   580 

   581     Selection properties

   582 

   583     \value FullWidthSelection When set on the characterFormat of a selection,

   584                               the whole width of the text will be shown selected.

   585 

   586     Page break properties

   587 

   588     \value PageBreakPolicy Specifies how pages are broken. See the PageBreakFlag enum.

   589 

   590     \value UserProperty

   591 

   592     \sa property(), setProperty()

   593 */

   594 

   595 /*!

   596     \enum QTextFormat::ObjectTypes

   597 

   598     This enum describes what kind of QTextObject this format is associated with.

   599 

   600     \value NoObject

   601     \value ImageObject

   602     \value TableObject

   603     \value TableCellObject

   604     \value UserObject The first object that can be used for application-specific purposes.

   605 

   606     \sa QTextObject, QTextTable, QTextObject::format()

   607 */

   608 

   609 /*!

   610     \enum QTextFormat::PageBreakFlag

   611     \since 4.2

   612 

   613     This enum describes how page breaking is performed when printing. It maps to the

   614     corresponding css properties.

   615 

   616     \value PageBreak_Auto The page break is determined automatically depending on the

   617                           available space on the current page

   618     \value PageBreak_AlwaysBefore The page is always broken before the paragraph/table

   619     \value PageBreak_AlwaysAfter  A new page is always started after the paragraph/table

   620 

   621     \sa QTextBlockFormat::pageBreakPolicy(), QTextFrameFormat::pageBreakPolicy(),

   622     PageBreakPolicy

   623 */

   624 

   625 /*!

   626     \fn bool QTextFormat::isValid() const

   627 

   628     Returns true if the format is valid (i.e. is not

   629     InvalidFormat); otherwise returns false.

   630 */

   631 

   632 /*!

   633     \fn bool QTextFormat::isCharFormat() const

   634 

   635     Returns true if this text format is a \c CharFormat; otherwise

   636     returns false.

   637 */

   638 

   639 

   640 /*!

   641     \fn bool QTextFormat::isBlockFormat() const

   642 

   643     Returns true if this text format is a \c BlockFormat; otherwise

   644     returns false.

   645 */

   646 

   647 

   648 /*!

   649     \fn bool QTextFormat::isListFormat() const

   650 

   651     Returns true if this text format is a \c ListFormat; otherwise

   652     returns false.

   653 */

   654 

   655 

   656 /*!

   657     \fn bool QTextFormat::isTableFormat() const

   658 

   659     Returns true if this text format is a \c TableFormat; otherwise

   660     returns false.

   661 */

   662 

   663 

   664 /*!

   665     \fn bool QTextFormat::isFrameFormat() const

   666 

   667     Returns true if this text format is a \c FrameFormat; otherwise

   668     returns false.

   669 */

   670 

   671 

   672 /*!

   673     \fn bool QTextFormat::isImageFormat() const

   674 

   675     Returns true if this text format is an image format; otherwise

   676     returns false.

   677 */

   678 

   679 

   680 /*!

   681     \fn bool QTextFormat::isTableCellFormat() const

   682     \since 4.4

   683 

   684     Returns true if this text format is a \c TableCellFormat; otherwise

   685     returns false.

   686 */

   687 

   688 

   689 /*!

   690     Creates a new text format with an \c InvalidFormat.

   691 

   692     \sa FormatType

   693 */

   694 QTextFormat::QTextFormat()

   695     : format_type(InvalidFormat)

   696 {

   697 }

   698 

   699 /*!

   700     Creates a new text format of the given \a type.

   701 

   702     \sa FormatType

   703 */

   704 QTextFormat::QTextFormat(int type)

   705     : format_type(type)

   706 {

   707 }

   708 

   709 

   710 /*!

   711     \fn QTextFormat::QTextFormat(const QTextFormat &other)

   712 

   713     Creates a new text format with the same attributes as the \a other

   714     text format.

   715 */

   716 QTextFormat::QTextFormat(const QTextFormat &rhs)

   717     : d(rhs.d), format_type(rhs.format_type)

   718 {

   719 }

   720 

   721 /*!

   722     \fn QTextFormat &QTextFormat::operator=(const QTextFormat &other)

   723 

   724     Assigns the \a other text format to this text format, and returns a

   725     reference to this text format.

   726 */

   727 QTextFormat &QTextFormat::operator=(const QTextFormat &rhs)

   728 {

   729     d = rhs.d;

   730     format_type = rhs.format_type;

   731     return *this;

   732 }

   733 

   734 /*!

   735     Destroys this text format.

   736 */

   737 QTextFormat::~QTextFormat()

   738 {

   739 }

   740 

   741 

   742 /*!

   743    Returns the text format as a QVariant

   744 */

   745 QTextFormat::operator QVariant() const

   746 {

   747     return QVariant(QVariant::TextFormat, this);

   748 }

   749 

   750 /*!

   751     Merges the \a other format with this format; where there are

   752     conflicts the \a other format takes precedence.

   753 */

   754 void QTextFormat::merge(const QTextFormat &other)

   755 {

   756     if (format_type != other.format_type)

   757         return;

   758 

   759     if (!d) {

   760         d = other.d;

   761         return;

   762     }

   763 

   764     if (!other.d)

   765         return;

   766 

   767     QTextFormatPrivate *d = this->d;

   768 

   769     const QVector<QTextFormatPrivate::Property> &otherProps = other.d->props;

   770     d->props.reserve(d->props.size() + otherProps.size());

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

   772         const QTextFormatPrivate::Property &p = otherProps.at(i);

   773         d->insertProperty(p.key, p.value);

   774     }

   775 }

   776 

   777 /*!

   778     Returns the type of this format.

   779 

   780     \sa FormatType

   781 */

   782 int QTextFormat::type() const

   783 {

   784     return format_type;

   785 }

   786 

   787 /*!

   788     Returns this format as a block format.

   789 */

   790 QTextBlockFormat QTextFormat::toBlockFormat() const

   791 {

   792     return QTextBlockFormat(*this);

   793 }

   794 

   795 /*!

   796     Returns this format as a character format.

   797 */

   798 QTextCharFormat QTextFormat::toCharFormat() const

   799 {

   800     return QTextCharFormat(*this);

   801 }

   802 

   803 /*!

   804     Returns this format as a list format.

   805 */

   806 QTextListFormat QTextFormat::toListFormat() const

   807 {

   808     return QTextListFormat(*this);

   809 }

   810 

   811 /*!

   812     Returns this format as a table format.

   813 */

   814 QTextTableFormat QTextFormat::toTableFormat() const

   815 {

   816     return QTextTableFormat(*this);

   817 }

   818 

   819 /*!

   820     Returns this format as a frame format.

   821 */

   822 QTextFrameFormat QTextFormat::toFrameFormat() const

   823 {

   824     return QTextFrameFormat(*this);

   825 }

   826 

   827 /*!

   828     Returns this format as an image format.

   829 */

   830 QTextImageFormat QTextFormat::toImageFormat() const

   831 {

   832     return QTextImageFormat(*this);

   833 }

   834 

   835 /*!

   836     \since 4.4

   837 

   838     Returns this format as a table cell format.

   839 */

   840 QTextTableCellFormat QTextFormat::toTableCellFormat() const

   841 {

   842     return QTextTableCellFormat(*this);

   843 }

   844 

   845 /*!

   846     Returns the value of the property specified by \a propertyId. If the

   847     property isn't of QTextFormat::Bool type, false is returned instead.

   848 

   849     \sa setProperty() intProperty() doubleProperty() stringProperty() colorProperty() lengthProperty() lengthVectorProperty() Property

   850 */

   851 bool QTextFormat::boolProperty(int propertyId) const

   852 {

   853     if (!d)

   854         return false;

   855     const QVariant prop = d->property(propertyId);

   856     if (prop.userType() != QVariant::Bool)

   857         return false;

   858     return prop.toBool();

   859 }

   860 

   861 /*!

   862     Returns the value of the property specified by \a propertyId. If the

   863     property is not of QTextFormat::Integer type, 0 is returned instead.

   864 

   865     \sa setProperty() boolProperty() doubleProperty() stringProperty() colorProperty() lengthProperty() lengthVectorProperty() Property

   866 */

   867 int QTextFormat::intProperty(int propertyId) const

   868 {

   869     if (!d)

   870         return 0;

   871     const QVariant prop = d->property(propertyId);

   872     if (prop.userType() != QVariant::Int)

   873         return 0;

   874     return prop.toInt();

   875 }

   876 

   877 /*!

   878     Returns the value of the property specified by \a propertyId. If the

   879     property isn't of QVariant::Double or QMetaType::Float type, 0 is

   880     returned instead.

   881 

   882     \sa setProperty() boolProperty() intProperty() stringProperty() colorProperty() lengthProperty() lengthVectorProperty() Property

   883 */

   884 qreal QTextFormat::doubleProperty(int propertyId) const

   885 {

   886     if (!d)

   887         return 0.;

   888     const QVariant prop = d->property(propertyId);

   889     if (prop.userType() != QVariant::Double && prop.userType() != QMetaType::Float)

   890         return 0.;

   891     return qVariantValue<qreal>(prop);

   892 }

   893 

   894 /*!

   895     Returns the value of the property given by \a propertyId; if the

   896     property isn't of QVariant::String type, an empty string is

   897     returned instead.

   898 

   899     \sa setProperty() boolProperty() intProperty() doubleProperty() colorProperty() lengthProperty() lengthVectorProperty() Property

   900 */

   901 QString QTextFormat::stringProperty(int propertyId) const

   902 {

   903     if (!d)

   904         return QString();

   905     const QVariant prop = d->property(propertyId);

   906     if (prop.userType() != QVariant::String)

   907         return QString();

   908     return prop.toString();

   909 }

   910 

   911 /*!

   912     Returns the value of the property given by \a propertyId; if the

   913     property isn't of QVariant::Color type, an invalid color is

   914     returned instead.

   915 

   916     \sa setProperty(), boolProperty(), intProperty(), doubleProperty(),

   917         stringProperty(), lengthProperty(), lengthVectorProperty(), Property

   918 */

   919 QColor QTextFormat::colorProperty(int propertyId) const

   920 {

   921     if (!d)

   922         return QColor();

   923     const QVariant prop = d->property(propertyId);

   924     if (prop.userType() != QVariant::Color)

   925         return QColor();

   926     return qvariant_cast<QColor>(prop);

   927 }

   928 

   929 /*!

   930     Returns the value of the property given by \a propertyId; if the

   931     property isn't of QVariant::Pen type, Qt::NoPen is

   932     returned instead.

   933 

   934     \sa setProperty() boolProperty() intProperty() doubleProperty() stringProperty() lengthProperty() lengthVectorProperty() Property

   935 */

   936 QPen QTextFormat::penProperty(int propertyId) const

   937 {

   938     if (!d)

   939         return QPen(Qt::NoPen);

   940     const QVariant prop = d->property(propertyId);

   941     if (prop.userType() != QVariant::Pen)

   942         return QPen(Qt::NoPen);

   943     return qvariant_cast<QPen>(prop);

   944 }

   945 

   946 /*!

   947     Returns the value of the property given by \a propertyId; if the

   948     property isn't of QVariant::Brush type, Qt::NoBrush is

   949     returned instead.

   950 

   951     \sa setProperty() boolProperty() intProperty() doubleProperty() stringProperty() lengthProperty() lengthVectorProperty() Property

   952 */

   953 QBrush QTextFormat::brushProperty(int propertyId) const

   954 {

   955     if (!d)

   956         return QBrush(Qt::NoBrush);

   957     const QVariant prop = d->property(propertyId);

   958     if (prop.userType() != QVariant::Brush)

   959         return QBrush(Qt::NoBrush);

   960     return qvariant_cast<QBrush>(prop);

   961 }

   962 

   963 /*!

   964     Returns the value of the property given by \a propertyId.

   965 

   966     \sa setProperty() boolProperty() intProperty() doubleProperty() stringProperty() colorProperty() lengthVectorProperty() Property

   967 */

   968 QTextLength QTextFormat::lengthProperty(int propertyId) const

   969 {

   970     if (!d)

   971         return QTextLength();

   972     return qvariant_cast<QTextLength>(d->property(propertyId));

   973 }

   974 

   975 /*!

   976     Returns the value of the property given by \a propertyId. If the

   977     property isn't of QTextFormat::LengthVector type, an empty length

   978     vector is returned instead.

   979 

   980     \sa setProperty() boolProperty() intProperty() doubleProperty() stringProperty() colorProperty() lengthProperty() Property

   981 */

   982 QVector<QTextLength> QTextFormat::lengthVectorProperty(int propertyId) const

   983 {

   984     QVector<QTextLength> vector;

   985     if (!d)

   986         return vector;

   987     const QVariant prop = d->property(propertyId);

   988     if (prop.userType() != QVariant::List)

   989         return vector;

   990 

   991     QList<QVariant> propertyList = prop.toList();

   992     for (int i=0; i<propertyList.size(); ++i) {

   993         QVariant var = propertyList.at(i);

   994         if (var.userType() == QVariant::TextLength)

   995             vector.append(qvariant_cast<QTextLength>(var));

   996     }

   997 

   998     return vector;

   999 }

  1000 

  1001 /*!

  1002     Returns the property specified by the given \a propertyId.

  1003 

  1004     \sa Property

  1005 */

  1006 QVariant QTextFormat::property(int propertyId) const

  1007 {

  1008     return d ? d->property(propertyId) : QVariant();

  1009 }

  1010 

  1011 /*!

  1012     Sets the property specified by the \a propertyId to the given \a value.

  1013 

  1014     \sa Property

  1015 */

  1016 void QTextFormat::setProperty(int propertyId, const QVariant &value)

  1017 {

  1018     if (!d)

  1019         d = new QTextFormatPrivate;

  1020     if (!value.isValid())

  1021         clearProperty(propertyId);

  1022     else

  1023         d->insertProperty(propertyId, value);

  1024 }

  1025 

  1026 /*!

  1027     Sets the value of the property given by \a propertyId to \a value.

  1028 

  1029     \sa lengthVectorProperty() Property

  1030 */

  1031 void QTextFormat::setProperty(int propertyId, const QVector<QTextLength> &value)

  1032 {

  1033     if (!d)

  1034         d = new QTextFormatPrivate;

  1035     QVariantList list;

  1036     for (int i=0; i<value.size(); ++i)

  1037         list << value.at(i);

  1038     d->insertProperty(propertyId, list);

  1039 }

  1040 

  1041 /*!

  1042     Clears the value of the property given by \a propertyId

  1043 

  1044     \sa Property

  1045 */

  1046 void QTextFormat::clearProperty(int propertyId)

  1047 {

  1048     if (!d)

  1049         return;

  1050     d->clearProperty(propertyId);

  1051 }

  1052 

  1053 

  1054 /*!

  1055     \fn void QTextFormat::setObjectType(int type)

  1056 

  1057     Sets the text format's object type to \a type.

  1058 

  1059     \sa ObjectTypes, objectType()

  1060 */

  1061 

  1062 

  1063 /*!

  1064     \fn int QTextFormat::objectType() const

  1065 

  1066     Returns the text format's object type.

  1067 

  1068     \sa ObjectTypes, setObjectType()

  1069 */

  1070 

  1071 

  1072 /*!

  1073     Returns the index of the format object, or -1 if the format object is invalid.

  1074 

  1075     \sa setObjectIndex()

  1076 */

  1077 int QTextFormat::objectIndex() const

  1078 {

  1079     if (!d)

  1080         return -1;

  1081     const QVariant prop = d->property(ObjectIndex);

  1082     if (prop.userType() != QVariant::Int) // ####

  1083         return -1;

  1084     return prop.toInt();

  1085 }

  1086 

  1087 /*!

  1088     \fn void QTextFormat::setObjectIndex(int index)

  1089 

  1090     Sets the format object's object \a index.

  1091 

  1092     \sa objectIndex()

  1093 */

  1094 void QTextFormat::setObjectIndex(int o)

  1095 {

  1096     if (o == -1) {

  1097         if (d)

  1098             d->clearProperty(ObjectIndex);

  1099     } else {

  1100         if (!d)

  1101             d = new QTextFormatPrivate;

  1102         // ### type

  1103         d->insertProperty(ObjectIndex, o);

  1104     }

  1105 }

  1106 

  1107 /*!

  1108     Returns true if the text format has a property with the given \a

  1109     propertyId; otherwise returns false.

  1110 

  1111     \sa properties() Property

  1112 */

  1113 bool QTextFormat::hasProperty(int propertyId) const

  1114 {

  1115     return d ? d->hasProperty(propertyId) : false;

  1116 }

  1117 

  1118 /*

  1119     Returns the property type for the given \a propertyId.

  1120 

  1121     \sa hasProperty() allPropertyIds() Property

  1122 */

  1123 

  1124 /*!

  1125     Returns a map with all properties of this text format.

  1126 */

  1127 QMap<int, QVariant> QTextFormat::properties() const

  1128 {

  1129     QMap<int, QVariant> map;

  1130     if (d) {

  1131         for (int i = 0; i < d->props.count(); ++i)

  1132             map.insert(d->props.at(i).key, d->props.at(i).value);

  1133     }

  1134     return map;