qfontmetrics.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qfont.h"
#include "qpaintdevice.h"
#include "qfontmetrics.h"
 
#include "qfont_p.h"
#include "qfontengine_p.h"
 
QT_BEGIN_NAMESPACE
 
 
extern void qt_format_text(const QFont& font, const QRectF &_r,
                           int tf, const QString &text, QRectF *brect,
                           int tabStops, int *tabArray, int tabArrayLen,
                           QPainter *painter);
 
/*****************************************************************************
  QFontMetrics member functions
 *****************************************************************************/
 
QFontMetrics::QFontMetrics(const QFont &font)
    : d(font.d)
{
}
 
QFontMetrics::QFontMetrics(const QFont &font, const QPaintDevice *paintdevice)
{
    const int dpi = paintdevice ? paintdevice->logicalDpiY() : qt_defaultDpi();
    if (font.d->dpi != dpi) {
        d = new QFontPrivate(*font.d);
        d->dpi = dpi;
    } else {
        d = font.d;
    }
 
}
 
QFontMetrics::QFontMetrics(const QFontMetrics &fm)
    : d(fm.d)
{
}
 
QFontMetrics::~QFontMetrics()
{
}
 
QFontMetrics &QFontMetrics::operator=(const QFontMetrics &fm)
{
    d = fm.d;
    return *this;
}
 
bool QFontMetrics::operator ==(const QFontMetrics &other) const
{
    return d == other.d;
}
 
int QFontMetrics::ascent() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return qRound(engine->ascent());
}
 
int QFontMetrics::capHeight() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return qRound(engine->capHeight());
}
 
int QFontMetrics::descent() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return qRound(engine->descent());
}
 
int QFontMetrics::height() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return qRound(engine->ascent()) + qRound(engine->descent());
}
 
int QFontMetrics::leading() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return qRound(engine->leading());
}
 
int QFontMetrics::lineSpacing() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return qRound(engine->leading()) + qRound(engine->ascent()) + qRound(engine->descent());
}
 
int QFontMetrics::minLeftBearing() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return qRound(engine->minLeftBearing());
}
 
int QFontMetrics::minRightBearing() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return qRound(engine->minRightBearing());
}
 
int QFontMetrics::maxWidth() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return qRound(engine->maxCharWidth());
}
 
int QFontMetrics::xHeight() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    if (d->capital == QFont::SmallCaps)
        return qRound(d->smallCapsFontPrivate()->engineForScript(QChar::Script_Common)->ascent());
    return qRound(engine->xHeight());
}
 
int QFontMetrics::averageCharWidth() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return qRound(engine->averageCharWidth());
}
 
bool QFontMetrics::inFont(QChar ch) const
{
    return inFontUcs4(ch.unicode());
}
 
bool QFontMetrics::inFontUcs4(uint ucs4) const
{
    const int script = QChar::script(ucs4);
    QFontEngine *engine = d->engineForScript(script);
    Q_ASSERT(engine != nullptr);
    if (engine->type() == QFontEngine::Box)
        return false;
    return engine->canRender(ucs4);
}
 
int QFontMetrics::leftBearing(QChar ch) const
{
    const int script = ch.script();
    QFontEngine *engine;
    if (d->capital == QFont::SmallCaps && ch.isLower())
        engine = d->smallCapsFontPrivate()->engineForScript(script);
    else
        engine = d->engineForScript(script);
    Q_ASSERT(engine != nullptr);
    if (engine->type() == QFontEngine::Box)
        return 0;
 
    d->alterCharForCapitalization(ch);
 
    glyph_t glyph = engine->glyphIndex(ch.unicode());
 
    qreal lb;
    engine->getGlyphBearings(glyph, &lb);
    return qRound(lb);
}
 
int QFontMetrics::rightBearing(QChar ch) const
{
    const int script = ch.script();
    QFontEngine *engine;
    if (d->capital == QFont::SmallCaps && ch.isLower())
        engine = d->smallCapsFontPrivate()->engineForScript(script);
    else
        engine = d->engineForScript(script);
    Q_ASSERT(engine != nullptr);
    if (engine->type() == QFontEngine::Box)
        return 0;
 
    d->alterCharForCapitalization(ch);
 
    glyph_t glyph = engine->glyphIndex(ch.unicode());
 
    qreal rb;
    engine->getGlyphBearings(glyph, nullptr, &rb);
    return qRound(rb);
}
 
