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 "qfont.h"

    43 #include "qpaintdevice.h"

    44 #include "qfontmetrics.h"

    45 

    46 #include "qfont_p.h"

    47 #include "qfontengine_p.h"

    48 #include <private/qunicodetables_p.h>

    49 

    50 #include <math.h>

    51 

    52 #ifdef Q_WS_X11

    53 #include "qx11info_x11.h"

    54 #endif

    55 

    56 QT_BEGIN_NAMESPACE

    57 

    58 #ifdef Q_WS_X11

    59 extern const QX11Info *qt_x11Info(const QPaintDevice *pd);

    60 #endif

    61 

    62 extern void qt_format_text(const QFont& font, const QRectF &_r,

    63                            int tf, const QString &text, QRectF *brect,

    64                            int tabStops, int *tabArray, int tabArrayLen,

    65                            QPainter *painter);

    66 extern int qt_defaultDpi();

    67 

    68 /*****************************************************************************

    69   QFontMetrics member functions

    70  *****************************************************************************/

    71 

    72 /*!

    73     \class QFontMetrics

    74     \reentrant

    75 

    76     \brief The QFontMetrics class provides font metrics information.

    77 

    78     \ingroup painting

    79     \ingroup shared

    80 

    81     QFontMetrics functions calculate the size of characters and

    82     strings for a given font. There are three ways you can create a

    83     QFontMetrics object:

    84 

    85     \list 1

    86     \o Calling the QFontMetrics constructor with a QFont creates a

    87     font metrics object for a screen-compatible font, i.e. the font

    88     cannot be a printer font. If the font is changed

    89     later, the font metrics object is \e not updated.

    90 

    91     (Note: If you use a printer font the values returned may be

    92     inaccurate. Printer fonts are not always accessible so the nearest

    93     screen font is used if a printer font is supplied.)

    94 

    95     \o QWidget::fontMetrics() returns the font metrics for a widget's

    96     font. This is equivalent to QFontMetrics(widget->font()). If the

    97     widget's font is changed later, the font metrics object is \e not

    98     updated.

    99 

   100     \o QPainter::fontMetrics() returns the font metrics for a

   101     painter's current font. If the painter's font is changed later, the

   102     font metrics object is \e not updated.

   103     \endlist

   104 

   105     Once created, the object provides functions to access the

   106     individual metrics of the font, its characters, and for strings

   107     rendered in the font.

   108 

   109     There are several functions that operate on the font: ascent(),

   110     descent(), height(), leading() and lineSpacing() return the basic

   111     size properties of the font. The underlinePos(), overlinePos(),

   112     strikeOutPos() and lineWidth() functions, return the properties of

   113     the line that underlines, overlines or strikes out the

   114     characters. These functions are all fast.

   115 

   116     There are also some functions that operate on the set of glyphs in

   117     the font: minLeftBearing(), minRightBearing() and maxWidth().

   118     These are by necessity slow, and we recommend avoiding them if

   119     possible.

   120 

   121     For each character, you can get its width(), leftBearing() and

   122     rightBearing() and find out whether it is in the font using

   123     inFont(). You can also treat the character as a string, and use

   124     the string functions on it.

   125 

   126     The string functions include width(), to return the width of a

   127     string in pixels (or points, for a printer), boundingRect(), to

   128     return a rectangle large enough to contain the rendered string,

   129     and size(), to return the size of that rectangle.

   130 

   131     Example:

   132     \snippet doc/src/snippets/code/src_gui_text_qfontmetrics.cpp 0

   133 

   134     \sa QFont, QFontInfo, QFontDatabase, QFontComboBox, {Character Map Example}

   135 */

   136 

   137 /*!

   138     \fn QRect QFontMetrics::boundingRect(int x, int y, int width, int height,

   139         int flags, const QString &text, int tabStops, int *tabArray) const

   140     \overload

   141 

   142     Returns the bounding rectangle for the given \a text within the

   143     rectangle specified by the \a x and \a y coordinates, \a width, and

   144     \a height.

   145 

   146     If Qt::TextExpandTabs is set in \a flags and \a tabArray is

   147     non-null, it specifies a 0-terminated sequence of pixel-positions

   148     for tabs; otherwise, if \a tabStops is non-zero, it is used as the

   149     tab spacing (in pixels).

   150 */

   151 

   152 /*!

   153     Constructs a font metrics object for \a font.

   154 

   155     The font metrics will be compatible with the paintdevice used to

   156     create \a font.

   157 

   158     The font metrics object holds the information for the font that is

   159     passed in the constructor at the time it is created, and is not

   160     updated if the font's attributes are changed later.

   161 

   162     Use QFontMetrics(const QFont &, QPaintDevice *) to get the font

   163     metrics that are compatible with a certain paint device.

   164 */

   165 QFontMetrics::QFontMetrics(const QFont &font)

   166     : d(font.d.data())

   167 {

   168 }

   169 

   170 /*!

   171     Constructs a font metrics object for \a font and \a paintdevice.

   172 

   173     The font metrics will be compatible with the paintdevice passed.

   174     If the \a paintdevice is 0, the metrics will be screen-compatible,

   175     ie. the metrics you get if you use the font for drawing text on a

   176     \link QWidget widgets\endlink or \link QPixmap pixmaps\endlink,

   177     not on a QPicture or QPrinter.

   178 

   179     The font metrics object holds the information for the font that is

   180     passed in the constructor at the time it is created, and is not

   181     updated if the font's attributes are changed later.

   182 */

   183 QFontMetrics::QFontMetrics(const QFont &font, QPaintDevice *paintdevice)

   184 {

   185     int dpi = paintdevice ? paintdevice->logicalDpiY() : qt_defaultDpi();

   186 #ifdef Q_WS_X11

   187     const QX11Info *info = qt_x11Info(paintdevice);

   188     int screen = info ? info->screen() : 0;

   189 #else

   190     const int screen = 0;

   191 #endif

   192     if (font.d->dpi != dpi || font.d->screen != screen ) {

   193         d = new QFontPrivate(*font.d);

   194         d->dpi = dpi;

   195         d->screen = screen;

   196     } else {

   197         d = font.d.data();

   198     }

   199 

   200 }

   201 

   202 /*!

   203     Constructs a copy of \a fm.

   204 */

   205 QFontMetrics::QFontMetrics(const QFontMetrics &fm)

   206     : d(fm.d.data())

   207 {

   208 }

   209 

   210 /*!

   211     Destroys the font metrics object and frees all allocated

   212     resources.

   213 */

   214 QFontMetrics::~QFontMetrics()

   215 {

   216 }

   217 

   218 /*!

   219     Assigns the font metrics \a fm.

   220 */

   221 QFontMetrics &QFontMetrics::operator=(const QFontMetrics &fm)

   222 {

   223     d = fm.d.data();

   224     return *this;

   225 }

   226 

   227 /*!

   228     \overload

   229     Returns true if \a other is equal to this object; otherwise

   230     returns false.

   231 

   232     Two font metrics are considered equal if they were constructed

   233     from the same QFont and the paint devices they were constructed

   234     for are considered compatible.

   235 

   236     \sa operator!=()

   237 */

   238 bool QFontMetrics::operator ==(const QFontMetrics &other) const

   239 {

   240     return d == other.d;

   241 }

   242 

   243 /*!

   244     Returns true if \a other is equal to this object; otherwise

   245     returns false.

   246 

   247     Two font metrics are considered equal if they were constructed

   248     from the same QFont and the paint devices they were constructed

   249     for are considered compatible.

   250 

   251     \sa operator!=()

   252 */

   253 bool QFontMetrics::operator ==(const QFontMetrics &other)

   254 {

   255     return d == other.d;

   256 }

   257 

   258 /*!

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

   260 

   261     Returns true if \a other is not equal to this object; otherwise returns false.

   262 

   263     Two font metrics are considered equal if they were constructed

   264     from the same QFont and the paint devices they were constructed

   265     for are considered compatible.

   266 

   267     \sa operator==()

   268 */

   269 

   270 /*!

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

   272 

   273     Returns true if \a other is not equal to this object; otherwise returns false.

   274 

   275     Two font metrics are considered equal if they were constructed

   276     from the same QFont and the paint devices they were constructed

   277     for are considered compatible.

   278 

   279     \sa operator==()

   280 */

   281 

   282 /*!

   283     Returns the ascent of the font.

   284 

   285     The ascent of a font is the distance from the baseline to the

   286     highest position characters extend to. In practice, some font

   287     designers break this rule, e.g. when they put more than one accent

   288     on top of a character, or to accommodate an unusual character in

   289     an exotic language, so it is possible (though rare) that this

   290     value will be too small.

   291 

   292     \sa descent()

   293 */

   294 int QFontMetrics::ascent() const

   295 {

   296     QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

   297     Q_ASSERT(engine != 0);

   298     return qRound(engine->ascent());

   299 }

   300 

   301 

   302 /*!

   303     Returns the descent of the font.

   304 

   305     The descent is the distance from the base line to the lowest point

   306     characters extend to. In practice, some font designers break this rule,

   307     e.g. to accommodate an unusual character in an exotic language, so

   308     it is possible (though rare) that this value will be too small.

   309 

   310     \sa ascent()

   311 */

   312 int QFontMetrics::descent() const

   313 {

   314     QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

   315     Q_ASSERT(engine != 0);

   316     return qRound(engine->descent());

   317 }

   318 

   319 /*!

   320     Returns the height of the font.

   321 

   322     This is always equal to ascent()+descent()+1 (the 1 is for the

   323     base line).

   324 

   325     \sa leading(), lineSpacing()

   326 */

   327 int QFontMetrics::height() const

   328 {

   329     QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

   330     Q_ASSERT(engine != 0);

   331     return qRound(engine->ascent() + engine->descent()) + 1;

   332 }

   333 

   334 /*!

   335     Returns the leading of the font.

   336 

   337     This is the natural inter-line spacing.

   338 

   339     \sa height(), lineSpacing()

   340 */

   341 int QFontMetrics::leading() const

   342 {

   343     QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

   344     Q_ASSERT(engine != 0);

   345     return qRound(engine->leading());

   346 }

   347 

   348 /*!

   349     Returns the distance from one base line to the next.

   350 

   351     This value is always equal to leading()+height().

   352 

   353     \sa height(), leading()

   354 */

   355 int QFontMetrics::lineSpacing() const

   356 {

   357     QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

   358     Q_ASSERT(engine != 0);

   359     return qRound(engine->leading() + engine->ascent() + engine->descent()) + 1;

   360 }

   361 

   362 /*!

   363     Returns the minimum left bearing of the font.

   364 

   365     This is the smallest leftBearing(char) of all characters in the

   366     font.

   367 

   368     Note that this function can be very slow if the font is large.

   369 

   370     \sa minRightBearing(), leftBearing()

   371 */

   372 int QFontMetrics::minLeftBearing() const

   373 {

   374     QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

   375     Q_ASSERT(engine != 0);

   376     return qRound(engine->minLeftBearing());

   377 }

   378 

   379 /*!

   380     Returns the minimum right bearing of the font.

   381 

   382     This is the smallest rightBearing(char) of all characters in the

   383     font.

   384 

   385     Note that this function can be very slow if the font is large.

   386 

   387     \sa minLeftBearing(), rightBearing()

   388 */

   389 int QFontMetrics::minRightBearing() const

   390 {

   391     QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

   392     Q_ASSERT(engine != 0);

   393     return qRound(engine->minRightBearing());

   394 }

   395 

   396 /*!

   397     Returns the width of the widest character in the font.

   398 */

   399 int QFontMetrics::maxWidth() const

   400 {

   401     QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

   402     Q_ASSERT(engine != 0);

   403     return qRound(engine->maxCharWidth());

   404 }

   405 

   406 /*!

   407     Returns the 'x' height of the font. This is often but not always

   408     the same as the height of the character 'x'.

   409 */

   410 int QFontMetrics::xHeight() const

   411 {

   412     QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

   413     Q_ASSERT(engine != 0);

   414     if (d->capital == QFont::SmallCaps)

   415         return qRound(d->smallCapsFontPrivate()->engineForScript(QUnicodeTables::Common)->ascent());

   416     return qRound(engine->xHeight());

   417 }

   418 

   419 /*!

   420     \since 4.2

   421 

   422     Returns the average width of glyphs in the font.

   423 */

   424 int QFontMetrics::averageCharWidth() const

   425 {

   426     QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

   427     Q_ASSERT(engine != 0);

   428     return qRound(engine->averageCharWidth());

   429 }

   430 

   431 /*!

   432     Returns true if character \a ch is a valid character in the font;

   433     otherwise returns false.

   434 */

   435 bool QFontMetrics::inFont(QChar ch) const

   436 {

   437     const int script = QUnicodeTables::script(ch);

   438     QFontEngine *engine = d->engineForScript(script);

   439     Q_ASSERT(engine != 0);

   440     if (engine->type() == QFontEngine::Box)

   441         return false;

   442     return engine->canRender(&ch, 1);

   443 }

   444 

   445 /*!

   446     Returns the left bearing of character \a ch in the font.

   447 

   448     The left bearing is the right-ward distance of the left-most pixel

   449     of the character from the logical origin of the character. This

   450     value is negative if the pixels of the character extend to the

   451     left of the logical origin.

   452 

   453     See width(QChar) for a graphical description of this metric.

   454 

   455     \sa rightBearing(), minLeftBearing(), width()

   456 */

   457 int QFontMetrics::leftBearing(QChar ch) const

   458 {

   459     const int script = QUnicodeTables::script(ch);

   460     QFontEngine *engine;

   461     if (d->capital == QFont::SmallCaps && ch.isLower())

   462         engine = d->smallCapsFontPrivate()->engineForScript(script);

   463     else

   464         engine = d->engineForScript(script);

   465     Q_ASSERT(engine != 0);

   466     if (engine->type() == QFontEngine::Box)

   467         return 0;

   468 

   469     d->alterCharForCapitalization(ch);

   470 

   471     QGlyphLayoutArray<10> glyphs;

   472     int nglyphs = 9;

   473     engine->stringToCMap(&ch, 1, &glyphs, &nglyphs, 0);

   474     // ### can nglyphs != 1 happen at all? Not currently I think

   475     qreal lb;

   476     engine->getGlyphBearings(glyphs.glyphs[0], &lb);

   477     return qRound(lb);

   478 }

   479 

   480 /*!

   481     Returns the right bearing of character \a ch in the font.

   482 

   483     The right bearing is the left-ward distance of the right-most

   484     pixel of the character from the logical origin of a subsequent

   485     character. This value is negative if the pixels of the character

   486     extend to the right of the width() of the character.

   487 

   488     See width() for a graphical description of this metric.

   489 

   490     \sa leftBearing(), minRightBearing(), width()

   491 */

   492 int QFontMetrics::rightBearing(QChar ch) const

   493 {

   494     const int script = QUnicodeTables::script(ch);

   495     QFontEngine *engine;

   496     if (d->capital == QFont::SmallCaps && ch.isLower())

   497         engine = d->smallCapsFontPrivate()->engineForScript(script);

   498     else

   499         engine = d->engineForScript(script);

   500     Q_ASSERT(engine != 0);

   501     if (engine->type() == QFontEngine::Box)

   502         return 0;

   503 

   504     d->alterCharForCapitalization(ch);

   505 

   506     QGlyphLayoutArray<10> glyphs;

   507     int nglyphs = 9;

   508     engine->stringToCMap(&ch, 1, &glyphs, &nglyphs, 0);

   509     // ### can nglyphs != 1 happen at all? Not currently I think

   510     qreal rb;

   511     engine->getGlyphBearings(glyphs.glyphs[0], 0, &rb);

   512     return qRound(rb);

   513 }

   514 

   515 /*!

   516     Returns the width in pixels of the first \a len characters of \a

   517     text. If \a len is negative (the default), the entire string is

   518     used.

   519 

   520     Note that this value is \e not equal to boundingRect().width();

   521     boundingRect() returns a rectangle describing the pixels this

   522     string will cover whereas width() returns the distance to where

   523     the next string should be drawn.

   524 

   525     \sa boundingRect()

   526 */

   527 int QFontMetrics::width(const QString &text, int len) const

   528 {

   529     int pos = text.indexOf(QLatin1Char('\x9c'));

   530     if (pos != -1) {

   531         len = (len < 0) ? pos : qMin(pos, len);

   532     } else if (len < 0) {

   533         len = text.length();

   534     }

   535     if (len == 0)

   536         return 0;

   537 

   538     QTextEngine layout(text, d.data());

   539     layout.ignoreBidi = true;

   540     return qRound(layout.width(0, len));

   541 }

   542 

   543 /*!

   544     \overload

   545 

   546     \img bearings.png Bearings

   547 

   548     Returns the logical width of character \a ch in pixels. This is a

   549     distance appropriate for drawing a subsequent character after \a

   550     ch.

   551 

   552     Some of the metrics are described in the image to the right. The

   553     central dark rectangles cover the logical width() of each

   554     character. The outer pale rectangles cover the leftBearing() and

   555     rightBearing() of each character. Notice that the bearings of "f"

   556     in this particular font are both negative, while the bearings of

   557     "o" are both positive.

   558 

   559     \warning This function will produce incorrect results for Arabic

   560     characters or non-spacing marks in the middle of a string, as the

   561     glyph shaping and positioning of marks that happens when

   562     processing strings cannot be taken into account. When implementing

   563     an interactive text control, use QTextLayout instead.

   564 

   565     \sa boundingRect()

   566 */

   567 int QFontMetrics::width(QChar ch) const

   568 {

   569     if (QChar::category(ch.unicode()) == QChar::Mark_NonSpacing)

   570         return 0;

   571 

   572     const int script = QUnicodeTables::script(ch);

   573     QFontEngine *engine;

   574     if (d->capital == QFont::SmallCaps && ch.isLower())

   575         engine = d->smallCapsFontPrivate()->engineForScript(script);

   576     else

   577         engine = d->engineForScript(script);

   578     Q_ASSERT(engine != 0);

   579 

   580     d->alterCharForCapitalization(ch);

   581 

   582     QGlyphLayoutArray<8> glyphs;

   583     int nglyphs = 7;

   584     engine->stringToCMap(&ch, 1, &glyphs, &nglyphs, 0);

   585     return qRound(glyphs.advances_x[0]);

   586 }

   587 

   588 /*! \obsolete

   589 

   590     Returns the width of the character at position \a pos in the

   591     string \a text.

   592 

   593     The whole string is needed, as the glyph drawn may change

   594     depending on the context (the letter before and after the current

   595     one) for some languages (e.g. Arabic).

   596 

   597     This function also takes non spacing marks and ligatures into

   598     account.

   599 */

   600 int QFontMetrics::charWidth(const QString &text, int pos) const

   601 {

   602     if (pos < 0 || pos > (int)text.length())

   603         return 0;

   604 

   605     QChar ch = text.unicode()[pos];

   606     const int script = QUnicodeTables::script(ch);

   607     int width;

   608 

   609     if (script != QUnicodeTables::Common) {

   610         // complex script shaping. Have to do some hard work

   611         int from = qMax(0, pos - 8);

   612         int to = qMin(text.length(), pos + 8);

   613         QString cstr = QString::fromRawData(text.unicode() + from, to - from);

   614         QTextEngine layout(cstr, d.data());

   615         layout.ignoreBidi = true;

   616         layout.itemize();

   617         width = qRound(layout.width(pos-from, 1));

   618     } else if (QChar::category(ch.unicode()) == QChar::Mark_NonSpacing) {

   619         width = 0;

   620     } else {

   621         QFontEngine *engine;

   622         if (d->capital == QFont::SmallCaps && ch.isLower())

   623             engine = d->smallCapsFontPrivate()->engineForScript(script);

   624         else

   625             engine = d->engineForScript(script);

   626         Q_ASSERT(engine != 0);

   627 

   628         d->alterCharForCapitalization(ch);

   629 

   630         QGlyphLayoutArray<8> glyphs;

   631         int nglyphs = 7;

   632         engine->stringToCMap(&ch, 1, &glyphs, &nglyphs, 0);

   633         width = qRound(glyphs.advances_x[0]);

   634     }

   635     return width;

   636 }

   637 

   638 /*!

   639     Returns the bounding rectangle of the characters in the string

   640     specified by \a text. The bounding rectangle always covers at least

   641     the set of pixels the text would cover if drawn at (0, 0).

   642 

   643     Note that the bounding rectangle may extend to the left of (0, 0),

   644     e.g. for italicized fonts, and that the width of the returned

   645     rectangle might be different than what the width() method returns.

   646 

   647     If you want to know the advance width of the string (to layout

   648     a set of strings next to each other), use width() instead.

   649 

   650     Newline characters are processed as normal characters, \e not as

   651     linebreaks.

   652 

   653     The height of the bounding rectangle is at least as large as the

   654     value returned by height().

   655 

   656     \sa width(), height(), QPainter::boundingRect(), tightBoundingRect()

   657 */

   658 QRect QFontMetrics::boundingRect(const QString &text) const

   659 {

   660     if (text.length() == 0)

   661         return QRect();

   662 

   663     QTextEngine layout(text, d.data());

   664     layout.ignoreBidi = true;

   665     layout.itemize();

   666     glyph_metrics_t gm = layout.boundingBox(0, text.length());

   667     return QRect(qRound(gm.x), qRound(gm.y), qRound(gm.width), qRound(gm.height));

   668 }

   669 

   670 /*!

   671     Returns the rectangle that is covered by ink if character \a ch

   672     were to be drawn at the origin of the coordinate system.

   673 

   674     Note that the bounding rectangle may extend to the left of (0, 0)

   675     (e.g., for italicized fonts), and that the text output may cover \e

   676     all pixels in the bounding rectangle. For a space character the rectangle

   677     will usually be empty.

   678 

   679     Note that the rectangle usually extends both above and below the

   680     base line.

   681 

   682     \warning The width of the returned rectangle is not the advance width

   683     of the character. Use boundingRect(const QString &) or width() instead.

   684 

   685     \sa width()

   686 */

   687 QRect QFontMetrics::boundingRect(QChar ch) const

   688 {

   689     const int script = QUnicodeTables::script(ch);

   690     QFontEngine *engine;

   691     if (d->capital == QFont::SmallCaps && ch.isLower())

   692         engine = d->smallCapsFontPrivate()->engineForScript(script);

   693     else

   694         engine = d->engineForScript(script);

   695     Q_ASSERT(engine != 0);

   696 

   697     d->alterCharForCapitalization(ch);

   698 

   699     QGlyphLayoutArray<10> glyphs;

   700     int nglyphs = 9;

   701     engine->stringToCMap(&ch, 1, &glyphs, &nglyphs, 0);

   702     glyph_metrics_t gm = engine->boundingBox(glyphs.glyphs[0]);

   703     return QRect(qRound(gm.x), qRound(gm.y), qRound(gm.width), qRound(gm.height));

   704 }

   705 

   706 /*!

   707     \overload

   708 

   709     Returns the bounding rectangle of the characters in the string

   710     specified by \a text, which is the set of pixels the text would

   711     cover if drawn at (0, 0). The drawing, and hence the bounding

   712     rectangle, is constrained to the rectangle \a rect.

   713 

   714     The \a flags argument is the bitwise OR of the following flags:

   715     \list

   716     \o Qt::AlignLeft aligns to the left border, except for

   717           Arabic and Hebrew where it aligns to the right.

   718     \o Qt::AlignRight aligns to the right border, except for

   719           Arabic and Hebrew where it aligns to the left.

   720     \o Qt::AlignJustify produces justified text.

   721     \o Qt::AlignHCenter aligns horizontally centered.

   722     \o Qt::AlignTop aligns to the top border.

   723     \o Qt::AlignBottom aligns to the bottom border.

   724     \o Qt::AlignVCenter aligns vertically centered

   725     \o Qt::AlignCenter (== \c{Qt::AlignHCenter | Qt::AlignVCenter})

   726     \o Qt::TextSingleLine ignores newline characters in the text.

   727     \o Qt::TextExpandTabs expands tabs (see below)

   728     \o Qt::TextShowMnemonic interprets "&x" as \underline{x}; i.e., underlined.

   729     \o Qt::TextWordWrap breaks the text to fit the rectangle.

   730     \endlist

   731 

   732     Qt::Horizontal alignment defaults to Qt::AlignLeft and vertical

   733     alignment defaults to Qt::AlignTop.

   734 

   735     If several of the horizontal or several of the vertical alignment

   736     flags are set, the resulting alignment is undefined.

   737 

   738     If Qt::TextExpandTabs is set in \a flags, then: if \a tabArray is

   739     non-null, it specifies a 0-terminated sequence of pixel-positions

   740     for tabs; otherwise if \a tabStops is non-zero, it is used as the

   741     tab spacing (in pixels).

   742 

   743     Note that the bounding rectangle may extend to the left of (0, 0),

   744     e.g. for italicized fonts, and that the text output may cover \e

   745     all pixels in the bounding rectangle.

   746 

   747     Newline characters are processed as linebreaks.

   748 

   749     Despite the different actual character heights, the heights of the

   750     bounding rectangles of "Yes" and "yes" are the same.

   751 

   752     The bounding rectangle returned by this function is somewhat larger

   753     than that calculated by the simpler boundingRect() function. This

   754     function uses the \link minLeftBearing() maximum left \endlink and

   755     \link minRightBearing() right \endlink font bearings as is

   756     necessary for multi-line text to align correctly. Also,

   757     fontHeight() and lineSpacing() are used to calculate the height,

   758     rather than individual character heights.

   759 

   760     \sa width(), QPainter::boundingRect(), Qt::Alignment

   761 */

   762 QRect QFontMetrics::boundingRect(const QRect &rect, int flags, const QString &text, int tabStops,

   763                                  int *tabArray) const

   764 {

   765     int tabArrayLen = 0;

   766     if (tabArray)

   767         while (tabArray[tabArrayLen])

   768             tabArrayLen++;

   769 

   770     QRectF rb;

   771     QRectF rr(rect);

   772     qt_format_text(QFont(d.data()), rr, flags | Qt::TextDontPrint, text, &rb, tabStops, tabArray,

   773                    tabArrayLen, 0);

   774 

   775     return rb.toAlignedRect();

   776 }

   777 

   778 /*!

   779     Returns the size in pixels of \a text.

   780 

   781     The \a flags argument is the bitwise OR of the following flags:

   782     \list

   783     \o Qt::TextSingleLine ignores newline characters.

   784     \o Qt::TextExpandTabs expands tabs (see below)

   785     \o Qt::TextShowMnemonic interprets "&x" as \underline{x}; i.e., underlined.

   786     \o Qt::TextWordBreak breaks the text to fit the rectangle.

   787     \endlist

   788 

   789     If Qt::TextExpandTabs is set in \a flags, then: if \a tabArray is

   790     non-null, it specifies a 0-terminated sequence of pixel-positions

   791     for tabs; otherwise if \a tabStops is non-zero, it is used as the

   792     tab spacing (in pixels).

   793 

   794     Newline characters are processed as linebreaks.

   795 

   796     Despite the different actual character heights, the heights of the

   797     bounding rectangles of "Yes" and "yes" are the same.

   798 

   799     \sa boundingRect()

   800 */

   801 QSize QFontMetrics::size(int flags, const QString &text, int tabStops, int *tabArray) const

   802 {

   803     return boundingRect(QRect(0,0,0,0), flags | Qt::TextLongestVariant, text, tabStops, tabArray).size();

   804 }

   805 

   806 /*!

   807   \since 4.3

   808 

   809     Returns a tight bounding rectangle around the characters in the

   810     string specified by \a text. The bounding rectangle always covers

   811     at least the set of pixels the text would cover if drawn at (0,

   812     0).

   813 

   814     Note that the bounding rectangle may extend to the left of (0, 0),

   815     e.g. for italicized fonts, and that the width of the returned

   816     rectangle might be different than what the width() method returns.

   817 

   818     If you want to know the advance width of the string (to layout

   819     a set of strings next to each other), use width() instead.

   820 

   821     Newline characters are processed as normal characters, \e not as

   822     linebreaks.

   823 

   824     \warning Calling this method is very slow on Windows.

   825 

   826     \sa width(), height(), boundingRect()

   827 */

   828 QRect QFontMetrics::tightBoundingRect(const QString &text) const

   829 {

   830     if (text.length() == 0)

   831         return QRect();

   832 

   833     QTextEngine layout(text, d.data());

   834     layout.ignoreBidi = true;

   835     layout.itemize();

   836     glyph_metrics_t gm = layout.tightBoundingBox(0, text.length());

   837     return QRect(qRound(gm.x), qRound(gm.y), qRound(gm.width), qRound(gm.height));

   838 }

   839 

   840 

   841 /*!

   842     \since 4.2

   843 

   844     If the string \a text is wider than \a width, returns an elided

   845     version of the string (i.e., a string with "..." in it).

   846     Otherwise, returns the original string.

   847 

   848     The \a mode parameter specifies whether the text is elided on the

   849     left (e.g., "...tech"), in the middle (e.g., "Tr...ch"), or on

   850     the right (e.g., "Trol...").

   851 

   852     The \a width is specified in pixels, not characters.

   853 

   854     The \a flags argument is optional and currently only supports

   855     Qt::TextShowMnemonic as value.

   856 

   857     The elide mark will follow the \l{Qt::LayoutDirection}{layout

   858     direction}; it will be on the right side of the text for

   859     right-to-left layouts, and on the left side for right-to-left

   860     layouts. Note that this behavior is independent of the text

   861     language.

   862 */

   863 QString QFontMetrics::elidedText(const QString &text, Qt::TextElideMode mode, int width, int flags) const

   864 {

   865     QString _text = text;

   866     if (!(flags & Qt::TextLongestVariant)) {

   867         int posA = 0;

   868         int posB = _text.indexOf(QLatin1Char('\x9c'));

   869         while (posB >= 0) {

   870             QString portion = _text.mid(posA, posB - posA);

   871             if (size(flags, portion).width() <= width)

   872                 return portion;

   873             posA = posB + 1;

   874             posB = _text.indexOf(QLatin1Char('\x9c'), posA);

   875         }

   876         _text = _text.mid(posA);

   877     }

   878     QStackTextEngine engine(_text, QFont(d.data()));

   879     return engine.elidedText(mode, width, flags);

   880 }

   881 

   882 /*!

   883     Returns the distance from the base line to where an underscore

   884     should be drawn.

   885 

   886     \sa overlinePos(), strikeOutPos(), lineWidth()

   887 */

   888 int QFontMetrics::underlinePos() const

   889 {

   890     QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

   891     Q_ASSERT(engine != 0);

   892     return qRound(engine->underlinePosition());

   893 }

   894 

   895 /*!

   896     Returns the distance from the base line to where an overline

   897     should be drawn.

   898 

   899     \sa underlinePos(), strikeOutPos(), lineWidth()

   900 */

   901 int QFontMetrics::overlinePos() const

   902 {

   903     return ascent() + 1;

   904 }

   905 

   906 /*!

   907     Returns the distance from the base line to where the strikeout

   908     line should be drawn.

   909 

   910     \sa underlinePos(), overlinePos(), lineWidth()

   911 */

   912 int QFontMetrics::strikeOutPos() const

   913 {

   914     int pos = ascent() / 3;

   915     return pos > 0 ? pos : 1;

   916 }

   917 

   918 /*!

   919     Returns the width of the underline and strikeout lines, adjusted

   920     for the point size of the font.

   921 

   922     \sa underlinePos(), overlinePos(), strikeOutPos()

   923 */

   924 int QFontMetrics::lineWidth() const

   925 {

   926     QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

   927     Q_ASSERT(engine != 0);

   928     return qRound(engine->lineThickness());

   929 }

   930 

   931 

   932 

   933 

   934 /*****************************************************************************

   935   QFontMetricsF member functions

   936  *****************************************************************************/

   937 

   938 /*!

   939     \class QFontMetricsF

   940     \reentrant

   941 

   942     \brief The QFontMetricsF class provides font metrics information.

   943 

   944     \ingroup painting

   945     \ingroup shared

   946 

   947     QFontMetricsF functions calculate the size of characters and

   948     strings for a given font. You can construct a QFontMetricsF object

   949     with an existing QFont to obtain metrics for that font. If the

   950     font is changed later, the font metrics object is \e not updated.

   951 

   952     Once created, the object provides functions to access the

   953     individual metrics of the font, its characters, and for strings

   954     rendered in the font.

   955 

   956     There are several functions that operate on the font: ascent(),

   957     descent(), height(), leading() and lineSpacing() return the basic

   958     size properties of the font. The underlinePos(), overlinePos(),

   959     strikeOutPos() and lineWidth() functions, return the properties of

   960     the line that underlines, overlines or strikes out the

   961     characters. These functions are all fast.

   962 

   963     There are also some functions that operate on the set of glyphs in

   964     the font: minLeftBearing(), minRightBearing() and maxWidth().

   965     These are by necessity slow, and we recommend avoiding them if

   966     possible.

   967 

   968     For each character, you can get its width(), leftBearing() and

   969     rightBearing() and find out whether it is in the font using

   970     inFont(). You can also treat the character as a string, and use

   971     the string functions on it.

   972 

   973     The string functions include width(), to return the width of a

   974     string in pixels (or points, for a printer), boundingRect(), to

   975     return a rectangle large enough to contain the rendered string,

   976     and size(), to return the size of that rectangle.

   977 

   978     Example:

   979     \snippet doc/src/snippets/code/src_gui_text_qfontmetrics.cpp 1

   980 

   981     \sa QFont QFontInfo QFontDatabase

   982 */

   983 

   984 /*!

   985     \since 4.2

   986 

   987     Constructs a font metrics object with floating point precision

   988     from the given \a fontMetrics object.

   989 */

   990 QFontMetricsF::QFontMetricsF(const QFontMetrics &fontMetrics)

   991     : d(fontMetrics.d.data())

   992 {

   993 }

   994 

   995 /*!

   996     \since 4.2

   997 

   998     Assigns \a other to this object.

   999 */

  1000 QFontMetricsF &QFontMetricsF::operator=(const QFontMetrics &other)

  1001 {

  1002     d = other.d.data();

  1003     return *this;

  1004 }

  1005 

  1006 /*!

  1007     Constructs a font metrics object for \a font.

  1008 

  1009     The font metrics will be compatible with the paintdevice used to

  1010     create \a font.

  1011 

  1012     The font metrics object holds the information for the font that is

  1013     passed in the constructor at the time it is created, and is not

  1014     updated if the font's attributes are changed later.

  1015 

  1016     Use QFontMetricsF(const QFont &, QPaintDevice *) to get the font

  1017     metrics that are compatible with a certain paint device.

  1018 */

  1019 QFontMetricsF::QFontMetricsF(const QFont &font)

  1020     : d(font.d.data())

  1021 {

  1022 }

  1023 

  1024 /*!

  1025     Constructs a font metrics object for \a font and \a paintdevice.

  1026 

  1027     The font metrics will be compatible with the paintdevice passed.

  1028     If the \a paintdevice is 0, the metrics will be screen-compatible,

  1029     ie. the metrics you get if you use the font for drawing text on a

  1030     \link QWidget widgets\endlink or \link QPixmap pixmaps\endlink,

  1031     not on a QPicture or QPrinter.

  1032 

  1033     The font metrics object holds the information for the font that is

  1034     passed in the constructor at the time it is created, and is not

  1035     updated if the font's attributes are changed later.

  1036 */

  1037 QFontMetricsF::QFontMetricsF(const QFont &font, QPaintDevice *paintdevice)

  1038 {

  1039     int dpi = paintdevice ? paintdevice->logicalDpiY() : qt_defaultDpi();

  1040 #ifdef Q_WS_X11

  1041     const QX11Info *info = qt_x11Info(paintdevice);

  1042     int screen = info ? info->screen() : 0;

  1043 #else

  1044     const int screen = 0;

  1045 #endif

  1046     if (font.d->dpi != dpi || font.d->screen != screen ) {

  1047         d = new QFontPrivate(*font.d);

  1048         d->dpi = dpi;

  1049         d->screen = screen;

  1050     } else {

  1051         d = font.d.data();

  1052     }

  1053 

  1054 }

  1055 

  1056 /*!

  1057     Constructs a copy of \a fm.

  1058 */

  1059 QFontMetricsF::QFontMetricsF(const QFontMetricsF &fm)

  1060     : d(fm.d.data())

  1061 {

  1062 }

  1063 

  1064 /*!

  1065     Destroys the font metrics object and frees all allocated

  1066     resources.

  1067 */

  1068 QFontMetricsF::~QFontMetricsF()

  1069 {

  1070 }

  1071 

  1072 /*!

  1073     Assigns the font metrics \a fm to this font metrics object.

  1074 */

  1075 QFontMetricsF &QFontMetricsF::operator=(const QFontMetricsF &fm)

  1076 {

  1077     d = fm.d.data();

  1078     return *this;

  1079 }

  1080 

  1081 /*!

  1082   \overload

  1083   Returns true if the font metrics are equal to the \a other font

  1084   metrics; otherwise returns false.

  1085 

  1086   Two font metrics are considered equal if they were constructed from the

  1087   same QFont and the paint devices they were constructed for are

  1088   considered to be compatible.

  1089 */

  1090 bool QFontMetricsF::operator ==(const QFontMetricsF &other) const

  1091 {

  1092     return d == other.d;

  1093 }

  1094 

  1095 /*!

  1096   Returns true if the font metrics are equal to the \a other font

  1097   metrics; otherwise returns false.

  1098 

  1099   Two font metrics are considered equal if they were constructed from the

  1100   same QFont and the paint devices they were constructed for are

  1101   considered to be compatible.

  1102 */

  1103 bool QFontMetricsF::operator ==(const QFontMetricsF &other)

  1104 {

  1105     return d == other.d;

  1106 }

  1107 

  1108 /*!

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

  1110 

  1111     Returns true if the font metrics are not equal to the \a other font

  1112     metrics; otherwise returns false.

  1113 

  1114     \sa operator==()

  1115 */

  1116 

  1117 /*!

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

  1119     \overload

  1120 

  1121     Returns true if the font metrics are not equal to the \a other font

  1122     metrics; otherwise returns false.

  1123 

  1124     \sa operator==()

  1125 */

  1126 

  1127 /*!

  1128     Returns the ascent of the font.

  1129 

  1130     The ascent of a font is the distance from the baseline to the

  1131     highest position characters extend to. In practice, some font

  1132     designers break this rule, e.g. when they put more than one accent

  1133     on top of a character, or to accommodate an unusual character in

  1134     an exotic language, so it is possible (though rare) that this

  1135     value will be too small.