Merge branch 'release/20.04'

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

diff --git a/src/views/dolphinviewactionhandler.cpp b/src/views/dolphinviewactionhandler.cpp
index f66aebc843a2b2b631a44bbf18bf9aa25a4bf9b2..e89e2e62c2b705e32223dca048334d6c22f7f224 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,29 +20,30 @@
 
 #include "dolphinviewactionhandler.h"
 
 
 #include "dolphinviewactionhandler.h"
 

-#include "additionalinfoaccessor.h"
+#include "dolphindebug.h"
+#include "kitemviews/kfileitemmodel.h"

 #include "settings/viewpropertiesdialog.h"
 #include "settings/viewpropertiesdialog.h"

-#include "views/dolphinview.h"

 #include "views/zoomlevelinfo.h"
 #include "views/zoomlevelinfo.h"

-#include <konq_operations.h>

 
 

-#include <KAction>
+#ifdef HAVE_BALOO
+#include <Baloo/IndexerConfig>
+#endif

 #include <KActionCollection>
 #include <KActionMenu>
 #include <KActionCollection>
 #include <KActionMenu>

-#include <KFileItemDelegate>
-#include <KLocale>
+#include <KLocalizedString>

 #include <KNewFileMenu>
 #include <KNewFileMenu>

-#include <KSelectAction>
-#include <KToggleAction>
-#include <KRun>

 #include <KPropertiesDialog>
 #include <KPropertiesDialog>

+#include <KProtocolManager>

 
 

-#include <KDebug>
+#include <QMenu>
+#include <QPointer>

 
 

-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(nullptr),
+    m_sortByActions(),
+    m_visibleRoles()

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


@@ -52,31 +54,31 @@ void DolphinViewActionHandler::setCurrentView(DolphinView* view)
     Q_ASSERT(view);
 
     if (m_currentView) {
     Q_ASSERT(view);
 
     if (m_currentView) {

-        disconnect(m_currentView, 0, this, 0);
+        disconnect(m_currentView, nullptr, this, nullptr);

     }
 
     m_currentView = view;
 
     }
 
     m_currentView = view;
 

