Implemented the new KParts' listing filter extension, KParts::ListingFilterExtension.

REVIEW: 106289

4 files changed, 133 insertions, 33 deletions

diff --git a/src/kitemviews/kfileitemmodel.cpp b/src/kitemviews/kfileitemmodel.cpp
index 6936af431..752bc9365 100644
--- a/src/kitemviews/kfileitemmodel.cpp
+++ b/src/kitemviews/kfileitemmodel.cpp
@@ -508,46 +508,64 @@ void KFileItemModel::setNameFilter(const QString& nameFilter)
 {
     if (m_filter.pattern() != nameFilter) {
         dispatchPendingItemsToInsert();
-
         m_filter.setPattern(nameFilter);
+        applyFilters();
+    }
+}
+
+QString KFileItemModel::nameFilter() const
+{
+    return m_filter.pattern();
+}
+
+void KFileItemModel::setMimeTypeFilters(const QStringList& filters)
+{
+    if (m_filter.mimeTypes() != filters) {
+        dispatchPendingItemsToInsert();
+        m_filter.setMimeTypes(filters);
+        applyFilters();
+    }
+}
+
+QStringList KFileItemModel::mimeTypeFilters() const
+{
+    return m_filter.mimeTypes();
+}
 
-        // Check which shown items from m_itemData must get
-        // hidden and hence moved to m_filteredItems.
-        KFileItemList newFilteredItems;
 
-        foreach (ItemData* itemData, m_itemData) {
+void KFileItemModel::applyFilters()
+{
+    // Check which shown items from m_itemData must get
+    // hidden and hence moved to m_filteredItems.
+    KFileItemList newFilteredItems;
+
+    foreach (ItemData* itemData, m_itemData) {
+        // Only filter non-expanded items as child items may never
+        // exist without a parent item
+        if (!itemData->values.value("isExpanded").toBool()) {
             if (!m_filter.matches(itemData->item)) {
-                // Only filter non-expanded items as child items may never
-                // exist without a parent item
-                if (!itemData->values.value("isExpanded").toBool()) {
-                    newFilteredItems.append(itemData->item);
-                    m_filteredItems.insert(itemData->item);
-                }
+                newFilteredItems.append(itemData->item);
+                m_filteredItems.insert(itemData->item);
             }
         }
+    }
 
-        removeItems(newFilteredItems);
+    removeItems(newFilteredItems);
 
-        // Check which hidden items from m_filteredItems should
-        // get visible again and hence removed from m_filteredItems.
-        KFileItemList newVisibleItems;
+    // Check which hidden items from m_filteredItems should
+    // get visible again and hence removed from m_filteredItems.
+    KFileItemList newVisibleItems;
 
-        QMutableSetIterator<KFileItem> it(m_filteredItems);
-        while (it.hasNext()) {
-            const KFileItem item = it.next();
-            if (m_filter.matches(item)) {
-                newVisibleItems.append(item);
-                it.remove();
-            }
+    QMutableSetIterator<KFileItem> it(m_filteredItems);
+    while (it.hasNext()) {
+        const KFileItem item = it.next();
+        if (m_filter.matches(item)) {
+            newVisibleItems.append(item);
+            it.remove();
         }
-
-        insertItems(newVisibleItems);
     }
-}
 
-QString KFileItemModel::nameFilter() const
-{
-    return m_filter.pattern();
+    insertItems(newVisibleItems);
 }
 
 QList<KFileItemModel::RoleInfo> KFileItemModel::rolesInformation()
@@ -729,10 +747,10 @@ void KFileItemModel::slotNewItems(const KFileItemList& items)
         }
     }
 