static constexpr QLatin1Char s_variableLengthStringSeparator('\x9c');
 
int QFontMetrics::horizontalAdvance(const QString &text, int len) const
{
    int pos = (len >= 0)
            ? QStringView(text).left(len).indexOf(s_variableLengthStringSeparator)
            : text.indexOf(s_variableLengthStringSeparator);
    if (pos != -1) {
        len = pos;
    } else if (len < 0) {
        len = text.size();
    }
    if (len == 0)
        return 0;
 
    QStackTextEngine layout(text, QFont(d.data()));
    return qRound(layout.width(0, len));
}
 
int QFontMetrics::horizontalAdvance(const QString &text, const QTextOption &option) const
{
    int pos = text.indexOf(s_variableLengthStringSeparator);
    int len = -1;
    if (pos != -1) {
        len = pos;
    } else {
        len = text.size();
    }
    if (len == 0)
        return 0;
 
    QStackTextEngine layout(text, QFont(d.data()));
    layout.option = option;
    return qRound(layout.width(0, len));
}
 
int QFontMetrics::horizontalAdvance(QChar ch) const
{
    if (QChar::category(ch.unicode()) == QChar::Mark_NonSpacing)
        return 0;
 
    const int script = ch.script();
    QFontEngine *engine;
    if (d->capital == QFont::SmallCaps && ch.isLower())
        engine = d->smallCapsFontPrivate()->engineForScript(script);
    else
        engine = d->engineForScript(script);
    Q_ASSERT(engine != nullptr);
 
    d->alterCharForCapitalization(ch);
 
    glyph_t glyph = engine->glyphIndex(ch.unicode());
    QFixed advance;
 
    QGlyphLayout glyphs;
    glyphs.numGlyphs = 1;
    glyphs.glyphs = &glyph;
    glyphs.advances = &advance;
    engine->recalcAdvances(&glyphs, { });
 
    return qRound(advance);
}
 
QRect QFontMetrics::boundingRect(const QString &text) const
{
    if (text.size() == 0)
        return QRect();
 
    QStackTextEngine layout(text, QFont(d.data()));
    layout.itemize();
    glyph_metrics_t gm = layout.boundingBox(0, text.size());
    return QRect(qRound(gm.x), qRound(gm.y), qRound(gm.width), qRound(gm.height));
}
 
QRect QFontMetrics::boundingRect(const QString &text, const QTextOption &option) const
{
    if (text.size() == 0)
        return QRect();
 
    QStackTextEngine layout(text, QFont(d.data()));
    layout.option = option;
    layout.itemize();
    glyph_metrics_t gm = layout.boundingBox(0, text.size());
    return QRect(qRound(gm.x), qRound(gm.y), qRound(gm.width), qRound(gm.height));
}
 
QRect QFontMetrics::boundingRect(QChar ch) const
{
    const int script = ch.script();
    QFontEngine *engine;
    if (d->capital == QFont::SmallCaps && ch.isLower())
        engine = d->smallCapsFontPrivate()->engineForScript(script);
    else
        engine = d->engineForScript(script);
    Q_ASSERT(engine != nullptr);
 
    d->alterCharForCapitalization(ch);
 
    glyph_t glyph = engine->glyphIndex(ch.unicode());
 
    glyph_metrics_t gm = engine->boundingBox(glyph);
    return QRect(qRound(gm.x), qRound(gm.y), qRound(gm.width), qRound(gm.height));
}
 
QRect QFontMetrics::boundingRect(const QRect &rect, int flags, const QString &text, int tabStops,
                                 int *tabArray) const
{
    int tabArrayLen = 0;
    if (tabArray)
        while (tabArray[tabArrayLen])
            tabArrayLen++;
 
    QRectF rb;
    QRectF rr(rect);
    qt_format_text(QFont(d.data()), rr, flags | Qt::TextDontPrint, text, &rb, tabStops, tabArray,
                   tabArrayLen, nullptr);
 
    return rb.toAlignedRect();
}
 
QSize QFontMetrics::size(int flags, const QString &text, int tabStops, int *tabArray) const
{
    return boundingRect(QRect(0,0,0,0), flags | Qt::TextLongestVariant, text, tabStops, tabArray).size();
}
 
