qstatictext.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 "qstatictext.h"
#include "qstatictext_p.h"
#include <qmath.h>
#include <private/qtextengine_p.h>
#include <private/qfontengine_p.h>
#include <qabstracttextdocumentlayout.h>
 
QT_BEGIN_NAMESPACE
 
QT_IMPL_METATYPE_EXTERN(QStaticText)
 
QStaticTextUserData::~QStaticTextUserData()
{
}
 
QStaticText::QStaticText()
    : data(new QStaticTextPrivate)
{
}
 
QStaticText::QStaticText(const QString &text)
    : data(new QStaticTextPrivate)
{
    data->text = text;
    data->invalidate();
}
 
QStaticText::QStaticText(const QStaticText &other)
{
    data = other.data;
}
 
QStaticText::~QStaticText()
{
    Q_ASSERT(!data || data->ref.loadRelaxed() >= 1);
}
 
void QStaticText::detach()
{
    if (data->ref.loadRelaxed() != 1)
        data.detach();
}
 
void QStaticText::prepare(const QTransform &matrix, const QFont &font)
{
    data->matrix = matrix;
    data->font = font;
    data->init();
}
 
 
QStaticText &QStaticText::operator=(const QStaticText &other)
{
    data = other.data;
    return *this;
}
 
bool QStaticText::operator==(const QStaticText &other) const
{
    return (data == other.data
            || (data->text == other.data->text
                && data->font == other.data->font
                && data->textWidth == other.data->textWidth));
}
 
bool QStaticText::operator!=(const QStaticText &other) const
{
    return !(*this == other);
}
 
void QStaticText::setText(const QString &text)
{
    detach();
    data->text = text;
    data->invalidate();
}
 
void QStaticText::setTextFormat(Qt::TextFormat textFormat)
{
    detach();
    data->textFormat = textFormat;
    data->invalidate();
}
 
Qt::TextFormat QStaticText::textFormat() const
{
    return Qt::TextFormat(data->textFormat);
}
 
QString QStaticText::text() const
{
    return data->text;
}
 
void QStaticText::setPerformanceHint(PerformanceHint performanceHint)
{
    if ((performanceHint == ModerateCaching && !data->useBackendOptimizations)
        || (performanceHint == AggressiveCaching && data->useBackendOptimizations)) {
        return;
    }
    detach();
    data->useBackendOptimizations = (performanceHint == AggressiveCaching);
    data->invalidate();
}
 
QStaticText::PerformanceHint QStaticText::performanceHint() const
{
    return data->useBackendOptimizations ? AggressiveCaching : ModerateCaching;
}
 
void QStaticText::setTextOption(const QTextOption &textOption)
{
    detach();
    data->textOption = textOption;
    data->invalidate();
}
 
QTextOption QStaticText::textOption() const
{
    return data->textOption;
}
 
void QStaticText::setTextWidth(qreal textWidth)
{
    detach();
    data->textWidth = textWidth;
    data->invalidate();
}
 
qreal QStaticText::textWidth() const
{
    return data->textWidth;
}
 
QSizeF QStaticText::size() const
{
    if (data->needsRelayout)
        data->init();
    return data->actualSize;
}
 
QStaticTextPrivate::QStaticTextPrivate()
        : textWidth(-1.0), items(nullptr), itemCount(0), glyphPool(nullptr), positionPool(nullptr),
          needsRelayout(true), useBackendOptimizations(false), textFormat(Qt::AutoText),
          untransformedCoordinates(false)
{
}
 
QStaticTextPrivate::QStaticTextPrivate(const QStaticTextPrivate &other)
    : text(other.text), font(other.font), textWidth(other.textWidth), matrix(other.matrix),
      items(nullptr), itemCount(0), glyphPool(nullptr), positionPool(nullptr), textOption(other.textOption),
      needsRelayout(true), useBackendOptimizations(other.useBackendOptimizations),
      textFormat(other.textFormat), untransformedCoordinates(other.untransformedCoordinates)
{
}
 
QStaticTextPrivate::~QStaticTextPrivate()
{
    delete[] items;
    delete[] glyphPool;
    delete[] positionPool;
}
 
QStaticTextPrivate *QStaticTextPrivate::get(const QStaticText *q)
{
    return q->data.data();
}
 
