Additionally to sorting by name, size and date it is now possible to sort by permissi...

svn path=/trunk/playground/utils/dolphin/; revision=631058

diff --git a/src/dolphindetailsview.cpp b/src/dolphindetailsview.cpp
index f434936dc0de3c7b9c9948b087934a0c972405b4..24692b5a83c20ca63c55858ec23cbb17b1e6051c 100644 (file)
--- a/src/dolphindetailsview.cpp
+++ b/src/dolphindetailsview.cpp
@@ -21,6 +21,7 @@
 #include "dolphindetailsview.h"
 
 #include "dolphinmainwindow.h"
+#include "dolphinsortfilterproxymodel.h"
 #include "dolphinview.h"
 #include "viewproperties.h"
 
@@ -142,33 +143,21 @@ void DolphinDetailsView::synchronizeSortingState(int column)
     // The sorting has already been changed in QTreeView if this slot is
     // invoked, but Dolphin was not informed about this. This is bypassed by changing
     // the sorting and sort order to a temporary other value and readjust it again.
-    const bool update = (column == KDirModel::Name) || (column == KDirModel::Size) ||
-                        (column == KDirModel::ModifiedTime);
-    if (update) {
-        DolphinView::Sorting sorting = DolphinView::SortByName;
-        switch (column) {
-            case KDirModel::Size:         sorting = DolphinView::SortBySize; break;
-            case KDirModel::ModifiedTime: sorting = DolphinView::SortByDate; break;
-            case KDirModel::Name:
-            default: break;
-        }
-
-        const Qt::SortOrder sortOrder = header()->sortIndicatorOrder();
-
-        // temporary adjust the sorting and sort order to different values...
-        const DolphinView::Sorting tempSorting = (sorting == DolphinView::SortByName) ?
-                                                 DolphinView::SortBySize :
-                                                 DolphinView::SortByName;
-        m_dolphinView->setSorting(tempSorting);
-        const Qt::SortOrder tempSortOrder = (sortOrder == Qt::Ascending) ?
-                                            Qt::Descending : Qt::Ascending;
-        m_dolphinView->setSortOrder(tempSortOrder);
-
-        // ... so that setting them again results in storing the new setting.
-        m_dolphinView->setSorting(sorting);
-        m_dolphinView->setSortOrder(sortOrder);
-    }
-
+    DolphinView::Sorting sorting = DolphinSortFilterProxyModel::sortingForColumn(column);
+    const Qt::SortOrder sortOrder = header()->sortIndicatorOrder();
+
+    // temporary adjust the sorting and sort order to different values...
+    const DolphinView::Sorting tempSorting = (sorting == DolphinView::SortByName) ?
+                                             DolphinView::SortBySize :
+                                             DolphinView::SortByName;
+    m_dolphinView->setSorting(tempSorting);
+    const Qt::SortOrder tempSortOrder = (sortOrder == Qt::Ascending) ?
+                                        Qt::Descending : Qt::Ascending;
+    m_dolphinView->setSortOrder(tempSortOrder);
+
+    // ... so that setting them again results in storing the new setting.
+    m_dolphinView->setSorting(sorting);
+    m_dolphinView->setSortOrder(sortOrder);
 }
 
 #include "dolphindetailsview.moc"

diff --git a/src/dolphinmainwindow.cpp b/src/dolphinmainwindow.cpp
index 5e9948939fe61489dd807bff457c7371f90d7045..262bc8558f9f8891a0fa33d5f92d8b3ef47d8a5e 100644 (file)
--- a/src/dolphinmainwindow.cpp
+++ b/src/dolphinmainwindow.cpp
@@ -256,6 +256,15 @@ void DolphinMainWindow::slotSortingChanged(DolphinView::Sorting sorting)
         case DolphinView::SortByDate:\r
             action = actionCollection()->action("by_date");\r
             break;\r
+        case DolphinView::SortByPermissions:\r
+            action = actionCollection()->action("by_permissions");\r
+            break;\r
+        case DolphinView::SortByOwner:\r
+            action = actionCollection()->action("by_owner");\r
+            break;\r
+        case DolphinView::SortByGroup:\r
+            action = actionCollection()->action("by_group");\r
+            break;\r
         default:\r
             break;\r
     }\r
@@ -635,6 +644,21 @@ void DolphinMainWindow::sortByDate()
     m_activeView->setSorting(DolphinView::SortByDate);\r
 }\r
 \r
