QTextLayout: Support inline objects for standalone layouts

Add support for ObjectReplacementCharacter as an inline object in
standalone QTextLayout (without QTextDocument). When a QTextImageFormat
is applied to an ObjectReplacementCharacter position via setFormats(),
QTextEngine now recognizes it as an inline object and sizes it
according to the format's width and height.

In itemize(), ObjectReplacementCharacter is flagged as
QScriptAnalysis::Object when a matching QTextImageFormat is found in
specialData->formats. In shape(), the object dimensions are read from
the image format and baseline metrics are computed to match what
QQuickText expects.

In layout_helper(), the ascent/descent update is now also applied for
Object items in standalone layouts (no QTextDocument), since there is
no special vertical alignment or floating to handle without a document.

This enables QQuickText (StyledText) to use ObjectReplacementCharacter
instead of Nbsp padding for inline images, giving the text layout
engine accurate knowledge of image dimensions. This is a prerequisite
for correct eliding, wrapping, and positioning of inline images.

Task-number: QTBUG-112717
Task-number: QTBUG-97536
Task-number: QTBUG-57191
Task-number: QTBUG-36163
Task-number: QTBUG-39107
Task-number: QTBUG-43820
Task-number: QTBUG-113829
Task-number: QTBUG-133284
Change-Id: I49c3a81e4b6c35b4195af87dbcedeaaf1ff5e663
Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@qt.io>

Author: VladimirBelyavsky

src/gui/text/qtextengine.cpp

@@ -1879,6 +1879,40 @@ void QTextEngine::shape(int item) const
             docLayout()->resizeInlineObject(QTextInlineObject(item, const_cast<QTextEngine *>(this)),
                                             li.position + block.position(),
                                             format(&li));
+        } else {
+            // Standalone QTextLayout (no QTextDocument): read the
+            // object size from a QTextImageFormat set via setFormats().
+            QTextCharFormat fmt = format(&li);
+            if (fmt.isImageFormat()) {
+                QTextImageFormat imgFmt = fmt.toImageFormat();
+                const qreal w = imgFmt.width();
+                const qreal h = imgFmt.height();
+                if (w > 0 && h > 0) {
+                    QTextInlineObject obj(item, const_cast<QTextEngine *>(this));
+                    obj.setWidth(w);
+                    // Mirror QTextDocumentLayout::resizeInlineObject()
+                    // vertical alignment logic.
+                    const QFontMetricsF fm(fnt);
+                    switch (fmt.verticalAlignment()) {
+                    case QTextCharFormat::AlignMiddle: {
+                        const qreal halfX = fm.xHeight() / 2.0;
+                        obj.setAscent((h + halfX) / 2.0);
+                        obj.setDescent((h - halfX) / 2.0);
+                        break;
+                    }
+                    case QTextCharFormat::AlignBaseline: {
+                        const qreal descent = fm.descent();
+                        obj.setDescent(descent);
+                        obj.setAscent(h - descent);
+                        break;
+                    }
+                    default:
+                        obj.setDescent(0);
+                        obj.setAscent(h);
+                        break;
+                    }
+                }
+            }
         }
         // fix log clusters to point to the previous glyph, as the object doesn't have a glyph of it's own.
         // This is required so that all entries in the array get initialized and are ordered correctly.
@@ -2100,6 +2134,18 @@ void QTextEngine::itemize() const
                         && QAbstractTextDocumentLayoutPrivate::get(doc_p->layout()) != nullptr
                         && QAbstractTextDocumentLayoutPrivate::get(doc_p->layout())->hasHandlers()) {
                     analysis->flags = QScriptAnalysis::Object;
+                } else if (specialData) {
+                    // Standalone QTextLayout: check if a QTextImageFormat
+                    // was set for this position via setFormats().
+                    const int pos = uc - string;
+                    analysis->flags = QScriptAnalysis::None;
+                    for (const auto &range : std::as_const(specialData->formats)) {
+                        if (range.start <= pos && pos < range.start + range.length
+                            && range.format.isImageFormat()) {
+                            analysis->flags = QScriptAnalysis::Object;
+                            break;
+                        }
+                    }
                 } else {
                     analysis->flags = QScriptAnalysis::None;
                 }