-    connect(view, SIGNAL(modeChanged(DolphinView::Mode,DolphinView::Mode)),
-            this, SLOT(updateViewActions()));
-    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(additionalInfoListChanged(QList<DolphinView::AdditionalInfo>,
-                                                   QList<DolphinView::AdditionalInfo>)),
-            this, SLOT(slotAdditionalInfoListChanged(QList<DolphinView::AdditionalInfo>,
-                                                     QList<DolphinView::AdditionalInfo>)));
-    connect(view, SIGNAL(groupedSortingChanged(bool)),
-            this, SLOT(slotGroupedSortingChanged(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, &DolphinView::modeChanged,
+            this, &DolphinViewActionHandler::updateViewActions);
+    connect(view, &DolphinView::previewsShownChanged,
+            this, &DolphinViewActionHandler::slotPreviewsShownChanged);
+    connect(view, &DolphinView::sortOrderChanged,
+            this, &DolphinViewActionHandler::slotSortOrderChanged);
+    connect(view, &DolphinView::sortFoldersFirstChanged,
+            this, &DolphinViewActionHandler::slotSortFoldersFirstChanged);
+    connect(view, &DolphinView::visibleRolesChanged,
+            this, &DolphinViewActionHandler::slotVisibleRolesChanged);
+    connect(view, &DolphinView::groupedSortingChanged,
+            this, &DolphinViewActionHandler::slotGroupedSortingChanged);
+    connect(view, &DolphinView::hiddenFilesShownChanged,
+            this, &DolphinViewActionHandler::slotHiddenFilesShownChanged);
+    connect(view, &DolphinView::sortRoleChanged,
+            this, &DolphinViewActionHandler::slotSortRoleChanged);
+    connect(view, &DolphinView::zoomLevelChanged,
+            this, &DolphinViewActionHandler::slotZoomLevelChanged);
+    connect(view, &DolphinView::writeStateChanged,
+            this, &DolphinViewActionHandler::slotWriteStateChanged);

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


@@ -88,174 +90,285 @@ void DolphinViewActionHandler::createActions()
 {
     // This action doesn't appear in the GUI, it's for the shortcut only.
     // KNewFileMenu takes care of the GUI stuff.
 {
     // This action doesn't appear in the GUI, it's for the shortcut only.
     // KNewFileMenu takes care of the GUI stuff.

-    KAction* newDirAction = m_actionCollection->addAction("create_dir");
+    QAction* newDirAction = m_actionCollection->addAction(QStringLiteral("create_dir"));

     newDirAction->setText(i18nc("@action", "Create Folder..."));
     newDirAction->setText(i18nc("@action", "Create Folder..."));

-    newDirAction->setShortcut(Qt::Key_F10);
-    newDirAction->setIcon(KIcon("folder-new"));
-    connect(newDirAction, SIGNAL(triggered()), this, SIGNAL(createDirectory()));
+    m_actionCollection->setDefaultShortcut(newDirAction, Qt::Key_F10);
+    newDirAction->setIcon(QIcon::fromTheme(QStringLiteral("folder-new")));
+    newDirAction->setEnabled(false);    // Will be enabled in slotWriteStateChanged(bool) if the current URL is writable
+    connect(newDirAction, &QAction::triggered, this, &DolphinViewActionHandler::createDirectoryTriggered);

 
     // File menu
 
 
     // File menu
 

-    KAction* rename = m_actionCollection->addAction("rename");
-    rename->setText(i18nc("@action:inmenu File", "Rename..."));
-    rename->setShortcut(Qt::Key_F2);
-    rename->setIcon(KIcon("edit-rename"));
-    connect(rename, SIGNAL(triggered()), this, SLOT(slotRename()));
-
-    KAction* moveToTrash = m_actionCollection->addAction("move_to_trash");
-    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)));
-
-    KAction* deleteAction = m_actionCollection->addAction("delete");
-    deleteAction->setIcon(KIcon("edit-delete"));
-    deleteAction->setText(i18nc("@action:inmenu File", "Delete"));
-    deleteAction->setShortcut(Qt::SHIFT | Qt::Key_Delete);
-    connect(deleteAction, SIGNAL(triggered()), this, SLOT(slotDeleteItems()));
-
-    // This action is useful for being enabled when "move_to_trash" should be
-    // disabled and "delete" is enabled (e.g. non-local files), so that Key_Del
+    auto renameAction = KStandardAction::renameFile(this, &DolphinViewActionHandler::slotRename, m_actionCollection);
+    renameAction->setWhatsThis(xi18nc("@info:whatsthis", "This renames the "
+        "items in your current selection.<nl/>Renaming multiple items "
+        "at once amounts to their new names differing only in a number."));
+
+    auto trashAction = KStandardAction::moveToTrash(this, &DolphinViewActionHandler::slotTrashActivated, m_actionCollection);
+    auto trashShortcuts = trashAction->shortcuts();
+    if (!trashShortcuts.contains(QKeySequence::Delete)) {
+        trashShortcuts.append(QKeySequence::Delete);
+        m_actionCollection->setDefaultShortcuts(trashAction, trashShortcuts);
+    }
+    trashAction->setWhatsThis(xi18nc("@info:whatsthis", "This moves the "
+        "items in your current selection to the <filename>Trash"
+        "</filename>.<nl/>The trash is a temporary storage where "
+        "items can be deleted from if disk space is needed."));
+
+    auto deleteAction = KStandardAction::deleteFile(this, &DolphinViewActionHandler::slotDeleteItems, m_actionCollection);
+    auto deleteShortcuts = deleteAction->shortcuts();
+    if (!deleteShortcuts.contains(Qt::SHIFT | Qt::Key_Delete)) {
+        deleteShortcuts.append(Qt::SHIFT | Qt::Key_Delete);
+        m_actionCollection->setDefaultShortcuts(deleteAction, deleteShortcuts);
+    }
+    deleteAction->setWhatsThis(xi18nc("@info:whatsthis", "This deletes "
+        "the items in your current selection completely. They can "
+        "not be recovered by normal means."));
+
+    // This action is useful for being enabled when KStandardAction::MoveToTrash should be
+    // disabled and KStandardAction::DeleteFile is enabled (e.g. non-local files), so that Key_Del

     // can be used for deleting the file (#76016). It needs to be a separate action
     // so that the Edit menu isn't affected.
     // can be used for deleting the file (#76016). It needs to be a separate action
     // so that the Edit menu isn't affected.

-    KAction* deleteWithTrashShortcut = m_actionCollection->addAction("delete_shortcut");
+    QAction* deleteWithTrashShortcut = m_actionCollection->addAction(QStringLiteral("delete_shortcut"));

     // The descriptive text is just for the shortcuts editor.
     deleteWithTrashShortcut->setText(i18nc("@action \"Move to Trash\" for non-local files, etc.", "Delete (using shortcut for Trash)"));
     // The descriptive text is just for the shortcuts editor.
     deleteWithTrashShortcut->setText(i18nc("@action \"Move to Trash\" for non-local files, etc.", "Delete (using shortcut for Trash)"));

-    deleteWithTrashShortcut->setShortcut(QKeySequence::Delete);
+    m_actionCollection->setDefaultShortcuts(deleteWithTrashShortcut, KStandardShortcut::moveToTrash());

     deleteWithTrashShortcut->setEnabled(false);
     deleteWithTrashShortcut->setEnabled(false);

-    connect(deleteWithTrashShortcut, SIGNAL(triggered()), this, SLOT(slotDeleteItems()));
+    connect(deleteWithTrashShortcut, &QAction::triggered, this, &DolphinViewActionHandler::slotDeleteItems);

 
 

-    KAction *propertiesAction = m_actionCollection->addAction( "properties" );
+    QAction* duplicateAction = m_actionCollection->addAction(QStringLiteral("duplicate"));
+    duplicateAction->setText(i18nc("@action:inmenu File", "Duplicate Here"));
+    duplicateAction->setIcon(QIcon::fromTheme(QStringLiteral("edit-duplicate")));
+    m_actionCollection->setDefaultShortcut(duplicateAction, Qt::CTRL | Qt::Key_D);
+    duplicateAction->setEnabled(false);
+    connect(duplicateAction, &QAction::triggered, this, &DolphinViewActionHandler::slotDuplicate);
+
+    QAction *propertiesAction = m_actionCollection->addAction( QStringLiteral("properties") );

     // Well, it's the File menu in dolphinmainwindow and the Edit menu in dolphinpart... :)
     propertiesAction->setText( i18nc("@action:inmenu File", "Properties") );
     // Well, it's the File menu in dolphinmainwindow and the Edit menu in dolphinpart... :)
     propertiesAction->setText( i18nc("@action:inmenu File", "Properties") );

-    propertiesAction->setIcon(KIcon("document-properties"));
-    propertiesAction->setShortcut(Qt::ALT | Qt::Key_Return);
-    connect(propertiesAction, SIGNAL(triggered()), SLOT(slotProperties()));
+    propertiesAction->setWhatsThis(xi18nc("@info:whatsthis properties",
+        "This shows a complete list of properties of the currently "
+        "selected items in a new window.<nl/>If nothing is selected the "
+        "window will be about the currently viewed folder instead.<nl/>"
+        "You can configure advanced options there like managing "
+        "read- and write-permissions."));
+    propertiesAction->setIcon(QIcon::fromTheme(QStringLiteral("document-properties")));
+    m_actionCollection->setDefaultShortcuts(propertiesAction, {Qt::ALT + Qt::Key_Return, Qt::ALT + Qt::Key_Enter});
+    connect(propertiesAction, &QAction::triggered, this, &DolphinViewActionHandler::slotProperties);

 
     // View menu
     KToggleAction* iconsAction = iconsModeAction();
     KToggleAction* compactAction = compactModeAction();
     KToggleAction* detailsAction = detailsModeAction();
 
 
     // View menu
     KToggleAction* iconsAction = iconsModeAction();
     KToggleAction* compactAction = compactModeAction();
     KToggleAction* detailsAction = detailsModeAction();
 

-    KSelectAction* viewModeActions = m_actionCollection->add<KSelectAction>("view_mode");
+    iconsAction->setWhatsThis(xi18nc("@info:whatsthis Icons view mode",
+        "<para>This switches to a view mode that focuses on the folder "
+        "and file icons. This mode makes it easy to distinguish folders "
+        "from files and to detect items with distinctive <emphasis>"
+        "file types</emphasis>.</para><para> This mode is handy to "
+        "browse through pictures when the <interface>Preview"
+        "</interface> option is enabled.</para>"));
+    compactAction->setWhatsThis(xi18nc("@info:whatsthis Compact view mode",
+        "<para>This switches to a compact view mode that lists the folders "
+        "and files in columns with the names beside the icons.</para><para>"
+        "This helps to keep the overview in folders with many items.</para>"));
+    detailsAction->setWhatsThis(xi18nc("@info:whatsthis Details view mode",
+        "<para>This switches to a list view mode that focuses on folder "
+        "and file details.</para><para>Click on a detail in the column "
+        "header to sort the items by it. Click again to sort the other "
+        "way around. To select which details should be displayed click "
+        "the header with the right mouse button.</para><para>You can "
+        "view the contents of a folder without leaving the current "
+        "location by clicking to the left of it. This way you can view "
+        "the contents of multiple folders in the same list.</para>"));
+
+    KSelectAction* viewModeActions = m_actionCollection->add<KSelectAction>(QStringLiteral("view_mode"));

     viewModeActions->setText(i18nc("@action:intoolbar", "View Mode"));
     viewModeActions->addAction(iconsAction);
     viewModeActions->addAction(compactAction);
     viewModeActions->addAction(detailsAction);
     viewModeActions->setToolBarMode(KSelectAction::MenuMode);
     viewModeActions->setText(i18nc("@action:intoolbar", "View Mode"));
     viewModeActions->addAction(iconsAction);
     viewModeActions->addAction(compactAction);
     viewModeActions->addAction(detailsAction);
     viewModeActions->setToolBarMode(KSelectAction::MenuMode);

-    connect(viewModeActions, SIGNAL(triggered(QAction*)), this, SLOT(slotViewModeActionTriggered(QAction*)));
+    connect(viewModeActions, QOverload<QAction*>::of(&KSelectAction::triggered), this, &DolphinViewActionHandler::slotViewModeActionTriggered);

 
 

-    KStandardAction::zoomIn(this,
-                            SLOT(zoomIn()),
+    QAction* zoomInAction = KStandardAction::zoomIn(this,
+                            &DolphinViewActionHandler::zoomIn,

                             m_actionCollection);
                             m_actionCollection);

-
-    KStandardAction::zoomOut(this,
-                             SLOT(zoomOut()),
+    zoomInAction->setWhatsThis(i18nc("@info:whatsthis zoom in", "This increases the icon size."));
+
+    QAction* zoomResetAction = m_actionCollection->addAction(QStringLiteral("view_zoom_reset"));
+    zoomResetAction->setText(i18nc("@action:inmenu View", "Reset Zoom Level"));
+    zoomResetAction->setToolTip(i18n("Zoom To Default"));
+    zoomResetAction->setWhatsThis(i18nc("@info:whatsthis zoom reset", "This resets the icon size to default."));
+    zoomResetAction->setIcon(QIcon::fromTheme(QStringLiteral("zoom-original")));
+    m_actionCollection->setDefaultShortcuts(zoomResetAction, {Qt::CTRL + Qt::Key_0});
+    connect(zoomResetAction, &QAction::triggered, this, &DolphinViewActionHandler::zoomReset);
+
+    QAction* zoomOutAction = KStandardAction::zoomOut(this,
+                             &DolphinViewActionHandler::zoomOut,

                              m_actionCollection);
                              m_actionCollection);

+    zoomOutAction->setWhatsThis(i18nc("@info:whatsthis zoom out", "This reduces the icon size."));

 
 

-    KToggleAction* showPreview = m_actionCollection->add<KToggleAction>("show_preview");
-    showPreview->setText(i18nc("@action:intoolbar", "Preview"));
+    KToggleAction* showPreview = m_actionCollection->add<KToggleAction>(QStringLiteral("show_preview"));
+    showPreview->setText(i18nc("@action:intoolbar", "Show Previews"));

     showPreview->setToolTip(i18nc("@info", "Show preview of files and folders"));
     showPreview->setToolTip(i18nc("@info", "Show preview of files and folders"));

-    showPreview->setIcon(KIcon("view-preview"));
-    connect(showPreview, SIGNAL(triggered(bool)), this, SLOT(togglePreview(bool)));
-
-    KToggleAction* sortDescending = m_actionCollection->add<KToggleAction>("descending");
-    sortDescending->setText(i18nc("@action:inmenu Sort", "Descending"));
-    connect(sortDescending, SIGNAL(triggered()), this, SLOT(toggleSortOrder()));
-
-    KToggleAction* sortFoldersFirst = m_actionCollection->add<KToggleAction>("folders_first");
+    showPreview->setWhatsThis(xi18nc("@info:whatsthis", "When this is "
+        "enabled, the icons are based on the actual file or folder "
+        "contents.<nl/>For example the icons of images become scaled "
+        "down versions of the images."));
+    showPreview->setIcon(QIcon::fromTheme(QStringLiteral("view-preview")));
+    connect(showPreview, &KToggleAction::triggered, this, &DolphinViewActionHandler::togglePreview);
+
+    KToggleAction* sortFoldersFirst = m_actionCollection->add<KToggleAction>(QStringLiteral("folders_first"));

     sortFoldersFirst->setText(i18nc("@action:inmenu Sort", "Folders First"));
     sortFoldersFirst->setText(i18nc("@action:inmenu Sort", "Folders First"));

-    connect(sortFoldersFirst, SIGNAL(triggered()), this, SLOT(toggleSortFoldersFirst()));
+    connect(sortFoldersFirst, &KToggleAction::triggered, this, &DolphinViewActionHandler::toggleSortFoldersFirst);

 
     // View -> Sort By
 
     // View -> Sort By

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

 
 

-    KActionMenu* sortByActionMenu = m_actionCollection->add<KActionMenu>("sort");
+    KActionMenu* sortByActionMenu = m_actionCollection->add<KActionMenu>(QStringLiteral("sort"));
+    sortByActionMenu->setIcon(QIcon::fromTheme(QStringLiteral("view-sort")));

     sortByActionMenu->setText(i18nc("@action:inmenu View", "Sort By"));
     sortByActionMenu->setDelayed(false);
 
     foreach (QAction* action, sortByActionGroup->actions()) {
         sortByActionMenu->addAction(action);
     }
     sortByActionMenu->setText(i18nc("@action:inmenu View", "Sort By"));
     sortByActionMenu->setDelayed(false);
 
     foreach (QAction* action, sortByActionGroup->actions()) {
         sortByActionMenu->addAction(action);
     }

-    sortByActionMenu->addSeparator();
-    sortByActionMenu->addAction(sortDescending);
-    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);
-    }
+    sortByActionMenu->addSeparator();

 
 