+void DolphinMainWindow::sortByPermissions()\r
+{\r
+    m_activeView->setSorting(DolphinView::SortByPermissions);\r
+}\r
+\r
+void DolphinMainWindow::sortByOwner()\r
+{\r
+    m_activeView->setSorting(DolphinView::SortByOwner);\r
+}\r
+\r
+void DolphinMainWindow::sortByGroup()\r
+{\r
+    m_activeView->setSorting(DolphinView::SortByGroup);\r
+}\r
+\r
 void DolphinMainWindow::toggleSortOrder()\r
 {\r
     const Qt::SortOrder order = (m_activeView->sortOrder() == Qt::Ascending) ?\r
@@ -1035,10 +1059,25 @@ void DolphinMainWindow::setupActions()
     sortByDate->setText(i18n("By Date"));\r
     connect(sortByDate, SIGNAL(triggered()), this, SLOT(sortByDate()));\r
 \r
+    KToggleAction* sortByPermissions = actionCollection()->add<KToggleAction>("by_permissions");\r
+    sortByPermissions->setText(i18n("By Permissions"));\r
+    connect(sortByPermissions, SIGNAL(triggered()), this, SLOT(sortByPermissions()));\r
+\r
+    KToggleAction* sortByOwner = actionCollection()->add<KToggleAction>("by_owner");\r
+    sortByOwner->setText(i18n("By Owner"));\r
+    connect(sortByOwner, SIGNAL(triggered()), this, SLOT(sortByOwner()));\r
+\r
+    KToggleAction* sortByGroup = actionCollection()->add<KToggleAction>("by_group");\r
+    sortByGroup->setText(i18n("By Group"));\r
+    connect(sortByGroup, SIGNAL(triggered()), this, SLOT(sortByGroup()));\r
+\r
     QActionGroup* sortGroup = new QActionGroup(this);\r
     sortGroup->addAction(sortByName);\r
     sortGroup->addAction(sortBySize);\r
     sortGroup->addAction(sortByDate);\r
+    sortGroup->addAction(sortByPermissions);\r
+    sortGroup->addAction(sortByOwner);\r
+    sortGroup->addAction(sortByGroup);\r
 \r
     KToggleAction* sortDescending = actionCollection()->add<KToggleAction>("descending");\r
     sortDescending->setText(i18n("Descending"));\r

diff --git a/src/dolphinmainwindow.h b/src/dolphinmainwindow.h
index bc285a4db4c617cc7211ecb305c434451758477c..4cfe31077138480461569740c886ecd1e12e5d81 100644 (file)
--- a/src/dolphinmainwindow.h
+++ b/src/dolphinmainwindow.h
@@ -217,6 +217,15 @@ private slots:
     /** The sorting of the current view should be done by the date. */
     void sortByDate();
 
+    /** The sorting of the current view should be done by the permissions. */
+    void sortByPermissions();
+
+    /** The sorting of the current view should be done by the owner. */
+    void sortByOwner();
+
+    /** The sorting of the current view should be done by the group. */
+    void sortByGroup();
+
     /** Switches between an ascending and descending sorting order. */
     void toggleSortOrder();
 

diff --git a/src/dolphinsortfilterproxymodel.cpp b/src/dolphinsortfilterproxymodel.cpp
index 20b8bf164fcef443497241886a010c92324fadc8..a1dc3e3d0751d1a3215bcd2980d787776e1d95ac 100644 (file)
--- a/src/dolphinsortfilterproxymodel.cpp
+++ b/src/dolphinsortfilterproxymodel.cpp
@@ -24,17 +24,23 @@
 #include <kdirmodel.h>
 #include <kfileitem.h>
 
-static const int dolphinMapSize = 3;
+static const int dolphinMapSize = 6;
 static int dolphinViewToDirModelColumn[] = {
-    KDirModel::Name,        // DolphinView::SortByName
-    KDirModel::Size,        // DolphinView::SortBySize
-    KDirModel::ModifiedTime // DolphinView::SortByDate
+    KDirModel::Name,         // DolphinView::SortByName
+    KDirModel::Size,         // DolphinView::SortBySize
+    KDirModel::ModifiedTime, // DolphinView::SortByDate
+    KDirModel::Permissions,  // DolphinView::SortByPermissions
+    KDirModel::Owner,        // DolphinView::SortByOwner
+    KDirModel::Group         // DolphinView::SortByGroup
 };
 
 static DolphinView::Sorting dirModelColumnToDolphinView[] = {
-    DolphinView::SortByName, // KDirModel::Name
-    DolphinView::SortBySize, // KDirModel::Size
-    DolphinView::SortByDate  // KDirModel::ModifiedTime
+    DolphinView::SortByName,        // KDirModel::Name
+    DolphinView::SortBySize,        // KDirModel::Size
+    DolphinView::SortByDate,        // KDirModel::ModifiedTime
+    DolphinView::SortByPermissions, // KDirModel::Permissions
+    DolphinView::SortByOwner,       // KDirModel::Owner
+    DolphinView::SortByGroup        // KDirModel::Group
 };
 
 
@@ -81,6 +87,14 @@ void DolphinSortFilterProxyModel::sort(int column, Qt::SortOrder sortOrder)
     QSortFilterProxyModel::sort(column, sortOrder);
 }
 
