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

     2 **

     3 ** Copyright (C) 2010 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 // this is only safe if sizeof(int) == sizeof(float)

   269 static inline uint hash(float d)

   270 {

   271     return reinterpret_cast<uint&>(d);

   272 }

   273 

   274 static inline uint hash(const QColor &color)

   275 {

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

   277 }

   278 

   279 static inline uint hash(const QPen &pen)

   280 {

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

   282 }

   283 

   284 static inline uint hash(const QBrush &brush)

   285 {

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

   287 }

   288 

   289 static inline uint variantHash(const QVariant &variant)

   290 {

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

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

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

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

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

   296     case QVariant::Brush:

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

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

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

   300     case QVariant::List:

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

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

   303       case QVariant::TextLength:

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

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

   306     case QVariant::Invalid: return 0;

   307     default: break;

   308     }

   309     return qHash(variant.typeName());

   310 }

   311 

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

   313 {

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

   315 }

   316 

   317 uint QTextFormatPrivate::recalcHash() const

   318 {

   319     hashValue = 0;

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

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

   322 

   323     hashDirty = false;

   324 

   325     return hashValue;

   326 }

   327 

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

   329 {

   330     recalcFont();

   331     const uint oldMask = fnt.resolve();

   332     fnt = fnt.resolve(defaultFont);

   333 

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

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

   336 

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

   338 

   339 

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

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

   342             fnt.setPixelSize(qRound(pixelSize));

   343         } else {

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

   345             fnt.setPointSizeF(pointSize);

   346         }

   347     }

   348 

   349     fnt.resolve(oldMask);

   350 }

   351 

   352 void QTextFormatPrivate::recalcFont() const

   353 {

   354     // update cached font as well

   355     QFont f;

   356 

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

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

   359             case QTextFormat::FontFamily:

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

   361                 break;

   362             case QTextFormat::FontPointSize:

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

   364                 break;

   365             case  QTextFormat::FontPixelSize:

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

   367                 break;

   368             case QTextFormat::FontWeight: {

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

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

   371                 f.setWeight(weight);

   372                 break; }

   373             case QTextFormat::FontItalic:

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

   375                 break;

   376             case QTextFormat::FontUnderline:

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

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

   379                 break;

   380             case QTextFormat::TextUnderlineStyle:

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

   382                 break;

   383             case QTextFormat::FontOverline:

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

   385                 break;

   386             case QTextFormat::FontStrikeOut:

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

   388                 break;

   389             case QTextFormat::FontLetterSpacing:

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

   391                 break;

   392             case QTextFormat::FontWordSpacing:

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

   394                 break;

   395             case QTextFormat::FontCapitalization:

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

   397                 break;

   398             case QTextFormat::FontFixedPitch: {

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

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

   401                     f.setFixedPitch(value);

   402                 break; }

   403             case QTextFormat::FontStyleHint:

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

   405                 break;

   406             case QTextFormat::FontStyleStrategy:

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

   408                 break;

   409             case QTextFormat::FontKerning:

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

   411                 break;

   412             default:

   413                 break;

   414             }

   415     }

   416     fnt = f;

   417     fontDirty = false;

   418 }

   419 

   420 #ifndef QT_NO_DATASTREAM

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

   422 {

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

   424     return stream;

   425 }

   426 

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

   428 {

   429     QMap<qint32, QVariant> properties;

   430     stream >> fmt.format_type >> properties;

   431 

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

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

   434     if(!fmt.d)

   435         fmt.d = new QTextFormatPrivate();

   436 

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

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

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

   440 

   441     return stream;

   442 }

   443 #endif // QT_NO_DATASTREAM

   444 

   445 /*!

   446     \class QTextFormat

   447     \reentrant

   448 

   449     \brief The QTextFormat class provides formatting information for a

   450     QTextDocument.

   451 

   452     \ingroup richtext-processing

   453     \ingroup shared

   454 

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

   456     parts of a QTextDocument. The derived classes QTextCharFormat,

   457     QTextBlockFormat, QTextListFormat, and QTextTableFormat are usually

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

   459     specific parts of the document.

   460 

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

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

   463     also has various properties (some specific to particular format

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

   465     corresponding Property.

   466 

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

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

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

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

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

   472     and toImageFormat().

   473 

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

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

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

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

   478     be merged into another using merge().

   479 

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

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

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

   483     lists, frames, and tables inside the document.

   484 

   485     \sa {Rich Text Processing}

   486 */

   487 

   488 /*!

   489     \enum QTextFormat::FormatType

   490 

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

   492 

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

   494                          constructor

   495     \value BlockFormat The object formats a text block

   496     \value CharFormat The object formats a single character

   497     \value ListFormat The object formats a list

   498     \value TableFormat The object formats a table

   499     \value FrameFormat The object formats a frame

   500 

   501     \value UserFormat

   502 

   503     \sa QTextCharFormat, QTextBlockFormat, QTextListFormat,

   504     QTextTableFormat, type()

   505 */

   506 

   507 /*!

   508     \enum QTextFormat::Property

   509 

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

   511 

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

   513 

   514     Paragraph and character properties

   515 

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

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

   518                             (Qt::LayoutDirection).

   519 

   520     \value OutlinePen

   521     \value ForegroundBrush

   522     \value BackgroundBrush

   523     \value BackgroundImageUrl

   524 

   525     Paragraph properties

   526 

   527     \value BlockAlignment

   528     \value BlockTopMargin

   529     \value BlockBottomMargin

   530     \value BlockLeftMargin

   531     \value BlockRightMargin

   532     \value TextIndent

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

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

   535     \value BlockIndent

   536     \value BlockNonBreakableLines

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

   538 

   539     Character properties

   540 

   541     \value FontFamily

   542     \value FontPointSize

   543     \value FontPixelSize

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

   545                                     FontPointSize or FontPixelSize.

   546     \value FontFixedPitch

   547     \omitvalue FontSizeIncrement

   548     \value FontWeight

   549     \value FontItalic

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

   551     \value FontOverline

   552     \value FontStrikeOut

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

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

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

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

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

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

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

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

   561 

   562     \omitvalue FirstFontProperty

   563     \omitvalue LastFontProperty

   564 

   565     \value TextUnderlineColor

   566     \value TextVerticalAlignment

   567     \value TextOutline

   568     \value TextUnderlineStyle

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

   570 

   571     \value IsAnchor

   572     \value AnchorHref

   573     \value AnchorName

   574     \value ObjectType

   575 

   576     List properties

   577 

   578     \value ListStyle

   579     \value ListIndent

   580 

   581     Table and frame properties

   582 

   583     \value FrameBorder

   584     \value FrameBorderBrush

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

   586     \value FrameBottomMargin

   587     \value FrameHeight

   588     \value FrameLeftMargin

   589     \value FrameMargin

   590     \value FramePadding

   591     \value FrameRightMargin

   592     \value FrameTopMargin

   593     \value FrameWidth

   594     \value TableCellSpacing

   595     \value TableCellPadding

   596     \value TableColumns

   597     \value TableColumnWidthConstraints

   598     \value TableHeaderRowCount

   599 

   600     Table cell properties

   601 

   602     \value TableCellRowSpan

   603     \value TableCellColumnSpan

   604     \value TableCellLeftPadding

   605     \value TableCellRightPadding

   606     \value TableCellTopPadding

   607     \value TableCellBottomPadding

   608 

   609     Image properties

   610 

   611     \value ImageName

   612     \value ImageWidth

   613     \value ImageHeight

   614 

   615     Selection properties

   616 

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

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

   619 

   620     Page break properties

   621 

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

   623 

   624     \value UserProperty

   625 

   626     \sa property(), setProperty()

   627 */

   628 

   629 /*!

   630     \enum QTextFormat::ObjectTypes

   631 

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

   633 

   634     \value NoObject

   635     \value ImageObject

   636     \value TableObject

   637     \value TableCellObject

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

   639 

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

   641 */

   642 

   643 /*!

   644     \enum QTextFormat::PageBreakFlag

   645     \since 4.2

   646 

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

   648     corresponding css properties.

   649 

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

   651                           available space on the current page

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

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

   654 

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

   656     PageBreakPolicy

   657 */

   658 

   659 /*!

   660     \fn bool QTextFormat::isValid() const

   661 

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

   663     InvalidFormat); otherwise returns false.

   664 */

   665 

   666 /*!

   667     \fn bool QTextFormat::isCharFormat() const

   668 

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

   670     returns false.

   671 */

   672 

   673 

   674 /*!

   675     \fn bool QTextFormat::isBlockFormat() const

   676 

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

   678     returns false.

   679 */

   680 

   681 

   682 /*!

   683     \fn bool QTextFormat::isListFormat() const

   684 

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

   686     returns false.

   687 */

   688 

   689 

   690 /*!

   691     \fn bool QTextFormat::isTableFormat() const

   692 

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

   694     returns false.

   695 */

   696 

   697 

   698 /*!

   699     \fn bool QTextFormat::isFrameFormat() const

   700 

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

   702     returns false.

   703 */

   704 

   705 

   706 /*!

   707     \fn bool QTextFormat::isImageFormat() const

   708 

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

   710     returns false.

   711 */

   712 

   713 

   714 /*!

   715     \fn bool QTextFormat::isTableCellFormat() const

   716     \since 4.4

   717 

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

   719     returns false.

   720 */

   721 

   722 

   723 /*!

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

   725 

   726     \sa FormatType

   727 */

   728 QTextFormat::QTextFormat()

   729     : format_type(InvalidFormat)

   730 {

   731 }

   732 

   733 /*!

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

   735 

   736     \sa FormatType

   737 */

   738 QTextFormat::QTextFormat(int type)

   739     : format_type(type)

   740 {

   741 }

   742 

   743 

   744 /*!

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

   746 

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

   748     text format.

   749 */

   750 QTextFormat::QTextFormat(const QTextFormat &rhs)

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

   752 {

   753 }

   754 

   755 /*!

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

   757 

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

   759     reference to this text format.

   760 */

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

   762 {

   763     d = rhs.d;

   764     format_type = rhs.format_type;

   765     return *this;

   766 }

   767 

   768 /*!

   769     Destroys this text format.

   770 */

   771 QTextFormat::~QTextFormat()

   772 {

   773 }

   774 

   775 

   776 /*!

   777    Returns the text format as a QVariant

   778 */

   779 QTextFormat::operator QVariant() const

   780 {

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

   782 }

   783 

   784 /*!

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

   786     conflicts the \a other format takes precedence.

   787 */

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

   789 {

   790     if (format_type != other.format_type)

   791         return;

   792 

   793     if (!d) {

   794         d = other.d;

   795         return;

   796     }

   797 

   798     if (!other.d)

   799         return;

   800 

   801     QTextFormatPrivate *d = this->d;

   802 

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

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

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

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

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

   808     }

   809 }

   810 

   811 /*!

   812     Returns the type of this format.

   813 

   814     \sa FormatType

   815 */

   816 int QTextFormat::type() const

   817 {

   818     return format_type;

   819 }

   820 

   821 /*!

   822     Returns this format as a block format.

   823 */

   824 QTextBlockFormat QTextFormat::toBlockFormat() const

   825 {

   826     return QTextBlockFormat(*this);

   827 }

   828 

   829 /*!

   830     Returns this format as a character format.

   831 */

   832 QTextCharFormat QTextFormat::toCharFormat() const

   833 {

   834     return QTextCharFormat(*this);

   835 }

   836 

   837 /*!

   838     Returns this format as a list format.

   839 */

   840 QTextListFormat QTextFormat::toListFormat() const

   841 {

   842     return QTextListFormat(*this);

   843 }

   844 

   845 /*!

   846     Returns this format as a table format.

   847 */

   848 QTextTableFormat QTextFormat::toTableFormat() const

   849 {

   850     return QTextTableFormat(*this);

   851 }

   852 

   853 /*!

   854     Returns this format as a frame format.

   855 */

   856 QTextFrameFormat QTextFormat::toFrameFormat() const

   857 {

   858     return QTextFrameFormat(*this);

   859 }

   860 

   861 /*!

   862     Returns this format as an image format.

   863 */

   864 QTextImageFormat QTextFormat::toImageFormat() const

   865 {

   866     return QTextImageFormat(*this);

   867 }

   868 

   869 /*!

   870     \since 4.4

   871 

   872     Returns this format as a table cell format.

   873 */

   874 QTextTableCellFormat QTextFormat::toTableCellFormat() const

   875 {

   876     return QTextTableCellFormat(*this);

   877 }

   878 

   879 /*!

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

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

   882 

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

   884 */

   885 bool QTextFormat::boolProperty(int propertyId) const

   886 {

   887     if (!d)

   888         return false;

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

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

   891         return false;

   892     return prop.toBool();

   893 }

   894 

   895 /*!

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

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

   898 

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

   900 */

   901 int QTextFormat::intProperty(int propertyId) const

   902 {

   903     if (!d)

   904         return 0;

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

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

   907         return 0;

   908     return prop.toInt();

   909 }

   910 

   911 /*!

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

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

   914     returned instead.

   915 

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

   917 */

   918 qreal QTextFormat::doubleProperty(int propertyId) const

   919 {

   920     if (!d)

   921         return 0.;

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

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

   924         return 0.;

   925     return qVariantValue<qreal>(prop);

   926 }

   927 

   928 /*!

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

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

   931     returned instead.

   932 

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

   934 */

   935 QString QTextFormat::stringProperty(int propertyId) const

   936 {

   937     if (!d)

   938         return QString();

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

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

   941         return QString();

   942     return prop.toString();

   943 }

   944 

   945 /*!

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

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

   948     returned instead.

   949 

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

   951         stringProperty(), lengthProperty(), lengthVectorProperty(), Property

   952 */

   953 QColor QTextFormat::colorProperty(int propertyId) const

   954 {

   955     if (!d)

   956         return QColor();

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

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

   959         return QColor();

   960     return qvariant_cast<QColor>(prop);

   961 }

   962 

   963 /*!

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

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

   966     returned instead.

   967 

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

   969 */

   970 QPen QTextFormat::penProperty(int propertyId) const

   971 {

   972     if (!d)

   973         return QPen(Qt::NoPen);

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

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

   976         return QPen(Qt::NoPen);

   977     return qvariant_cast<QPen>(prop);

   978 }

   979 

   980 /*!

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

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

   983     returned instead.

   984 

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

   986 */

   987 QBrush QTextFormat::brushProperty(int propertyId) const

   988 {

   989     if (!d)

   990         return QBrush(Qt::NoBrush);

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

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

   993         return QBrush(Qt::NoBrush);

   994     return qvariant_cast<QBrush>(prop);

   995 }

   996 

   997 /*!

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

   999 

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

  1001 */

  1002 QTextLength QTextFormat::lengthProperty(int propertyId) const

  1003 {

  1004     if (!d)

  1005         return QTextLength();

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

  1007 }

  1008 

  1009 /*!

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

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

  1012     vector is returned instead.

  1013 

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

  1015 */

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

  1017 {

  1018     QVector<QTextLength> vector;

  1019     if (!d)

  1020         return vector;

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

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

  1023         return vector;

  1024 

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

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

  1027         QVariant var = propertyList.at(i);

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

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

  1030     }

  1031 

  1032     return vector;

  1033 }

  1034 

  1035 /*!

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

  1037 

  1038     \sa Property

  1039 */

  1040 QVariant QTextFormat::property(int propertyId) const

  1041 {

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

  1043 }

  1044 

  1045 /*!

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

  1047 

  1048     \sa Property

  1049 */

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

  1051 {

  1052     if (!d)

  1053         d = new QTextFormatPrivate;

  1054     if (!value.isValid())

  1055         clearProperty(propertyId);

  1056     else

  1057         d->insertProperty(propertyId, value);

  1058 }

  1059 

  1060 /*!

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

  1062 

  1063     \sa lengthVectorProperty() Property

  1064 */

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

  1066 {

  1067     if (!d)

  1068         d = new QTextFormatPrivate;

  1069     QVariantList list;

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

  1071         list << value.at(i);

  1072     d->insertProperty(propertyId, list);

  1073 }

  1074 

  1075 /*!

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

  1077 

  1078     \sa Property

  1079 */

  1080 void QTextFormat::clearProperty(int propertyId)

  1081 {

  1082     if (!d)

  1083         return;

  1084     d->clearProperty(propertyId);

  1085 }

  1086 

  1087 

  1088 /*!

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

  1090 

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

  1092 

  1093     \sa ObjectTypes, objectType()

  1094 */

  1095 

  1096 

  1097 /*!

  1098     \fn int QTextFormat::objectType() const

  1099 

  1100     Returns the text format's object type.

  1101 

  1102     \sa ObjectTypes, setObjectType()

  1103 */

  1104 

  1105 

  1106 /*!

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

  1108 

  1109     \sa setObjectIndex()

  1110 */

  1111 int QTextFormat::objectIndex() const

  1112 {

  1113     if (!d)

  1114         return -1;

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

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

  1117         return -1;

  1118     return prop.toInt();

  1119 }

  1120 

  1121 /*!

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

  1123 

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

  1125 

  1126     \sa objectIndex()

  1127 */

  1128 void QTextFormat::setObjectIndex(int o)

  1129 {

  1130     if (o == -1) {

  1131         if (d)

  1132             d->clearProperty(ObjectIndex);

  1133     } else {

  1134         if (!d)

  1135             d = new QTextFormatPrivate;