namespace {
 
    class DrawTextItemRecorder: public QPaintEngine
    {
    public:
        DrawTextItemRecorder(bool untransformedCoordinates, bool useBackendOptimizations)
                : m_dirtyPen(false), m_useBackendOptimizations(useBackendOptimizations),
                  m_untransformedCoordinates(untransformedCoordinates), m_currentColor(0, 0, 0, 0)
        {
        }
 
        virtual void updateState(const QPaintEngineState &newState) override
        {
            if (newState.state() & QPaintEngine::DirtyPen
                && newState.pen().color() != m_currentColor) {
                m_dirtyPen = true;
                m_currentColor = newState.pen().color();
            }
        }
 
        virtual void drawTextItem(const QPointF &position, const QTextItem &textItem) override
        {
            const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
 
            QStaticTextItem currentItem;
            currentItem.setFontEngine(ti.fontEngine);
            currentItem.font = ti.font();
            currentItem.glyphOffset = m_glyphs.size(); // Store offset into glyph pool
            currentItem.positionOffset = m_glyphs.size(); // Offset into position pool
            currentItem.useBackendOptimizations = m_useBackendOptimizations;
            if (m_dirtyPen)
                currentItem.color = m_currentColor;
 
            QTransform matrix = m_untransformedCoordinates ? QTransform() : state->transform();
            matrix.translate(position.x(), position.y());
 
            QVarLengthArray<glyph_t> glyphs;
            QVarLengthArray<QFixedPoint> positions;
            ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
 
            int size = glyphs.size();
            Q_ASSERT(size == positions.size());
            currentItem.numGlyphs = size;
 
            m_glyphs.resize(m_glyphs.size() + size);
            m_positions.resize(m_glyphs.size());
 
            glyph_t *glyphsDestination = m_glyphs.data() + currentItem.glyphOffset;
            memcpy(glyphsDestination, glyphs.constData(), sizeof(glyph_t) * currentItem.numGlyphs);
 
            QFixedPoint *positionsDestination = m_positions.data() + currentItem.positionOffset;
            memcpy(positionsDestination, positions.constData(), sizeof(QFixedPoint) * currentItem.numGlyphs);
 
            m_items.append(currentItem);
        }
 
        virtual void drawPolygon(const QPointF *, int , PolygonDrawMode ) override
        {
            /* intentionally empty */
        }
 
        virtual bool begin(QPaintDevice *) override  { return true; }
        virtual bool end() override { return true; }
        virtual void drawPixmap(const QRectF &, const QPixmap &, const QRectF &) override {}
        virtual Type type() const override
        {
            return User;
        }
 
        QList<QStaticTextItem> items() const
        {
            return m_items;
        }
 
        QList<QFixedPoint> positions() const
        {
            return m_positions;
        }
 
        QList<glyph_t> glyphs() const
        {
            return m_glyphs;
        }
 
    private:
        QList<QStaticTextItem> m_items;
        QList<QFixedPoint> m_positions;
        QList<glyph_t> m_glyphs;
 
        bool m_dirtyPen;
        bool m_useBackendOptimizations;
        bool m_untransformedCoordinates;
        QColor m_currentColor;
    };
 
    class DrawTextItemDevice: public QPaintDevice
    {
    public:
        DrawTextItemDevice(bool untransformedCoordinates, bool useBackendOptimizations)
        {
            m_paintEngine = new DrawTextItemRecorder(untransformedCoordinates,
                                                     useBackendOptimizations);
        }
 
        ~DrawTextItemDevice()
        {
            delete m_paintEngine;
        }
 
        int metric(PaintDeviceMetric m) const override
        {
            int val;
            switch (m) {
            case PdmWidth:
            case PdmHeight:
            case PdmWidthMM:
            case PdmHeightMM:
                val = 0;
                break;
            case PdmDpiX:
            case PdmPhysicalDpiX:
                val = qt_defaultDpiX();
                break;
            case PdmDpiY:
            case PdmPhysicalDpiY:
                val = qt_defaultDpiY();
                break;
            case PdmNumColors:
                val = 16777216;
                break;
            case PdmDepth:
                val = 24;
                break;
            case PdmDevicePixelRatio:
                val = 1;
                break;
            case PdmDevicePixelRatioScaled:
                val = devicePixelRatioFScale();
                break;
            default:
                val = 0;
                qWarning("DrawTextItemDevice::metric: Invalid metric command");
            }
            return val;
        }
 