-    if (m_filter.pattern().isEmpty()) {
+    if (!m_filter.hasSetFilters()) {
         m_pendingItemsToInsert.append(items);
     } else {
-        // The name-filter is active. Hide filtered items
+        // The name or type filter is active. Hide filtered items
         // before inserting them into the model and remember
         // the filtered items in m_filteredItems.
         KFileItemList filteredItems;
diff --git a/src/kitemviews/kfileitemmodel.h b/src/kitemviews/kfileitemmodel.h
index d9bebdf02..958fa104b 100644
--- a/src/kitemviews/kfileitemmodel.h
+++ b/src/kitemviews/kfileitemmodel.h
@@ -179,6 +179,9 @@ public:
     void setNameFilter(const QString& nameFilter);
     QString nameFilter() const;
 
+    void setMimeTypeFilters(const QStringList& filters);
+    QStringList mimeTypeFilters() const;
+
     struct RoleInfo
     {   QByteArray role;
         QString translation;
@@ -389,6 +392,11 @@ private:
     void emitSortProgress(int resolvedCount);
 
     /**
+     * Applies the filters set through @ref setNameFilter and @ref setMimeTypeFilters.
+     */
+    void applyFilters();
+
+    /**
      * Maps the QByteArray-roles to RoleTypes and provides translation- and
      * group-contexts.
      */
diff --git a/src/kitemviews/private/kfileitemmodelfilter.cpp b/src/kitemviews/private/kfileitemmodelfilter.cpp
index 816d35634..2e320f2d9 100644
--- a/src/kitemviews/private/kfileitemmodelfilter.cpp
+++ b/src/kitemviews/private/kfileitemmodelfilter.cpp
@@ -23,6 +23,7 @@
 #include <KFileItem>
 #include <QRegExp>
 
+
 KFileItemModelFilter::KFileItemModelFilter() :
     m_useRegExp(false),
     m_regExp(0),
@@ -61,11 +62,61 @@ QString KFileItemModelFilter::pattern() const
     return m_pattern;
 }
 
+void KFileItemModelFilter::setMimeTypes(const QStringList& types)
+{
+    m_mimeTypes = types;
+}
+
+QStringList KFileItemModelFilter::mimeTypes() const
+{
+    return m_mimeTypes;
+}
+
+bool KFileItemModelFilter::hasSetFilters() const
+{
+    return (!m_pattern.isEmpty() || !m_mimeTypes.isEmpty());
+}
+
+
 bool KFileItemModelFilter::matches(const KFileItem& item) const
 {
+    const bool hasPatternFilter = !m_pattern.isEmpty();
+    const bool hasMimeTypesFilter = !m_mimeTypes.isEmpty();
+
+    // If no filter is set, return true.
+    if (!hasPatternFilter && !hasMimeTypesFilter) {
+        return true;
+    }
+
+    // If both filters are set, return true when both filters are matched
+    if (hasPatternFilter && hasMimeTypesFilter) {
+        return (matchesPattern(item) && matchesType(item));
+    }
+
+    // If only one filter is set, return true when that filter is matched
+    if (hasPatternFilter) {
+        return matchesPattern(item);
+    }
+
+    return matchesType(item);
+}
+
+bool KFileItemModelFilter::matchesPattern(const KFileItem& item) const
+{
     if (m_useRegExp) {
         return m_regExp->exactMatch(item.text());
     } else {
         return item.text().toLower().contains(m_lowerCasePattern);
     }
 }
+
+bool KFileItemModelFilter::matchesType(const KFileItem& item) const
+{
+    foreach (const QString& mimeType, m_mimeTypes) {
+        if (item.mimetype() == mimeType) {
+            return true;
+        }
+    }
+
+    return m_mimeTypes.isEmpty();
+}
diff --git a/src/kitemviews/private/kfileitemmodelfilter.h b/src/kitemviews/private/kfileitemmodelfilter.h
index 9bdf1fd95..e4fb0a2ee 100644
--- a/src/kitemviews/private/kfileitemmodelfilter.h
+++ b/src/kitemviews/private/kfileitemmodelfilter.h
@@ -22,7 +22,7 @@
 #define KFILEITEMMODELFILTER_H
 
 #include <libdolphin_export.h>
-#include <QString>
+#include <QStringList>
 
 class KFileItem;
 class QRegExp;
@@ -52,18 +52,41 @@ public:
     QString pattern() const;
 
     /**
+     * Set the list of mimetypes that are used for comparison with the
+     * item in KFileItemModelFilter::matchesMimeType.
+     */
+    void setMimeTypes(const QStringList& types);
+    QStringList mimeTypes() const;
+
+    /**
+     * @return True if either the pattern or mimetype filters has been set.
+     */
+    bool hasSetFilters() const;
+
+    /**
      * @return True if the item matches with the pattern defined by
-     *         KFileItemModelFilter::setPattern().
+     *         @ref setPattern() or @ref setMimeTypes
      */
     bool matches(const KFileItem& item) const;
 
 private:
+    /**
+     * @return True if item matches pattern set by @ref setPattern.
+     */
+    bool matchesPattern(const KFileItem& item) const;
+
+    /**
+     * @return True if item matches mimetypes set by @ref setMimeTypes.
+     */
+    bool matchesType(const KFileItem& item) const;
+
     bool m_useRegExp;           // If true, m_regExp is used for filtering,
                                 // otherwise m_lowerCaseFilter is used.
     QRegExp* m_regExp;
     QString m_lowerCasePattern; // Lowercase version of m_filter for
                                 // faster comparison in matches().
-    QString m_pattern;          // Property set by setFilter().
+    QString m_pattern;          // Property set by setPattern().
+    QStringList m_mimeTypes;    // Property set by setMimeTypes()
 };
 #endif