PathMultiline: allow lists/vectors of polygons or point lists/vectors

If a C++ model object can make a vector of vectors of points available
directly, and it is bound to a PathMultiline's paths property to provide
the view layer, it's a waste of time to convert it to a QVariantList of
QVariantLists and back again.  Changing the type of the property to
QVariant instead of QVariantList enables an extensible set of supported
types: all those that make sense.

Fixes: QTBUG-77929
Change-Id: If749c2171173e7b9933fc9ecdf6d2741dc1c7500
Reviewed-by: Paolo Angelelli <paolo.angelelli@qt.io>

3 files changed, 212 insertions, 0 deletions

diff --git a/tests/auto/quick/qquickshape/data/multiline.png b/tests/auto/quick/qquickshape/data/multiline.png
new file mode 100644
index 0000000000..ae25d111df
--- /dev/null
+++ b/tests/auto/quick/qquickshape/data/multiline.png
diff --git a/tests/auto/quick/qquickshape/data/multiline.qml b/tests/auto/quick/qquickshape/data/multiline.qml
new file mode 100644
index 0000000000..ad07506972
--- /dev/null
+++ b/tests/auto/quick/qquickshape/data/multiline.qml
@@ -0,0 +1,52 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+import QtQuick 2.14
+import QtQuick.Shapes 1.14
+
+Shape {
+    width: 200
+    height: 150
+    vendorExtensionsEnabled: false
+    objectName: "shape"
+    id: shape
+    property alias paths: multiline.paths
+    property point vertexBeingChecked;
+
+    function checkVertexAt(i, j) {
+        vertexBeingChecked = multiline.paths[i][j]
+    }
+
+    ShapePath {
+        strokeWidth: 4
+        strokeColor: "green"
+        PathMultiline {
+            id: multiline
+        }
+    }
+}
diff --git a/tests/auto/quick/qquickshape/tst_qquickshape.cpp b/tests/auto/quick/qquickshape/tst_qquickshape.cpp
index 69b65f0ec9..6bd8562823 100644
--- a/tests/auto/quick/qquickshape/tst_qquickshape.cpp
+++ b/tests/auto/quick/qquickshape/tst_qquickshape.cpp
@@ -62,6 +62,8 @@ private slots:
     void renderMultiline();
     void polylineDataTypes_data();
     void polylineDataTypes();
+    void multilineDataTypes_data();
+    void multilineDataTypes();
 
 private:
     QVector<QPolygonF> m_lowPolyLogo;
@@ -475,6 +477,164 @@ void tst_QQuickShape::polylineDataTypes()
     }
 }
 
