Implement sorting by "tags". Same performance problems occur as when using sorting...

svn path=/trunk/KDE/kdebase/apps/; revision=678957

diff --git a/src/dolphinitemcategorizer.cpp b/src/dolphinitemcategorizer.cpp
index a6d329f6d90ebf061d93c16dc612dae8ebae87a4..c83f9383f2bf3d2d35cec291149e0ead3fdfdbde 100644 (file)
--- a/src/dolphinitemcategorizer.cpp
+++ b/src/dolphinitemcategorizer.cpp
@@ -21,6 +21,7 @@
 #include "dolphinitemcategorizer.h"
 
 #include "dolphinview.h"
 #include "dolphinitemcategorizer.h"
 
 #include "dolphinview.h"

+#include "dolphinsortfilterproxymodel.h"

 
 #ifdef HAVE_NEPOMUK
 #include <config-nepomuk.h>
 
 #ifdef HAVE_NEPOMUK
 #include <config-nepomuk.h>


@@ -34,7 +35,8 @@
 #include <klocale.h>
 #include <kurl.h>
 
 #include <klocale.h>
 #include <kurl.h>
 

-#include <QtGui/QSortFilterProxyModel>
+#include <QList>
+#include <QSortFilterProxyModel>

 
 DolphinItemCategorizer::DolphinItemCategorizer() :
     KItemCategorizer()
 
 DolphinItemCategorizer::DolphinItemCategorizer() :
     KItemCategorizer()


@@ -164,19 +166,19 @@ QString DolphinItemCategorizer::categoryForItem(const QModelIndex& index,
 
 #ifdef HAVE_NEPOMUK
         case DolphinView::SortByRating: {
 
 #ifdef HAVE_NEPOMUK
         case DolphinView::SortByRating: {

-            KFileItem* item = dirModel->itemForIndex(index);
-            if (item != 0) {
-                const Nepomuk::Resource resource(item->url().url(), Nepomuk::NFO::File());
-                const quint32 rating = resource.rating();
-                if (!rating)
-                    retString = i18n("Not yet rated");
-                else
-                    retString = i18np("1 star", "%1 stars", rating);
+            const quint32 rating = DolphinSortFilterProxyModel::ratingForIndex(index);
+            if (rating) {
+                retString = i18np("1 star", "%1 stars", rating);
+            } else {
+                retString = i18n("Not yet rated");

             }
             break;
         }
             }
             break;
         }

-        case DolphinView::SortByTags:
+
+        case DolphinView::SortByTags: {
+            retString = DolphinSortFilterProxyModel::tagsForIndex(index);

             break;
             break;

+        }

 #endif
     }
 
 #endif
     }
 

diff --git a/src/dolphinsortfilterproxymodel.cpp b/src/dolphinsortfilterproxymodel.cpp
index 648b6133b66b8a5b103c3912334e10e0690e504c..e30a73d50f439c58e69be3f07c93f4d84473d345 100644 (file)
--- a/src/dolphinsortfilterproxymodel.cpp
+++ b/src/dolphinsortfilterproxymodel.cpp
@@ -26,11 +26,13 @@
 #include <config-nepomuk.h>
 #include <nepomuk/global.h>
 #include <nepomuk/resource.h>
 #include <config-nepomuk.h>
 #include <nepomuk/global.h>
 #include <nepomuk/resource.h>

+#include <nepomuk/tag.h>

 #endif
 
 #include <kdirmodel.h>
 #include <kfileitem.h>
 #include <kdatetime.h>
 #endif
 
 #include <kdirmodel.h>
 #include <kfileitem.h>
 #include <kdatetime.h>

+#include <klocale.h>

 
 static DolphinView::Sorting sortingTypeTable[] =
 {
 
 static DolphinView::Sorting sortingTypeTable[] =
 {


@@ -173,6 +175,9 @@ bool DolphinSortFilterProxyModel::lessThanGeneralPurpose(const QModelIndex &left
         const quint32 rightRating = ratingForIndex(right);
         return leftRating > rightRating;
     }
         const quint32 rightRating = ratingForIndex(right);
         return leftRating > rightRating;
     }

+    case DolphinView::SortByTags: {
+        return naturalCompare(tagsForIndex(left), tagsForIndex(right)) < 0;
+    }

 #endif
     default:
         break;
 #endif
     default:
         break;


@@ -331,6 +336,10 @@ bool DolphinSortFilterProxyModel::lessThan(const QModelIndex& left,
 
         return leftRating > rightRating;
     }
 
         return leftRating > rightRating;
     }

