Use sub-menus for the "Sort By"- and "Additional Information"-menu

[dolphin.git] / src / views / dolphinviewactionhandler.cpp

diff --git a/src/views/dolphinviewactionhandler.cpp b/src/views/dolphinviewactionhandler.cpp
index 87e828dfa8b0851bcf9539f3705a6486f721fb23..aead11d2502854e4631bac8e23a11609eda854b3 100644 (file)
--- a/src/views/dolphinviewactionhandler.cpp
+++ b/src/views/dolphinviewactionhandler.cpp
@@ -1,5 +1,6 @@
 /***************************************************************************
  *   Copyright (C) 2008 by David Faure <faure@kde.org>                     *
 /***************************************************************************
  *   Copyright (C) 2008 by David Faure <faure@kde.org>                     *

+ *   Copyright (C) 2012 by Peter Penz <peter.penz19@gmail.com>             *

  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *


@@ -19,7 +20,6 @@
 
 #include "dolphinviewactionhandler.h"
 
 
 #include "dolphinviewactionhandler.h"
 

-#include "additionalinfoaccessor.h"

 #include "settings/viewpropertiesdialog.h"
 #include "views/dolphinview.h"
 #include "views/zoomlevelinfo.h"
 #include "settings/viewpropertiesdialog.h"
 #include "views/dolphinview.h"
 #include "views/zoomlevelinfo.h"


@@ -28,8 +28,9 @@
 #include <KAction>
 #include <KActionCollection>
 #include <KActionMenu>
 #include <KAction>
 #include <KActionCollection>
 #include <KActionMenu>

-#include <KFileItemDelegate>
+#include <kitemviews/kfileitemmodel.h>

 #include <KLocale>
 #include <KLocale>

+#include <KMenu>

 #include <KNewFileMenu>
 #include <KSelectAction>
 #include <KToggleAction>
 #include <KNewFileMenu>
 #include <KSelectAction>
 #include <KToggleAction>


@@ -38,10 +39,12 @@
 
 #include <KDebug>
 
 
 #include <KDebug>
 

-DolphinViewActionHandler::DolphinViewActionHandler(KActionCollection* collection, QObject* parent)
-    : QObject(parent),
-      m_actionCollection(collection),
-      m_currentView(0)
+DolphinViewActionHandler::DolphinViewActionHandler(KActionCollection* collection, QObject* parent) :
+    QObject(parent),
+    m_actionCollection(collection),
+    m_currentView(0),
+    m_sortByActions(),
+    m_visibleRoles()

 {
     Q_ASSERT(m_actionCollection);
     createActions();
 {
     Q_ASSERT(m_actionCollection);
     createActions();


@@ -57,7 +60,7 @@ void DolphinViewActionHandler::setCurrentView(DolphinView* view)
 
     m_currentView = view;
 
 
     m_currentView = view;
 

-    connect(view, SIGNAL(modeChanged(DolphinView::Mode, DolphinView::Mode)),
+    connect(view, SIGNAL(modeChanged(DolphinView::Mode,DolphinView::Mode)),

             this, SLOT(updateViewActions()));
     connect(view, SIGNAL(previewsShownChanged(bool)),
             this, SLOT(slotPreviewsShownChanged(bool)));
             this, SLOT(updateViewActions()));
     connect(view, SIGNAL(previewsShownChanged(bool)),
             this, SLOT(slotPreviewsShownChanged(bool)));


@@ -65,18 +68,16 @@ void DolphinViewActionHandler::setCurrentView(DolphinView* view)
             this, SLOT(slotSortOrderChanged(Qt::SortOrder)));
     connect(view, SIGNAL(sortFoldersFirstChanged(bool)),
             this, SLOT(slotSortFoldersFirstChanged(bool)));
             this, SLOT(slotSortOrderChanged(Qt::SortOrder)));
     connect(view, SIGNAL(sortFoldersFirstChanged(bool)),
             this, SLOT(slotSortFoldersFirstChanged(bool)));

-    connect(view, SIGNAL(additionalInfoListChanged(QList<DolphinView::AdditionalInfo>,
-                                                   QList<DolphinView::AdditionalInfo>)),
-            this, SLOT(slotAdditionalInfoListChanged(QList<DolphinView::AdditionalInfo>,
-                                                     QList<DolphinView::AdditionalInfo>)));
-    connect(view, SIGNAL(categorizedSortingChanged(bool)),
-            this, SLOT(slotCategorizedSortingChanged(bool)));
+    connect(view, SIGNAL(visibleRolesChanged(QList<QByteArray>,QList<QByteArray>)),
+            this, SLOT(slotVisibleRolesChanged(QList<QByteArray>,QList<QByteArray>)));
+    connect(view, SIGNAL(groupedSortingChanged(bool)),
+            this, SLOT(slotGroupedSortingChanged(bool)));

     connect(view, SIGNAL(hiddenFilesShownChanged(bool)),
             this, SLOT(slotHiddenFilesShownChanged(bool)));
     connect(view, SIGNAL(hiddenFilesShownChanged(bool)),
             this, SLOT(slotHiddenFilesShownChanged(bool)));

-    connect(view, SIGNAL(sortingChanged(DolphinView::Sorting)),
-            this, SLOT(slotSortingChanged(DolphinView::Sorting)));
-    connect(view, SIGNAL(zoomLevelChanged(int, int)),
-            this, SLOT(slotZoomLevelChanged(int, int)));
+    connect(view, SIGNAL(sortRoleChanged(QByteArray)),
+            this, SLOT(slotSortRoleChanged(QByteArray)));
+    connect(view, SIGNAL(zoomLevelChanged(int,int)),
+            this, SLOT(slotZoomLevelChanged(int,int)));

 }
 
 DolphinView* DolphinViewActionHandler::currentView()
 }
 
 DolphinView* DolphinViewActionHandler::currentView()


@@ -106,8 +107,8 @@ void DolphinViewActionHandler::createActions()
     moveToTrash->setText(i18nc("@action:inmenu File", "Move to Trash"));
     moveToTrash->setIcon(KIcon("user-trash"));
     moveToTrash->setShortcut(QKeySequence::Delete);
     moveToTrash->setText(i18nc("@action:inmenu File", "Move to Trash"));
     moveToTrash->setIcon(KIcon("user-trash"));
     moveToTrash->setShortcut(QKeySequence::Delete);

-    connect(moveToTrash, SIGNAL(triggered(Qt::MouseButtons, Qt::KeyboardModifiers)),
-            this, SLOT(slotTrashActivated(Qt::MouseButtons, Qt::KeyboardModifiers)));
+    connect(moveToTrash, SIGNAL(triggered(Qt::MouseButtons,Qt::KeyboardModifiers)),
+            this, SLOT(slotTrashActivated(Qt::MouseButtons,Qt::KeyboardModifiers)));

 
     KAction* deleteAction = m_actionCollection->addAction("delete");
     deleteAction->setIcon(KIcon("edit-delete"));
 
     KAction* deleteAction = m_actionCollection->addAction("delete");
     deleteAction->setIcon(KIcon("edit-delete"));


@@ -169,8 +170,7 @@ void DolphinViewActionHandler::createActions()
     connect(sortFoldersFirst, SIGNAL(triggered()), this, SLOT(toggleSortFoldersFirst()));
 
     // View -> Sort By
     connect(sortFoldersFirst, SIGNAL(triggered()), this, SLOT(toggleSortFoldersFirst()));
 
     // View -> Sort By

-    QActionGroup* sortByActionGroup = createSortByActionGroup();
-    connect(sortByActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(slotSortTriggered(QAction*)));
+    QActionGroup* sortByActionGroup = createFileItemRolesActionGroup("sort_by_");

 
     KActionMenu* sortByActionMenu = m_actionCollection->add<KActionMenu>("sort");
     sortByActionMenu->setText(i18nc("@action:inmenu View", "Sort By"));
 
     KActionMenu* sortByActionMenu = m_actionCollection->add<KActionMenu>("sort");
     sortByActionMenu->setText(i18nc("@action:inmenu View", "Sort By"));


@@ -184,19 +184,20 @@ void DolphinViewActionHandler::createActions()
     sortByActionMenu->addAction(sortFoldersFirst);
 
     // View -> Additional Information
     sortByActionMenu->addAction(sortFoldersFirst);
 
     // View -> Additional Information

-    QActionGroup* additionalInfoGroup = createAdditionalInformationActionGroup();
-    connect(additionalInfoGroup, SIGNAL(triggered(QAction*)), this, SLOT(toggleAdditionalInfo(QAction*)));
-
-    KActionMenu* additionalInfoMenu = m_actionCollection->add<KActionMenu>("additional_info");
-    additionalInfoMenu->setText(i18nc("@action:inmenu View", "Additional Information"));
-    additionalInfoMenu->setDelayed(false);
-    foreach (QAction* action, additionalInfoGroup->actions()) {
-        additionalInfoMenu->addAction(action);
+    QActionGroup* visibleRolesGroup = createFileItemRolesActionGroup("show_");
+
+    KActionMenu* visibleRolesMenu = m_actionCollection->add<KActionMenu>("additional_info");
+    visibleRolesMenu->setText(i18nc("@action:inmenu View", "Additional Information"));
+    visibleRolesMenu->setDelayed(false);
+
+    foreach (QAction* action, visibleRolesGroup->actions()) {
+        visibleRolesMenu->addAction(action);

     }
 
     KToggleAction* showInGroups = m_actionCollection->add<KToggleAction>("show_in_groups");
     }
 
     KToggleAction* showInGroups = m_actionCollection->add<KToggleAction>("show_in_groups");

+    showInGroups->setIcon(KIcon("view-group"));

     showInGroups->setText(i18nc("@action:inmenu View", "Show in Groups"));
     showInGroups->setText(i18nc("@action:inmenu View", "Show in Groups"));

-    connect(showInGroups, SIGNAL(triggered(bool)), this, SLOT(toggleSortCategorization(bool)));
+    connect(showInGroups, SIGNAL(triggered(bool)), this, SLOT(toggleGroupedSorting(bool)));

 
     KToggleAction* showHiddenFiles = m_actionCollection->add<KToggleAction>("show_hidden_files");
     showHiddenFiles->setText(i18nc("@action:inmenu View", "Show Hidden Files"));
 
     KToggleAction* showHiddenFiles = m_actionCollection->add<KToggleAction>("show_hidden_files");
     showHiddenFiles->setText(i18nc("@action:inmenu View", "Show Hidden Files"));


@@ -208,53 +209,70 @@ void DolphinViewActionHandler::createActions()
     connect(adjustViewProps, SIGNAL(triggered()), this, SLOT(slotAdjustViewProperties()));
 }
 
     connect(adjustViewProps, SIGNAL(triggered()), this, SLOT(slotAdjustViewProperties()));
 }
 

-QActionGroup* DolphinViewActionHandler::createAdditionalInformationActionGroup()
+QActionGroup* DolphinViewActionHandler::createFileItemRolesActionGroup(const QString& groupPrefix)

 {
 {

-    QActionGroup* additionalInfoGroup = new QActionGroup(m_actionCollection);
-    additionalInfoGroup->setExclusive(false);
-
-    KActionMenu* showInformationMenu = m_actionCollection->add<KActionMenu>("additional_info");
-    showInformationMenu->setText(i18nc("@action:inmenu View", "Additional Information"));
-    showInformationMenu->setDelayed(false);
+    const bool isSortGroup = (groupPrefix == QLatin1String("sort_by_"));
+    Q_ASSERT(isSortGroup || (!isSortGroup && groupPrefix == QLatin1String("show_")));

 
 

-    const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
-
-    const QList<DolphinView::AdditionalInfo> infoList = infoAccessor.keys();
-    foreach (DolphinView::AdditionalInfo info, infoList) {
-        const QString name = infoAccessor.actionCollectionName(info, AdditionalInfoAccessor::AdditionalInfoType);
-        KToggleAction* action = m_actionCollection->add<KToggleAction>(name);
-        action->setText(infoAccessor.translation(info));
-        action->setData(info);
-        action->setActionGroup(additionalInfoGroup);
+    QActionGroup* rolesActionGroup = new QActionGroup(m_actionCollection);
+    rolesActionGroup->setExclusive(isSortGroup);
+    if (isSortGroup) {
+        connect(rolesActionGroup, SIGNAL(triggered(QAction*)),
+                this, SLOT(slotSortTriggered(QAction*)));
+    } else {
+        connect(rolesActionGroup, SIGNAL(triggered(QAction*)),
+                this, SLOT(toggleVisibleRole(QAction*)));

     }
 
     }
 

-    return additionalInfoGroup;
-}
+    QString groupName;
+    KActionMenu* groupMenu = 0;
+    QActionGroup* groupMenuGroup = 0;

 
 

-Q_DECLARE_METATYPE(DolphinView::Sorting)
+    const QList<KFileItemModel::RoleInfo> rolesInfo = KFileItemModel::rolesInformation();
+    foreach (const KFileItemModel::RoleInfo& info, rolesInfo) {
+        if (!isSortGroup && info.role == "name") {
+            // It should not be possible to hide the "name" role
+            continue;
+        }

 
 

-QActionGroup* DolphinViewActionHandler::createSortByActionGroup()
-{
-    QActionGroup* sortByActionGroup = new QActionGroup(m_actionCollection);
-    sortByActionGroup->setExclusive(true);
+        KToggleAction* action = 0;
+        const QString name = groupPrefix + info.role;
+        if (info.group.isEmpty()) {
+            action = m_actionCollection->add<KToggleAction>(name);
+            action->setActionGroup(rolesActionGroup);
+        } else {
+            if (!groupMenu || info.group != groupName) {
+                groupName = info.group;
+                groupMenu = m_actionCollection->add<KActionMenu>(groupName);
+                groupMenu->setText(groupName);
+                groupMenu->setActionGroup(rolesActionGroup);
+
+                groupMenuGroup = new QActionGroup(groupMenu);
+                groupMenuGroup->setExclusive(isSortGroup);
+                if (isSortGroup) {
+                    connect(groupMenuGroup, SIGNAL(triggered(QAction*)),
+                            this, SLOT(slotSortTriggered(QAction*)));
+                } else {
+                    connect(groupMenuGroup, SIGNAL(triggered(QAction*)),
+                            this, SLOT(toggleVisibleRole(QAction*)));
+                }
+            }

 
 

-    KToggleAction* sortByName = m_actionCollection->add<KToggleAction>("sort_by_name");
-    sortByName->setText(i18nc("@action:inmenu Sort By", "Name"));
-    sortByName->setData(QVariant::fromValue(DolphinView::SortByName));
-    sortByActionGroup->addAction(sortByName);
+            action = new KToggleAction(groupMenu);
+            action->setActionGroup(groupMenuGroup);
+            groupMenu->addAction(action);
+        }
+        action->setText(info.translation);
+        action->setData(info.role);

 
 

-    const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
-    const QList<DolphinView::AdditionalInfo> infoList = infoAccessor.keys();
-    foreach (DolphinView::AdditionalInfo info, infoList) {
-        const QString name = infoAccessor.actionCollectionName(info, AdditionalInfoAccessor::SortByType);
-        KToggleAction* action = m_actionCollection->add<KToggleAction>(name);
-        action->setText(infoAccessor.translation(info));
-        const DolphinView::Sorting sorting = infoAccessor.sorting(info);
-        action->setData(QVariant::fromValue(sorting));
-        sortByActionGroup->addAction(action);
+        if (isSortGroup) {
+            m_sortByActions.insert(info.role, action);
+        } else {
+            m_visibleRoles.insert(info.role, action);
+        }

     }
 
     }
 

-    return sortByActionGroup;
+    return rolesActionGroup;

 }
 
 void DolphinViewActionHandler::slotViewModeActionTriggered(QAction* action)
 }
 
 void DolphinViewActionHandler::slotViewModeActionTriggered(QAction* action)


@@ -314,6 +332,9 @@ QString DolphinViewActionHandler::currentViewModeActionName() const
         return "details";
     case DolphinView::CompactView:
         return "compact";
         return "details";
     case DolphinView::CompactView:
         return "compact";

+    default:
+        Q_ASSERT(false);
+        break;

     }
     return QString(); // can't happen
 }
     }
     return QString(); // can't happen
 }


@@ -338,9 +359,9 @@ void DolphinViewActionHandler::updateViewActions()
 
     slotSortOrderChanged(m_currentView->sortOrder());
     slotSortFoldersFirstChanged(m_currentView->sortFoldersFirst());
 
     slotSortOrderChanged(m_currentView->sortOrder());
     slotSortFoldersFirstChanged(m_currentView->sortFoldersFirst());

-    slotAdditionalInfoListChanged(m_currentView->additionalInfoList(), QList<DolphinView::AdditionalInfo>());
-    slotCategorizedSortingChanged(m_currentView->categorizedSorting());
-    slotSortingChanged(m_currentView->sorting());
+    slotVisibleRolesChanged(m_currentView->visibleRoles(), QList<QByteArray>());
+    slotGroupedSortingChanged(m_currentView->groupedSorting());
+    slotSortRoleChanged(m_currentView->sortRole());

     slotZoomLevelChanged(m_currentView->zoomLevel(), -1);
 
     QAction* showHiddenFilesAction = m_actionCollection->action("show_hidden_files");
     slotZoomLevelChanged(m_currentView->zoomLevel(), -1);
 
     QAction* showHiddenFilesAction = m_actionCollection->action("show_hidden_files");


@@ -387,56 +408,52 @@ void DolphinViewActionHandler::slotSortFoldersFirstChanged(bool foldersFirst)
     m_actionCollection->action("folders_first")->setChecked(foldersFirst);
 }
 
     m_actionCollection->action("folders_first")->setChecked(foldersFirst);
 }
 

-void DolphinViewActionHandler::toggleAdditionalInfo(QAction* action)
+void DolphinViewActionHandler::toggleVisibleRole(QAction* action)

 {
     emit actionBeingHandled();
 
 {
     emit actionBeingHandled();
 

-    const DolphinView::AdditionalInfo info =
-        static_cast<DolphinView::AdditionalInfo>(action->data().toInt());
+    const QByteArray toggledRole = action->data().toByteArray();

 
 

-    QList<DolphinView::AdditionalInfo> list = m_currentView->additionalInfoList();
+    QList<QByteArray> roles = m_currentView->visibleRoles();

 
     const bool show = action->isChecked();
 
 
     const bool show = action->isChecked();
 

-    const int index = list.indexOf(info);
+    const int index = roles.indexOf(toggledRole);

     const bool containsInfo = (index >= 0);
     if (show && !containsInfo) {
     const bool containsInfo = (index >= 0);
     if (show && !containsInfo) {

-        list.append(info);
-        m_currentView->setAdditionalInfoList(list);
+        roles.append(toggledRole);
+        m_currentView->setVisibleRoles(roles);

     } else if (!show && containsInfo) {
     } else if (!show && containsInfo) {

-        list.removeAt(index);
-        m_currentView->setAdditionalInfoList(list);
-        Q_ASSERT(list.indexOf(info) < 0);
+        roles.removeAt(index);
+        m_currentView->setVisibleRoles(roles);
+        Q_ASSERT(roles.indexOf(toggledRole) < 0);

     }
 }
 
     }
 }
 

-void DolphinViewActionHandler::slotAdditionalInfoListChanged(const QList<DolphinView::AdditionalInfo>& current,
-                                                             const QList<DolphinView::AdditionalInfo>& previous)
+void DolphinViewActionHandler::slotVisibleRolesChanged(const QList<QByteArray>& current,
+                                                       const QList<QByteArray>& previous)

 {
     Q_UNUSED(previous);
 
 {
     Q_UNUSED(previous);
 

-    const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
-
-    const QList<DolphinView::AdditionalInfo> checkedInfo = current;
-    const QList<DolphinView::AdditionalInfo> infoList = infoAccessor.keys();
-
-    foreach (DolphinView::AdditionalInfo info, infoList) {
-        const QString name = infoAccessor.actionCollectionName(info, AdditionalInfoAccessor::AdditionalInfoType);
-        QAction* action = m_actionCollection->action(name);
-        Q_ASSERT(action);
-        action->setChecked(checkedInfo.contains(info));
+    const QSet<QByteArray> checkedRoles = current.toSet();
+    QHashIterator<QByteArray, KToggleAction*> it(m_visibleRoles);
+    while (it.hasNext()) {
+        it.next();
+        const QByteArray& role = it.key();
+        KToggleAction* action = it.value();
+        action->setChecked(checkedRoles.contains(role));

     }
 }
 
     }
 }
 

-void DolphinViewActionHandler::toggleSortCategorization(bool categorizedSorting)
+void DolphinViewActionHandler::toggleGroupedSorting(bool grouped)

 {
 {

-    m_currentView->setCategorizedSorting(categorizedSorting);
+    m_currentView->setGroupedSorting(grouped);

 }
 
 }
 

-void DolphinViewActionHandler::slotCategorizedSortingChanged(bool sortCategorized)
+void DolphinViewActionHandler::slotGroupedSortingChanged(bool groupedSorting)

 {
     QAction* showInGroupsAction = m_actionCollection->action("show_in_groups");
 {
     QAction* showInGroupsAction = m_actionCollection->action("show_in_groups");

-    showInGroupsAction->setChecked(sortCategorized);
+    showInGroupsAction->setChecked(groupedSorting);

 }
 
 void DolphinViewActionHandler::toggleShowHiddenFiles(bool show)
 }
 
 void DolphinViewActionHandler::toggleShowHiddenFiles(bool show)


@@ -451,7 +468,6 @@ void DolphinViewActionHandler::slotHiddenFilesShownChanged(bool shown)
     showHiddenFilesAction->setChecked(shown);
 }
 
     showHiddenFilesAction->setChecked(shown);
 }
 

-

 KToggleAction* DolphinViewActionHandler::iconsModeAction()
 {
     KToggleAction* iconsView = m_actionCollection->add<KToggleAction>("icons");
 KToggleAction* DolphinViewActionHandler::iconsModeAction()
 {
     KToggleAction* iconsView = m_actionCollection->add<KToggleAction>("icons");


@@ -480,28 +496,14 @@ KToggleAction* DolphinViewActionHandler::detailsModeAction()
     detailsView->setText(i18nc("@action:inmenu View Mode", "Details"));
     detailsView->setToolTip(i18nc("@info", "Details view mode"));
     detailsView->setShortcut(Qt::CTRL | Qt::Key_3);
     detailsView->setText(i18nc("@action:inmenu View Mode", "Details"));
     detailsView->setToolTip(i18nc("@info", "Details view mode"));
     detailsView->setShortcut(Qt::CTRL | Qt::Key_3);

-    detailsView->setIcon(KIcon("view-list-text"));
+    detailsView->setIcon(KIcon("view-list-tree"));

     detailsView->setData(QVariant::fromValue(DolphinView::DetailsView));
     return detailsView;
 }
 
     detailsView->setData(QVariant::fromValue(DolphinView::DetailsView));
     return detailsView;
 }
 

-void DolphinViewActionHandler::slotSortingChanged(DolphinView::Sorting sorting)
+void DolphinViewActionHandler::slotSortRoleChanged(const QByteArray& role)

 {
 {

-    QAction* action = 0;
-    if (sorting == DolphinView::SortByName) {
-        action = m_actionCollection->action("sort_by_name");
-    } else {
-        const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
-        const QList<DolphinView::AdditionalInfo> infoList = infoAccessor.keys();
-        foreach (DolphinView::AdditionalInfo info, infoList) {
-            if (sorting == infoAccessor.sorting(info)) {
-                const QString name = infoAccessor.actionCollectionName(info, AdditionalInfoAccessor::SortByType);
-                action = m_actionCollection->action(name);
-                break;
-            }
-        }
-    }
-
+    KToggleAction* action = m_sortByActions.value(role);

     if (action) {
         action->setChecked(true);
 
     if (action) {
         action->setChecked(true);
 


@@ -527,8 +529,27 @@ void DolphinViewActionHandler::slotZoomLevelChanged(int current, int previous)
 
 void DolphinViewActionHandler::slotSortTriggered(QAction* action)
 {
 
 void DolphinViewActionHandler::slotSortTriggered(QAction* action)
 {

-    const DolphinView::Sorting sorting = action->data().value<DolphinView::Sorting>();
-    m_currentView->setSorting(sorting);
+    // The radiobuttons of the "Sort By"-menu are split between the main-menu
+    // and several sub-menus. Because of this they don't have a common
+    // action-group that assures an exclusive toggle-state between the main-menu
+    // actions and the sub-menu-actions. If an action gets checked, it must
+    // be assured that all other actions get unchecked.
+    QAction* sortByMenu =  m_actionCollection->action("sort");
+    foreach (QAction* groupAction, sortByMenu->menu()->actions()) {
+        KActionMenu* actionMenu = qobject_cast<KActionMenu*>(groupAction);
+        if (actionMenu) {
+            foreach (QAction* subAction, actionMenu->menu()->actions()) {
+                subAction->setChecked(false);
+            }
+        } else if (groupAction->actionGroup()) {
+            groupAction->setChecked(false);
+        }
+    }
+    action->setChecked(true);
+
+    // Apply the activated sort-role to the view
+    const QByteArray role = action->data().toByteArray();
+    m_currentView->setSortRole(role);

 }
 
 void DolphinViewActionHandler::slotAdjustViewProperties()
 }
 
 void DolphinViewActionHandler::slotAdjustViewProperties()