qsginternaltextnode.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
// Qt-Security score:significant reason:default
 
#include "qsginternaltextnode_p.h"
 
#include "qquicktextnodeengine_p.h"
 
#include <private/qsgadaptationlayer_p.h>
#include <private/qsgdistancefieldglyphnode_p.h>
#include <private/qquickclipnode_p.h>
#include <private/qquickitem_p.h>
#include <private/qquicktextdocument_p.h>
#include <private/qsgrendernode_p.h>
 
#include <QtCore/qpoint.h>
#include <qtextdocument.h>
#include <qtextlayout.h>
#include <qabstracttextdocumentlayout.h>
#include <private/qquickstyledtext_p.h>
#include <private/qquicktext_p_p.h>
#include <private/qfont_p.h>
#include <private/qfontengine_p.h>
 
#include <private/qtextdocumentlayout_p.h>
#include <qhash.h>
 
// #define QSGINTERNALTEXTNODE_NO_RECYCLE
 
Q_STATIC_LOGGING_CATEGORY(lcTextRecycle, "qt.quick.text.noderecycling")
 
QT_BEGIN_NAMESPACE
 
/*!
    \class QSGInternalTextNode
    \inmodule QtQuick
    \internal
 
    Creates an empty QSGInternalTextNode
*/
QSGInternalTextNode::QSGInternalTextNode(QSGRenderContext *renderContext)
    : m_renderContext(renderContext)
{
#ifdef QSG_RUNTIME_DESCRIPTION
    qsgnode_set_description(this, QLatin1String("text"));
#endif
 
    static_assert(int(QSGTextNode::Normal) == int(QQuickText::Normal));
    static_assert(int(QSGTextNode::Outline) == int(QQuickText::Outline));
    static_assert(int(QSGTextNode::Raised) == int(QQuickText::Raised));
    static_assert(int(QSGTextNode::Sunken) == int(QQuickText::Sunken));
 
    static_assert(int(QSGTextNode::QtRendering) == int(QQuickText::QtRendering));
    static_assert(int(QSGTextNode::NativeRendering) == int(QQuickText::NativeRendering));
    static_assert(int(QSGTextNode::CurveRendering) == int(QQuickText::CurveRendering));
}
 
QSGInternalTextNode::~QSGInternalTextNode()
{
    qDeleteAll(m_textures);
}
 
QSGGlyphNode *QSGInternalTextNode::addGlyphs(const QPointF &position,
                                             const QGlyphRun &glyphs,
                                             const QColor &color,
                                             RecycleBin *recycleBin,
                                             QQuickText::TextStyle style,
                                             const QColor &styleColor,
                                             QSGNode *parentNode)
{
    QRawFont font = glyphs.rawFont();
 
    QSGTextNode::RenderType preferredRenderType = m_renderType;
    if (m_renderType != NativeRendering) {
        if (const QFontEngine *fe = QRawFontPrivate::get(font)->fontEngine)
            if (fe->hasUnreliableGlyphOutline() || !fe->isSmoothlyScalable)
                preferredRenderType = QSGTextNode::NativeRendering;
    }
 
    if (preferredRenderType == NativeRendering)
        m_containsUnscalableGlyphs = true;
 
    QSGGlyphNode *node = findOrCreateGlyphNode(preferredRenderType, recycleBin);
    node->setRenderTypeQuality(m_renderTypeQuality);
    node->setGlyphs(position + QPointF(0, glyphs.rawFont().ascent()), glyphs);
    node->setStyle(style);
    node->setStyleColor(styleColor);
    node->setColor(color);
    node->update();
 
    /* We flag the geometry as static, but we never call markVertexDataDirty
       or markIndexDataDirty on them. This is because all text nodes are
       discarded when a change occurs. If we start appending/removing from
       existing geometry, then we also need to start marking the geometry as
       dirty.
     */
    node->geometry()->setIndexDataPattern(QSGGeometry::StaticPattern);
    node->geometry()->setVertexDataPattern(QSGGeometry::StaticPattern);
 
    if (parentNode == nullptr)
        parentNode = this;
 
    if (node->parent() == nullptr)
        parentNode->appendChildNode(node);
 
    if (style == QQuickText::Outline && color.alpha() > 0 && styleColor != color) {
        QSGGlyphNode *fillNode = findOrCreateGlyphNode(preferredRenderType, recycleBin);
        fillNode->setRenderTypeQuality(m_renderTypeQuality);
        fillNode->setGlyphs(position + QPointF(0, glyphs.rawFont().ascent()), glyphs);
        fillNode->setStyle(QQuickText::Normal);
        fillNode->setPreferredAntialiasingMode(QSGGlyphNode::GrayAntialiasing);
        fillNode->setColor(color);
        fillNode->update();
 
        fillNode->geometry()->setIndexDataPattern(QSGGeometry::StaticPattern);
        fillNode->geometry()->setVertexDataPattern(QSGGeometry::StaticPattern);
 
        if (fillNode->parent() == nullptr)
            parentNode->appendChildNode(fillNode);
        fillNode->setRenderOrder(node->renderOrder() + 1);
    }
 
    return node;
}
 