QRect QFontMetrics::tightBoundingRect(const QString &text) const
{
    if (text.size() == 0)
        return QRect();
 
    QStackTextEngine layout(text, QFont(d.data()));
    layout.itemize();
    glyph_metrics_t gm = layout.tightBoundingBox(0, text.size());
    return QRect(qRound(gm.x), qRound(gm.y), qRound(gm.width), qRound(gm.height));
}
 
QRect QFontMetrics::tightBoundingRect(const QString &text, const QTextOption &option) const
{
    if (text.size() == 0)
        return QRect();
 
    QStackTextEngine layout(text, QFont(d.data()));
    layout.option = option;
    layout.itemize();
    glyph_metrics_t gm = layout.tightBoundingBox(0, text.size());
    return QRect(qRound(gm.x), qRound(gm.y), qRound(gm.width), qRound(gm.height));
}
 
QString QFontMetrics::elidedText(const QString &text, Qt::TextElideMode mode, int width, int flags) const
{
    QString _text = text;
    if (!(flags & Qt::TextLongestVariant)) {
        int posA = 0;
        int posB = _text.indexOf(s_variableLengthStringSeparator);
        while (posB >= 0) {
            QString portion = _text.mid(posA, posB - posA);
            if (size(flags, portion).width() <= width)
                return portion;
            posA = posB + 1;
            posB = _text.indexOf(s_variableLengthStringSeparator, posA);
        }
        _text = _text.mid(posA);
    }
    QStackTextEngine engine(_text, QFont(d.data()));
    return engine.elidedText(mode, width, flags);
}
 
int QFontMetrics::underlinePos() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return qRound(engine->underlinePosition());
}
 
int QFontMetrics::overlinePos() const
{
    return ascent() + 1;
}
 
int QFontMetrics::strikeOutPos() const
{
    int pos = ascent() / 3;
    return pos > 0 ? pos : 1;
}
 
int QFontMetrics::lineWidth() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return qRound(engine->lineThickness());
}
 
qreal QFontMetrics::fontDpi() const
{
    return d->dpi;
}
 
/*****************************************************************************
  QFontMetricsF member functions
 *****************************************************************************/
 
QFontMetricsF::QFontMetricsF(const QFontMetrics &fontMetrics)
    : d(fontMetrics.d)
{
}
 
QFontMetricsF &QFontMetricsF::operator=(const QFontMetrics &other)
{
    d = other.d;
    return *this;
}
 
QFontMetricsF::QFontMetricsF(const QFont &font)
    : d(font.d)
{
}
 
QFontMetricsF::QFontMetricsF(const QFont &font, const QPaintDevice *paintdevice)
{
    int dpi = paintdevice ? paintdevice->logicalDpiY() : qt_defaultDpi();
    if (font.d->dpi != dpi) {
        d = new QFontPrivate(*font.d);
        d->dpi = dpi;
    } else {
        d = font.d;
    }
 
}
 
QFontMetricsF::QFontMetricsF(const QFontMetricsF &fm)
    : d(fm.d)
{
}
 
QFontMetricsF::~QFontMetricsF()
{
}
 
QFontMetricsF &QFontMetricsF::operator=(const QFontMetricsF &fm)
{
    d = fm.d;
    return *this;
}
 
bool QFontMetricsF::operator ==(const QFontMetricsF &other) const
{
    return d == other.d;
}
 
qreal QFontMetricsF::ascent() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return engine->ascent().toReal();
}
 
qreal QFontMetricsF::capHeight() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return engine->capHeight().toReal();
}
 
qreal QFontMetricsF::descent() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return engine->descent().toReal();
}
 
qreal QFontMetricsF::height() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
 
    return (engine->ascent() + engine->descent()).toReal();
}
 
qreal QFontMetricsF::leading() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return engine->leading().toReal();
}
 
qreal QFontMetricsF::lineSpacing() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return (engine->leading() + engine->ascent() + engine->descent()).toReal();
}
 
qreal QFontMetricsF::minLeftBearing() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return engine->minLeftBearing();
}
 
qreal QFontMetricsF::minRightBearing() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return engine->minRightBearing();
}
 
qreal QFontMetricsF::maxWidth() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return engine->maxCharWidth();
}
 
