Merge lp:~fboucault/unity-2d/renderer_grid_limit_count into lp:unity-2d/3.0

[Florian Boucault]

[dash] RendererGrid: actually filter out the items that are not displayed because of group folding.

[Gerry Boland (gerboland)]

No problems as far as I can see. Accept

review: Approve

Unmerged revisions

=== modified file 'libunity-2d-private/Unity2d/qsortfilterproxymodelqml.cpp'
--- libunity-2d-private/Unity2d/qsortfilterproxymodelqml.cpp	2011-07-15 10:57:31 +0000
+++ libunity-2d-private/Unity2d/qsortfilterproxymodelqml.cpp	2011-07-27 12:25:44 +0000
@@ -18,8 +18,11 @@
 #include <debug_p.h>
 
 QSortFilterProxyModelQML::QSortFilterProxyModelQML(QObject *parent) :
-    QSortFilterProxyModel(parent)
+    QSortFilterProxyModel(parent), m_limit(-1)
 {
+    connect(this, SIGNAL(modelReset()), SIGNAL(countChanged()));
+    connect(this, SIGNAL(rowsInserted(QModelIndex,int,int)), SIGNAL(countChanged()));
+    connect(this, SIGNAL(rowsRemoved(QModelIndex,int,int)), SIGNAL(countChanged()));
 }
 
 void QSortFilterProxyModelQML::setRoleNames(const QHash<int,QByteArray> &roleNames)
@@ -64,6 +67,12 @@
     setRoleNames(itemModel->roleNames());
 
     setSourceModel(itemModel);
+
+    connect(itemModel, SIGNAL(modelReset()), SIGNAL(totalCountChanged()));
+    connect(itemModel, SIGNAL(rowsInserted(QModelIndex,int,int)), SIGNAL(totalCountChanged()));
+    connect(itemModel, SIGNAL(rowsRemoved(QModelIndex,int,int)), SIGNAL(totalCountChanged()));
+    Q_EMIT totalCountChanged();
+    Q_EMIT countChanged();
 }
 
 QVariantMap
@@ -85,7 +94,97 @@
 }
 
 int
+QSortFilterProxyModelQML::totalCount() const
+{
+    if (sourceModel() != NULL) {
+        return sourceModel()->rowCount();
+    } else {
+        return 0;
+    }
+}
+
+int
 QSortFilterProxyModelQML::count()
 {
     return rowCount();
 }
+
+int
+QSortFilterProxyModelQML::rowCount(const QModelIndex &parent) const
+{
+    int count = QSortFilterProxyModel::rowCount(parent);
+    if (m_limit >= 0) {
+        return qMin(count, m_limit);
+    } else {
+        return count;
+    }
+}
+
+int
+QSortFilterProxyModelQML::limit() const
+{
+    return m_limit;
+}
+
+void
+QSortFilterProxyModelQML::setLimit(int limit)
+{
+    if (limit != m_limit) {
+        int count = QSortFilterProxyModel::rowCount();
+        int start;
+        int end;
+        bool inserted = false;
+        bool removed = false;
+
+        if (m_limit == -1) {
+            if (limit < count) {
+                start = qMin(count, limit);
+                end = count-1;
+                removed = true;
+            }
+        } else if (limit == -1) {
+            if (m_limit < count) {
+                start = qMin(count, m_limit);
+                end = count-1;
+                inserted = true;
+            }
+        } else if (m_limit >= count && limit >= count) {
+            // Nothing
+        } else if (m_limit >= count && limit < count) {
+            start = qMin(count, limit);
+            end = count-1;
+            removed = true;
+        } else if (m_limit < count && limit >= count) {
+            start = qMin(count, m_limit);
+            end = count-1;
+            inserted = true;
+        } else if (m_limit < count && limit < count) {
+            if (m_limit < limit) {
+                start = qMin(count, m_limit);
+                end = qMin(count, limit)-1;
+                inserted = true;
+            } else {
+                start = qMin(count, limit);
+                end = qMin(count, m_limit)-1;
+                removed = true;
+            }
+        }
+
+        if (inserted) {
+            beginInsertRows(QModelIndex(), start, end);
+        }
+        if (removed) {
+            beginRemoveRows(QModelIndex(), start, end);
+        }
+        m_limit = limit;
+
+        if (inserted) {
+            endInsertRows();
+        }
+        if (removed) {
+            endRemoveRows();
+        }
+
+        Q_EMIT limitChanged();
+    }
+}