void QSGInternalTextNode::setCursor(const QRectF &rect, const QColor &color, RecycleBin *recycleBin)
{
    if (m_cursorNode == nullptr)
        m_cursorNode = findOrCreateRectangleNode(recycleBin);
    m_cursorNode->setRect(rect);
    m_cursorNode->setColor(color);
    m_cursorNode->update();
    if (m_cursorNode->parent() == nullptr)
        appendChildNode(m_cursorNode);
}
 
void QSGInternalTextNode::clearCursor()
{
    if (m_cursorNode)
        removeChildNode(m_cursorNode);
    delete m_cursorNode;
    m_cursorNode = nullptr;
}
 
void QSGInternalTextNode::addDecorationNode(const QRectF &rect,
                                            const QColor &color,
                                            QTextCharFormat::UnderlineStyle style,
                                            RecycleBin *recycleBin)
{
    Q_UNUSED(style); // Software renderer does not support styled underlines
    addRectangleNode(rect, color, recycleBin);
}
 
void QSGInternalTextNode::addRectangleNode(const QRectF &rect,
                                           const QColor &color,
                                           RecycleBin *recycleBin)
{
    QSGInternalRectangleNode *node = findOrCreateRectangleNode(recycleBin);
    node->setRect(rect);
    node->setColor(color);
    node->update();
 
    if (node->parent() == nullptr)
        appendChildNode(node);
}
 
void QSGInternalTextNode::addImage(const QRectF &rect, const QImage &image, RecycleBin *recycleBin)
{
    QSGInternalImageNode *node = findOrCreateImageNode(recycleBin);
    QSGTexture *texture = m_renderContext->createTexture(image);
    texture->setFiltering(m_filtering);
    m_textures.append(texture);
    node->setTargetRect(rect);
    node->setInnerTargetRect(rect);
    node->setTexture(texture);
    node->setFiltering(m_filtering);
    if (node->parent() == nullptr)
        appendChildNode(node);
    node->update();
}
 
void QSGInternalTextNode::doAddTextDocument(QPointF position,
                                            QTextDocument *textDocument,
                                            int selectionStart,
                                            int selectionEnd,
                                            RecycleBin *recycleBin)
{
    QQuickTextNodeEngine engine;
    engine.setTextColor(m_color);
    engine.setSelectedTextColor(m_selectionTextColor);
    engine.setSelectionColor(m_selectionColor);
    engine.setAnchorColor(m_linkColor);
    engine.setPosition(position);
    engine.setDevicePixelRatio(m_devicePixelRatio);
 
    QList<QTextFrame *> frames;
    frames.append(textDocument->rootFrame());
    while (!frames.isEmpty()) {
        QTextFrame *textFrame = frames.takeFirst();
        frames.append(textFrame->childFrames());
 
        engine.addFrameDecorations(textDocument, textFrame);
 
        if (textFrame->firstPosition() > textFrame->lastPosition()
         && textFrame->frameFormat().position() != QTextFrameFormat::InFlow) {
            const int pos = textFrame->firstPosition() - 1;
            auto *a = static_cast<QtPrivate::ProtectedLayoutAccessor *>(textDocument->documentLayout());
            QTextCharFormat format = a->formatAccessor(pos);
            QRectF rect = a->frameBoundingRect(textFrame);
 
            QTextBlock block = textFrame->firstCursorPosition().block();
            engine.setCurrentLine(block.layout()->lineForTextPosition(pos - block.position()));
            engine.addTextObject(block, rect.topLeft(), format, QQuickTextNodeEngine::Unselected, textDocument,
                                 pos, textFrame->frameFormat().position());
        } else {
            QTextFrame::iterator it = textFrame->begin();
 
            while (!it.atEnd()) {
                Q_ASSERT(!engine.currentLine().isValid());
 
                QTextBlock block = it.currentBlock();
                engine.addTextBlock(textDocument, block, position, m_color, m_linkColor, selectionStart, selectionEnd,
                                    (textDocument->characterCount() > QQuickTextPrivate::largeTextSizeThreshold ?
                                         m_viewport : QRectF()));
                ++it;
            }
        }
    }
 
    engine.addToSceneGraph(this, recycleBin, QQuickText::TextStyle(m_textStyle), m_styleColor);
}
 