+void tst_QQuickShape::multilineDataTypes_data()
+{
+    QTest::addColumn<QVariant>("paths");
+
+    QTest::newRow("vector of polygons") << QVariant::fromValue(m_lowPolyLogo);
+    {
+        QVector<QVector<QPointF>> paths;
+        for (const auto &poly : m_lowPolyLogo) {
+            QVector<QPointF> points;
+            points << poly;
+            paths << points;
+        }
+        QTest::newRow("vector of point vectors") << QVariant::fromValue(paths);
+    }
+    {
+        QList<QVector<QPointF>> paths;
+        for (const auto &poly : m_lowPolyLogo) {
+            QVector<QPointF> points;
+            points << poly;
+            paths << points;
+        }
+        QTest::newRow("list of point vectors") << QVariant::fromValue(paths);
+    }
+    {
+        QList<QList<QPointF>> paths;
+        for (const auto &poly : m_lowPolyLogo) {
+            QList<QPointF> points;
+            for (const auto &point : poly)
+                points << point;
+            paths << points;
+        }
+        QTest::newRow("list of point lists") << QVariant::fromValue(paths);
+    }
+    {
+        QVariantList paths;
+        for (const auto &poly : m_lowPolyLogo) {
+            QVector<QPointF> points;
+            points << poly;
+            paths << QVariant::fromValue(points);
+        }
+        QTest::newRow("QVariantList of point vectors") << QVariant::fromValue(paths);
+    }
+    {
+        QVariantList paths;
+        for (const auto &poly : m_lowPolyLogo) {
+            QList<QPointF> points;
+            for (const auto &point : poly)
+                points << point;
+            paths << QVariant::fromValue(points);
+        }
+        QTest::newRow("QVariantList of point lists") << QVariant::fromValue(paths);
+    }
+    {
+        QVariantList paths;
+        for (const auto &poly : m_lowPolyLogo) {
+            QVariantList points;
+            for (const auto &point : poly)
+                points << point;
+            paths << QVariant::fromValue(points);
+        }
+        QTest::newRow("QVariantList of QVariantLists") << QVariant::fromValue(paths);
+    }
+    /* These could be supported if QVariant knew how to convert lists and vectors of QPolygon to QPolygonF.
+       But they are omitted for now because we don't want to have special cases for them
+       in QQuickPathMultiline::setPaths().  Floating point is preferred for geometry in Qt Quick.
+    {
+        QList<QPolygon> paths;
+        for (const auto &poly : m_lowPolyLogo)
+            paths << poly.toPolygon();
+        QTest::newRow("list of QPolygon (integer points)") << QVariant::fromValue(paths);
+    }
+    {
+        QVector<QPolygon> paths;
+        for (const auto &poly : m_lowPolyLogo)
+            paths << poly.toPolygon();
+        QTest::newRow("vector of QPolygon (integer points)") << QVariant::fromValue(paths);
+    }
+    */
+    {
+        QList<QList<QPoint>> paths;
+        for (const auto &poly : m_lowPolyLogo) {
+            QList<QPoint> points;
+            for (const auto &point : poly)
+                points << point.toPoint();
+            paths << points;
+        }
+        QTest::newRow("list of integer point lists") << QVariant::fromValue(paths);
+    }
+    {
+        QVector<QList<QPoint>> paths;
+        for (const auto &poly : m_lowPolyLogo) {
+            QList<QPoint> points;
+            for (const auto &point : poly)
+                points << point.toPoint();
+            paths << points;
+        }
+        QTest::newRow("vector of integer point lists") << QVariant::fromValue(paths);
+    }
+    {
+        QList<QVector<QPoint>> paths;
+        for (const auto &poly : m_lowPolyLogo) {
+            QVector<QPoint> points;
+            for (const auto &point : poly)
+                points << point.toPoint();
+            paths << points;
+        }
+        QTest::newRow("list of integer point vectors") << QVariant::fromValue(paths);
+    }
+}
+
+void tst_QQuickShape::multilineDataTypes()
+{
+    QFETCH(QVariant, paths);
+
+    QScopedPointer<QQuickView> window(createView());
+    window->setSource(testFileUrl("multiline.qml"));
+    QQuickShape *shape = qobject_cast<QQuickShape *>(window->rootObject());
+    QVERIFY(shape);
+    shape->setProperty("paths", paths);
+    window->show();
+    QVERIFY(QTest::qWaitForWindowExposed(window.data()));
+
+    if ((QGuiApplication::platformName() == QLatin1String("offscreen"))
+        || (QGuiApplication::platformName() == QLatin1String("minimal")))
+        QEXPECT_FAIL("", "Failure due to grabWindow not functional on offscreen/minimimal platforms", Abort);
+
+    QImage img = window->grabWindow();
+    QVERIFY(!img.isNull());
+
+    QImage refImg(testFileUrl("multiline.png").toLocalFile());
+    QVERIFY(!refImg.isNull());
+
+    QString errorMessage;
+    const QImage actualImg = img.convertToFormat(refImg.format());
+    const bool res = QQuickVisualTestUtil::compareImages(actualImg, refImg, &errorMessage);
+    if (!res) { // For visual inspection purposes.
+        QTest::qWait(5000);
+        const QString &tempLocation = QStandardPaths::writableLocation(QStandardPaths::TempLocation);
+        actualImg.save(tempLocation + QLatin1String("/multiline.png"));
+    }
+    QVERIFY2(res, qPrintable(errorMessage));
+
+    QVector<QVector<QPointF>> pointVectors;
+    for (auto v : m_lowPolyLogo)
+        pointVectors << v;
+    QCOMPARE(shape->property("paths").value<QVector<QVector<QPointF>>>(), pointVectors);
+    // Verify that QML sees it as an array of arrays of points
+    int i = 0;
+    for (auto pv : m_lowPolyLogo) {
+        int j = 0;
+        for (QPointF p : pv) {
+            QMetaObject::invokeMethod(shape, "checkVertexAt", Q_ARG(QVariant, QVariant::fromValue<int>(i)), Q_ARG(QVariant, QVariant::fromValue<int>(j++)));
+            QCOMPARE(shape->property("vertexBeingChecked").toPointF(), p);
+        }
+        ++i;
+    }
+}
+
 QTEST_MAIN(tst_QQuickShape)
 
 #include "tst_qquickshape.moc"