src/gui/text/qtextlayout.cpp

@@ -1906,8 +1906,12 @@ void QTextLine::layout_helper(int maxGlyphs)
         lbh.tmpData.leading = qMax(lbh.tmpData.leading + lbh.tmpData.ascent,
                                    current.leading + current.ascent) - qMax(lbh.tmpData.ascent,
                                                                             current.ascent);
-        if (current.analysis.flags != QScriptAnalysis::Object) {
-            // objects need some special treatment as they can special alignment or be floating
+        if (current.analysis.flags != QScriptAnalysis::Object
+            || QTextDocumentPrivate::get(eng->block) == nullptr) {
+            // Objects with a QTextDocument may need special vertical alignment
+            // or floating treatment handled later, so skip the ascent/descent
+            // update for them here.  Standalone objects (no document) are
+            // always included because no such post-processing exists.
             lbh.tmpData.ascent = qMax(lbh.tmpData.ascent, current.ascent);
             lbh.tmpData.descent = qMax(lbh.tmpData.descent, current.descent);
         }

tests/auto/gui/text/qtextlayout/tst_qtextlayout.cpp

@@ -129,6 +129,14 @@ private slots:
     void embeddedImageLineHeight();
     void unmatchedShapedSubstring();
     void maximumLayoutWidthInWrappedLayout();
+    void standaloneInlineObject_lineHeight();
+    void standaloneInlineObject_verticalAlignment();
+#ifdef QT_BUILD_INTERNAL
+    void standaloneInlineObject_cursorToX_data();
+    void standaloneInlineObject_cursorToX();
+    void standaloneInlineObject_wrapping();
+    void standaloneInlineObject_eliding();
+#endif
 
 private:
     QFont testFont;
@@ -2873,5 +2881,228 @@ void tst_QTextLayout::maximumLayoutWidthInWrappedLayout()
     QCOMPARE(reference.maximumWidth(), breakByWidth.maximumWidth());
 }
 