void QSGInternalTextNode::doAddTextLayout(QPointF position,
                                          QTextLayout *textLayout,
                                          int selectionStart,
                                          int selectionEnd,
                                          int lineStart,
                                          int lineCount,
                                          RecycleBin *recycleBin)
{
    QQuickTextNodeEngine engine;
    engine.setTextColor(m_color);
    engine.setSelectedTextColor(m_selectionTextColor);
    engine.setSelectionColor(m_selectionColor);
    engine.setAnchorColor(m_linkColor);
    engine.setPosition(position);
    engine.setDevicePixelRatio(m_devicePixelRatio);
 
#if QT_CONFIG(im)
    int preeditLength = textLayout->preeditAreaText().size();
    int preeditPosition = textLayout->preeditAreaPosition();
#endif
 
    QVarLengthArray<QTextLayout::FormatRange> colorChanges;
    engine.mergeFormats(textLayout, &colorChanges);
 
    lineCount = lineCount >= 0
            ? qMin(lineStart + lineCount, textLayout->lineCount())
            : textLayout->lineCount();
 
    bool inViewport = false;
    for (int i=lineStart; i<lineCount; ++i) {
        QTextLine line = textLayout->lineAt(i);
 
        int start = line.textStart();
        int length = line.textLength();
        int end = start + length;
 
#if QT_CONFIG(im)
        if (preeditPosition >= 0
         && preeditPosition >= start
         && preeditPosition < end) {
            end += preeditLength;
        }
#endif
        // If there's a lot of text, insert only the range of lines that can possibly be visible within the viewport.
        if (m_viewport.isNull() || (line.y() + line.height() > m_viewport.top() && line.y() < m_viewport.bottom())) {
            if (!inViewport && !m_viewport.isNull()) {
                m_firstLineInViewport = i;
                qCDebug(lcVP) << "first line in viewport" << i << "@" << line.y();
            }
            inViewport = true;
            engine.setCurrentLine(line);
            engine.addGlyphsForRanges(colorChanges, start, end, selectionStart, selectionEnd);
        } else if (inViewport) {
            Q_ASSERT(!m_viewport.isNull());
            m_firstLinePastViewport = i;
            qCDebug(lcVP) << "first omitted line past bottom of viewport" << i << "@" << line.y();
            break; // went past the bottom of the viewport, so we're done
        }
    }
 
    engine.addToSceneGraph(this, recycleBin, QQuickText::TextStyle(m_textStyle), m_styleColor);
}
 
namespace {
 
    class ChildNodeCollector : public QSGNodeVisitorEx
    {
    public:
        ChildNodeCollector(QSGInternalTextNode::RecycleBin &recycleBin,
                           std::vector<QSGNode *> &untrackedNodes)
            : m_recycleBin(recycleBin)
            , m_untrackedNodes(untrackedNodes)
        {
        }
 
        bool visit(QSGTransformNode *node) override
        {
            Q_UNREACHABLE();
            m_untrackedNodes.push_back(node);
            return false;
        }
 
        void endVisit(QSGTransformNode *) override
        {
        }
 
        bool visit(QSGClipNode *node) override
        {
            // Clip nodes are used for selections and are currently not recycled. Clip nodes
            // will anyway be separate batch roots, so this text does not trigger reuploads.
            m_untrackedNodes.push_back(node);
            return false;
        }
 
        void endVisit(QSGClipNode *) override
        {
        }
 
        bool visit(QSGGeometryNode *node) override
        {
            Q_UNREACHABLE();
            m_untrackedNodes.push_back(node);
            return false;
        }
 
        void endVisit(QSGGeometryNode *) override
        {
        }
 