=== modified file 'libunity-2d-private/Unity2d/qsortfilterproxymodelqml.h'
--- libunity-2d-private/Unity2d/qsortfilterproxymodelqml.h	2011-07-15 10:35:21 +0000
+++ libunity-2d-private/Unity2d/qsortfilterproxymodelqml.h	2011-07-27 12:25:44 +0000
@@ -24,23 +24,36 @@
     Q_OBJECT
 
     Q_PROPERTY(QObject* model READ sourceModelQObject WRITE setSourceModelQObject)
+    Q_PROPERTY(int limit READ limit WRITE setLimit NOTIFY limitChanged)
+    Q_PROPERTY(int totalCount READ totalCount NOTIFY totalCountChanged)
+    Q_PROPERTY(int count READ count NOTIFY countChanged)
 
 public:
     explicit QSortFilterProxyModelQML(QObject *parent = 0);
 
     Q_INVOKABLE QVariantMap get(int row);
     Q_INVOKABLE int count();
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
 
     /* getters */
     QObject* sourceModelQObject() const;
+    int limit() const;
+    int totalCount() const;
 
     /* setters */
     void setSourceModelQObject(QObject *model);
+    void setLimit(int limit);
 
     Q_SLOT void setRoleNames(const QHash<int,QByteArray> &roleNames);
 
 Q_SIGNALS:
+    void limitChanged();
+    void totalCountChanged();
+    void countChanged();
     void roleNamesChanged(const QHash<int,QByteArray> &);
+
+private:
+    int m_limit;
 };
 
 #endif // QSORTFILTERPROXYMODELQML_H

=== modified file 'libunity-2d-private/tests/CMakeLists.txt'
--- libunity-2d-private/tests/CMakeLists.txt	2011-07-12 10:30:50 +0000
+++ libunity-2d-private/tests/CMakeLists.txt	2011-07-27 12:25:44 +0000
@@ -40,6 +40,7 @@
     unity2dtrtest
     launchermenutest
     listaggregatormodeltest