+DolphinView::Sorting DolphinSortFilterProxyModel::sortingForColumn(int column)
+{
+    if ((column >= 0) && (column <= dolphinMapSize)) {
+        return dirModelColumnToDolphinView[column];
+    }
+    return DolphinView::SortByName;
+}
+
 bool DolphinSortFilterProxyModel::lessThan(const QModelIndex& left,
                                            const QModelIndex& right) const
 {

diff --git a/src/dolphinsortfilterproxymodel.h b/src/dolphinsortfilterproxymodel.h
index d73f4579bba7cb622ed9af1bfc22d44b62479e4e..87d074e07b0ffeaeba60e71471caa92bd88314bc 100644 (file)
--- a/src/dolphinsortfilterproxymodel.h
+++ b/src/dolphinsortfilterproxymodel.h
@@ -61,6 +61,13 @@ public:
     virtual void sort(int column,
                       Qt::SortOrder order = Qt::AscendingOrder);
 
+    /**
+     * Helper method to get the DolphinView::Sorting type for a given
+     * column \a column. If the column is smaller 0 or greater than the
+     * available columns, DolphinView::SortByName is returned.
+     */
+    static DolphinView::Sorting sortingForColumn(int column);
+
 protected:
     virtual bool lessThan(const QModelIndex& left,
                           const QModelIndex& right) const;

diff --git a/src/dolphinui.rc b/src/dolphinui.rc
index 9bdf9143a93d148be759a3f8a8f91961128094c5..601c9f859d1f8f07a3893e3ce9e2e660206aa7cc 100644 (file)
--- a/src/dolphinui.rc
+++ b/src/dolphinui.rc
@@ -26,6 +26,9 @@
     <Action name="by_name" />
     <Action name="by_size" />
     <Action name="by_date" />
+    <Action name="by_permissions" />
+    <Action name="by_owner" />
+    <Action name="by_group" />
     <Separator/>
     <Action name="descending" />
    </Menu>

diff --git a/src/dolphinview.h b/src/dolphinview.h
index cc9f11dc1675d54ae4c03e595ab0464664a92194..dbd6622d72c985a0498a02d53a072426f247e549 100644 (file)
--- a/src/dolphinview.h
+++ b/src/dolphinview.h
@@ -94,9 +94,12 @@ public:
     enum Sorting
     {
         SortByName = 0,
-        SortBySize = 1,
-        SortByDate = 2,
-        MaxSortEnum = SortByDate
+        SortBySize,
+        SortByDate,
+        SortByPermissions,
+        SortByOwner,
+        SortByGroup,
+        MaxSortEnum = SortByGroup
     };
 
     DolphinView(DolphinMainWindow* mainwindow,

diff --git a/src/viewpropertiesdialog.cpp b/src/viewpropertiesdialog.cpp
index dea4020f2ec8e8a2bd763b1ccaa57e2d2c1ce3f8..48e565a0910157f800b411eeb3055527f6452af3 100644 (file)
--- a/src/viewpropertiesdialog.cpp
+++ b/src/viewpropertiesdialog.cpp
@@ -22,6 +22,7 @@
 #include "viewpropsprogressinfo.h"
 #include "dolphinview.h"
 #include "dolphinsettings.h"
+#include "dolphinsortfilterproxymodel.h"
 #include "generalsettings.h"
 #include "viewproperties.h"
 
@@ -78,14 +79,10 @@ ViewPropertiesDialog::ViewPropertiesDialog(DolphinView* dolphinView) :
     m_sorting->addItem("By Name");
     m_sorting->addItem("By Size");
     m_sorting->addItem("By Date");
-    int sortingIdx = 0;
-    switch (m_viewProps->sorting()) {
-        case DolphinView::SortByName: sortingIdx = 0; break;
-        case DolphinView::SortBySize: sortingIdx = 1; break;
-        case DolphinView::SortByDate: sortingIdx = 2; break;
-        default: break;
-    }
-    m_sorting->setCurrentIndex(sortingIdx);
+    m_sorting->addItem("By Permissions");
+    m_sorting->addItem("By Owner");
+    m_sorting->addItem("By Group");
+    m_sorting->setCurrentIndex(m_viewProps->sorting());
 
     QLabel* sortOrderLabel = new QLabel(i18n("Sort order:"), propsBox);
     m_sortOrder = new QComboBox(propsBox);
@@ -172,12 +169,7 @@ void ViewPropertiesDialog::slotViewModeChanged(int index)
 
 void ViewPropertiesDialog::slotSortingChanged(int index)
 {
-    DolphinView::Sorting sorting = DolphinView::SortByName;
-    switch (index) {
-        case 1: sorting = DolphinView::SortBySize; break;
-        case 2: sorting = DolphinView::SortByDate; break;
-        default: break;
-    }
+    const DolphinView::Sorting sorting = DolphinSortFilterProxyModel::sortingForColumn(index);
     m_viewProps->setSorting(sorting);
     m_isDirty = true;
 }