        bool visit(QSGOpacityNode *node) override
        {
            Q_UNREACHABLE();
            m_untrackedNodes.push_back(node);
            return false;
        }
 
        void endVisit(QSGOpacityNode *) override
        {
        }
 
        bool visit(QSGInternalImageNode *node) override
        {
            m_recycleBin.unusedImageNodes.append(node);
            return false;
        }
 
        void endVisit(QSGInternalImageNode *) override
        {
        }
 
        bool visit(QSGPainterNode *node) override
        {
            Q_UNREACHABLE();
            m_untrackedNodes.push_back(node);
            return false;
        }
 
        void endVisit(QSGPainterNode *) override
        {
        }
 
        bool visit(QSGInternalRectangleNode *node) override
        {
            m_recycleBin.unusedRectangleNodes.append(node);
            return false;
        }
 
        void endVisit(QSGInternalRectangleNode *) override
        {
        }
 
        bool visit(QSGGlyphNode *node) override
        {
            // Some glyph nodes with a lot of content have content split into child nodes.
            // For now, we do not recycle these nodes as it is an uncommon case and adds
            // complexity. This also affects curve-rendered glyphs, which will have children
            // and thus be excluded from recycling.
            if (node->childCount() > 0)
                m_untrackedNodes.push_back(node);
            else
                m_recycleBin.unusedGlyphNodes.append(node);
 
            return false;
        }
 
        void endVisit(QSGGlyphNode *) override
        {
        }
 
        bool visit(QSGRootNode *node) override
        {
            Q_UNREACHABLE();
            m_untrackedNodes.push_back(node);
            return false;
        }
 
        void endVisit(QSGRootNode *) override
        {
        }
 
#if QT_CONFIG(quick_sprite)
        bool visit(QSGSpriteNode *node) override
        {
            Q_UNREACHABLE();
            m_untrackedNodes.push_back(node);
            return false;
        }
 
        void endVisit(QSGSpriteNode *) override
        {
        }
#endif
        bool visit(QSGRenderNode *node) override
        {
            Q_UNREACHABLE();
            m_untrackedNodes.push_back(node);
            return false;
        }
 
        void endVisit(QSGRenderNode *) override
        {
        }
 
    private:
        QSGInternalTextNode::RecycleBin &m_recycleBin;
        std::vector<QSGNode *> &m_untrackedNodes;
    };
}
 
QSGInternalRectangleNode *QSGInternalTextNode::findOrCreateRectangleNode(RecycleBin *recycleBin)
{
    qCDebug(lcTextRecycle) << "Searching for rectangle node";
 
    if (recycleBin == nullptr || recycleBin->unusedRectangleNodes.isEmpty()) {
        qCDebug(lcTextRecycle) << "    Creating new rectangle node, no suitable node found";
        return m_renderContext->sceneGraphContext()->createInternalRectangleNode();
    }
 
    qCDebug(lcTextRecycle) << "    Found node, recycling";
    auto *node = recycleBin->unusedRectangleNodes.last();
    recycleBin->unusedRectangleNodes.removeLast();
    return node;
}
 
 
QSGInternalImageNode *QSGInternalTextNode::findOrCreateImageNode(RecycleBin *recycleBin)
{
    qCDebug(lcTextRecycle) << "Searching for image node";
 
    if (recycleBin == nullptr || recycleBin->unusedImageNodes.isEmpty()) {
        qCDebug(lcTextRecycle) << "    Creating new image node, no suitable node found";
        return m_renderContext->sceneGraphContext()->createInternalImageNode(m_renderContext);
    }
 
    qCDebug(lcTextRecycle) << "    Found node, recycling";
    auto *node = recycleBin->unusedImageNodes.last();
    recycleBin->unusedImageNodes.removeLast();
    return node;
}
 
QSGGlyphNode *QSGInternalTextNode::findOrCreateGlyphNode(RenderType renderType,
                                                         RecycleBin *recycleBin)
{
    qCDebug(lcTextRecycle) << "Searching for glyph node with renderType" << renderType;
    renderType = m_renderContext->sceneGraphContext()->processTextRenderType(renderType);
 
    if (recycleBin != nullptr) {
        for (int i = recycleBin->unusedGlyphNodes.size() - 1; i >= 0; --i) {
            QSGGlyphNode *n = recycleBin->unusedGlyphNodes.at(i);
            if (n->renderType() == renderType) {
                qCDebug(lcTextRecycle) << "    Found node, recycling";
                recycleBin->unusedGlyphNodes.removeAt(i);
                return n;
            } else {
                qCDebug(lcTextRecycle) << "    Unsuitable node found:" << n->renderType();
            }
        }
    }
 
    qCDebug(lcTextRecycle) << "    Creating new glyph node, no suitable node found";
    return m_renderContext->sceneGraphContext()->createGlyphNode(m_renderContext,
                                                                 renderType);
}
 
