First step to introduce dynamic roles

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

diff --git a/src/views/dolphinviewactionhandler.cpp b/src/views/dolphinviewactionhandler.cpp
index a8b044a41166b93974425f927877f95192d63f17..f6bc1374a0e6026628c5bb3689f23faef6c21866 100644 (file)
--- a/src/views/dolphinviewactionhandler.cpp
+++ b/src/views/dolphinviewactionhandler.cpp
@@ -19,7 +19,7 @@
 
 #include "dolphinviewactionhandler.h"
 
 
 #include "dolphinviewactionhandler.h"
 

-#include "additionalinfoaccessor.h"
+#include "rolesaccessor.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"


@@ -30,12 +30,14 @@
 #include <KActionMenu>
 #include <KFileItemDelegate>
 #include <KLocale>
 #include <KActionMenu>
 #include <KFileItemDelegate>
 #include <KLocale>

-#include <knewmenu.h>
+#include <KNewFileMenu>

 #include <KSelectAction>
 #include <KToggleAction>
 #include <KRun>
 #include <KPropertiesDialog>
 
 #include <KSelectAction>
 #include <KToggleAction>
 #include <KRun>
 #include <KPropertiesDialog>
 

+#include <KDebug>
+

 DolphinViewActionHandler::DolphinViewActionHandler(KActionCollection* collection, QObject* parent)
     : QObject(parent),
       m_actionCollection(collection),
 DolphinViewActionHandler::DolphinViewActionHandler(KActionCollection* collection, QObject* parent)
     : QObject(parent),
       m_actionCollection(collection),


@@ -49,29 +51,30 @@ void DolphinViewActionHandler::setCurrentView(DolphinView* view)
 {
     Q_ASSERT(view);
 
 {
     Q_ASSERT(view);
 

-    if (m_currentView)
+    if (m_currentView) {

         disconnect(m_currentView, 0, this, 0);
         disconnect(m_currentView, 0, this, 0);

+    }

 
     m_currentView = view;
 
 
     m_currentView = view;
 

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

             this, SLOT(updateViewActions()));
             this, SLOT(updateViewActions()));

-    connect(view, SIGNAL(showPreviewChanged()),
-            this, SLOT(slotShowPreviewChanged()));
+    connect(view, SIGNAL(previewsShownChanged(bool)),
+            this, SLOT(slotPreviewsShownChanged(bool)));

     connect(view, SIGNAL(sortOrderChanged(Qt::SortOrder)),
             this, SLOT(slotSortOrderChanged(Qt::SortOrder)));
     connect(view, SIGNAL(sortFoldersFirstChanged(bool)),
             this, SLOT(slotSortFoldersFirstChanged(bool)));
     connect(view, SIGNAL(sortOrderChanged(Qt::SortOrder)),
             this, SLOT(slotSortOrderChanged(Qt::SortOrder)));
     connect(view, SIGNAL(sortFoldersFirstChanged(bool)),
             this, SLOT(slotSortFoldersFirstChanged(bool)));

-    connect(view, SIGNAL(additionalInfoChanged()),
-            this, SLOT(slotAdditionalInfoChanged()));
-    connect(view, SIGNAL(categorizedSortingChanged()),
-            this, SLOT(slotCategorizedSortingChanged()));
-    connect(view, SIGNAL(showHiddenFilesChanged()),
-            this, SLOT(slotShowHiddenFilesChanged()));
-    connect(view, SIGNAL(sortingChanged(DolphinView::Sorting)),
-            this, SLOT(slotSortingChanged(DolphinView::Sorting)));
-    connect(view, SIGNAL(zoomLevelChanged(int)),
-            this, SLOT(slotZoomLevelChanged(int)));
+    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(sortRoleChanged(QByteArray)),
+            this, SLOT(slotSortRoleChanged(QByteArray)));
+    connect(view, SIGNAL(zoomLevelChanged(int,int)),
+            this, SLOT(slotZoomLevelChanged(int,int)));

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