-    KToggleAction* showInGroups = m_actionCollection->add<KToggleAction>("show_in_groups");
-    showInGroups->setIcon(KIcon("view-group"));
-    showInGroups->setText(i18nc("@action:inmenu View", "Show in Groups"));
-    connect(showInGroups, SIGNAL(triggered(bool)), this, SLOT(toggleGroupedSorting(bool)));
+    QActionGroup* group = new QActionGroup(sortByActionMenu);
+    group->setExclusive(true);

 
 

-    KToggleAction* showHiddenFiles = m_actionCollection->add<KToggleAction>("show_hidden_files");
-    showHiddenFiles->setText(i18nc("@action:inmenu View", "Show Hidden Files"));
-    showHiddenFiles->setShortcuts(QList<QKeySequence>() << Qt::ALT + Qt::Key_Period << Qt::Key_F8);
-    connect(showHiddenFiles, SIGNAL(triggered(bool)), this, SLOT(toggleShowHiddenFiles(bool)));
+    KToggleAction* ascendingAction = m_actionCollection->add<KToggleAction>(QStringLiteral("ascending"));
+    ascendingAction->setActionGroup(group);
+    connect(ascendingAction, &QAction::triggered, this, [this] {
+        m_currentView->setSortOrder(Qt::AscendingOrder);
+    });

 
 

