Filter enabled folders using a krecursivefilterproxymodel

The KRecursiveFilterProxyModel is necessary until Qt 5.10 when
QSortFilterProxyModel will support recursive filtering.
For the recursive filtering to work we need to make all data available,
so we trigger fetchMore on all added indexes.

5 files changed, 583 insertions, 6 deletions

diff --git a/framework/src/CMakeLists.txt b/framework/src/CMakeLists.txt
index 9c845022..86145d5a 100644
--- a/framework/src/CMakeLists.txt
+++ b/framework/src/CMakeLists.txt
@@ -42,6 +42,7 @@ set(SRCS
     sinkfabric.cpp
     kubeimage.cpp
     clipboardproxy.cpp
+    krecursivefilterproxymodel.cpp
 )
 
 add_library(frameworkplugin SHARED ${SRCS})
diff --git a/framework/src/domain/folderlistmodel.cpp b/framework/src/domain/folderlistmodel.cpp
index 0abc70c5..1fe2abe6 100644
--- a/framework/src/domain/folderlistmodel.cpp
+++ b/framework/src/domain/folderlistmodel.cpp
@@ -26,11 +26,20 @@
 using namespace Sink;
 using namespace Sink::ApplicationDomain;
 
-FolderListModel::FolderListModel(QObject *parent) : QSortFilterProxyModel()
+FolderListModel::FolderListModel(QObject *parent) : KRecursiveFilterProxyModel()
 {
     setDynamicSortFilter(true);
     sort(0, Qt::AscendingOrder);
 
+    //Automatically fetch all folders, otherwise the recursive filtering does not work.
+    QObject::connect(this, &QSortFilterProxyModel::sourceModelChanged, [this] () {
+        QObject::connect(sourceModel(), &QAbstractItemModel::rowsInserted, sourceModel(), [this] (QModelIndex parent, int first, int last) {
+            for (int row = first; row <= last; row++) {
+                auto idx = sourceModel()->index(row, 0, parent);
+                sourceModel()->fetchMore(idx);
+            }
+        });
+    });
 }
 
 FolderListModel::~FolderListModel()
@@ -99,7 +108,6 @@ void FolderListModel::setAccountId(const QVariant &accountId)
     auto query = Query();
     query.resourceFilter<SinkResource::Account>(account);
     query.setFlags(Sink::Query::LiveQuery | Sink::Query::UpdateStatus);
-    query.filter<Folder::Enabled>(true);
     query.request<Folder::Name>()
          .request<Folder::Icon>()
          .request<Folder::Parent>()
@@ -144,6 +152,14 @@ bool FolderListModel::lessThan(const QModelIndex &left, const QModelIndex &right
     return leftPriority < rightPriority;
 }
 