+
+    case DolphinView::SortByTags: {
+        return naturalCompare(tagsForIndex(left), tagsForIndex(right)) < 0;
+    }

 #endif
     }
 
 #endif
     }
 


@@ -339,12 +348,12 @@ bool DolphinSortFilterProxyModel::lessThan(const QModelIndex& left,
     return QSortFilterProxyModel::lessThan(left, right);
 }
 
     return QSortFilterProxyModel::lessThan(left, right);
 }
 

-quint32 DolphinSortFilterProxyModel::ratingForIndex(const QModelIndex& index) const
+quint32 DolphinSortFilterProxyModel::ratingForIndex(const QModelIndex& index)

 {
 #ifdef HAVE_NEPOMUK
     quint32 rating = 0;
 
 {
 #ifdef HAVE_NEPOMUK
     quint32 rating = 0;
 

-    const KDirModel* dirModel = static_cast<const KDirModel*>(sourceModel());
+    const KDirModel* dirModel = static_cast<const KDirModel*>(index.model());

     KFileItem* item = dirModel->itemForIndex(index);
     if (item != 0) {
         const Nepomuk::Resource resource(item->url().url(), Nepomuk::NFO::File());
     KFileItem* item = dirModel->itemForIndex(index);
     if (item != 0) {
         const Nepomuk::Resource resource(item->url().url(), Nepomuk::NFO::File());


@@ -357,6 +366,38 @@ quint32 DolphinSortFilterProxyModel::ratingForIndex(const QModelIndex& index) co
 #endif
 }
 
 #endif
 }
 

+QString DolphinSortFilterProxyModel::tagsForIndex(const QModelIndex& index)
+{
+#ifdef HAVE_NEPOMUK
+    QString tagsString;
+
+    const KDirModel* dirModel = static_cast<const KDirModel*>(index.model());
+    KFileItem* item = dirModel->itemForIndex(index);
+    if (item != 0) {
+        const Nepomuk::Resource resource(item->url().url(), Nepomuk::NFO::File());
+        const QList<Nepomuk::Tag> tags = resource.tags();
+        QStringList stringList;
+        foreach (const Nepomuk::Tag& tag, tags) {
+            stringList.append(tag.label());
+        }
+        stringList.sort();
+
+        foreach (const QString& str, stringList) {
+            tagsString += str;
+            tagsString += ' ';
+        }
+    }
+
+    if (tagsString.isEmpty()) {
+        tagsString = i18n("(no tags)");
+    }
+
+    return tagsString;
+#else
+    return QString();
+#endif
+}
+

 int DolphinSortFilterProxyModel::naturalCompare(const QString& a,
                                                 const QString& b)
 {
 int DolphinSortFilterProxyModel::naturalCompare(const QString& a,
                                                 const QString& b)
 {

diff --git a/src/dolphinsortfilterproxymodel.h b/src/dolphinsortfilterproxymodel.h
index 5bf4bc1466ce767909a9a164eefe12ab640976a0..56ee77dba4833c13949c85c48bd88bb0deecfab3 100644 (file)
--- a/src/dolphinsortfilterproxymodel.h
+++ b/src/dolphinsortfilterproxymodel.h
@@ -87,13 +87,21 @@ private:
      * Returns the rating for the item with the index \a index. 0 is
      * returned if no item could be found.
      */
      * Returns the rating for the item with the index \a index. 0 is
      * returned if no item could be found.
      */

-    quint32 ratingForIndex(const QModelIndex& index) const;
+    static quint32 ratingForIndex(const QModelIndex& index);
+
+    /**
+     * Returns the tags for the item with the index \a index. If no
+     * tag is applied, a predefined string will be returned.
+     */
+    static QString tagsForIndex(const QModelIndex& index);

 
     static int naturalCompare(const QString& a, const QString& b);
 
 private:
     DolphinView::Sorting m_sorting;
     Qt::SortOrder m_sortOrder;
 
     static int naturalCompare(const QString& a, const QString& b);
 
 private:
     DolphinView::Sorting m_sorting;
     Qt::SortOrder m_sortOrder;

+
+    friend class DolphinItemCategorizer;

 };
 
 DolphinView::Sorting DolphinSortFilterProxyModel::sorting() const
 };
 
 DolphinView::Sorting DolphinSortFilterProxyModel::sorting() const