@@ -101,8 +104,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"));


@@ -130,14 +133,14 @@ void DolphinViewActionHandler::createActions()
 
     // View menu
     KToggleAction* iconsAction = iconsModeAction();
 
     // View menu
     KToggleAction* iconsAction = iconsModeAction();

+    KToggleAction* compactAction = compactModeAction();

     KToggleAction* detailsAction = detailsModeAction();
     KToggleAction* detailsAction = detailsModeAction();

-    KToggleAction* columnsAction = columnsModeAction();

 
     KSelectAction* viewModeActions = m_actionCollection->add<KSelectAction>("view_mode");
     viewModeActions->setText(i18nc("@action:intoolbar", "View Mode"));
     viewModeActions->addAction(iconsAction);
 
     KSelectAction* viewModeActions = m_actionCollection->add<KSelectAction>("view_mode");
     viewModeActions->setText(i18nc("@action:intoolbar", "View Mode"));
     viewModeActions->addAction(iconsAction);

+    viewModeActions->addAction(compactAction);

     viewModeActions->addAction(detailsAction);
     viewModeActions->addAction(detailsAction);

-    viewModeActions->addAction(columnsAction);

     viewModeActions->setToolBarMode(KSelectAction::MenuMode);
     connect(viewModeActions, SIGNAL(triggered(QAction*)), this, SLOT(slotViewModeActionTriggered(QAction*)));
 
     viewModeActions->setToolBarMode(KSelectAction::MenuMode);
     connect(viewModeActions, SIGNAL(triggered(QAction*)), this, SLOT(slotViewModeActionTriggered(QAction*)));
 


@@ -190,8 +193,9 @@ void DolphinViewActionHandler::createActions()
     }
 
     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"));


@@ -212,40 +216,37 @@ QActionGroup* DolphinViewActionHandler::createAdditionalInformationActionGroup()
     showInformationMenu->setText(i18nc("@action:inmenu View", "Additional Information"));
     showInformationMenu->setDelayed(false);
 
     showInformationMenu->setText(i18nc("@action:inmenu View", "Additional Information"));
     showInformationMenu->setDelayed(false);
 

-    const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
+    const RolesAccessor& rolesAccessor = RolesAccessor::instance();
+
+    const QList<QByteArray> roles = rolesAccessor.roles();
+    foreach (const QByteArray& role, roles) {
+        if (role == "name") {
+            // It should not be possible to hide the "name" role
+            continue;
+        }

 
 

-    const KFileItemDelegate::InformationList infoKeys = infoAccessor.keys();
-    foreach (KFileItemDelegate::Information info, infoKeys) {
-        const QString name = infoAccessor.actionCollectionName(info, AdditionalInfoAccessor::AdditionalInfoType);
+        const QString name = QLatin1String("show_") + role;

         KToggleAction* action = m_actionCollection->add<KToggleAction>(name);
         KToggleAction* action = m_actionCollection->add<KToggleAction>(name);

-        action->setText(infoAccessor.translation(info));
-        action->setData(info);
+        action->setText(rolesAccessor.translation(role));
+        action->setData(role);

         action->setActionGroup(additionalInfoGroup);
     }
 
     return additionalInfoGroup;
 }
 
         action->setActionGroup(additionalInfoGroup);
     }
 
     return additionalInfoGroup;
 }
 