-    KAction* adjustViewProps = m_actionCollection->addAction("view_properties");
-    adjustViewProps->setText(i18nc("@action:inmenu View", "Adjust View Properties..."));
-    connect(adjustViewProps, SIGNAL(triggered()), this, SLOT(slotAdjustViewProperties()));
-}
+    KToggleAction* descendingAction = m_actionCollection->add<KToggleAction>(QStringLiteral("descending"));
+    descendingAction->setActionGroup(group);
+    connect(descendingAction, &QAction::triggered, this, [this] {
+        m_currentView->setSortOrder(Qt::DescendingOrder);
+    });

 
 

-QActionGroup* DolphinViewActionHandler::createAdditionalInformationActionGroup()
-{
-    QActionGroup* additionalInfoGroup = new QActionGroup(m_actionCollection);
-    additionalInfoGroup->setExclusive(false);
+    sortByActionMenu->addAction(ascendingAction);
+    sortByActionMenu->addAction(descendingAction);
+    sortByActionMenu->addSeparator();
+    sortByActionMenu->addAction(sortFoldersFirst);

 
 

-    KActionMenu* showInformationMenu = m_actionCollection->add<KActionMenu>("additional_info");
-    showInformationMenu->setText(i18nc("@action:inmenu View", "Additional Information"));
-    showInformationMenu->setDelayed(false);
+    // View -> Additional Information
+    QActionGroup* visibleRolesGroup = createFileItemRolesActionGroup(QStringLiteral("show_"));

 
 

-    const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
+    KActionMenu* visibleRolesMenu = m_actionCollection->add<KActionMenu>(QStringLiteral("additional_info"));
+    visibleRolesMenu->setText(i18nc("@action:inmenu View", "Show Additional Information"));
+    visibleRolesMenu->setIcon(QIcon::fromTheme(QStringLiteral("documentinfo")));
+    visibleRolesMenu->setDelayed(false);

 
 

-    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);
+    foreach (QAction* action, visibleRolesGroup->actions()) {
+        visibleRolesMenu->addAction(action);

     }
 
     }
 