qreal QFontMetricsF::xHeight() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    if (d->capital == QFont::SmallCaps)
        return d->smallCapsFontPrivate()->engineForScript(QChar::Script_Common)->ascent().toReal();
    return engine->xHeight().toReal();
}
 
qreal QFontMetricsF::averageCharWidth() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return engine->averageCharWidth().toReal();
}
 
bool QFontMetricsF::inFont(QChar ch) const
{
    return inFontUcs4(ch.unicode());
}
 
bool QFontMetricsF::inFontUcs4(uint ucs4) const
{
    const int script = QChar::script(ucs4);
    QFontEngine *engine = d->engineForScript(script);
    Q_ASSERT(engine != nullptr);
    if (engine->type() == QFontEngine::Box)
        return false;
    return engine->canRender(ucs4);
}
 
qreal QFontMetricsF::leftBearing(QChar ch) const
{
    const int script = ch.script();
    QFontEngine *engine;
    if (d->capital == QFont::SmallCaps && ch.isLower())
        engine = d->smallCapsFontPrivate()->engineForScript(script);
    else
        engine = d->engineForScript(script);
    Q_ASSERT(engine != nullptr);
    if (engine->type() == QFontEngine::Box)
        return 0;
 
    d->alterCharForCapitalization(ch);
 
    glyph_t glyph = engine->glyphIndex(ch.unicode());
 
    qreal lb;
    engine->getGlyphBearings(glyph, &lb);
    return lb;
}
 
qreal QFontMetricsF::rightBearing(QChar ch) const
{
    const int script = ch.script();
    QFontEngine *engine;
    if (d->capital == QFont::SmallCaps && ch.isLower())
        engine = d->smallCapsFontPrivate()->engineForScript(script);
    else
        engine = d->engineForScript(script);
    Q_ASSERT(engine != nullptr);
    if (engine->type() == QFontEngine::Box)
        return 0;
 
    d->alterCharForCapitalization(ch);
 
    glyph_t glyph = engine->glyphIndex(ch.unicode());
 
    qreal rb;
    engine->getGlyphBearings(glyph, nullptr, &rb);
    return rb;
 
}
 
qreal QFontMetricsF::horizontalAdvance(const QString &text, int length) const
{
    int pos = (length >= 0)
            ? QStringView(text).left(length).indexOf(s_variableLengthStringSeparator)
            : text.indexOf(s_variableLengthStringSeparator);
    if (pos != -1)
        length = pos;
    else if (length < 0)
        length = text.size();
 
    if (length == 0)
        return 0;
 
    QStackTextEngine layout(text, QFont(d.data()));
    layout.itemize();
    return layout.width(0, length).toReal();
}
 
qreal QFontMetricsF::horizontalAdvance(const QString &text, const QTextOption &option) const
{
    int pos = text.indexOf(s_variableLengthStringSeparator);
    int length = -1;
    if (pos != -1)
        length = pos;
    else
        length = text.size();
 
    if (length == 0)
        return 0;
 
    QStackTextEngine layout(text, QFont(d.data()));
    layout.option = option;
    layout.itemize();
    return layout.width(0, length).toReal();
}
 
qreal QFontMetricsF::horizontalAdvance(QChar ch) const
{
    if (ch.category() == QChar::Mark_NonSpacing)
        return 0.;
 
    const int script = ch.script();
    QFontEngine *engine;
    if (d->capital == QFont::SmallCaps && ch.isLower())
        engine = d->smallCapsFontPrivate()->engineForScript(script);
    else
        engine = d->engineForScript(script);
    Q_ASSERT(engine != nullptr);
 
    d->alterCharForCapitalization(ch);
 
    glyph_t glyph = engine->glyphIndex(ch.unicode());
    QFixed advance;
 
    QGlyphLayout glyphs;
    glyphs.numGlyphs = 1;
    glyphs.glyphs = &glyph;
    glyphs.advances = &advance;
    engine->recalcAdvances(&glyphs, { });
 
    return advance.toReal();
}
 
 
QRectF QFontMetricsF::boundingRect(const QString &text) const
{
    int len = text.size();
    if (len == 0)
        return QRectF();
 
    QStackTextEngine layout(text, QFont(d.data()));
    layout.itemize();
    glyph_metrics_t gm = layout.boundingBox(0, len);
    return QRectF(gm.x.toReal(), gm.y.toReal(),
                  gm.width.toReal(), gm.height.toReal());
}
 