        virtual QPaintEngine *paintEngine() const override
        {
            return m_paintEngine;
        }
 
        QList<glyph_t> glyphs() const
        {
            return m_paintEngine->glyphs();
        }
 
        QList<QFixedPoint> positions() const
        {
            return m_paintEngine->positions();
        }
 
        QList<QStaticTextItem> items() const
        {
            return m_paintEngine->items();
        }
 
    private:
        DrawTextItemRecorder *m_paintEngine;
    };
}
 
void QStaticTextPrivate::paintText(const QPointF &topLeftPosition, QPainter *p, const QColor &pen)
{
    bool preferRichText = textFormat == Qt::RichText
                          || (textFormat == Qt::AutoText && Qt::mightBeRichText(text));
 
    if (!preferRichText) {
        QTextLayout textLayout;
        textLayout.setText(text);
        textLayout.setFont(font);
        textLayout.setTextOption(textOption);
        textLayout.setCacheEnabled(true);
 
        qreal height = 0;
        textLayout.beginLayout();
        while (1) {
            QTextLine line = textLayout.createLine();
            if (!line.isValid())
                break;
            line.setLeadingIncluded(true);
 
            if (textWidth >= 0.0)
                line.setLineWidth(textWidth);
            else
                line.setLineWidth(QFIXED_MAX);
            line.setPosition(QPointF(0.0, height));
            height += line.height();
            if (line.leading() < 0)
                height += qCeil(line.leading());
        }
        textLayout.endLayout();
 
        actualSize = textLayout.boundingRect().size();
        p->setPen(pen);
        textLayout.draw(p, topLeftPosition);
    } else {
        QTextDocument document;
#ifndef QT_NO_CSSPARSER
        document.setDefaultStyleSheet(QString::fromLatin1("body { color: rgba(%1, %2, %3, %4%) }")
                                      .arg(QString::number(pen.red()))
                                      .arg(QString::number(pen.green()))
                                      .arg(QString::number(pen.blue()))
                                      .arg(QString::number(pen.alpha())));
#endif
        document.setDefaultFont(font);
        document.setDocumentMargin(0.0);
#ifndef QT_NO_TEXTHTMLPARSER
        document.setHtml(text);
#else
        document.setPlainText(text);
#endif
        if (textWidth >= 0.0)
            document.setTextWidth(textWidth);
        else
            document.adjustSize();
        document.setDefaultTextOption(textOption);
 
        p->save();
        p->translate(topLeftPosition);
        QAbstractTextDocumentLayout::PaintContext ctx;
        ctx.palette.setColor(QPalette::Text, pen);
        document.documentLayout()->draw(p, ctx);
        p->restore();
 
        actualSize = document.size();
    }
}
 
void QStaticTextPrivate::init()
{
    delete[] items;
    delete[] glyphPool;
    delete[] positionPool;
 
    position = QPointF(0, 0);
 
    DrawTextItemDevice device(untransformedCoordinates, useBackendOptimizations);
    {
        QPainter painter(&device);
        painter.setFont(font);
        painter.setTransform(matrix);
 
        paintText(QPointF(0, 0), &painter, QColor(0, 0, 0, 0));
    }
 
    QList<QStaticTextItem> deviceItems = device.items();
    QList<QFixedPoint> positions = device.positions();
    QList<glyph_t> glyphs = device.glyphs();
 
    itemCount = deviceItems.size();
    items = new QStaticTextItem[itemCount];
 
    glyphPool = new glyph_t[glyphs.size()];
    memcpy(glyphPool, glyphs.constData(), glyphs.size() * sizeof(glyph_t));
 
    positionPool = new QFixedPoint[positions.size()];
    memcpy(positionPool, positions.constData(), positions.size() * sizeof(QFixedPoint));
 
    for (int i=0; i<itemCount; ++i) {
        items[i] = deviceItems.at(i);
 
        items[i].glyphs = glyphPool + items[i].glyphOffset;
        items[i].glyphPositions = positionPool + items[i].positionOffset;
    }
 
    needsRelayout = false;
}
 
QT_END_NAMESPACE