+// Helper: build a standalone QTextLayout with ObjectReplacementCharacter
+// at each position listed in |objectPositions|, sized via QTextImageFormat.
+
+static constexpr qreal TEST_OBJECT_WIDTH = 32;
+
+static void setupStandaloneLayoutWithObjects(QTextLayout &layout, const QString &text,
+                                             const QFont &font, const QList<int> &objectPositions,
+                                             qreal objWidth, qreal objHeight)
+{
+    layout.setText(text);
+    layout.setFont(font);
+
+    QList<QTextLayout::FormatRange> formats;
+    for (int pos : objectPositions) {
+        Q_ASSERT(text.at(pos) == QChar::ObjectReplacementCharacter);
+        QTextLayout::FormatRange range;
+        QTextImageFormat imgFmt;
+        imgFmt.setWidth(objWidth);
+        imgFmt.setHeight(objHeight);
+        range.format = imgFmt;
+        range.start = pos;
+        range.length = 1;
+        formats.append(range);
+    }
+    layout.setFormats(formats);
+}
+
+void tst_QTextLayout::standaloneInlineObject_lineHeight()
+{
+    // Not data-driven because expected values depend on testFont metrics
+    // which are only available after initTestCase() loads the test font.
+    const QChar orc = QChar::ObjectReplacementCharacter;
+    QString text = QStringLiteral("X") + orc + QStringLiteral("Y");
+
+    // Reference: plain text line metrics (no inline object).
+    QTextLayout refLayout(QStringLiteral("XY"), testFont);
+    refLayout.beginLayout();
+    QTextLine refLine = refLayout.createLine();
+    refLine.setLineWidth(1000);
+    refLayout.endLayout();
+
+    const qreal fontHeight = refLine.height();
+    const qreal fontDescent = refLine.descent();
+
+    auto testCase = [&](qreal objHeight, qreal expectedHeight) {
+        QTextLayout layout;
+        setupStandaloneLayoutWithObjects(layout, text, testFont, { 1 }, 20, objHeight);
+        layout.beginLayout();
+        QTextLine line = layout.createLine();
+        line.setLineWidth(1000);
+        layout.endLayout();
+
+        QCOMPARE(line.height(), expectedHeight);
+        QCOMPARE(line.descent(), fontDescent);
+    };
+
+    // Large object (taller than font) — line height equals object height.
+    testCase(80, 80);
+    // Font-sized object — line height equals font height.
+    testCase(TESTFONT_SIZE, fontHeight);
+    // Small object (shorter than font) — line height equals font height.
+    testCase(TESTFONT_SIZE / 4, fontHeight);
+}
+
+void tst_QTextLayout::standaloneInlineObject_verticalAlignment()
+{
+    // Verify that the three vertical alignment modes from
+    // QTextDocumentLayout::resizeInlineObject() are supported.
+    const QChar orc = QChar::ObjectReplacementCharacter;
+    const qreal objHeight = 80;
+    const qreal objWidth = 20;
+    QString text = QStringLiteral("X") + orc + QStringLiteral("Y");
+
+    auto layoutWithAlignment = [&](QTextCharFormat::VerticalAlignment align) {
+        QTextLayout layout;
+        layout.setText(text);
+        layout.setFont(testFont);
+
+        QTextLayout::FormatRange range;
+        QTextImageFormat imgFmt;
+        imgFmt.setWidth(objWidth);
+        imgFmt.setHeight(objHeight);
+        imgFmt.setVerticalAlignment(align);
+        range.format = imgFmt;
+        range.start = 1;
+        range.length = 1;
+        layout.setFormats({ range });
+
+        layout.beginLayout();
+        QTextLine line = layout.createLine();
+        line.setLineWidth(1000);
+        layout.endLayout();
+        return std::make_pair(line.ascent(), line.descent());
+    };
+
+    // Default: descent=0, ascent=h → baseline at bottom of image.
+    {
+        auto [ascent, descent] = layoutWithAlignment(QTextCharFormat::AlignNormal);
+        QCOMPARE(ascent, objHeight);
+        QCOMPARE(descent, qreal(0));
+    }
+
+    // AlignBaseline: descent=fm.descent(), ascent=h-descent.
+    {
+        const QFontMetricsF fm(testFont);
+        auto [ascent, descent] = layoutWithAlignment(QTextCharFormat::AlignBaseline);
+        QCOMPARE(descent, fm.descent());
+        QCOMPARE(ascent, objHeight - fm.descent());
+    }
+
+    // AlignMiddle: centered on x-height/2.
+    {
+        const QFontMetricsF fm(testFont);
+        const qreal halfX = fm.xHeight() / 2.0;
+        auto [ascent, descent] = layoutWithAlignment(QTextCharFormat::AlignMiddle);
+        QCOMPARE(ascent, (objHeight + halfX) / 2.0);
+        QCOMPARE(descent, (objHeight - halfX) / 2.0);
+    }
+}
+
+#ifdef QT_BUILD_INTERNAL
+void tst_QTextLayout::standaloneInlineObject_cursorToX_data()
+{
+    QTest::addColumn<QString>("text");
+    QTest::addColumn<QList<int>>("objectPositions");
+    QTest::addColumn<int>("cursorPos");
+    QTest::addColumn<qreal>("expectedX");
+
+    const QChar orc = QChar::ObjectReplacementCharacter;
+
+    // Single object: "A<ORC>B"
+    const QString single = QStringLiteral("A") + orc + QStringLiteral("B");
+    QTest::newRow("single: before text") << single << QList<int>{1} << 0 << qreal(0);
+    QTest::newRow("single: before object") << single << QList<int>{1} << 1 << qreal(TESTFONT_SIZE);
+    QTest::newRow("single: after object") << single << QList<int>{1} << 2 << qreal(TESTFONT_SIZE + TEST_OBJECT_WIDTH);
+
+    // Multiple adjacent objects: "A<ORC><ORC>B"
+    const QString multi = QStringLiteral("A") + orc + orc + QStringLiteral("B");
+    QTest::newRow("multi: before first object") << multi << QList<int>{1, 2} << 1 << qreal(TESTFONT_SIZE);
+    QTest::newRow("multi: between objects") << multi << QList<int>{1, 2} << 2 << qreal(TESTFONT_SIZE + TEST_OBJECT_WIDTH);
+    QTest::newRow("multi: after second object") << multi << QList<int>{1, 2} << 3 << qreal(TESTFONT_SIZE + TEST_OBJECT_WIDTH * 2);
+
+    // Object at start: "<ORC>B"
+    const QString atStart = QString(orc) + QStringLiteral("B");
+    QTest::newRow("start: before object") << atStart << QList<int>{0} << 0 << qreal(0);
+    QTest::newRow("start: after object") << atStart << QList<int>{0} << 1 << qreal(TEST_OBJECT_WIDTH);
+
+    // Object at end: "A<ORC>"
+    const QString atEnd = QStringLiteral("A") + orc;
+    QTest::newRow("end: before object") << atEnd << QList<int>{1} << 1 << qreal(TESTFONT_SIZE);
+    QTest::newRow("end: after object") << atEnd << QList<int>{1} << 2 << qreal(TESTFONT_SIZE + TEST_OBJECT_WIDTH);
+}
+
+void tst_QTextLayout::standaloneInlineObject_cursorToX()
+{
+    QFETCH(QString, text);
+    QFETCH(QList<int>, objectPositions);
+    QFETCH(int, cursorPos);
+    QFETCH(qreal, expectedX);
+
+    QTextLayout layout;
+    setupStandaloneLayoutWithObjects(layout, text, testFont, objectPositions,
+                                     TEST_OBJECT_WIDTH, TEST_OBJECT_WIDTH);
+    layout.beginLayout();
+    QTextLine line = layout.createLine();
+    line.setLineWidth(1000);
+    layout.endLayout();
+
+    QCOMPARE(line.cursorToX(cursorPos), expectedX);
+}
+
+void tst_QTextLayout::standaloneInlineObject_wrapping()
+{
+    // "<ORC>A" — object is 3*TESTFONT_SIZE wide, line width fits the object
+    // but not object + 'A', so 'A' must wrap to the second line.
+    const QChar orc = QChar::ObjectReplacementCharacter;
+    const qreal objWidth = 3 * TESTFONT_SIZE;
+    QString text = QString(orc) + QStringLiteral("A");
+
+    QTextLayout layout;
+    setupStandaloneLayoutWithObjects(layout, text, testFont, { 0 }, objWidth, 10);
+
+    QTextOption opt;
+    opt.setWrapMode(QTextOption::WrapAnywhere);
+    layout.setTextOption(opt);
+
+    layout.beginLayout();
+    QTextLine line1 = layout.createLine();
+    line1.setLineWidth(3.5 * TESTFONT_SIZE);
+    QTextLine line2 = layout.createLine();
+    if (line2.isValid())
+        line2.setLineWidth(3.5 * TESTFONT_SIZE);
+    layout.endLayout();
+
+    QVERIFY(line2.isValid());
+    QCOMPARE(line1.textLength(), 1);
+}
+
+void tst_QTextLayout::standaloneInlineObject_eliding()
+{
+    // "A<ORC>B" — total width exceeds availableWidth, so eliding must truncate.
+    const QChar orc = QChar::ObjectReplacementCharacter;
+    QString text = QStringLiteral("A") + orc + QStringLiteral("B");
+
+    QTextLayout layout;
+    setupStandaloneLayoutWithObjects(layout, text, testFont, { 1 }, TEST_OBJECT_WIDTH, 16);
+
+    const qreal availableWidth = TESTFONT_SIZE + TEST_OBJECT_WIDTH;
+
+    layout.beginLayout();
+    QTextLine line = layout.createLine();
+    line.setLineWidth(availableWidth);
+    layout.endLayout();
+
+    QString elided = layout.engine()->elidedText(Qt::ElideRight, QFixed::fromReal(availableWidth),
+                                                 0, 0, text.size());
+
+    QVERIFY(!elided.isEmpty());
+    QVERIFY(elided.size() < text.size());
+    QVERIFY(elided.contains(QChar(0x2026)) || elided.contains(QLatin1String("...")));
+}
+#endif
+
 QTEST_MAIN(tst_QTextLayout)
 #include "tst_qtextlayout.moc"