src/gui/text/qrawfont.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/
   5 **
   6 ** This file is part of the QtGui module of the Qt Toolkit.
   7 **
   8 ** $QT_BEGIN_LICENSE:LGPL$
   9 ** GNU Lesser General Public License Usage
  10 ** This file may be used under the terms of the GNU Lesser General Public
  11 ** License version 2.1 as published by the Free Software Foundation and
  12 ** appearing in the file LICENSE.LGPL included in the packaging of this
  13 ** file. Please review the following information to ensure the GNU Lesser
  14 ** General Public License version 2.1 requirements will be met:
  15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  16 **
  17 ** In addition, as a special exception, Nokia gives you certain additional
  18 ** rights. These rights are described in the Nokia Qt LGPL Exception
  19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  20 **
  21 ** GNU General Public License Usage
  22 ** Alternatively, this file may be used under the terms of the GNU General
  23 ** Public License version 3.0 as published by the Free Software Foundation
  24 ** and appearing in the file LICENSE.GPL included in the packaging of this
  25 ** file. Please review the following information to ensure the GNU General
  26 ** Public License version 3.0 requirements will be met:
  27 ** http://www.gnu.org/copyleft/gpl.html.
  28 **
  29 ** Other Usage
  30 ** Alternatively, this file may be used in accordance with the terms and
  31 ** conditions contained in a signed written agreement between you and Nokia.
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include "qglobal.h"
  43
  44 #if !defined(QT_NO_RAWFONT)
  45
  46 #include "qrawfont.h"
  47 #include "qrawfont_p.h"
  48
  49 #include <QtCore/qendian.h>
  50
  51 QT_BEGIN_NAMESPACE
  52
  53 /*!
  54    \class QRawFont
  55    \brief The QRawFont class provides access to a single physical instance of a font.
  56    \since 4.8
  57     \inmodule QtGui
  58
  59    \ingroup text
  60    \mainclass
  61
  62    \note QRawFont is a low level class. For most purposes QFont is a more appropriate class.
  63
  64    Most commonly, when presenting text in a user interface, the exact fonts used
  65    to render the characters is to some extent unknown. This can be the case for several
  66    reasons: For instance, the actual, physical fonts present on the target system could be
  67    unexpected to the developers, or the text could contain user selected styles, sizes or
  68    writing systems that are not supported by font chosen in the code.
  69
  70    Therefore, Qt's QFont class really represents a query for fonts. When text is interpreted,
  71    Qt will do its best to match the text to the query, but depending on the support, different
  72    fonts can be used behind the scenes.
  73
  74    For most use cases, this is both expected and necessary, as it minimizes the possibility of
  75    text in the user interface being undisplayable. In some cases, however, more direct control
  76    over the process might be useful. It is for these use cases the QRawFont class exists.
  77
  78    A QRawFont object represents a single, physical instance of a given font in a given pixel size.
  79    I.e. in the typical case it represents a set of TrueType or OpenType font tables and uses a
  80    user specified pixel size to convert metrics into logical pixel units. It can be used in
  81    combination with the QGlyphRun class to draw specific glyph indexes at specific positions, and
  82    also have accessors to some relevant data in the physical font.
  83
  84    QRawFont only provides support for the main font technologies: GDI and DirectWrite on Windows
  85    platforms, FreeType on Linux platforms and CoreText on Mac OS X. For other
  86    font back-ends, the APIs will be disabled.
  87
  88    QRawFont can be constructed in a number of ways:
  89    \list
  90    \li It can be constructed by calling QTextLayout::glyphs() or QTextFragment::glyphs(). The
  91       returned QGlyphs objects will contain QRawFont objects which represent the actual fonts
  92       used to render each portion of the text.
  93    \li It can be constructed by passing a QFont object to QRawFont::fromFont(). The function
  94       will return a QRawFont object representing the font that will be selected as response to
  95       the QFont query and the selected writing system.
  96    \li It can be constructed by passing a file name or QByteArray directly to the QRawFont
  97       constructor, or by calling loadFromFile() or loadFromData(). In this case, the
  98       font will not be registered in QFontDatabase, and it will not be available as part of
  99       regular font selection.
 100    \endlist
 101
 102    QRawFont is considered local to the thread in which it is constructed (either using a
 103    constructor, or by calling loadFromData() or loadFromFile()). The QRawFont cannot be moved to a
 104    different thread, but will have to be recreated in the thread in question.
 105
 106    \note For the requirement of caching glyph indexes and font selections for static text to avoid
 107    reshaping and relayouting in the inner loop of an application, a better choice is the QStaticText
 108    class, since it optimizes the memory cost of the cache and also provides the possibility of paint
 109    engine specific caches for an additional speed-up.
 110 */
 111
 112 /*!
 113     \enum QRawFont::AntialiasingType
 114
 115     This enum represents the different ways a glyph can be rasterized in the function
 116     alphaMapForGlyph().
 117
 118     \value PixelAntialiasing Will rasterize by measuring the coverage of the shape on whole pixels.
 119            The returned image contains the alpha values of each pixel based on the coverage of
 120            the glyph shape.
 121     \value SubPixelAntialiasing Will rasterize by measuring the coverage of each subpixel,
 122            returning a separate alpha value for each of the red, green and blue components of
 123            each pixel.
 124 */
 125
 126 /*!
 127    Constructs an invalid QRawFont.
 128 */
 129 QRawFont::QRawFont()
 130     : d(new QRawFontPrivate)
 131 {
 132 }
 133
 134 /*!
 135    Constructs a QRawFont representing the font contained in the file referenced
 136    by \a fileName for the size (in pixels) given by \a pixelSize, and using the
 137    hinting preference specified by \a hintingPreference.
 138
 139    \note The referenced file must contain a TrueType or OpenType font.
 140 */
 141 QRawFont::QRawFont(const QString &fileName,
 142                    qreal pixelSize,
 143                    QFont::HintingPreference hintingPreference)
 144     : d(new QRawFontPrivate)
 145 {
 146     loadFromFile(fileName, pixelSize, hintingPreference);
 147 }
 148
 149 /*!
 150    Constructs a QRawFont representing the font contained in the supplied
 151    \a fontData for the size (in pixels) given by \a pixelSize, and using the
 152    hinting preference specified by \a hintingPreference.
 153
 154    \note The data must contain a TrueType or OpenType font.
 155 */
 156 QRawFont::QRawFont(const QByteArray &fontData,
 157                    qreal pixelSize,
 158                    QFont::HintingPreference hintingPreference)
 159     : d(new QRawFontPrivate)
 160 {
 161     loadFromData(fontData, pixelSize, hintingPreference);
 162 }
 163
 164 /*!
 165    Creates a QRawFont which is a copy of \a other.
 166 */
 167 QRawFont::QRawFont(const QRawFont &other)
 168 {
 169     d = other.d;
 170 }
 171
 172 /*!
 173    Destroys the QRawFont
 174 */
 175 QRawFont::~QRawFont()
 176 {
 177 }
 178
 179 /*!
 180   Assigns \a other to this QRawFont.
 181 */
 182 QRawFont &QRawFont::operator=(const QRawFont &other)
 183 {
 184     d = other.d;
 185     return *this;
 186 }
 187
 188 /*!
 189    Returns true if the QRawFont is valid and false otherwise.
 190 */
 191 bool QRawFont::isValid() const
 192 {
 193     return d->isValid();
 194 }
 195
 196 /*!
 197    Replaces the current QRawFont with the contents of the file referenced
 198    by \a fileName for the size (in pixels) given by \a pixelSize, and using the
 199    hinting preference specified by \a hintingPreference.
 200
 201    The file must reference a TrueType or OpenType font.
 202
 203    \sa loadFromData()
 204 */
 205 void QRawFont::loadFromFile(const QString &fileName,
 206                             qreal pixelSize,
 207                             QFont::HintingPreference hintingPreference)
 208 {
 209     QFile file(fileName);
 210     if (file.open(QIODevice::ReadOnly))
 211         loadFromData(file.readAll(), pixelSize, hintingPreference);
 212 }
 213
 214 /*!
 215    Replaces the current QRawFont with the font contained in the supplied
 216    \a fontData for the size (in pixels) given by \a pixelSize, and using the
 217    hinting preference specified by \a hintingPreference.
 218
 219    The \a fontData must contain a TrueType or OpenType font.
 220
 221    \sa loadFromFile()
 222 */
 223 void QRawFont::loadFromData(const QByteArray &fontData,
 224                             qreal pixelSize,
 225                             QFont::HintingPreference hintingPreference)
 226 {
 227     d.detach();
 228     d->cleanUp();
 229     d->hintingPreference = hintingPreference;
 230     d->thread = QThread::currentThread();
 231     d->platformLoadFromData(fontData, pixelSize, hintingPreference);
 232 }
 233
 234 /*!
 235    This function returns a rasterized image of the glyph at the given
 236    \a glyphIndex in the underlying font, using the \a transform specified.
 237    If the QRawFont is not valid, this function will return an invalid QImage.
 238
 239    If \a antialiasingType is set to QRawFont::SubPixelAntialiasing, then the resulting image will be
 240    in QImage::Format_RGB32 and the RGB values of each pixel will represent the subpixel opacities of
 241    the pixel in the rasterization of the glyph. Otherwise, the image will be in the format of
 242    QImage::Format_Indexed8 and each pixel will contain the opacity of the pixel in the
 243    rasterization.
 244
 245    \sa pathForGlyph(), QPainter::drawGlyphRun()
 246 */
 247 QImage QRawFont::alphaMapForGlyph(quint32 glyphIndex, AntialiasingType antialiasingType,
 248                                   const QTransform &transform) const
 249 {
 250     if (!d->isValid())
 251         return QImage();
 252
 253     if (antialiasingType == SubPixelAntialiasing)
 254         return d->fontEngine->alphaRGBMapForGlyph(glyphIndex, QFixed(), transform);
 255
 256     return d->fontEngine->alphaMapForGlyph(glyphIndex, QFixed(), transform);
 257 }
 258
 259 /*!
 260    This function returns the shape of the glyph at a given \a glyphIndex in the underlying font
 261    if the QRawFont is valid. Otherwise, it returns an empty QPainterPath.
 262
 263    The returned glyph will always be unhinted.
 264
 265    \sa alphaMapForGlyph(), QPainterPath::addText()
 266 */
 267 QPainterPath QRawFont::pathForGlyph(quint32 glyphIndex) const
 268 {
 269     if (!d->isValid())
 270         return QPainterPath();
 271
 272     QFixedPoint position;
 273     QPainterPath path;
 274     d->fontEngine->addGlyphsToPath(&glyphIndex, &position, 1, &path, 0);
 275     return path;
 276 }
 277
 278 /*!
 279    Returns true if this QRawFont is equal to \a other. Otherwise, returns false.
 280 */
 281 bool QRawFont::operator==(const QRawFont &other) const
 282 {
 283     return d->fontEngine == other.d->fontEngine;
 284 }
 285
 286 /*!
 287     \fn bool QRawFont::operator!=(const QRawFont &other) const
 288
 289     Returns true if this QRawFont is not equal to \a other. Otherwise, returns false.
 290 */
 291
 292 /*!
 293    Returns the ascent of this QRawFont in pixel units.
 294
 295    \sa QFontMetricsF::ascent()
 296 */
 297 qreal QRawFont::ascent() const
 298 {
 299     return d->isValid() ? d->fontEngine->ascent().toReal() : 0.0;
 300 }
 301
 302 /*!
 303    Returns the descent of this QRawFont in pixel units.
 304
 305    \sa QFontMetricsF::descent()
 306 */
 307 qreal QRawFont::descent() const
 308 {
 309     return d->isValid() ? d->fontEngine->descent().toReal() : 0.0;
 310 }
 311
 312 /*!
 313    Returns the xHeight of this QRawFont in pixel units.
 314
 315    \sa QFontMetricsF::xHeight()
 316 */
 317 qreal QRawFont::xHeight() const
 318 {
 319     return d->isValid() ? d->fontEngine->xHeight().toReal() : 0.0;
 320 }
 321
 322 /*!
 323    Returns the leading of this QRawFont in pixel units.
 324
 325    \sa QFontMetricsF::leading()
 326 */
 327 qreal QRawFont::leading() const
 328 {
 329     return d->isValid() ? d->fontEngine->leading().toReal() : 0.0;
 330 }
 331
 332 /*!
 333    Returns the average character width of this QRawFont in pixel units.
 334
 335    \sa QFontMetricsF::averageCharWidth()
 336 */
 337 qreal QRawFont::averageCharWidth() const
 338 {
 339     return d->isValid() ? d->fontEngine->averageCharWidth().toReal() : 0.0;
 340 }
 341
 342 /*!
 343    Returns the width of the widest character in the font.
 344
 345    \sa QFontMetricsF::maxWidth()
 346 */
 347 qreal QRawFont::maxCharWidth() const
 348 {
 349     return d->isValid() ? d->fontEngine->maxCharWidth() : 0.0;
 350 }
 351
 352 /*!
 353    Returns the pixel size set for this QRawFont. The pixel size affects how glyphs are
 354    rasterized, the size of glyphs returned by pathForGlyph(), and is used to convert
 355    internal metrics from design units to logical pixel units.
 356
 357    \sa setPixelSize()
 358 */
 359 qreal QRawFont::pixelSize() const
 360 {
 361     return d->isValid() ? d->fontEngine->fontDef.pixelSize : 0.0;
 362 }
 363
 364 /*!
 365    Returns the number of design units define the width and height of the em square
 366    for this QRawFont. This value is used together with the pixel size when converting design metrics
 367    to pixel units, as the internal metrics are specified in design units and the pixel size gives
 368    the size of 1 em in pixels.
 369
 370    \sa pixelSize(), setPixelSize()
 371 */
 372 qreal QRawFont::unitsPerEm() const
 373 {
 374     return d->isValid() ? d->fontEngine->emSquareSize().toReal() : 0.0;
 375 }
 376
 377 /*!
 378    Returns the thickness for drawing lines (underline, overline, etc.)
 379    along with text drawn in this font.
 380  */
 381 qreal QRawFont::lineThickness() const
 382 {
 383     if (!isValid())
 384         return 0.0;
 385
 386     return d->fontEngine->lineThickness().toReal();
 387 }
 388
 389 /*!
 390    Returns the position from baseline for drawing underlines below the text
 391    rendered with this font.
 392  */
 393 qreal QRawFont::underlinePosition() const
 394 {
 395     if (!isValid())
 396         return 0.0;
 397
 398     return d->fontEngine->underlinePosition().toReal();
 399 }
 400
 401 /*!
 402    Returns the family name of this QRawFont.
 403 */
 404 QString QRawFont::familyName() const
 405 {
 406     return d->isValid() ? d->fontEngine->fontDef.family : QString();
 407 }
 408
 409 /*!
 410    Returns the style name of this QRawFont.
 411
 412    \sa QFont::styleName()
 413 */
 414 QString QRawFont::styleName() const
 415 {
 416     return d->isValid() ? d->fontEngine->fontDef.styleName : QString();
 417 }
 418
 419 /*!
 420    Returns the style of this QRawFont.
 421
 422    \sa QFont::style()
 423 */
 424 QFont::Style QRawFont::style() const
 425 {
 426     return d->isValid() ? QFont::Style(d->fontEngine->fontDef.style) : QFont::StyleNormal;
 427 }
 428
 429 /*!
 430    Returns the weight of this QRawFont.
 431
 432    \sa QFont::weight()
 433 */
 434 int QRawFont::weight() const
 435 {
 436     return d->isValid() ? int(d->fontEngine->fontDef.weight) : -1;
 437 }
 438
 439 /*!
 440    Converts the string of unicode points given by \a text to glyph indexes
 441    using the CMAP table in the underlying font, and returns a vector containing
 442    the result.
 443
 444    Note that, in cases where there are other tables in the font that affect the
 445    shaping of the text, the returned glyph indexes will not correctly represent
 446    the rendering of the text. To get the correctly shaped text, you can use
 447    QTextLayout to lay out and shape the text, then call QTextLayout::glyphs()
 448    to get the set of glyph index list and QRawFont pairs.
 449
 450    \sa advancesForGlyphIndexes(), glyphIndexesForChars(), QGlyphRun, QTextLayout::glyphRuns(), QTextFragment::glyphRuns()
 451 */
 452 QVector<quint32> QRawFont::glyphIndexesForString(const QString &text) const
 453 {
 454     if (!d->isValid())
 455         return QVector<quint32>();
 456
 457     int nglyphs = text.size();
 458     QVarLengthGlyphLayoutArray glyphs(nglyphs);
 459     if (!glyphIndexesForChars(text.data(), text.size(), glyphs.glyphs, &nglyphs)) {
 460         glyphs.resize(nglyphs);
 461         if (!glyphIndexesForChars(text.data(), text.size(), glyphs.glyphs, &nglyphs)) {
 462             Q_ASSERT_X(false, Q_FUNC_INFO, "stringToCMap shouldn't fail twice");
 463             return QVector<quint32>();
 464         }
 465     }
 466
 467     QVector<quint32> glyphIndexes;
 468     for (int i=0; i<nglyphs; ++i)
 469         glyphIndexes.append(glyphs.glyphs[i]);
 470
 471     return glyphIndexes;
 472 }
 473
 474 /*!
 475    Converts a string of unicode points to glyph indexes using the CMAP table in the
 476    underlying font. The function works like glyphIndexesForString() except it take
 477    an array (\a chars), the results will be returned though \a glyphIndexes array
 478    and number of glyphs will be set in \a numGlyphs. The size of \a glyphIndexes array
 479    must be at least \a numChars, if that's still not enough, this function will return
 480    false, then you can resize \a glyphIndexes from the size returned in \a numGlyphs.
 481
 482    \sa glyphIndexesForString(), advancesForGlyphIndexes(), QGlyphs, QTextLayout::glyphs(), QTextFragment::glyphs()
 483 */
 484 bool QRawFont::glyphIndexesForChars(const QChar *chars, int numChars, quint32 *glyphIndexes, int *numGlyphs) const
 485 {
 486     if (!d->isValid())
 487         return false;
 488
 489     QGlyphLayout glyphs;
 490     glyphs.glyphs = glyphIndexes;
 491     return d->fontEngine->stringToCMap(chars, numChars, &glyphs, numGlyphs, QTextEngine::GlyphIndicesOnly);
 492 }
 493
 494 /*!
 495    Returns the QRawFont's advances for each of the \a glyphIndexes in pixel units. The advances
 496    give the distance from the position of a given glyph to where the next glyph should be drawn
 497    to make it appear as if the two glyphs are unspaced.
 498
 499    \sa QTextLine::horizontalAdvance(), QFontMetricsF::width()
 500 */
 501 QVector<QPointF> QRawFont::advancesForGlyphIndexes(const QVector<quint32> &glyphIndexes) const
 502 {
 503     if (!d->isValid())
 504         return QVector<QPointF>();
 505
 506     int numGlyphs = glyphIndexes.size();
 507     QVarLengthGlyphLayoutArray glyphs(numGlyphs);
 508     memcpy(glyphs.glyphs, glyphIndexes.data(), numGlyphs * sizeof(quint32));
 509
 510     d->fontEngine->recalcAdvances(&glyphs, 0);
 511
 512     QVector<QPointF> advances;
 513     for (int i=0; i<numGlyphs; ++i)
 514         advances.append(QPointF(glyphs.advances_x[i].toReal(), glyphs.advances_y[i].toReal()));
 515
 516     return advances;
 517 }
 518
 519 /*!
 520    Returns the QRawFont's advances for each of the \a glyphIndexes in pixel units. The advances
 521    give the distance from the position of a given glyph to where the next glyph should be drawn
 522    to make it appear as if the two glyphs are unspaced. The glyph indexes are given with the
 523    array \a glyphIndexes while the results are returned through \a advances, both of them must
 524    have \a numGlyphs elements.
 525
 526    \sa QTextLine::horizontalAdvance(), QFontMetricsF::width()
 527 */
 528 bool QRawFont::advancesForGlyphIndexes(const quint32 *glyphIndexes, QPointF *advances, int numGlyphs) const
 529 {
 530     if (!d->isValid())
 531         return false;
 532
 533     QGlyphLayout glyphs;
 534     glyphs.glyphs = const_cast<HB_Glyph *>(glyphIndexes);
 535     glyphs.numGlyphs = numGlyphs;
 536     QVarLengthArray<QFixed> advances_x(numGlyphs);
 537     QVarLengthArray<QFixed> advances_y(numGlyphs);
 538     glyphs.advances_x = advances_x.data();
 539     glyphs.advances_y = advances_y.data();
 540
 541     d->fontEngine->recalcAdvances(&glyphs, 0);
 542
 543     for (int i=0; i<numGlyphs; ++i)
 544         advances[i] = QPointF(glyphs.advances_x[i].toReal(), glyphs.advances_y[i].toReal());
 545
 546     return true;
 547 }
 548
 549 /*!
 550    Returns the hinting preference used to construct this QRawFont.
 551
 552    \sa QFont::hintingPreference()
 553 */
 554 QFont::HintingPreference QRawFont::hintingPreference() const
 555 {
 556     return d->isValid() ? d->hintingPreference : QFont::PreferDefaultHinting;
 557 }
 558
 559 /*!
 560    Retrieves the sfnt table named \a tagName from the underlying physical font, or an empty
 561    byte array if no such table was found. The returned font table's byte order is Big Endian, like
 562    the sfnt format specifies. The \a tagName must be four characters long and should be formatted
 563    in the default endianness of the current platform.
 564 */
 565 QByteArray QRawFont::fontTable(const char *tagName) const
 566 {
 567     if (!d->isValid())
 568         return QByteArray();
 569
 570     const quint32 *tagId = reinterpret_cast<const quint32 *>(tagName);
 571     return d->fontEngine->getSfntTable(qToBigEndian(*tagId));
 572 }
 573
 574 // From qfontdatabase.cpp
 575 extern QList<QFontDatabase::WritingSystem> qt_determine_writing_systems_from_truetype_bits(quint32 unicodeRange[4], quint32 codePageRange[2]);
 576
 577 /*!
 578    Returns a list of writing systems supported by the font according to designer supplied
 579    information in the font file. Please note that this does not guarantee support for a
 580    specific unicode point in the font. You can use the supportsCharacter() to check support
 581    for a single, specific character.
 582
 583    \note The list is determined based on the unicode ranges and codepage ranges set in the font's
 584    OS/2 table and requires such a table to be present in the underlying font file.
 585
 586    \sa supportsCharacter()
 587 */
 588 QList<QFontDatabase::WritingSystem> QRawFont::supportedWritingSystems() const
 589 {
 590     if (d->isValid()) {
 591         QByteArray os2Table = fontTable("OS/2");
 592         if (os2Table.size() > 86) {
 593             char *data = os2Table.data();
 594             quint32 *bigEndianUnicodeRanges = reinterpret_cast<quint32 *>(data + 42);
 595             quint32 *bigEndianCodepageRanges = reinterpret_cast<quint32 *>(data + 78);
 596
 597             quint32 unicodeRanges[4];
 598             quint32 codepageRanges[2];
 599
 600             for (int i=0; i<4; ++i) {
 601                 if (i < 2)
 602                     codepageRanges[i] = qFromBigEndian(bigEndianCodepageRanges[i]);
 603                 unicodeRanges[i] = qFromBigEndian(bigEndianUnicodeRanges[i]);
 604             }
 605
 606             return qt_determine_writing_systems_from_truetype_bits(unicodeRanges, codepageRanges);
 607         }
 608     }
 609
 610     return QList<QFontDatabase::WritingSystem>();
 611 }
 612
 613 /*!
 614     Returns true if the font has a glyph that corresponds to the given \a character.
 615
 616     \sa supportedWritingSystems()
 617 */
 618 bool QRawFont::supportsCharacter(QChar character) const
 619 {
 620     return d->isValid() && d->fontEngine->canRender(&character, 1);
 621 }
 622
 623 /*!
 624     \overload
 625
 626    Returns true if the font has a glyph that corresponds to the UCS-4 encoded character \a ucs4.
 627
 628    \sa supportedWritingSystems()
 629 */
 630 bool QRawFont::supportsCharacter(uint ucs4) const
 631 {
 632     return d->isValid() && d->fontEngine->canRender(ucs4);
 633 }
 634
 635 // qfontdatabase.cpp
 636 extern int qt_script_for_writing_system(QFontDatabase::WritingSystem writingSystem);
 637
 638 /*!
 639    Fetches the physical representation based on a \a font query. The physical font returned is
 640    the font that will be preferred by Qt in order to display text in the selected \a writingSystem.
 641
 642    \warning This function is potentially expensive and should not be called in performance
 643    sensitive code.
 644 */
 645 QRawFont QRawFont::fromFont(const QFont &font, QFontDatabase::WritingSystem writingSystem)
 646 {
 647     QRawFont rawFont;
 648     QFontPrivate *font_d = QFontPrivate::get(font);
 649     int script = qt_script_for_writing_system(writingSystem);
 650     QFontEngine *fe = font_d->engineForScript(script);
 651
 652     if (fe != 0 && fe->type() == QFontEngine::Multi) {
 653         QFontEngineMulti *multiEngine = static_cast<QFontEngineMulti *>(fe);
 654         fe = multiEngine->engine(0);
 655         if (fe == 0) {
 656             multiEngine->loadEngine(0);
 657             fe = multiEngine->engine(0);
 658         }
 659     }
 660
 661     if (fe != 0) {
 662         rawFont.d.data()->fontEngine = fe;
 663         rawFont.d.data()->fontEngine->ref.ref();
 664         rawFont.d.data()->hintingPreference = font.hintingPreference();
 665     }
 666     return rawFont;
 667 }
 668
 669 /*!
 670    Sets the pixel size with which this font should be rendered to \a pixelSize.
 671 */
 672 void QRawFont::setPixelSize(qreal pixelSize)
 673 {
 674     if (d->fontEngine == 0 || qFuzzyCompare(d->fontEngine->fontDef.pixelSize, pixelSize))
 675         return;
 676
 677     d.detach();
 678     QFontEngine *oldFontEngine = d->fontEngine;
 679
 680     d->fontEngine = d->fontEngine->cloneWithSize(pixelSize);
 681     if (d->fontEngine != 0)
 682         d->fontEngine->ref.ref();
 683
 684     oldFontEngine->ref.deref();
 685     if (oldFontEngine->cache_count == 0 && oldFontEngine->ref.load() == 0)
 686         delete oldFontEngine;
 687 }
 688
 689 /*!
 690     \internal
 691 */
 692 void QRawFontPrivate::cleanUp()
 693 {
 694     platformCleanUp();
 695     if (fontEngine != 0) {
 696         fontEngine->ref.deref();
 697         if (fontEngine->cache_count == 0 && fontEngine->ref.load() == 0)
 698             delete fontEngine;
 699         fontEngine = 0;
 700     }
 701     hintingPreference = QFont::PreferDefaultHinting;
 702 }
 703
 704 /*!
 705   Returns the smallest rectangle containing the glyph with the given \a glyphIndex.
 706
 707   \since 5.0
 708 */
 709 QRectF QRawFont::boundingRect(quint32 glyphIndex) const
 710 {
 711     if (!isValid())
 712         return QRectF();
 713
 714     glyph_metrics_t gm = d->fontEngine->boundingBox(glyphIndex);
 715     return QRectF(gm.x.toReal(), gm.y.toReal(), gm.width.toReal(), gm.height.toReal());
 716 }
 717
 718 #endif // QT_NO_RAWFONT
 719
 720 QT_END_NAMESPACE