void QSGInternalTextNode::clear()
{
    while (firstChild() != nullptr)
        delete firstChild();
    m_cursorNode = nullptr;
    qDeleteAll(m_textures);
    m_textures.clear();
}
 
void QSGInternalTextNode::recycle(RecycleBin *recycleBin)
{
    Q_ASSERT(recycleBin != nullptr);
    Q_ASSERT(recycleBin->unusedGlyphNodes.isEmpty());
    Q_ASSERT(recycleBin->unusedImageNodes.isEmpty());
    Q_ASSERT(recycleBin->unusedRectangleNodes.isEmpty());
 
    recycleBin->unusedGlyphNodes.reserve(childCount());
 
    std::vector<QSGNode *> untrackedNodes;
    ChildNodeCollector collector(*recycleBin, untrackedNodes);
 
    // We retain nodes for recycling and then discard the unused ones after adding a new layout.
    // This is because removing and adding nodes to the root batch can cause expensive reuploads
    // of all data. So we visit all immediate children of the text node and keep them around
    // until they are either used or discardUnusedNodes() is called later. For rapid updates,
    // you will typically just have a single glyph node and rapidly replace its text, so this
    // is what we are optimzing for.
    QSGNode *node = firstChild();
    while (node != nullptr) {
        if (node->type() == QSGNode::GeometryNodeType
            && node->flags().testFlag(QSGNode::IsVisitableNode)) {
            QSGVisitableNode *visitableNode = static_cast<QSGVisitableNode *>(node);
            visitableNode->accept(&collector);
        } else {
            untrackedNodes.push_back(node);
        }
 
        node = node->nextSibling();
    }
 
    for (QSGGlyphNode *glyphNode : recycleBin->unusedGlyphNodes)
        glyphNode->recycle();
 
    qDeleteAll(untrackedNodes);
 
#if defined(QSGINTERNALTEXTNODE_NO_RECYCLE)
    qDeleteAll(recycleBin->unusedGlyphNodes);
    recycleBin->unusedGlyphNodes = {};
 
    qDeleteAll(recycleBin->unusedImageNodes);
    recycleBin->unusedImageNodes = {};
 
    qDeleteAll(recycleBin->unusedRectangleNodes);
    recycleBin->unusedRectangleNodes = {};
 
    qDeleteAll(m_textures);
#else
    recycleBin->unusedTextures = m_textures;
#endif
 
    qCDebug(lcTextRecycle) << "Recycle: "
                           << recycleBin->unusedGlyphNodes.size() << "glyph nodes"
                           << recycleBin->unusedImageNodes.size() << "image nodes"
                           << recycleBin->unusedRectangleNodes.size() << "rectangle nodes"
                           << recycleBin->unusedTextures.size() << "textures";
 
    m_textures.clear();
    m_cursorNode = nullptr;
    recycleBin->unusedGlyphNodes.squeeze();
}
 
void QSGInternalTextNode::discardUnusedNodes(RecycleBin *recycleBin)
{
    qCDebug(lcTextRecycle) << "Discard: "
                           << recycleBin->unusedGlyphNodes.size() << "glyph nodes"
                           << recycleBin->unusedImageNodes.size() << "image nodes"
                           << recycleBin->unusedRectangleNodes.size() << "rectangle nodes"
                           << recycleBin->unusedTextures.size() << "textures";
 
    qDeleteAll(recycleBin->unusedGlyphNodes);
    recycleBin->unusedGlyphNodes = {};
 
    qDeleteAll(recycleBin->unusedImageNodes);
    recycleBin->unusedImageNodes = {};
 
    qDeleteAll(recycleBin->unusedRectangleNodes);
    recycleBin->unusedRectangleNodes = {};
 
    qDeleteAll(recycleBin->unusedTextures);
    recycleBin->unusedTextures = {};
}
 
QT_END_NAMESPACE