QQuickTableView: be more precise about when to load and unload a column

The current implementation would unload a column/row if the right edge
was greater than the right edge of the viewport. At the same time, it
would load a column if the left edge was less than the right edge
of the viewport. But we did nothing if the edge was exactly at the
edge of the viewport. This patch will fix that, so that an edge is
seen as either inside or ouside (and never on the edge).

By handle this (corner) case, it will be easier to test the layout
from the auto test, since a column will either be seen as inside or
outside the viewport (and not exactly an the edge in addition).

Change-Id: I95fccaa4a1bb583036027d2fc8c6eb4895eeefc8
Reviewed-by: Mitch Curtis <mitch.curtis@qt.io>

1 files changed, 35 insertions, 46 deletions

diff --git a/tests/auto/quick/qquicktableview/tst_qquicktableview.cpp b/tests/auto/quick/qquicktableview/tst_qquicktableview.cpp
index c91085b0ff..69bed8be43 100644
--- a/tests/auto/quick/qquicktableview/tst_qquicktableview.cpp
+++ b/tests/auto/quick/qquicktableview/tst_qquicktableview.cpp
@@ -1119,6 +1119,8 @@ void tst_QQuickTableView::checkRowColumnCount()
     LOAD_TABLEVIEW("countingtableview.qml");
 
     const char *maxDelegateCountProp = "maxDelegateCount";
+    const qreal delegateWidth = 100;
+    const qreal delegateHeight = 50;
     auto model = TestModelAsVariant(100, 100);
 
     tableView->setModel(model);
@@ -1132,50 +1134,43 @@ void tst_QQuickTableView::checkRowColumnCount()
     // This test will keep track of the maximum number of delegate items TableView
     // had to show at any point while flicking (in countingtableview.qml). Because
     // of the geometries chosen for TableView and the delegate, only complete columns
-    // will be shown at start-up. But as we flick around, we expect the count to
-    // increase with one extra column. This is because TableView sometimes end up
-    // showing half a column on the left side, and half a column on the right side.
+    // will be shown at start-up.
     const QRect loadedTable = tableViewPrivate->loadedTable;
     QVERIFY(loadedTable.height() > loadedTable.width());
     QCOMPARE(tableViewPrivate->loadedTableOuterRect.width(), tableView->width());
     QCOMPARE(tableViewPrivate->loadedTableOuterRect.height(), tableView->height());
-    const int expectedMaxCountAfterFlick = qmlCountAfterInit + loadedTable.height();
+
+    // Flick half an item to the left+up, to force one extra column and row to load before we
+    // start. By doing so, we end up showing the maximum number of rows and columns that will
+    // ever be shown in the view. This will make things less complicated below, when checking
+    // how many items that end up visible while flicking.
+    tableView->setContentX(delegateWidth / 2);
+    tableView->setContentY(delegateHeight / 2);
+    const int qmlCountAfterFirstFlick = view->rootObject()->property(maxDelegateCountProp).toInt();
 
     // Flick a long distance right
     tableView->setContentX(tableView->width() * 2);
-    tableView->polish();
 
-    WAIT_UNTIL_POLISHED;
-
-    const int qmlCountAfterRightFlick = view->rootObject()->property(maxDelegateCountProp).toInt();
-    QCOMPARE(qmlCountAfterRightFlick, expectedMaxCountAfterFlick);
+    const int qmlCountAfterLongFlick = view->rootObject()->property(maxDelegateCountProp).toInt();
+    QCOMPARE(qmlCountAfterLongFlick, qmlCountAfterFirstFlick);
 
     // Flick a long distance down
     tableView->setContentX(tableView->height() * 2);
-    tableView->polish();
-
-    WAIT_UNTIL_POLISHED;
 
     const int qmlCountAfterDownFlick = view->rootObject()->property(maxDelegateCountProp).toInt();
-    QCOMPARE(qmlCountAfterDownFlick, expectedMaxCountAfterFlick);
+    QCOMPARE(qmlCountAfterDownFlick, qmlCountAfterFirstFlick);
 
     // Flick a long distance left
     tableView->setContentX(0);
-    tableView->polish();
-
-    WAIT_UNTIL_POLISHED;
 
     const int qmlCountAfterLeftFlick = view->rootObject()->property(maxDelegateCountProp).toInt();
-    QCOMPARE(qmlCountAfterLeftFlick, expectedMaxCountAfterFlick);
+    QCOMPARE(qmlCountAfterLeftFlick, qmlCountAfterFirstFlick);
 
     // Flick a long distance up
     tableView->setContentY(0);
-    tableView->polish();
-
-    WAIT_UNTIL_POLISHED;
 
     const int qmlCountAfterUpFlick = view->rootObject()->property(maxDelegateCountProp).toInt();