+    qsortfilterproxymodeltest
     )
 
 add_custom_target(unity2dtr_po COMMAND

=== added file 'libunity-2d-private/tests/qsortfilterproxymodeltest.cpp'
--- libunity-2d-private/tests/qsortfilterproxymodeltest.cpp	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/tests/qsortfilterproxymodeltest.cpp	2011-07-27 12:25:44 +0000
@@ -0,0 +1,380 @@
+/*
+ * Copyright (C) 2011 Canonical, Ltd.
+ *
+ * Authors:
+ *  Florian Boucault <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// local
+#include "qsortfilterproxymodelqml.h"
+
+// Qt
+#include <QTest>
+#include <QSignalSpy>
+#include <QModelIndex>
+#include <QAbstractListModel>
+#include <QDebug>
+
+
+class MockListModel : public QAbstractListModel
+{
+    Q_OBJECT
+
+public:
+    MockListModel(QObject* parent = 0)
+        : QAbstractListModel(parent)
+    {
+    }
+
+    int rowCount(const QModelIndex& parent = QModelIndex()) const
+    {
+        return m_list.size();
+    }
+
+    QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const
+    {
+        Q_UNUSED(role)
+
+        if (!index.isValid() || index.row() < 0 || index.row() >= m_list.size()) {
+           return QVariant();
+        }
+        return QVariant(m_list[index.row()]);
+    }
+
+    void setRoleNames(const QHash<int,QByteArray> &roleNames) {
+        QAbstractListModel::setRoleNames(roleNames);
+    }
+
+    bool insertRows(int row, int count, const QModelIndex &parent=QModelIndex()) {
+        beginInsertRows(parent, row, row+count-1);
+        for (int i=0; i<count; i++) {
+            m_list.insert(i+row, "test"+i);
+        }
+        endInsertRows();
+        return true;
+    }
+
+    bool removeRows(int row, int count, const QModelIndex &parent=QModelIndex()) {
+        beginRemoveRows(parent, row, row+count-1);
+        for (int i=0; i<count; i++) {
+            m_list.removeAt(row);
+        }
+        endInsertRows();
+        return true;
+    }
+
+private:
+    QStringList m_list;
+};
+
+class QSortFilterProxyModelTest : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+
+    void initTestCase() {
+        qRegisterMetaType<QModelIndex>("QModelIndex");
+    }
+
+    void testRoleNamesSetAfter()
+    {
+        QSortFilterProxyModelQML proxy;
+        MockListModel model;
+        QHash<int, QByteArray> roles;
+
+        proxy.setSourceModelQObject(&model);
+
+        roles.clear();
+        roles[0] = "role0";
+        roles[1] = "role1";
+        model.setRoleNames(roles);
+        QCOMPARE(model.roleNames(), proxy.roleNames());
+    }
+
+    void testRoleNamesSetBefore()
+    {
+        QSortFilterProxyModelQML proxy;
+        MockListModel model;
+        QHash<int, QByteArray> roles;
+
+        roles.clear();
+        roles[0] = "role0";
+        roles[1] = "role1";
+        model.setRoleNames(roles);
+
+        proxy.setSourceModelQObject(&model);
+        QCOMPARE(model.roleNames(), proxy.roleNames());
+    }
+
+    void testCountSetAfter()
+    {
+        QSortFilterProxyModelQML proxy;
+        MockListModel model;
+        model.insertRows(0, 5);
+
+        QSignalSpy spyOnCountChanged(&proxy, SIGNAL(countChanged()));
+
+        proxy.setSourceModelQObject(&model);
+        QCOMPARE(proxy.count(), 5);
+        QVERIFY(spyOnCountChanged.count() >= 1);
+    }
+
+    void testCountInsert()
+    {
+        QSortFilterProxyModelQML proxy;
+        MockListModel model;
+
+        proxy.setSourceModelQObject(&model);
+
+        QSignalSpy spyOnCountChanged(&proxy, SIGNAL(countChanged()));
+
+        model.insertRows(0, 5);
+        QCOMPARE(proxy.count(), 5);
+        QCOMPARE(spyOnCountChanged.count(), 1);
+    }
+
+    void testCountRemove()
+    {
+        QSortFilterProxyModelQML proxy;
+        MockListModel model;
+        model.insertRows(0, 5);
+
+        proxy.setSourceModelQObject(&model);
+
+        QSignalSpy spyOnCountChanged(&proxy, SIGNAL(countChanged()));
+
+        model.removeRows(0, 3);
+        QCOMPARE(proxy.count(), 2);
+        QCOMPARE(spyOnCountChanged.count(), 1);
+    }
+
+    void testLimitCount()
+    {
+        QSortFilterProxyModelQML proxy;
+        MockListModel model;
+
+        proxy.setSourceModelQObject(&model);
+        proxy.setLimit(3);
+
+        QSignalSpy spyOnCountChanged(&proxy, SIGNAL(countChanged()));
+
+        model.insertRows(0, 5);
+        QCOMPARE(proxy.count(), 3);
+        QCOMPARE(spyOnCountChanged.count(), 1);
+    }
+
+    void testLimitLesserThanCount()
+    {
+        QSortFilterProxyModelQML proxy;
+        MockListModel model;
+        QList<QVariant> arguments;
+        model.insertRows(0, 10);
+
+        proxy.setSourceModelQObject(&model);
+
+        QSignalSpy spyOnRowsRemoved(&proxy, SIGNAL(rowsRemoved(const QModelIndex &, int, int)));
+        QSignalSpy spyOnRowsInserted(&proxy, SIGNAL(rowsInserted(const QModelIndex &, int, int)));
+        QSignalSpy spyOnCountChanged(&proxy, SIGNAL(countChanged()));
+
+        proxy.setLimit(5);
+        QCOMPARE(spyOnRowsRemoved.count(), 1);
+        QCOMPARE(spyOnRowsInserted.count(), 0);
+        QCOMPARE(spyOnCountChanged.count(), 1);
+        arguments = spyOnRowsRemoved.takeFirst();
+        QCOMPARE(arguments.at(1).toInt(), 5);
+        QCOMPARE(arguments.at(2).toInt(), 9);
+        QCOMPARE(proxy.count(), 5);
+        spyOnRowsRemoved.clear();
+        spyOnCountChanged.clear();
+
+        proxy.setLimit(7);
+        QCOMPARE(spyOnRowsInserted.count(), 1);
+        QCOMPARE(spyOnRowsRemoved.count(), 0);
+        QCOMPARE(spyOnCountChanged.count(), 1);
+        arguments = spyOnRowsInserted.takeFirst();
+        QCOMPARE(arguments.at(1).toInt(), 5);
+        QCOMPARE(arguments.at(2).toInt(), 6);
+        QCOMPARE(proxy.count(), 7);
+        spyOnRowsInserted.clear();
+        spyOnCountChanged.clear();
+
+        proxy.setLimit(3);
+        QCOMPARE(spyOnRowsRemoved.count(), 1);
+        QCOMPARE(spyOnRowsInserted.count(), 0);
+        QCOMPARE(spyOnCountChanged.count(), 1);
+        arguments = spyOnRowsRemoved.takeFirst();
+        QCOMPARE(arguments.at(1).toInt(), 3);
+        QCOMPARE(arguments.at(2).toInt(), 6);
+        QCOMPARE(proxy.count(), 3);
+        spyOnRowsRemoved.clear();
+        spyOnCountChanged.clear();
+    }
+
+    void testLimitGreaterThanCount()
+    {
+        QSortFilterProxyModelQML proxy;
+        MockListModel model;
+        QList<QVariant> arguments;
+        model.insertRows(0, 5);
+
+        proxy.setSourceModelQObject(&model);
+
+        QSignalSpy spyOnRowsRemoved(&proxy, SIGNAL(rowsRemoved(const QModelIndex &, int, int)));
+        QSignalSpy spyOnRowsInserted(&proxy, SIGNAL(rowsInserted(const QModelIndex &, int, int)));
+        QSignalSpy spyOnCountChanged(&proxy, SIGNAL(countChanged()));
+
+        proxy.setLimit(7);
+        QCOMPARE(spyOnRowsRemoved.count(), 0);
+        QCOMPARE(spyOnRowsInserted.count(), 0);
+        QCOMPARE(spyOnCountChanged.count(), 0);
+        QCOMPARE(proxy.count(), 5);
+
+        proxy.setLimit(5);
+        QCOMPARE(spyOnRowsRemoved.count(), 0);
+        QCOMPARE(spyOnRowsInserted.count(), 0);
+        QCOMPARE(spyOnCountChanged.count(), 0);
+        QCOMPARE(proxy.count(), 5);
+
+        proxy.setLimit(3);
+        QCOMPARE(spyOnRowsInserted.count(), 0);
+        QCOMPARE(spyOnRowsRemoved.count(), 1);
+        QCOMPARE(spyOnCountChanged.count(), 1);
+        arguments = spyOnRowsRemoved.takeFirst();
+        QCOMPARE(arguments.at(1).toInt(), 3);
+        QCOMPARE(arguments.at(2).toInt(), 4);
+        QCOMPARE(proxy.count(), 3);
+        spyOnRowsRemoved.clear();
+        spyOnCountChanged.clear();
+
+        proxy.setLimit(4);
+        QCOMPARE(spyOnRowsRemoved.count(), 0);
+        QCOMPARE(spyOnRowsInserted.count(), 1);
+        QCOMPARE(spyOnCountChanged.count(), 1);
+        arguments = spyOnRowsInserted.takeFirst();
+        QCOMPARE(arguments.at(1).toInt(), 3);
+        QCOMPARE(arguments.at(2).toInt(), 3);
+        QCOMPARE(proxy.count(), 4);
+        spyOnRowsInserted.clear();
+        spyOnCountChanged.clear();
+
+        proxy.setLimit(7);
+        QCOMPARE(spyOnRowsRemoved.count(), 0);
+        QCOMPARE(spyOnRowsInserted.count(), 1);
+        QCOMPARE(spyOnCountChanged.count(), 1);
+        arguments = spyOnRowsInserted.takeFirst();
+        QCOMPARE(arguments.at(1).toInt(), 4);
+        QCOMPARE(arguments.at(2).toInt(), 4);
+        QCOMPARE(proxy.count(), 5);
+        spyOnRowsInserted.clear();
+        spyOnCountChanged.clear();
+    }
+
+    void testLimitMinusOne()
+    {
+        QSortFilterProxyModelQML proxy;
+        MockListModel model;
+        QList<QVariant> arguments;
+        model.insertRows(0, 5);
+
+        proxy.setSourceModelQObject(&model);
+
+        QSignalSpy spyOnRowsRemoved(&proxy, SIGNAL(rowsRemoved(const QModelIndex &, int, int)));
+        QSignalSpy spyOnRowsInserted(&proxy, SIGNAL(rowsInserted(const QModelIndex &, int, int)));
+        QSignalSpy spyOnCountChanged(&proxy, SIGNAL(countChanged()));
+
+        proxy.setLimit(7);
+        QCOMPARE(spyOnRowsRemoved.count(), 0);
+        QCOMPARE(spyOnRowsInserted.count(), 0);
+        QCOMPARE(spyOnCountChanged.count(), 0);
+        QCOMPARE(proxy.count(), 5);
+
+        proxy.setLimit(-1);
+        QCOMPARE(spyOnRowsRemoved.count(), 0);
+        QCOMPARE(spyOnRowsInserted.count(), 0);
+        QCOMPARE(spyOnCountChanged.count(), 0);
+        QCOMPARE(proxy.count(), 5);
+
+        proxy.setLimit(3);
+        QCOMPARE(spyOnRowsInserted.count(), 0);
+        QCOMPARE(spyOnRowsRemoved.count(), 1);
+        QCOMPARE(spyOnCountChanged.count(), 1);
+        arguments = spyOnRowsRemoved.takeFirst();
+        QCOMPARE(arguments.at(1).toInt(), 3);
+        QCOMPARE(arguments.at(2).toInt(), 4);
+        QCOMPARE(proxy.count(), 3);
+        spyOnRowsRemoved.clear();
+        spyOnCountChanged.clear();
+
+        proxy.setLimit(-1);
+        QCOMPARE(spyOnRowsRemoved.count(), 0);
+        QCOMPARE(spyOnRowsInserted.count(), 1);
+        QCOMPARE(spyOnCountChanged.count(), 1);
+        arguments = spyOnRowsInserted.takeFirst();
+        QCOMPARE(arguments.at(1).toInt(), 3);
+        QCOMPARE(arguments.at(2).toInt(), 4);
+        QCOMPARE(proxy.count(), 5);
+        spyOnRowsInserted.clear();
+        spyOnCountChanged.clear();
+    }
+
+    void testLimitInsert() {
+        QSortFilterProxyModelQML proxy;
+        MockListModel model;
+        QList<QVariant> arguments;
+
+        proxy.setSourceModelQObject(&model);
+        proxy.setLimit(7);
+
+        QSignalSpy spyOnRowsRemoved(&proxy, SIGNAL(rowsRemoved(const QModelIndex &, int, int)));
+        QSignalSpy spyOnRowsInserted(&proxy, SIGNAL(rowsInserted(const QModelIndex &, int, int)));
+        QSignalSpy spyOnCountChanged(&proxy, SIGNAL(countChanged()));
+
+        model.insertRows(0, 5);
+        QCOMPARE(spyOnRowsRemoved.count(), 0);
+        QCOMPARE(spyOnRowsInserted.count(), 1);
+        QCOMPARE(spyOnCountChanged.count(), 1);
+        arguments = spyOnRowsInserted.takeFirst();
+        QCOMPARE(arguments.at(1).toInt(), 0);
+        QCOMPARE(arguments.at(2).toInt(), 4);
+        QCOMPARE(proxy.count(), 5);
+        spyOnRowsInserted.clear();
+        spyOnCountChanged.clear();
+
+        model.insertRows(2, 2);
+        QCOMPARE(spyOnRowsRemoved.count(), 0);
+        QCOMPARE(spyOnRowsInserted.count(), 1);
+        QCOMPARE(spyOnCountChanged.count(), 1);
+        arguments = spyOnRowsInserted.takeFirst();
+        QCOMPARE(arguments.at(1).toInt(), 2);
+        QCOMPARE(arguments.at(2).toInt(), 3);
+        QCOMPARE(proxy.count(), 7);
+        spyOnRowsInserted.clear();
+        spyOnCountChanged.clear();
+
+        /* FIXME: failing case due to QSortFilterProxyModel emitting
+           rowsInserted/rowsRemoved regardless of the limit */
+        //model.insertRows(5, 3);
+        //QCOMPARE(proxy.count(), 7);
+        //QCOMPARE(spyOnRowsRemoved.count(), 0);
+        //QCOMPARE(spyOnRowsInserted.count(), 0);
+        //QCOMPARE(spyOnCountChanged.count(), 0);
+    }
+};
+
+QTEST_MAIN(QSortFilterProxyModelTest)
+
+#include "qsortfilterproxymodeltest.moc"
+