-Q_DECLARE_METATYPE(DolphinView::Sorting)
-

 QActionGroup* DolphinViewActionHandler::createSortByActionGroup()
 {
     QActionGroup* sortByActionGroup = new QActionGroup(m_actionCollection);
     sortByActionGroup->setExclusive(true);
 
 QActionGroup* DolphinViewActionHandler::createSortByActionGroup()
 {
     QActionGroup* sortByActionGroup = new QActionGroup(m_actionCollection);
     sortByActionGroup->setExclusive(true);
 

-    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);
-
-    const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
-    const KFileItemDelegate::InformationList infoKeys = infoAccessor.keys();
-    foreach (KFileItemDelegate::Information info, infoKeys) {
-        const QString name = infoAccessor.actionCollectionName(info, AdditionalInfoAccessor::SortByType);
+    const RolesAccessor& rolesAccessor = RolesAccessor::instance();
+    const QList<QByteArray> roles = rolesAccessor.roles();
+    foreach (const QByteArray& role, roles) {
+        const QString name = QLatin1String("sort_by_") + role;

         KToggleAction* action = m_actionCollection->add<KToggleAction>(name);
         KToggleAction* action = m_actionCollection->add<KToggleAction>(name);

-        action->setText(infoAccessor.translation(info));
-        const DolphinView::Sorting sorting = infoAccessor.sorting(info);
-        action->setData(QVariant::fromValue(sorting));
+        action->setText(rolesAccessor.translation(role));
+        action->setData(role);

         sortByActionGroup->addAction(action);
     }
 
         sortByActionGroup->addAction(action);
     }
 


@@ -289,11 +290,12 @@ void DolphinViewActionHandler::slotDeleteItems()
 void DolphinViewActionHandler::togglePreview(bool show)
 {
     emit actionBeingHandled();
 void DolphinViewActionHandler::togglePreview(bool show)
 {
     emit actionBeingHandled();

-    m_currentView->setShowPreview(show);
+    m_currentView->setPreviewsShown(show);

 }
 
 }
 

-void DolphinViewActionHandler::slotShowPreviewChanged()
+void DolphinViewActionHandler::slotPreviewsShownChanged(bool shown)

 {
 {

+    Q_UNUSED(shown);

     // It is not enough to update the 'Show Preview' action, also
     // the 'Zoom In' and 'Zoom Out' actions must be adapted.
     updateViewActions();
     // It is not enough to update the 'Show Preview' action, also
     // the 'Zoom In' and 'Zoom Out' actions must be adapted.
     updateViewActions();


@@ -306,8 +308,11 @@ QString DolphinViewActionHandler::currentViewModeActionName() const
         return "icons";
     case DolphinView::DetailsView:
         return "details";
         return "icons";
     case DolphinView::DetailsView:
         return "details";

-    case DolphinView::ColumnView:
-        return "columns";
+    case DolphinView::CompactView:
+        return "compact";
+    default:
+        Q_ASSERT(false);
+        break;

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


@@ -320,7 +325,7 @@ KActionCollection* DolphinViewActionHandler::actionCollection()
 void DolphinViewActionHandler::updateViewActions()
 {
     QAction* viewModeAction = m_actionCollection->action(currentViewModeActionName());
 void DolphinViewActionHandler::updateViewActions()
 {
     QAction* viewModeAction = m_actionCollection->action(currentViewModeActionName());

-    if (viewModeAction != 0) {
+    if (viewModeAction) {

         viewModeAction->setChecked(true);
 
         QAction* viewModeMenu = m_actionCollection->action("view_mode");
         viewModeAction->setChecked(true);
 
         QAction* viewModeMenu = m_actionCollection->action("view_mode");


@@ -328,17 +333,17 @@ void DolphinViewActionHandler::updateViewActions()
     }
 
     QAction* showPreviewAction = m_actionCollection->action("show_preview");
     }
 
     QAction* showPreviewAction = m_actionCollection->action("show_preview");

-    showPreviewAction->setChecked(m_currentView->showPreview());
+    showPreviewAction->setChecked(m_currentView->previewsShown());

 
     slotSortOrderChanged(m_currentView->sortOrder());
     slotSortFoldersFirstChanged(m_currentView->sortFoldersFirst());
 
     slotSortOrderChanged(m_currentView->sortOrder());
     slotSortFoldersFirstChanged(m_currentView->sortFoldersFirst());

-    slotAdditionalInfoChanged();
-    slotCategorizedSortingChanged();
-    slotSortingChanged(m_currentView->sorting());
-    slotZoomLevelChanged(m_currentView->zoomLevel());
+    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");
 
     QAction* showHiddenFilesAction = m_actionCollection->action("show_hidden_files");

-    showHiddenFilesAction->setChecked(m_currentView->showHiddenFiles());
+    showHiddenFilesAction->setChecked(m_currentView->hiddenFilesShown());

 }
 
 void DolphinViewActionHandler::zoomIn()
 }
 
 void DolphinViewActionHandler::zoomIn()


@@ -385,55 +390,66 @@ void DolphinViewActionHandler::toggleAdditionalInfo(QAction* action)
 {
     emit actionBeingHandled();
 
 {
     emit actionBeingHandled();
 

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

 
 

-    KFileItemDelegate::InformationList list = m_currentView->additionalInfo();
+    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->setAdditionalInfo(list);
+        roles.append(toggledRole);
+        m_currentView->setVisibleRoles(roles);

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

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

     }
 }
 
     }
 }
 

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

 {
 {

-    m_currentView->updateAdditionalInfoActions(m_actionCollection);
+    Q_UNUSED(previous);
+
+    const RolesAccessor& rolesAccessor = RolesAccessor::instance();
+
+    const QSet<QByteArray> checkedRoles = current.toSet();
+    const QList<QByteArray> roles = rolesAccessor.roles();
+
+    foreach (const QByteArray& role, roles) {
+        const QString name = QLatin1String("show_") + role;
+        QAction* action = m_actionCollection->action(name);
+        if (action) {
+            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()
+void DolphinViewActionHandler::slotGroupedSortingChanged(bool groupedSorting)

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

-    showInGroupsAction->setChecked(m_currentView->categorizedSorting());
-    showInGroupsAction->setEnabled(m_currentView->supportsCategorizedSorting());
+    showInGroupsAction->setChecked(groupedSorting);

 }
 
 void DolphinViewActionHandler::toggleShowHiddenFiles(bool show)
 {
     emit actionBeingHandled();
 }
 
 void DolphinViewActionHandler::toggleShowHiddenFiles(bool show)
 {
     emit actionBeingHandled();

-    m_currentView->setShowHiddenFiles(show);
+    m_currentView->setHiddenFilesShown(show);

 }
 
 }
 

-void DolphinViewActionHandler::slotShowHiddenFilesChanged()
+void DolphinViewActionHandler::slotHiddenFilesShownChanged(bool shown)

 {
     QAction* showHiddenFilesAction = m_actionCollection->action("show_hidden_files");
 {
     QAction* showHiddenFilesAction = m_actionCollection->action("show_hidden_files");

-    showHiddenFilesAction->setChecked(m_currentView->showHiddenFiles());
+    showHiddenFilesAction->setChecked(shown);

 }
 
 }
 

-

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


@@ -445,46 +461,33 @@ KToggleAction* DolphinViewActionHandler::iconsModeAction()
     return iconsView;
 }
 
     return iconsView;
 }
 

+KToggleAction* DolphinViewActionHandler::compactModeAction()
+{
+    KToggleAction* iconsView = m_actionCollection->add<KToggleAction>("compact");
+    iconsView->setText(i18nc("@action:inmenu View Mode", "Compact"));
+    iconsView->setToolTip(i18nc("@info", "Compact view mode"));
+    iconsView->setShortcut(Qt::CTRL | Qt::Key_2);
+    iconsView->setIcon(KIcon("view-list-details")); // TODO: discuss with Oxygen-team the wrong (?) name
+    iconsView->setData(QVariant::fromValue(DolphinView::CompactView));
+    return iconsView;
+}
+

 KToggleAction* DolphinViewActionHandler::detailsModeAction()
 {
     KToggleAction* detailsView = m_actionCollection->add<KToggleAction>("details");
     detailsView->setText(i18nc("@action:inmenu View Mode", "Details"));
     detailsView->setToolTip(i18nc("@info", "Details view mode"));
 KToggleAction* DolphinViewActionHandler::detailsModeAction()
 {
     KToggleAction* detailsView = m_actionCollection->add<KToggleAction>("details");
     detailsView->setText(i18nc("@action:inmenu View Mode", "Details"));
     detailsView->setToolTip(i18nc("@info", "Details view mode"));

-    detailsView->setShortcut(Qt::CTRL | Qt::Key_2);
-    detailsView->setIcon(KIcon("view-list-details"));
+    detailsView->setShortcut(Qt::CTRL | Qt::Key_3);
+    detailsView->setIcon(KIcon("view-list-tree"));

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

-KToggleAction* DolphinViewActionHandler::columnsModeAction()
-{
-    KToggleAction* columnView = m_actionCollection->add<KToggleAction>("columns");
-    columnView->setText(i18nc("@action:inmenu View Mode", "Columns"));
-    columnView->setToolTip(i18nc("@info", "Columns view mode"));
-    columnView->setShortcut(Qt::CTRL | Qt::Key_3);
-    columnView->setIcon(KIcon("view-file-columns"));
-    columnView->setData(QVariant::fromValue(DolphinView::ColumnView));
-    return columnView;
-}
-
-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 KFileItemDelegate::InformationList infoKeys = infoAccessor.keys();
-        foreach (const KFileItemDelegate::Information info, infoKeys) {
-            if (sorting == infoAccessor.sorting(info)) {
-                const QString name = infoAccessor.actionCollectionName(info, AdditionalInfoAccessor::SortByType);
-                action = m_actionCollection->action(name);
-                break;
-            }
-        }
-    }
-
-    if (action != 0) {
+    const QString name = QLatin1String("sort_by_") + role;
+    QAction* action = m_actionCollection->action(name);
+    if (action) {

         action->setChecked(true);
 
         QAction* sortByMenu =  m_actionCollection->action("sort");
         action->setChecked(true);
 
         QAction* sortByMenu =  m_actionCollection->action("sort");


@@ -492,23 +495,25 @@ void DolphinViewActionHandler::slotSortingChanged(DolphinView::Sorting sorting)
     }
 }
 
     }
 }
 