-    return additionalInfoGroup;
-}
+    KToggleAction* showInGroups = m_actionCollection->add<KToggleAction>(QStringLiteral("show_in_groups"));
+    showInGroups->setIcon(QIcon::fromTheme(QStringLiteral("view-group")));
+    showInGroups->setText(i18nc("@action:inmenu View", "Show in Groups"));
+    showInGroups->setWhatsThis(i18nc("@info:whatsthis", "This groups files and folders by their first letter."));
+    connect(showInGroups, &KToggleAction::triggered, this, &DolphinViewActionHandler::toggleGroupedSorting);

 
 

-Q_DECLARE_METATYPE(DolphinView::Sorting)
+    KToggleAction* showHiddenFiles = m_actionCollection->add<KToggleAction>(QStringLiteral("show_hidden_files"));
+    showHiddenFiles->setText(i18nc("@action:inmenu View", "Show Hidden Files"));
+    showHiddenFiles->setToolTip(i18nc("@info", "Visibility of hidden files and folders"));
+    showHiddenFiles->setWhatsThis(xi18nc("@info:whatsthis", "<para>When "
+        "this is enabled <emphasis>hidden</emphasis> files and folders "
+        "are visible. They will be displayed semi-transparent.</para>"
+        "<para>Hidden items only differ from other ones in that their "
+        "name starts with a \".\". In general there is no need for "
+        "users to access them which is why they are hidden.</para>"));
+    m_actionCollection->setDefaultShortcuts(showHiddenFiles, KStandardShortcut::showHideHiddenFiles());
+    connect(showHiddenFiles, &KToggleAction::triggered, this, &DolphinViewActionHandler::toggleShowHiddenFiles);
+
+    QAction* adjustViewProps = m_actionCollection->addAction(QStringLiteral("view_properties"));
+    adjustViewProps->setText(i18nc("@action:inmenu View", "Adjust View Display Style..."));
+    adjustViewProps->setIcon(QIcon::fromTheme(QStringLiteral("view-choose")));
+    adjustViewProps->setWhatsThis(i18nc("@info:whatsthis", "This opens a window "
+        "in which all folder view properties can be adjusted."));
+    connect(adjustViewProps, &QAction::triggered, this, &DolphinViewActionHandler::slotAdjustViewProperties);
+}
+
+QActionGroup* DolphinViewActionHandler::createFileItemRolesActionGroup(const QString& groupPrefix)
+{
+    const bool isSortGroup = (groupPrefix == QLatin1String("sort_by_"));
+    Q_ASSERT(isSortGroup || groupPrefix == QLatin1String("show_"));
+
+    QActionGroup* rolesActionGroup = new QActionGroup(m_actionCollection);
+    rolesActionGroup->setExclusive(isSortGroup);
+    if (isSortGroup) {
+        connect(rolesActionGroup, &QActionGroup::triggered,
+                this, &DolphinViewActionHandler::slotSortTriggered);
+    } else {
+        connect(rolesActionGroup, &QActionGroup::triggered,
+                this, &DolphinViewActionHandler::toggleVisibleRole);
+    }

 
 

-QActionGroup* DolphinViewActionHandler::createSortByActionGroup()
-{
-    QActionGroup* sortByActionGroup = new QActionGroup(m_actionCollection);
-    sortByActionGroup->setExclusive(true);
+    QString groupName;
+    KActionMenu* groupMenu = nullptr;
+    QActionGroup* groupMenuGroup = nullptr;
+
+    bool indexingEnabled = false;
+#ifdef HAVE_BALOO
+    Baloo::IndexerConfig config;
+    indexingEnabled = config.fileIndexingEnabled();
+#endif
+
+    const QList<KFileItemModel::RoleInfo> rolesInfo = KFileItemModel::rolesInformation();
+    foreach (const KFileItemModel::RoleInfo& info, rolesInfo) {
+        if (!isSortGroup && info.role == "text") {
+            // It should not be possible to hide the "text" role
+            continue;
+        }

 
 

-    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);
+        KToggleAction* action = nullptr;
+        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, &QActionGroup::triggered,
+                            this, &DolphinViewActionHandler::slotSortTriggered);
+                } else {
+                    connect(groupMenuGroup, &QActionGroup::triggered,
+                            this, &DolphinViewActionHandler::toggleVisibleRole);
+                }
+            }

 
 