=== modified file 'places/RendererGrid.qml'
--- places/RendererGrid.qml	2011-06-23 17:08:53 +0000
+++ places/RendererGrid.qml	2011-07-27 12:25:44 +0000
@@ -47,18 +47,18 @@
     /* Using results.contentHeight produces binding loop warnings and potential
        rendering issues. We compute the height manually.
     */
-    /* FIXME: tricking the system by making the delegate of height 0 and with
-              an invisible header is no good: the item in the model still
-              exists and some things such as keyboard selection break.
+    /* FIXME: tricking the system by making the delegate of height 0 and invisible
+              is no good: the item in the model still exists and some things
+              such as keyboard selection break.
     */
-    height: results.count > 0 ? header.height + results_layout.anchors.topMargin + results.totalHeight : 0
+    visible: results.model.totalCount > 0
+    height: visible ? header.height + results_layout.anchors.topMargin + results.totalHeight : 0
     //Behavior on height {NumberAnimation {duration: 200}}
 
     GroupHeader {
         id: header
 
-        visible: results.count > 0
-        availableCount: results.count - results.cellsPerRow
+        availableCount: results.model.totalCount - results.cellsPerRow
         folded: parent.folded
         anchors.top: parent.top
         anchors.left: parent.left
@@ -124,9 +124,7 @@
             width: flickable.width
             height: Math.min(totalHeight, flickable.height)
 
-            /* Only display one line of items when folded */
-            property int displayedCount: folded ? cellsPerRow : count
-            property int totalHeight: results.cellHeight*Math.ceil(displayedCount/cellsPerRow)
+            property int totalHeight: results.cellHeight*Math.ceil(count/cellsPerRow)
 
             minHorizontalSpacing: renderer.horizontalSpacing
             minVerticalSpacing: renderer.verticalSpacing
@@ -168,7 +166,11 @@
                 }
             }
 
-            model: renderer.model
+            /* Only display one line of items when folded */
+            model: SortFilterProxyModel {
+                model: renderer.model != undefined ? renderer.model : null
+                limit: folded ? results.cellsPerRow : -1
+            }
         }
     }
 }