QRectF QFontMetricsF::boundingRect(const QString &text, const QTextOption &option) const
{
    if (text.size() == 0)
        return QRectF();
 
    QStackTextEngine layout(text, QFont(d.data()));
    layout.option = option;
    layout.itemize();
    glyph_metrics_t gm = layout.boundingBox(0, text.size());
    return QRectF(gm.x.toReal(), gm.y.toReal(),
                  gm.width.toReal(), gm.height.toReal());
}
 
 
QRectF QFontMetricsF::boundingRect(QChar ch) const
{
    const int script = ch.script();
    QFontEngine *engine;
    if (d->capital == QFont::SmallCaps && ch.isLower())
        engine = d->smallCapsFontPrivate()->engineForScript(script);
    else
        engine = d->engineForScript(script);
    Q_ASSERT(engine != nullptr);
 
    d->alterCharForCapitalization(ch);
 
    glyph_t glyph = engine->glyphIndex(ch.unicode());
 
    glyph_metrics_t gm = engine->boundingBox(glyph);
    return QRectF(gm.x.toReal(), gm.y.toReal(), gm.width.toReal(), gm.height.toReal());
}
 
QRectF QFontMetricsF::boundingRect(const QRectF &rect, int flags, const QString& text,
                                   int tabStops, int *tabArray) const
{
    int tabArrayLen = 0;
    if (tabArray)
        while (tabArray[tabArrayLen])
            tabArrayLen++;
 
    QRectF rb;
    qt_format_text(QFont(d.data()), rect, flags | Qt::TextDontPrint, text, &rb, tabStops, tabArray,
                   tabArrayLen, nullptr);
    return rb;
}
 
QSizeF QFontMetricsF::size(int flags, const QString &text, int tabStops, int *tabArray) const
{
    return boundingRect(QRectF(), flags | Qt::TextLongestVariant, text, tabStops, tabArray).size();
}
 
QRectF QFontMetricsF::tightBoundingRect(const QString &text) const
{
    if (text.size() == 0)
        return QRectF();
 
    QStackTextEngine layout(text, QFont(d.data()));
    layout.itemize();
    glyph_metrics_t gm = layout.tightBoundingBox(0, text.size());
    return QRectF(gm.x.toReal(), gm.y.toReal(), gm.width.toReal(), gm.height.toReal());
}
 
QRectF QFontMetricsF::tightBoundingRect(const QString &text, const QTextOption &option) const
{
    if (text.size() == 0)
        return QRectF();
 
    QStackTextEngine layout(text, QFont(d.data()));
    layout.option = option;
    layout.itemize();
    glyph_metrics_t gm = layout.tightBoundingBox(0, text.size());
    return QRectF(gm.x.toReal(), gm.y.toReal(), gm.width.toReal(), gm.height.toReal());
}
 
QString QFontMetricsF::elidedText(const QString &text, Qt::TextElideMode mode, qreal width, int flags) const
{
    QString _text = text;
    if (!(flags & Qt::TextLongestVariant)) {
        int posA = 0;
        int posB = _text.indexOf(s_variableLengthStringSeparator);
        while (posB >= 0) {
            QString portion = _text.mid(posA, posB - posA);
            if (size(flags, portion).width() <= width)
                return portion;
            posA = posB + 1;
            posB = _text.indexOf(s_variableLengthStringSeparator, posA);
        }
        _text = _text.mid(posA);
    }
    QStackTextEngine engine(_text, QFont(d.data()));
    return engine.elidedText(mode, QFixed::fromReal(width), flags);
}
 
qreal QFontMetricsF::underlinePos() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return engine->underlinePosition().toReal();
}
 
qreal QFontMetricsF::overlinePos() const
{
    return ascent() + 1;
}
 
qreal QFontMetricsF::strikeOutPos() const
{
    return ascent() / 3.;
}
 
qreal QFontMetricsF::lineWidth() const
{
    QFontEngine *engine = d->engineForScript(QChar::Script_Common);
    Q_ASSERT(engine != nullptr);
    return engine->lineThickness().toReal();
}
 
qreal QFontMetricsF::fontDpi() const
{
    return d->dpi;
}
 
QT_END_NAMESPACE