-    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);
+            action = new KToggleAction(groupMenu);
+            action->setActionGroup(groupMenuGroup);
+            groupMenu->addAction(action);
+        }
+        action->setText(info.translation);
+        action->setData(info.role);
+
+        const bool enable = (!info.requiresBaloo && !info.requiresIndexer) ||
+                            (info.requiresBaloo) ||
+                            (info.requiresIndexer && indexingEnabled);
+        action->setEnabled(enable);
+
+        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)


@@ -263,8 +376,8 @@ void DolphinViewActionHandler::slotViewModeActionTriggered(QAction* action)
     const DolphinView::Mode mode = action->data().value<DolphinView::Mode>();
     m_currentView->setMode(mode);
 
     const DolphinView::Mode mode = action->data().value<DolphinView::Mode>();
     m_currentView->setMode(mode);
 

-    QAction* viewModeMenu = m_actionCollection->action("view_mode");
-    viewModeMenu->setIcon(KIcon(action->icon()));
+    QAction* viewModeMenu = m_actionCollection->action(QStringLiteral("view_mode"));
+    viewModeMenu->setIcon(action->icon());

 }
 
 void DolphinViewActionHandler::slotRename()
 }
 
 void DolphinViewActionHandler::slotRename()


@@ -273,17 +386,10 @@ void DolphinViewActionHandler::slotRename()
     m_currentView->renameSelectedItems();
 }
 
     m_currentView->renameSelectedItems();
 }
 

-void DolphinViewActionHandler::slotTrashActivated(Qt::MouseButtons, Qt::KeyboardModifiers modifiers)
+void DolphinViewActionHandler::slotTrashActivated()

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

-    // Note: kde3's konq_mainwindow.cpp used to check
-    // reason == KAction::PopupMenuActivation && ...
-    // but this isn't supported anymore
-    if (modifiers & Qt::ShiftModifier) {
-        m_currentView->deleteSelectedItems();
-    } else {
-        m_currentView->trashSelectedItems();
-    }
+    m_currentView->trashSelectedItems();

 }
 
 void DolphinViewActionHandler::slotDeleteItems()
 }
 
 void DolphinViewActionHandler::slotDeleteItems()


@@ -300,9 +406,9 @@ void DolphinViewActionHandler::togglePreview(bool show)
 
 void DolphinViewActionHandler::slotPreviewsShownChanged(bool shown)
 {
 
 void DolphinViewActionHandler::slotPreviewsShownChanged(bool shown)
 {

-    Q_UNUSED(shown);
+    Q_UNUSED(shown)

     // It is not enough to update the 'Show Preview' action, also
     // It is not enough to update the 'Show Preview' action, also

-    // the 'Zoom In' and 'Zoom Out' actions must be adapted.
+    // the 'Zoom In', 'Zoom Out' and 'Zoom Reset' actions must be adapted.

     updateViewActions();
 }
 
     updateViewActions();
 }
 