-void DolphinViewActionHandler::slotZoomLevelChanged(int level)
+void DolphinViewActionHandler::slotZoomLevelChanged(int current, int previous)

 {
 {

+    Q_UNUSED(previous);
+

     QAction* zoomInAction = m_actionCollection->action(KStandardAction::name(KStandardAction::ZoomIn));
     QAction* zoomInAction = m_actionCollection->action(KStandardAction::name(KStandardAction::ZoomIn));

-    if (zoomInAction != 0) {
-        zoomInAction->setEnabled(level < ZoomLevelInfo::maximumLevel());
+    if (zoomInAction) {
+        zoomInAction->setEnabled(current < ZoomLevelInfo::maximumLevel());

     }
 
     QAction* zoomOutAction = m_actionCollection->action(KStandardAction::name(KStandardAction::ZoomOut));
     }
 
     QAction* zoomOutAction = m_actionCollection->action(KStandardAction::name(KStandardAction::ZoomOut));

-    if (zoomOutAction != 0) {
-        zoomOutAction->setEnabled(level > ZoomLevelInfo::minimumLevel());
+    if (zoomOutAction) {
+        zoomOutAction->setEnabled(current > ZoomLevelInfo::minimumLevel());

     }
 }
 
 void DolphinViewActionHandler::slotSortTriggered(QAction* action)
 {
     }
 }
 
 void DolphinViewActionHandler::slotSortTriggered(QAction* action)
 {

-    const DolphinView::Sorting sorting = action->data().value<DolphinView::Sorting>();
-    m_currentView->setSorting(sorting);
+    const QByteArray role = action->data().toByteArray();
+    m_currentView->setSortRole(role);

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