+bool FolderListModel::acceptRow(int sourceRow, const QModelIndex &sourceParent) const
+{
+    auto index = sourceModel()->index(sourceRow, 0, sourceParent);
+    const auto folder = index.data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Folder::Ptr>();
+    const auto enabled = folder->getEnabled();
+    return enabled;
+}
+
 void FolderListModel::setFolderId(const QVariant &folderId)
 {
     const auto folder = folderId.toString().toUtf8();
diff --git a/framework/src/domain/folderlistmodel.h b/framework/src/domain/folderlistmodel.h
index 0e412202..738cf4a0 100644
--- a/framework/src/domain/folderlistmodel.h
+++ b/framework/src/domain/folderlistmodel.h
@@ -20,16 +20,14 @@
 
 #pragma once
 
-#include <QObject>
-#include <QSortFilterProxyModel>
+#include <krecursivefilterproxymodel.h>
 #include <QSharedPointer>
-#include <QStringList>
 
 namespace Sink {
     class Query;
 }
 
-class FolderListModel : public QSortFilterProxyModel
+class FolderListModel : public KRecursiveFilterProxyModel
 {
     Q_OBJECT
 
@@ -69,6 +67,7 @@ public:
     QVariant folderId() const;
 protected:
     bool lessThan(const QModelIndex &left, const QModelIndex &right) const Q_DECL_OVERRIDE;
+    bool acceptRow(int sourceRow, const QModelIndex &sourceParent) const Q_DECL_OVERRIDE;
 
 private:
     void runQuery(const Sink::Query &query);
diff --git a/framework/src/krecursivefilterproxymodel.cpp b/framework/src/krecursivefilterproxymodel.cpp
new file mode 100644
index 00000000..014e1076
--- /dev/null
+++ b/framework/src/krecursivefilterproxymodel.cpp
@@ -0,0 +1,426 @@
+/*
+    Copyright (c) 2009 Stephen Kelly <steveire@gmail.com>
+
+    This library is free software; you can redistribute it and/or modify it
+    under the terms of the GNU Library General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    This library 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 Library General Public
+    License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to the
+    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+    02110-1301, USA.
+*/
+
+#include "krecursivefilterproxymodel.h"
+
+#include <QMetaMethod>
+
+// Maintainability note:
+// This class invokes some Q_PRIVATE_SLOTs in QSortFilterProxyModel which are
+// private API and could be renamed or removed at any time.
+// If they are renamed, the invocations can be updated with an #if (QT_VERSION(...))
+// If they are removed, then layout{AboutToBe}Changed Q_SIGNALS should be used when the source model
+// gets new rows or has rowsremoved or moved. The Q_PRIVATE_SLOT invocation is an optimization
+// because layout{AboutToBe}Changed is expensive and causes the entire mapping of the tree in QSFPM
+// to be cleared, even if only a part of it is dirty.
+// Stephen Kelly, 30 April 2010.
+
+// All this is temporary anyway, the long term solution is support in QSFPM: https://codereview.qt-project.org/151000
+
+class KRecursiveFilterProxyModelPrivate
+{
+    Q_DECLARE_PUBLIC(KRecursiveFilterProxyModel)
+    KRecursiveFilterProxyModel *q_ptr;
+public:
+    KRecursiveFilterProxyModelPrivate(KRecursiveFilterProxyModel *model)
+        : q_ptr(model),
+          completeInsert(false)
+    {
+        qRegisterMetaType<QModelIndex>("QModelIndex");
+    }
+
+    inline QMetaMethod findMethod(const char *signature) const
+    {
+        Q_Q(const KRecursiveFilterProxyModel);
+        const int idx = q->metaObject()->indexOfMethod(signature);
+        Q_ASSERT(idx != -1);
+        return q->metaObject()->method(idx);
+    }
+
+    // Convenience methods for invoking the QSFPM Q_SLOTS. Those slots must be invoked with invokeMethod
+    // because they are Q_PRIVATE_SLOTs
+    inline void invokeDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles = QVector<int>())
+    {
+        Q_Q(KRecursiveFilterProxyModel);
+        // required for Qt 5.5 and upwards, see commit f96baeb75fc in qtbase
+        static const QMetaMethod m = findMethod("_q_sourceDataChanged(QModelIndex,QModelIndex,QVector<int>)");
+        bool success = m.invoke(q, Qt::DirectConnection,
+                Q_ARG(QModelIndex, topLeft),
+                Q_ARG(QModelIndex, bottomRight),
+                Q_ARG(QVector<int>, roles));
+        Q_UNUSED(success);
+        Q_ASSERT(success);
+    }
+
+    inline void invokeRowsInserted(const QModelIndex &source_parent, int start, int end)
+    {
+        Q_Q(KRecursiveFilterProxyModel);
+        static const QMetaMethod m = findMethod("_q_sourceRowsInserted(QModelIndex,int,int)");
+        bool success = m.invoke(q, Qt::DirectConnection,
+                                Q_ARG(QModelIndex, source_parent),
+                                Q_ARG(int, start),
+                                Q_ARG(int, end));
+        Q_UNUSED(success);
+        Q_ASSERT(success);
+    }
+
+    inline void invokeRowsAboutToBeInserted(const QModelIndex &source_parent, int start, int end)
+    {
+        Q_Q(KRecursiveFilterProxyModel);
+        static const QMetaMethod m = findMethod("_q_sourceRowsAboutToBeInserted(QModelIndex,int,int)");
+        bool success = m.invoke(q, Qt::DirectConnection,
+                                Q_ARG(QModelIndex, source_parent),
+                                Q_ARG(int, start),
+                                Q_ARG(int, end));
+        Q_UNUSED(success);
+        Q_ASSERT(success);
+    }
+
+    inline void invokeRowsRemoved(const QModelIndex &source_parent, int start, int end)
+    {
+        Q_Q(KRecursiveFilterProxyModel);
+        static const QMetaMethod m = findMethod("_q_sourceRowsRemoved(QModelIndex,int,int)");
+        bool success = m.invoke(q, Qt::DirectConnection,
+                                Q_ARG(QModelIndex, source_parent),
+                                Q_ARG(int, start),
+                                Q_ARG(int, end));
+        Q_UNUSED(success);
+        Q_ASSERT(success);
+    }
+
+    inline void invokeRowsAboutToBeRemoved(const QModelIndex &source_parent, int start, int end)
+    {
+        Q_Q(KRecursiveFilterProxyModel);
+        static const QMetaMethod m = findMethod("_q_sourceRowsAboutToBeRemoved(QModelIndex,int,int)");
+        bool success = m.invoke(q, Qt::DirectConnection,
+                                Q_ARG(QModelIndex, source_parent),
+                                Q_ARG(int, start),
+                                Q_ARG(int, end));
+        Q_UNUSED(success);
+        Q_ASSERT(success);
+    }
+
+    void sourceDataChanged(const QModelIndex &source_top_left, const QModelIndex &source_bottom_right, const QVector<int> &roles = QVector<int>());
+    void sourceRowsAboutToBeInserted(const QModelIndex &source_parent, int start, int end);
+    void sourceRowsInserted(const QModelIndex &source_parent, int start, int end);
+    void sourceRowsAboutToBeRemoved(const QModelIndex &source_parent, int start, int end);
+    void sourceRowsRemoved(const QModelIndex &source_parent, int start, int end);
+
+    /**
+    Force QSortFilterProxyModel to re-evaluate whether to hide or show index and its parents.
+    */
+    void refreshAscendantMapping(const QModelIndex &index);
+
+    QModelIndex lastFilteredOutAscendant(const QModelIndex &index);
+
+    bool completeInsert;
+    QModelIndex lastHiddenAscendantForInsert;
+};
+
+void KRecursiveFilterProxyModelPrivate::sourceDataChanged(const QModelIndex &source_top_left, const QModelIndex &source_bottom_right, const QVector<int> &roles)
+{
+    QModelIndex source_parent = source_top_left.parent();
+    Q_ASSERT(source_bottom_right.parent() == source_parent); // don't know how to handle different parents in this code...
+
+    // Tell the world.
+    invokeDataChanged(source_top_left, source_bottom_right, roles);
+
+    // We can't find out if the change really matters to us or not, for a lack of a dataAboutToBeChanged signal (or a cache).
+    // TODO: add a set of roles that we care for, so we can at least ignore the rest.
+
+    // Even if we knew the visibility was just toggled, we also can't find out what
+    // was the last filtered out ascendant (on show, like sourceRowsAboutToBeInserted does)
+    // or the last to-be-filtered-out ascendant (on hide, like sourceRowsRemoved does)
+    // So we have to refresh all parents.
+    QModelIndex sourceParent = source_parent;
+    while (sourceParent.isValid()) {
+        invokeDataChanged(sourceParent, sourceParent, roles);
+        sourceParent = sourceParent.parent();
+    }
+}
+
+QModelIndex KRecursiveFilterProxyModelPrivate::lastFilteredOutAscendant(const QModelIndex &idx)
+{
+    Q_Q(KRecursiveFilterProxyModel);
+    QModelIndex last = idx;
+    QModelIndex index = idx.parent();
+    while (index.isValid() && !q->filterAcceptsRow(index.row(), index.parent())) {
+        last = index;
+        index = index.parent();
+    }
+    return last;
+}
+
+void KRecursiveFilterProxyModelPrivate::sourceRowsAboutToBeInserted(const QModelIndex &source_parent, int start, int end)
+{
+    Q_Q(KRecursiveFilterProxyModel);
+
+    if (!source_parent.isValid() || q->filterAcceptsRow(source_parent.row(), source_parent.parent())) {
+        // If the parent is already in the model (directly or indirectly), we can just pass on the signal.
+        invokeRowsAboutToBeInserted(source_parent, start, end);
+        completeInsert = true;
+    } else {
+        // OK, so parent is not in the model.
+        // Maybe the grand parent neither.. Go up until the first one that is.
+        lastHiddenAscendantForInsert = lastFilteredOutAscendant(source_parent);
+    }
+}
+
+void KRecursiveFilterProxyModelPrivate::sourceRowsInserted(const QModelIndex &source_parent, int start, int end)
+{
+    Q_Q(KRecursiveFilterProxyModel);
+
+    if (completeInsert) {
+        // If the parent is already in the model, we can just pass on the signal.
+        completeInsert = false;
+        invokeRowsInserted(source_parent, start, end);
+        return;
+    }
+
+    bool requireRow = false;
+    for (int row = start; row <= end; ++row) {
+        if (q->filterAcceptsRow(row, source_parent)) {
+            requireRow = true;
+            break;
+        }
+    }
+
+    if (!requireRow) {
+        // The new rows doesn't have any descendants that match the filter. Filter them out.
+        return;
+    }
+
+    // Make QSFPM realize that lastHiddenAscendantForInsert should be shown now
+    invokeDataChanged(lastHiddenAscendantForInsert, lastHiddenAscendantForInsert);
+}
+
+void KRecursiveFilterProxyModelPrivate::sourceRowsAboutToBeRemoved(const QModelIndex &source_parent, int start, int end)
+{
+    invokeRowsAboutToBeRemoved(source_parent, start, end);
+}
+
+void KRecursiveFilterProxyModelPrivate::sourceRowsRemoved(const QModelIndex &source_parent, int start, int end)
+{
+    Q_Q(KRecursiveFilterProxyModel);
+
+    invokeRowsRemoved(source_parent, start, end);
+
+    // Find out if removing this visible row means that some ascendant
+    // row can now be hidden.
+    // We go up until we find a row that should still be visible
+    // and then make QSFPM re-evaluate the last one we saw before that, to hide it.
+
+    QModelIndex toHide;
+    QModelIndex sourceAscendant = source_parent;
+    while (sourceAscendant.isValid()) {
+        if (q->filterAcceptsRow(sourceAscendant.row(), sourceAscendant.parent())) {
+            break;
+        }
+        toHide = sourceAscendant;
+        sourceAscendant = sourceAscendant.parent();
+    }
+    if (toHide.isValid()) {
+        invokeDataChanged(toHide, toHide);
+    }
+}
+
+KRecursiveFilterProxyModel::KRecursiveFilterProxyModel(QObject *parent)
+    : QSortFilterProxyModel(parent), d_ptr(new KRecursiveFilterProxyModelPrivate(this))
+{
+    setDynamicSortFilter(true);
+}
+
+KRecursiveFilterProxyModel::~KRecursiveFilterProxyModel()
+{
+    delete d_ptr;
+}
+
+bool KRecursiveFilterProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
+{
+    // TODO: Implement some caching so that if one match is found on the first pass, we can return early results
+    // when the subtrees are checked by QSFPM.
+    if (acceptRow(sourceRow, sourceParent)) {
+        return true;
+    }
+
+    QModelIndex source_index = sourceModel()->index(sourceRow, 0, sourceParent);
+    Q_ASSERT(source_index.isValid());
+    bool accepted = false;
+
+    const int numChildren = sourceModel()->rowCount(source_index);
+    for (int row = 0, rows = numChildren; row < rows; ++row) {
+        if (filterAcceptsRow(row, source_index)) {
+            accepted = true;
+            break;
+        }
+    }
+
+    return accepted;
+}
+
+QModelIndexList KRecursiveFilterProxyModel::match(const QModelIndex &start, int role, const QVariant &value, int hits, Qt::MatchFlags flags) const
+{
+    if (role < Qt::UserRole) {
+        return QSortFilterProxyModel::match(start, role, value, hits, flags);
+    }
+
+    QModelIndexList list;
+    if (!sourceModel())
+        return list;
+
+    QModelIndex proxyIndex;
+    Q_FOREACH (const QModelIndex &idx, sourceModel()->match(mapToSource(start), role, value, hits, flags)) {
+        proxyIndex = mapFromSource(idx);
+        if (proxyIndex.isValid()) {
+            list << proxyIndex;
+        }
+    }
+
+    return list;
+}
+
+bool KRecursiveFilterProxyModel::acceptRow(int sourceRow, const QModelIndex &sourceParent) const
+{
+    return QSortFilterProxyModel::filterAcceptsRow(sourceRow, sourceParent);
+}
+
+void KRecursiveFilterProxyModel::setSourceModel(QAbstractItemModel *model)
+{
+    // Standard disconnect of the previous source model, if present
+    if (sourceModel()) {
+        disconnect(sourceModel(), SIGNAL(dataChanged(QModelIndex,QModelIndex,QVector<int>)),
+                this, SLOT(sourceDataChanged(QModelIndex,QModelIndex,QVector<int>)));
+
+        disconnect(sourceModel(), SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
+                this, SLOT(sourceRowsAboutToBeInserted(QModelIndex,int,int)));
+
+        disconnect(sourceModel(), SIGNAL(rowsInserted(QModelIndex,int,int)),
+                this, SLOT(sourceRowsInserted(QModelIndex,int,int)));
+
+        disconnect(sourceModel(), SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
+                this, SLOT(sourceRowsAboutToBeRemoved(QModelIndex,int,int)));
+
+        disconnect(sourceModel(), SIGNAL(rowsRemoved(QModelIndex,int,int)),
+                this, SLOT(sourceRowsRemoved(QModelIndex,int,int)));
+    }
+
+    QSortFilterProxyModel::setSourceModel(model);
+
+    // Disconnect in the QSortFilterProxyModel. These methods will be invoked manually
+    // in invokeDataChanged, invokeRowsInserted etc.
+    //
+    // The reason for that is that when the source model adds new rows for example, the new rows
+    // May not match the filter, but maybe their child items do match.
+    //
+    // Source model before insert:
+    //
+    // - A
+    // - B
+    // - - C
+    // - - D
+    // - - - E
+    // - - - F
+    // - - - G
+    // - H
+    // - I
+    //
+    // If the A F and L (which doesn't exist in the source model yet) match the filter
+    // the proxy will be:
+    //
+    // - A
+    // - B
+    // - - D
+    // - - - F
+    //
+    // New rows are inserted in the source model below H:
+    //
+    // - A
+    // - B
+    // - - C
+    // - - D
+    // - - - E
+    // - - - F
+    // - - - G
+    // - H
+    // - - J
+    // - - K
+    // - - - L
+    // - I
+    //
+    // As L matches the filter, it should be part of the KRecursiveFilterProxyModel.
+    //
+    // - A
+    // - B
+    // - - D
+    // - - - F
+    // - H
+    // - - K
+    // - - - L
+    //
+    // when the QSortFilterProxyModel gets a notification about new rows in H, it only checks
+    // J and K to see if they match, ignoring L, and therefore not adding it to the proxy.
+    // To work around that, we make sure that the QSFPM slot which handles that change in
+    // the source model (_q_sourceRowsAboutToBeInserted) does not get called directly.
+    // Instead we connect the sourceModel signal to our own slot in *this (sourceRowsAboutToBeInserted)
+    // Inside that method, the entire new subtree is queried (J, K *and* L) to see if there is a match,
+    // then the relevant Q_SLOTS in QSFPM are invoked.
+    // In the example above, we need to tell the QSFPM that H should be queried again to see if
+    // it matches the filter. It did not before, because L did not exist before. Now it does. That is
+    // achieved by telling the QSFPM that the data changed for H, which causes it to requery this class
+    // to see if H matches the filter (which it now does as L now exists).
+    // That is done in sourceRowsInserted.
+
+    if (!model) {
+        return;
+    }
+
+    disconnect(model, SIGNAL(dataChanged(QModelIndex,QModelIndex,QVector<int>)),
+            this, SLOT(_q_sourceDataChanged(QModelIndex,QModelIndex,QVector<int>)));
+
+    disconnect(model, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
+               this, SLOT(_q_sourceRowsAboutToBeInserted(QModelIndex,int,int)));
+
+    disconnect(model, SIGNAL(rowsInserted(QModelIndex,int,int)),
+               this, SLOT(_q_sourceRowsInserted(QModelIndex,int,int)));
+
+    disconnect(model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
+               this, SLOT(_q_sourceRowsAboutToBeRemoved(QModelIndex,int,int)));
+
+    disconnect(model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
+               this, SLOT(_q_sourceRowsRemoved(QModelIndex,int,int)));
+
+    // Slots for manual invoking of QSortFilterProxyModel methods.
+    connect(model, SIGNAL(dataChanged(QModelIndex,QModelIndex,QVector<int>)),
+            this, SLOT(sourceDataChanged(QModelIndex,QModelIndex,QVector<int>)));
+
+    connect(model, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
+            this, SLOT(sourceRowsAboutToBeInserted(QModelIndex,int,int)));
+
+    connect(model, SIGNAL(rowsInserted(QModelIndex,int,int)),
+            this, SLOT(sourceRowsInserted(QModelIndex,int,int)));
+
+    connect(model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
+            this, SLOT(sourceRowsAboutToBeRemoved(QModelIndex,int,int)));
+
+    connect(model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
+            this, SLOT(sourceRowsRemoved(QModelIndex,int,int)));
+
+}
+
+#include "moc_krecursivefilterproxymodel.cpp"
diff --git a/framework/src/krecursivefilterproxymodel.h b/framework/src/krecursivefilterproxymodel.h
new file mode 100644
index 00000000..d780b18c
--- /dev/null
+++ b/framework/src/krecursivefilterproxymodel.h
@@ -0,0 +1,135 @@
+/*
+    Copyright (c) 2009 Stephen Kelly <steveire@gmail.com>
+
+    This library is free software; you can redistribute it and/or modify it
+    under the terms of the GNU Library General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    This library 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 Library General Public
+    License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to the
+    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+    02110-1301, USA.
+*/
+
+#ifndef KRECURSIVEFILTERPROXYMODEL_H
+#define KRECURSIVEFILTERPROXYMODEL_H
+
+#include <QtCore/QSortFilterProxyModel>
+
+class KRecursiveFilterProxyModelPrivate;
+
+/**
+  @class KRecursiveFilterProxyModel krecursivefilterproxymodel.h KRecursiveFilterProxyModel
+
+  @brief Implements recursive filtering of models
+
+  Until Qt 5.10, QSortFilterProxyModel did not recurse when invoking a filtering stage, so that
+  if a particular row is filtered out, its children are not even checked to see if they match the filter.
+
+  If you can depend on Qt >= 5.10, then just use QSortFilterProxyModel::setRecursiveFiltering(true),
+  and you don't need to use KRecursiveFilterProxyModel.
+
+  For example, given a source model:
+
+  @verbatim
+    - A
+    - B
+    - - C
+    - - - D
+    - - - - E
+    - - - F
+    - - G
+    - - H
+    - I
+  @endverbatim
+
+  If a QSortFilterProxyModel is used with a filter matching A, D, G and I, the QSortFilterProxyModel will contain
+
+  @verbatim
+    - A
+    - I
+  @endverbatim
+
+  That is, even though D and E match the filter, they are not represented in the proxy model because B does not
+  match the filter and is filtered out.
+
+  The KRecursiveFilterProxyModel checks child indexes for filter matching and ensures that all matching indexes
+  are represented in the model.
+
+  In the above example, the KRecursiveFilterProxyModel will contain
+
+  @verbatim
+    - A
+    - B
+    - - C
+    - - - D
+    - - G
+    - I
+  @endverbatim
+
+  That is, the leaves in the model match the filter, but not necessarily the inner branches.
+
+  QSortFilterProxyModel provides the virtual method filterAcceptsRow to allow custom filter implementations.
+  Custom filter implementations can be written for KRecuriveFilterProxyModel using the acceptRow virtual method.
+
+  Note that using this proxy model is additional overhead compared to QSortFilterProxyModel as every index in the
+  model must be visited and queried.
+
+  @author Stephen Kelly <steveire@gmail.com>
+
+  @since 4.5
+
+*/
+class KRecursiveFilterProxyModel : public QSortFilterProxyModel
+{
+    Q_OBJECT
+public:
+    /**
+      Constructor
+    */
+    explicit KRecursiveFilterProxyModel(QObject *parent = nullptr);
+
+    /**
+      Destructor
+    */
+    virtual ~KRecursiveFilterProxyModel();
+
+    /** @reimp */
+    void setSourceModel(QAbstractItemModel *model) Q_DECL_OVERRIDE;
+
+    /**
+     * @reimplemented
+     */
+    QModelIndexList match(const QModelIndex &start, int role, const QVariant &value, int hits = 1,
+                                  Qt::MatchFlags flags = Qt::MatchFlags(Qt::MatchStartsWith | Qt::MatchWrap)) const Q_DECL_OVERRIDE;
+
+protected:
+    /**
+      Reimplement this method for custom filtering strategies.
+    */
+    virtual bool acceptRow(int sourceRow, const QModelIndex &sourceParent) const;
+
+    /** @reimp */
+    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const Q_DECL_OVERRIDE;
+
+    KRecursiveFilterProxyModelPrivate *const d_ptr;
+
+private:
+    //@cond PRIVATE
+    Q_DECLARE_PRIVATE(KRecursiveFilterProxyModel)
+
+    Q_PRIVATE_SLOT(d_func(), void sourceDataChanged(const QModelIndex &source_top_left, const QModelIndex &source_bottom_right, const QVector<int> &roles = QVector<int>()))
+    Q_PRIVATE_SLOT(d_func(), void sourceRowsAboutToBeInserted(const QModelIndex &source_parent, int start, int end))
+    Q_PRIVATE_SLOT(d_func(), void sourceRowsInserted(const QModelIndex &source_parent, int start, int end))
+    Q_PRIVATE_SLOT(d_func(), void sourceRowsAboutToBeRemoved(const QModelIndex &source_parent, int start, int end))
+    Q_PRIVATE_SLOT(d_func(), void sourceRowsRemoved(const QModelIndex &source_parent, int start, int end))
+    //@endcond
+};
+
+#endif