@@ -310,11 +416,11 @@ QString DolphinViewActionHandler::currentViewModeActionName() const
 {
     switch (m_currentView->mode()) {
     case DolphinView::IconsView:
 {
     switch (m_currentView->mode()) {
     case DolphinView::IconsView:

-        return "icons";
+        return QStringLiteral("icons");

     case DolphinView::DetailsView:
     case DolphinView::DetailsView:

-        return "details";
+        return QStringLiteral("details");

     case DolphinView::CompactView:
     case DolphinView::CompactView:

-        return "compact";
+        return QStringLiteral("compact");

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


@@ -333,22 +439,22 @@ void DolphinViewActionHandler::updateViewActions()
     if (viewModeAction) {
         viewModeAction->setChecked(true);
 
     if (viewModeAction) {
         viewModeAction->setChecked(true);
 

-        QAction* viewModeMenu = m_actionCollection->action("view_mode");
-        viewModeMenu->setIcon(KIcon(viewModeAction->icon()));
+        QAction* viewModeMenu = m_actionCollection->action(QStringLiteral("view_mode"));
+        viewModeMenu->setIcon(viewModeAction->icon());

     }
 
     }
 

-    QAction* showPreviewAction = m_actionCollection->action("show_preview");
+    QAction* showPreviewAction = m_actionCollection->action(QStringLiteral("show_preview"));

     showPreviewAction->setChecked(m_currentView->previewsShown());
 
     slotSortOrderChanged(m_currentView->sortOrder());
     slotSortFoldersFirstChanged(m_currentView->sortFoldersFirst());
     showPreviewAction->setChecked(m_currentView->previewsShown());
 
     slotSortOrderChanged(m_currentView->sortOrder());
     slotSortFoldersFirstChanged(m_currentView->sortFoldersFirst());

-    slotAdditionalInfoListChanged(m_currentView->additionalInfoList(), QList<DolphinView::AdditionalInfo>());
+    slotVisibleRolesChanged(m_currentView->visibleRoles(), QList<QByteArray>());

     slotGroupedSortingChanged(m_currentView->groupedSorting());
     slotGroupedSortingChanged(m_currentView->groupedSorting());

-    slotSortingChanged(m_currentView->sorting());
+    slotSortRoleChanged(m_currentView->sortRole());

     slotZoomLevelChanged(m_currentView->zoomLevel(), -1);
 
     slotZoomLevelChanged(m_currentView->zoomLevel(), -1);
 

-    QAction* showHiddenFilesAction = m_actionCollection->action("show_hidden_files");
-    showHiddenFilesAction->setChecked(m_currentView->hiddenFilesShown());
+    // Updates the "show_hidden_files" action state and icon
+    slotHiddenFilesShownChanged(m_currentView->hiddenFilesShown());

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


@@ -365,12 +471,10 @@ void DolphinViewActionHandler::zoomOut()
     updateViewActions();
 }
 
     updateViewActions();
 }
 

-void DolphinViewActionHandler::toggleSortOrder()
+void DolphinViewActionHandler::zoomReset()

 {
 {

-    const Qt::SortOrder order = (m_currentView->sortOrder() == Qt::AscendingOrder) ?
-                                Qt::DescendingOrder :
-                                Qt::AscendingOrder;
-    m_currentView->setSortOrder(order);
+    m_currentView->resetZoomLevel();
+    updateViewActions();

 }
 
 void DolphinViewActionHandler::toggleSortFoldersFirst()
 }
 
 void DolphinViewActionHandler::toggleSortFoldersFirst()


@@ -381,54 +485,52 @@ void DolphinViewActionHandler::toggleSortFoldersFirst()
 
 void DolphinViewActionHandler::slotSortOrderChanged(Qt::SortOrder order)
 {
 
 void DolphinViewActionHandler::slotSortOrderChanged(Qt::SortOrder order)
 {

-    QAction* descending = m_actionCollection->action("descending");
+    QAction* descending = m_actionCollection->action(QStringLiteral("descending"));
+    QAction* ascending = m_actionCollection->action(QStringLiteral("ascending"));

     const bool sortDescending = (order == Qt::DescendingOrder);
     descending->setChecked(sortDescending);
     const bool sortDescending = (order == Qt::DescendingOrder);
     descending->setChecked(sortDescending);

+    ascending->setChecked(!sortDescending);

 }
 
 void DolphinViewActionHandler::slotSortFoldersFirstChanged(bool foldersFirst)
 {
 }
 
 void DolphinViewActionHandler::slotSortFoldersFirstChanged(bool foldersFirst)
 {

-    m_actionCollection->action("folders_first")->setChecked(foldersFirst);
+    m_actionCollection->action(QStringLiteral("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);
-
-    const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
+    Q_UNUSED(previous)

 
 

-    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));

     }
 }
 
     }
 }
 


@@ -439,7 +541,7 @@ void DolphinViewActionHandler::toggleGroupedSorting(bool grouped)
 
 void DolphinViewActionHandler::slotGroupedSortingChanged(bool groupedSorting)
 {
 
 void DolphinViewActionHandler::slotGroupedSortingChanged(bool groupedSorting)
 {

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

     showInGroupsAction->setChecked(groupedSorting);
 }
 
     showInGroupsAction->setChecked(groupedSorting);
 }
 