-    QCOMPARE(qmlCountAfterUpFlick, expectedMaxCountAfterFlick);
+    QCOMPARE(qmlCountAfterUpFlick, qmlCountAfterFirstFlick);
 }
 
 void tst_QQuickTableView::modelSignals()
@@ -1315,6 +1310,8 @@ void tst_QQuickTableView::checkIfDelegatesAreReused()
     tableView->setModel(model);
     tableView->setReuseItems(reuseItems);
 
+    WAIT_UNTIL_POLISHED;
+
     // Flick half an item to the left, to force one extra column to load before we start.
     // This will make things less complicated below, when checking how many times the items
     // have been reused (all items will then report the same number).
@@ -1365,7 +1362,6 @@ void tst_QQuickTableView::checkIfDelegatesAreReusedAsymmetricTableSize()
     // row at the end of the test.
     LOAD_TABLEVIEW("countingtableview.qml");
 
-    const int pageFlickCount = 3;
     const int columnCount = 20;
     const int rowCount = 2;
     const qreal delegateWidth = tableView->width() / columnCount;
@@ -1393,10 +1389,13 @@ void tst_QQuickTableView::checkIfDelegatesAreReusedAsymmetricTableSize()
     // times the items have been reused (all items will then report the same number).
     tableView->setContentX(delegateWidth * 0.5);
     tableView->setContentY(delegateHeight * 0.5);
-    tableView->polish();
 
-    WAIT_UNTIL_POLISHED;
+    // Since we have flicked half a delegate to the left, the number of visible
+    // columns is now one more than the column count were when we started the test.
+    const int visibleColumnCount = tableViewPrivate->loadedTable.width();
+    QCOMPARE(visibleColumnCount, columnCount + 1);
 
+    // We expect no items to have been pooled so far
     pooledCount = initialTopLeftItem->property("pooledCount").toInt();
     reusedCount = initialTopLeftItem->property("reusedCount").toInt();
     QCOMPARE(pooledCount, 0);
@@ -1406,42 +1405,32 @@ void tst_QQuickTableView::checkIfDelegatesAreReusedAsymmetricTableSize()
     // Flick one row out of view. This will move one whole row of items into the
     // pool without reusing them, since no new row is exposed at the bottom.
     tableView->setContentY(delegateHeight + 1);
-    tableView->polish();
-
-    WAIT_UNTIL_POLISHED;
-
     pooledCount = initialTopLeftItem->property("pooledCount").toInt();
     reusedCount = initialTopLeftItem->property("reusedCount").toInt();
     QCOMPARE(pooledCount, 1);
     QCOMPARE(reusedCount, 0);
-    QCOMPARE(tableViewPrivate->tableModel->poolSize(), columnCount + 1);
+    QCOMPARE(tableViewPrivate->tableModel->poolSize(), visibleColumnCount);
 
-    const int visibleColumnCount = tableViewPrivate->loadedTable.width();
     const int delegateCountAfterInit = view->rootObject()->property(kDelegatesCreatedCountProp).toInt();
 
     // Start flicking in a lot of columns, and check that the created count stays the same
-    for (int column = 1; column <= (visibleColumnCount * pageFlickCount); ++column) {
-        tableView->setContentX((delegateWidth * column) + 1);
-        tableView->polish();
-
-        WAIT_UNTIL_POLISHED;
-
+    for (int column = 1; column <= 10; ++column) {
+        tableView->setContentX((delegateWidth * column) + 10);
         const int delegatesCreatedCount = view->rootObject()->property(kDelegatesCreatedCountProp).toInt();
+        // Since we reuse items while flicking, the created count should stay the same
         QCOMPARE(delegatesCreatedCount, delegateCountAfterInit);
+        // Since we flick out just as many columns as we flick in, the pool size should stay the same
+        QCOMPARE(tableViewPrivate->tableModel->poolSize(), visibleColumnCount);
     }
 
-    // Finally, flick one row back into view. The pool should still contain
-    // enough items so that we don't have to create any new ones.
-    tableView->setContentY(delegateHeight * 2);
-    tableView->polish();
-
-    WAIT_UNTIL_POLISHED;
-
+    // Finally, flick one row back into view (but without flicking so far that we push the third
+    // row out and into the pool). The pool should still contain the exact amount of items that
+    // we had after we flicked the first row out. And this should be exactly the amount of items
+    // needed to load the row back again. And this also means that the pool count should then return
+    // back to 0.
+    tableView->setContentY(delegateHeight - 1);
     const int delegatesCreatedCount = view->rootObject()->property(kDelegatesCreatedCountProp).toInt();
     QCOMPARE(delegatesCreatedCount, delegateCountAfterInit);
-
-    // After we flicked in a new row, we now expect all items
-    // to be visible in the view, effectively making the pool empty.
     QCOMPARE(tableViewPrivate->tableModel->poolSize(), 0);
 }