More changes will follow to fix logic. This makes the stuff compile.

CCMAIL: [email protected]

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

6 files changed, 341 insertions, 58 deletions

diff --git a/src/dolphincategorydrawer.cpp b/src/dolphincategorydrawer.cpp
index 2a5cd9e22..872a0c337 100644
--- a/src/dolphincategorydrawer.cpp
+++ b/src/dolphincategorydrawer.cpp
@@ -53,7 +53,7 @@ void DolphinCategoryDrawer::drawCategory(const QModelIndex &index, int sortRole,
     QRect starRect = option.rect;
 
     int iconSize = KIconLoader::global()->currentSize(KIconLoader::Small);
-    QVariant categoryVariant = index.model()->data(index, KCategorizedSortFilterProxyModel::CategoryRole);
+    QVariant categoryVariant = index.model()->data(index, KCategorizedSortFilterProxyModel::CategoryDisplayRole);
 
     if (!categoryVariant.isValid())
     {
diff --git a/src/dolphinmodel.cpp b/src/dolphinmodel.cpp
index fc68d3977..fad2dd781 100644
--- a/src/dolphinmodel.cpp
+++ b/src/dolphinmodel.cpp
@@ -58,7 +58,7 @@ DolphinModel::~DolphinModel()
 
 QVariant DolphinModel::data(const QModelIndex &index, int role) const
 {
-    if (role == KCategorizedSortFilterProxyModel::CategoryRole)
+    if (role == KCategorizedSortFilterProxyModel::CategoryDisplayRole)
     {
         QString retString;
 
@@ -234,6 +234,341 @@ QVariant DolphinModel::data(const QModelIndex &index, int role) const
 
         return retString;
     }
+    else if (role == KCategorizedSortFilterProxyModel::CategorySortRole)
+    {
+#if 0
+        QVariant retVariant;
+
+        if (!index.isValid())
+        {
+            return retVariant;
+        }
+
+        const KDirModel *dirModel = qobject_cast<const KDirModel*>(index.model());
+        KFileItem item = dirModel->itemForIndex(index);
+
+        switch (index.column()) {
+        case KDirModel::Name: {
+            bool leftFileNameStartsByLetter = false;
+            const QString str(leftFileItem.name().toUpper());
+            const QChar* currA = str.unicode();
+            while (!currA->isNull() && !leftFileNameStartsByLetter) {
+                if (currA->isLetter())
+                    leftFileNameStartsByLetter = true;
+                else if (currA->isDigit()) {
+                    break;
+                } else
+                    ++currA;
+            }
+
+            bool rightFileNameStartsByLetter = false;
+            const QString strb(rightFileItem.name().toUpper());
+            const QChar *currB = strb.unicode();
+            while (!currB->isNull() && !rightFileNameStartsByLetter) {
+                if (currB->isLetter())
+                    rightFileNameStartsByLetter = true;
+                else if (currB->isDigit()) {
+                    break;
+                } else
+                    ++currB;
+            }
+
+            if (!rightFileNameStartsByLetter)
+                return -1;
+
+            if (!leftFileNameStartsByLetter && rightFileNameStartsByLetter)
+                return 1;
+
+            return naturalCompare(*currA, *currB);
+        }
+
+        case KDirModel::Size: {
+            // If we are sorting by size, show folders first. We will sort them
+            // correctly later.
+            if (leftFileItem.isDir() && !rightFileItem.isDir()) {
+                return -1;
+            }
+
+            if (!leftFileItem.isDir() && rightFileItem.isDir()) {
+                return 1;
+            }
+
+            if (leftFileItem.isDir() && rightFileItem.isDir()) {
+                return 0;
+            }
+
+            const int leftFileSize = !leftFileItem.isNull() ? leftFileItem.size() : -1;
+            const int rightFileSize = !rightFileItem.isNull() ? rightFileItem.size() : -1;
+            int leftGroup;
+            int rightGroup;
+
+            if (leftFileSize < 5242880) {
+                leftGroup = 0;
+            } else if (leftFileSize < 10485760) {
+                leftGroup = 1;
+            } else {
+                leftGroup = 2;
+            }
+
+            if (rightFileSize < 5242880) {
+                rightGroup = 0;
+            } else if (rightFileSize < 10485760) {
+                rightGroup = 1;
+            } else {
+                rightGroup = 2;
+            }
+
+            return leftGroup - rightGroup;
+        }
+
+        case KDirModel::ModifiedTime: {
+            KDateTime leftTime = leftFileItem.time(KFileItem::ModificationTime);
+            KDateTime rightTime = rightFileItem.time(KFileItem::ModificationTime);
+
+            if ((leftTime.date().year() == rightTime.date().year()) &&
+                (leftTime.date().month() == rightTime.date().month())) {
+                return 0;
+            }
+
+            if (leftTime > rightTime) {
+                return 1;
+            }
+
+            return -1;
+        }
+
+        case KDirModel::Permissions: {
+            QFileInfo leftFileInfo(leftFileItem.url().pathOrUrl());
+            QFileInfo rightFileInfo(rightFileItem.url().pathOrUrl());
+
+            int leftPermissionsPoints = pointsForPermissions(leftFileInfo);
+            int rightPermissionsPoints = pointsForPermissions(rightFileInfo);
+
+            return leftPermissionsPoints - rightPermissionsPoints;
+        }
+
+        case KDirModel::Owner: {
+            return naturalCompare(leftFileItem.user().toLower(),
+                                rightFileItem.user().toLower());
+        }
+
+        case KDirModel::Group: {
+            return naturalCompare(leftFileItem.group().toLower(),
+                                rightFileItem.group().toLower());
+        }
+
+        case KDirModel::Type: {
+            // If we are sorting by size, show folders first. We will sort them
+            // correctly later.
+            if (leftFileItem.isDir() && !rightFileItem.isDir()) {
+                return -1;
+            } else if (!leftFileItem.isDir() && rightFileItem.isDir()) {
+                return 1;
+            }
+
+            return naturalCompare(leftFileItem.mimeComment().toLower(),
+                                rightFileItem.mimeComment().toLower());
+        }
+
+#ifdef HAVE_NEPOMUK
+        case DolphinView::SortByRating: {
+            const qint32 leftRating = DolphinModel::ratingForIndex(left);
+            const qint32 rightRating = DolphinModel::ratingForIndex(right);
+            return leftRating - rightRating;
+        }
+
+        case DolphinView::SortByTags: {
+            const QString leftTags = DolphinModel::tagsForIndex(left);
+            const QString rightTags = DolphinModel::tagsForIndex(right);
+
+            if (leftTags.isEmpty() && !rightTags.isEmpty())
+                return 1;
+            else if (!leftTags.isEmpty() && rightTags.isEmpty())
+                return -1;
+
+            return naturalCompare(DolphinModel::tagsForIndex(left), DolphinModel::tagsForIndex(right)) < 0;
+        }
+#endif
+
+        default:
+            break;
+
+        }
+#endif
+        QString retString;
+
+        if (!index.isValid())
+        {
+            return retString;
+        }
+
+        const KDirModel *dirModel = qobject_cast<const KDirModel*>(index.model());
+        KFileItem item = dirModel->itemForIndex(index);
+
+        switch (index.column())
+        {
+            case KDirModel::Name:
+            {
+                // KDirModel checks columns to know to which role are
+                // we talking about
+                QModelIndex theIndex = index.model()->index(index.row(),
+                                                            KDirModel::Name,
+                                                            index.parent());
+
+                if (!theIndex.isValid()) {
+                    return retString;
+                }
+
+                QVariant data = theIndex.model()->data(theIndex, Qt::DisplayRole);
+                if (data.toString().size())
+                {
+                    if (!item.isHidden() && data.toString().at(0).isLetter())
+                        retString = data.toString().toUpper().at(0);
+                    else if (item.isHidden() && data.toString().at(0) == '.' &&
+                            data.toString().at(1).isLetter())
+                        retString = data.toString().toUpper().at(1);
+                    else if (item.isHidden() && data.toString().at(0) == '.' &&
+                            !data.toString().at(1).isLetter())
+                        retString = i18nc("@title:group Name", "Others");
+                    else if (item.isHidden() && data.toString().at(0) != '.')
+                        retString = data.toString().toUpper().at(0);
+                    else if (item.isHidden())
+                        retString = data.toString().toUpper().at(0);
+                    else
+                    {
+                        bool validCategory = false;
+
+                        const QString str(data.toString().toUpper());
+                        const QChar* currA = str.unicode();
+                        while (!currA->isNull() && !validCategory) {
+                            if (currA->isLetter())
+                                validCategory = true;
+                            else if (currA->isDigit())
+                                return i18nc("@title:group", "Others");
+                            else
+                                ++currA;
+                        }
+
+                        if (!validCategory)
+                            retString = i18nc("@title:group Name", "Others");
+                        else
+                            retString = *currA;
+                    }
+                }
+                break;
+            }
+
+            case KDirModel::Size: {
+                const int fileSize = !item.isNull() ? item.size() : -1;
+                if (!item.isNull() && item.isDir()) {
+                    retString = i18nc("@title:group Size", "Folders");
+                } else if (fileSize < 5242880) {
+                    retString = i18nc("@title:group Size", "Small");
+                } else if (fileSize < 10485760) {
+                    retString = i18nc("@title:group Size", "Medium");
+                } else {
+                    retString = i18nc("@title:group Size", "Big");
+                }
+                break;
+            }
+
+            case KDirModel::ModifiedTime:
+            {
+                KDateTime modifiedTime;
+                modifiedTime.setTime_t(item.time(KIO::UDSEntry::UDS_MODIFICATION_TIME));
+                modifiedTime = modifiedTime.toLocalZone();
+
+                retString = modifiedTime.toString(i18nc("Prints out the month and year: %B is full month name in current locale, and %Y is full year number", "%B, %Y"));
+                break;
+            }
+
+            case KDirModel::Permissions:
+            {
+                QString user;
+                QString group;
+                QString others;
+
+                QFileInfo info(item.url().pathOrUrl());
+
+                if (info.permission(QFile::ReadUser))
+                    user = i18n("Read, ");
+
+                if (info.permission(QFile::WriteUser))
+                    user += i18n("Write, ");
+
+                if (info.permission(QFile::ExeUser))
+                    user += i18n("Execute, ");
+
+                if (user.isEmpty())
+                    user = i18n("Forbidden");
+                else
+                    user = user.mid(0, user.count() - 2);
+
+                if (info.permission(QFile::ReadGroup))
+                    group = i18n("Read, ");
+
+                if (info.permission(QFile::WriteGroup))
+                    group += i18n("Write, ");
+
+                if (info.permission(QFile::ExeGroup))
+                    group += i18n("Execute, ");
+
+                if (group.isEmpty())
+                    group = i18n("Forbidden");
+                else
+                    group = group.mid(0, group.count() - 2);
+
+                if (info.permission(QFile::ReadOther))
+                    others = i18n("Read, ");
+
+                if (info.permission(QFile::WriteOther))
+                    others += i18n("Write, ");
+
+                if (info.permission(QFile::ExeOther))
+                    others += i18n("Execute, ");
+
+                if (others.isEmpty())
+                    others = i18n("Forbidden");
+                else
+                    others = others.mid(0, others.count() - 2);
+
+                retString = i18nc("This shows files and folders permissions: user, group and others", "(User: %1) (Group: %2) (Others: %3)", user, group, others);
+                break;
+            }
+
+            case KDirModel::Owner:
+                retString = item.user();
+                break;
+
+            case KDirModel::Group:
+                retString = item.group();
+                break;
+
+            case KDirModel::Type:
+                retString = item.mimeComment();
+                break;
+
+#ifdef HAVE_NEPOMUK
+            case DolphinModel::Rating: {
+                const quint32 rating = ratingForIndex(index);
+
+                retString = QString::number(rating);
+                break;
+            }
+
+            case DolphinModel::Tags: {
+                retString = tagsForIndex(index);
+
+                if (retString.isEmpty())
+                    retString = i18nc("@title:group Tags", "Not yet tagged");
+
+                break;
+            }
+#endif
+        }
+
+        return retString;
+    }
 
     return KDirModel::data(index, role);
 }
diff --git a/src/dolphinsortfilterproxymodel.cpp b/src/dolphinsortfilterproxymodel.cpp
index d62072830..563d1e4e8 100644
--- a/src/dolphinsortfilterproxymodel.cpp
+++ b/src/dolphinsortfilterproxymodel.cpp
@@ -93,43 +93,6 @@ DolphinView::Sorting DolphinSortFilterProxyModel::sortingForColumn(int column)
     return sortingTypeTable[column];
 }
 
-int DolphinSortFilterProxyModel::compareCategories(const QModelIndex &left,
-                                                   const QModelIndex &right) const
-{
-#ifdef HAVE_NEPOMUK
-    DolphinModel* dolphinModel = static_cast<DolphinModel*>(sourceModel());
-
-    const KFileItem leftFileItem  = dolphinModel->itemForIndex(left);
-    const KFileItem rightFileItem = dolphinModel->itemForIndex(right);
-
-    switch (left.column()) {
-
-    case DolphinView::SortByRating: {
-        const qint32 leftRating = DolphinModel::ratingForIndex(left);
-        const qint32 rightRating = DolphinModel::ratingForIndex(right);
-        return leftRating - rightRating;
-    }
-
-    case DolphinView::SortByTags: {
-        const QString leftTags = DolphinModel::tagsForIndex(left);
-        const QString rightTags = DolphinModel::tagsForIndex(right);
-
-        if (leftTags.isEmpty() && !rightTags.isEmpty())
-            return 1;
-        else if (!leftTags.isEmpty() && rightTags.isEmpty())
-            return -1;
-
-        return naturalCompare(DolphinModel::tagsForIndex(left), DolphinModel::tagsForIndex(right)) < 0;
-    }
-
-    default:
-        break;
-
-    }
-#endif
-    return KDirSortFilterProxyModel::compareCategories(left, right);
-}
-
 bool DolphinSortFilterProxyModel::subSortLessThan(const QModelIndex& left,
                                                   const QModelIndex& right) const
 {
diff --git a/src/dolphinsortfilterproxymodel.h b/src/dolphinsortfilterproxymodel.h
index a1dd5ff18..a421b3536 100644
--- a/src/dolphinsortfilterproxymodel.h
+++ b/src/dolphinsortfilterproxymodel.h
@@ -72,21 +72,6 @@ public:
      */
     static DolphinView::Sorting sortingForColumn(int column);
 
-    /**
-     * This method is essential for the categorized view.
-     * It does a basic sorting for finding out categories
-     * and their order. The lessThan() method will be applied for
-     * each category.
-     *
-     * The easy explanation is that not always folders go first.
-     * Imagine we sort by rating. Categories will be created by 10 stars,
-     * 9 stars, 8 stars, ... but a category with only a file rated by 10
-     * will go before a category with a folder with rating 8.
-     * That's the main reason for having the lessThanGeneralPurpose() method.
-     */
-    virtual int compareCategories(const QModelIndex &left,
-                                  const QModelIndex &right) const;
-
 signals:
     void sortingRoleChanged();
 
diff --git a/src/kcategorizedview.cpp b/src/kcategorizedview.cpp
index 894da2cae..7018b33bc 100644
--- a/src/kcategorizedview.cpp
+++ b/src/kcategorizedview.cpp
@@ -361,7 +361,7 @@ void KCategorizedView::Private::drawNewCategory(const QModelIndex &index,
     }
 
     QStyleOption optionCopy = option;
-    const QString category = proxyModel->data(index, KCategorizedSortFilterProxyModel::CategoryRole).toString();
+    const QString category = proxyModel->data(index, KCategorizedSortFilterProxyModel::CategoryDisplayRole).toString();
 
     optionCopy.state &= ~QStyle::State_Selected;
 
@@ -1329,7 +1329,7 @@ void KCategorizedView::rowsInsertedArtifficial(const QModelIndex &parent,
     }
 
     // Add all elements mapped to the source model and explore categories
-    QString prevCategory = d->proxyModel->data(d->proxyModel->index(0, d->proxyModel->sortColumn()), KCategorizedSortFilterProxyModel::CategoryRole).toString();
+    QString prevCategory = d->proxyModel->data(d->proxyModel->index(0, d->proxyModel->sortColumn()), KCategorizedSortFilterProxyModel::CategoryDisplayRole).toString();
     QString lastCategory = prevCategory;
     QModelIndexList modelIndexList;
     struct Private::ElementInfo elementInfo;
@@ -1346,7 +1346,7 @@ void KCategorizedView::rowsInsertedArtifficial(const QModelIndex &parent,
 
         d->modelIndexList << index;
 
-        lastCategory = d->proxyModel->data(index, KCategorizedSortFilterProxyModel::CategoryRole).toString();
+        lastCategory = d->proxyModel->data(index, KCategorizedSortFilterProxyModel::CategoryDisplayRole).toString();
 
         elementInfo.category = lastCategory;
 
diff --git a/src/kcategorydrawer.cpp b/src/kcategorydrawer.cpp
index da84de83c..d0c671915 100644
--- a/src/kcategorydrawer.cpp
+++ b/src/kcategorydrawer.cpp
@@ -38,7 +38,7 @@ void KCategoryDrawer::drawCategory(const QModelIndex &index,
                                    const QStyleOption &option,
                                    QPainter *painter) const
 {
-    const QString category = index.model()->data(index, KCategorizedSortFilterProxyModel::CategoryRole).toString();
+    const QString category = index.model()->data(index, KCategorizedSortFilterProxyModel::CategoryDisplayRole).toString();
 
     QColor color;