@@ -451,71 +553,95 @@ void DolphinViewActionHandler::toggleShowHiddenFiles(bool show)
 
 void DolphinViewActionHandler::slotHiddenFilesShownChanged(bool shown)
 {
 
 void DolphinViewActionHandler::slotHiddenFilesShownChanged(bool shown)
 {

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

     showHiddenFilesAction->setChecked(shown);
     showHiddenFilesAction->setChecked(shown);

+
+    // #374508: don't overwrite custom icons.
+    const QString iconName = showHiddenFilesAction->icon().name();
+    if (!iconName.isEmpty() && iconName != QLatin1String("view-visible") && iconName != QLatin1String("view-hidden")) {
+        return;
+    }
+
+    showHiddenFilesAction->setIcon(QIcon::fromTheme(shown ? QStringLiteral("view-visible") : QStringLiteral("view-hidden")));
+}
+
+void DolphinViewActionHandler::slotWriteStateChanged(bool isFolderWritable)
+{
+    m_actionCollection->action(QStringLiteral("create_dir"))->setEnabled(isFolderWritable &&
+                                                                         KProtocolManager::supportsMakeDir(currentView()->url()));

 }
 
 KToggleAction* DolphinViewActionHandler::iconsModeAction()
 {
 }
 
 KToggleAction* DolphinViewActionHandler::iconsModeAction()
 {

-    KToggleAction* iconsView = m_actionCollection->add<KToggleAction>("icons");
+    KToggleAction* iconsView = m_actionCollection->add<KToggleAction>(QStringLiteral("icons"));

     iconsView->setText(i18nc("@action:inmenu View Mode", "Icons"));
     iconsView->setToolTip(i18nc("@info", "Icons view mode"));
     iconsView->setText(i18nc("@action:inmenu View Mode", "Icons"));
     iconsView->setToolTip(i18nc("@info", "Icons view mode"));

-    iconsView->setShortcut(Qt::CTRL | Qt::Key_1);
-    iconsView->setIcon(KIcon("view-list-icons"));
+    m_actionCollection->setDefaultShortcut(iconsView, Qt::CTRL + Qt::Key_1);
+    iconsView->setIcon(QIcon::fromTheme(QStringLiteral("view-list-icons")));

     iconsView->setData(QVariant::fromValue(DolphinView::IconsView));
     return iconsView;
 }
 
 KToggleAction* DolphinViewActionHandler::compactModeAction()
 {
     iconsView->setData(QVariant::fromValue(DolphinView::IconsView));
     return iconsView;
 }
 
 KToggleAction* DolphinViewActionHandler::compactModeAction()
 {

-    KToggleAction* iconsView = m_actionCollection->add<KToggleAction>("compact");
+    KToggleAction* iconsView = m_actionCollection->add<KToggleAction>(QStringLiteral("compact"));

     iconsView->setText(i18nc("@action:inmenu View Mode", "Compact"));
     iconsView->setToolTip(i18nc("@info", "Compact view mode"));
     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
+    m_actionCollection->setDefaultShortcut(iconsView, Qt::CTRL + Qt::Key_2);
+    iconsView->setIcon(QIcon::fromTheme(QStringLiteral("view-list-details"))); // TODO: discuss with Oxygen-team the wrong (?) name

     iconsView->setData(QVariant::fromValue(DolphinView::CompactView));
     return iconsView;
 }
 
 KToggleAction* DolphinViewActionHandler::detailsModeAction()
 {
     iconsView->setData(QVariant::fromValue(DolphinView::CompactView));
     return iconsView;
 }
 
 KToggleAction* DolphinViewActionHandler::detailsModeAction()
 {

-    KToggleAction* detailsView = m_actionCollection->add<KToggleAction>("details");
+    KToggleAction* detailsView = m_actionCollection->add<KToggleAction>(QStringLiteral("details"));

     detailsView->setText(i18nc("@action:inmenu View Mode", "Details"));
     detailsView->setToolTip(i18nc("@info", "Details view mode"));
     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-tree"));
+    m_actionCollection->setDefaultShortcut(detailsView, Qt::CTRL + Qt::Key_3);
+    detailsView->setIcon(QIcon::fromTheme(QStringLiteral("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);
 

-        QAction* sortByMenu =  m_actionCollection->action("sort");
-        sortByMenu->setIcon(KIcon(action->icon()));
+        if (!action->icon().isNull()) {
+            QAction* sortByMenu = m_actionCollection->action(QStringLiteral("sort"));
+            sortByMenu->setIcon(action->icon());
+        }
+    }
+
+    QAction* descending = m_actionCollection->action(QStringLiteral("descending"));
+    QAction* ascending = m_actionCollection->action(QStringLiteral("ascending"));
+
+    if (role == "text" || role == "type" || role == "tags" || role == "comment") {
+        descending->setText(i18nc("Sort descending", "Z-A"));
+        ascending->setText(i18nc("Sort ascending", "A-Z"));
+    } else if (role == "size") {
+        descending->setText(i18nc("Sort descending", "Largest first"));
+        ascending->setText(i18nc("Sort ascending", "Smallest first"));
+    } else if (role == "modificationtime" || role == "creationtime" || role == "accesstime") {
+        descending->setText(i18nc("Sort descending", "Newest first"));
+        ascending->setText(i18nc("Sort ascending", "Oldest first"));
+    } else if (role == "rating") {
+        descending->setText(i18nc("Sort descending", "Highest first"));
+        ascending->setText(i18nc("Sort ascending", "Lowest first"));
+    } else {
+        descending->setText(i18nc("Sort descending", "Descending"));
+        ascending->setText(i18nc("Sort ascending", "Ascending"));

     }
     }

+
+    slotSortOrderChanged(m_currentView->sortOrder());

 }
 
 void DolphinViewActionHandler::slotZoomLevelChanged(int current, int previous)
 {
 }
 
 void DolphinViewActionHandler::slotZoomLevelChanged(int current, int previous)
 {

-    Q_UNUSED(previous);
+    Q_UNUSED(previous)

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


@@ -530,8 +656,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, except the ascending/
+    // descending actions
+    for (QAction *groupAction : qAsConst(m_sortByActions)) {
+        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()


@@ -542,12 +687,18 @@ void DolphinViewActionHandler::slotAdjustViewProperties()
     delete dialog;
 }
 
     delete dialog;
 }
 

+void DolphinViewActionHandler::slotDuplicate()
+{
+    emit actionBeingHandled();
+    m_currentView->duplicateSelectedItems();
+}
+

 void DolphinViewActionHandler::slotProperties()
 {
 void DolphinViewActionHandler::slotProperties()
 {

-    KPropertiesDialog* dialog = 0;
+    KPropertiesDialog* dialog = nullptr;

     const KFileItemList list = m_currentView->selectedItems();
     if (list.isEmpty()) {
     const KFileItemList list = m_currentView->selectedItems();
     if (list.isEmpty()) {

-        const KUrl url = m_currentView->url();
+        const QUrl url = m_currentView->url();

         dialog = new KPropertiesDialog(url, m_currentView);
     } else {
         dialog = new KPropertiesDialog(list, m_currentView);
         dialog = new KPropertiesDialog(url, m_currentView);
     } else {
         dialog = new KPropertiesDialog(list, m_currentView);