X-Git-Url: https://cloud.milkyroute.net/gitweb/dolphin.git/blobdiff_plain/28a74d178071c89dbdc53a193c1db68e0d10ddcb..18bcab4cf8d6052727363e4eaa0e5174710c77af:/src/views/dolphinview.cpp

diff --git a/src/views/dolphinview.cpp b/src/views/dolphinview.cpp
index 168e282b5..9bbdc3b10 100644
--- a/src/views/dolphinview.cpp
+++ b/src/views/dolphinview.cpp
@@ -7,11 +7,14 @@
 
 #include "dolphinview.h"
 
-#include "dolphin_generalsettings.h"
 #include "dolphin_detailsmodesettings.h"
+#include "dolphin_generalsettings.h"
 #include "dolphinitemlistview.h"
 #include "dolphinnewfilemenuobserver.h"
 #include "draganddrophelper.h"
+#ifndef QT_NO_ACCESSIBILITY
+#include "kitemviews/accessibility/kitemlistviewaccessible.h"
+#endif
 #include "kitemviews/kfileitemlistview.h"
 #include "kitemviews/kfileitemmodel.h"
 #include "kitemviews/kitemlistcontainer.h"
@@ -19,6 +22,7 @@
 #include "kitemviews/kitemlistheader.h"
 #include "kitemviews/kitemlistselectionmanager.h"
 #include "kitemviews/private/kitemlistroleeditor.h"
+#include "selectionmode/singleclickselectionproxystyle.h"
 #include "settings/viewmodes/viewmodesettings.h"
 #include "versioncontrol/versioncontrolobserver.h"
 #include "viewproperties.h"
@@ -34,19 +38,24 @@
 #include <KFileItemListProperties>
 #include <KFormat>
 #include <KIO/CopyJob>
-#include <KIO/DeleteJob>
+#include <KIO/DeleteOrTrashJob>
 #include <KIO/DropJob>
 #include <KIO/JobUiDelegate>
 #include <KIO/Paste>
 #include <KIO/PasteJob>
-#include <KIO/PreviewJob>
 #include <KIO/RenameFileDialog>
 #include <KJobWidgets>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KProtocolManager>
+#include <KUrlMimeData>
+
+#include <kwidgetsaddons_version.h>
 
 #include <QAbstractItemView>
+#ifndef QT_NO_ACCESSIBILITY
+#include <QAccessible>
+#endif
 #include <QActionGroup>
 #include <QApplication>
 #include <QClipboard>
@@ -63,34 +72,35 @@
 #include <QToolTip>
 #include <QVBoxLayout>
 
-DolphinView::DolphinView(const QUrl& url, QWidget* parent) :
-    QWidget(parent),
-    m_active(true),
-    m_tabsForFiles(false),
-    m_assureVisibleCurrentIndex(false),
-    m_isFolderWritable(true),
-    m_dragging(false),
-    m_loading(false),
-    m_url(url),
-    m_viewPropertiesContext(),
-    m_mode(DolphinView::IconsView),
-    m_visibleRoles(),
-    m_topLayout(nullptr),
-    m_model(nullptr),
-    m_view(nullptr),
-    m_container(nullptr),
-    m_toolTipManager(nullptr),
-    m_selectionChangedTimer(nullptr),
-    m_currentItemUrl(),
-    m_scrollToCurrentItem(false),
-    m_restoredContentsPosition(),
-    m_selectedUrls(),
-    m_clearSelectionBeforeSelectingNewItems(false),
-    m_markFirstNewlySelectedItemAsCurrent(false),
-    m_versionControlObserver(nullptr),
-    m_twoClicksRenamingTimer(nullptr),
-    m_placeholderLabel(nullptr),
-    m_showLoadingPlaceholderTimer(nullptr)
+DolphinView::DolphinView(const QUrl &url, QWidget *parent)
+    : QWidget(parent)
+    , m_active(true)
+    , m_tabsForFiles(false)
+    , m_assureVisibleCurrentIndex(false)
+    , m_isFolderWritable(true)
+    , m_dragging(false)
+    , m_selectNextItem(false)
+    , m_url(url)
+    , m_viewPropertiesContext()
+    , m_mode(DolphinView::IconsView)
+    , m_visibleRoles()
+    , m_topLayout(nullptr)
+    , m_model(nullptr)
+    , m_view(nullptr)
+    , m_container(nullptr)
+    , m_toolTipManager(nullptr)
+    , m_selectionChangedTimer(nullptr)
+    , m_currentItemUrl()
+    , m_scrollToCurrentItem(false)
+    , m_restoredContentsPosition()
+    , m_controlWheelAccumulatedDelta(0)
+    , m_selectedUrls()
+    , m_clearSelectionBeforeSelectingNewItems(false)
+    , m_markFirstNewlySelectedItemAsCurrent(false)
+    , m_versionControlObserver(nullptr)
+    , m_twoClicksRenamingTimer(nullptr)
+    , m_placeholderLabel(nullptr)
+    , m_showLoadingPlaceholderTimer(nullptr)
 {
     m_topLayout = new QVBoxLayout(this);
     m_topLayout->setSpacing(0);
@@ -99,24 +109,22 @@ DolphinView::DolphinView(const QUrl& url, QWidget* parent) :
     // When a new item has been created by the "Create New..." menu, the item should
     // get selected and it must be assured that the item will get visible. As the
     // creation is done asynchronously, several signals must be checked:
-    connect(&DolphinNewFileMenuObserver::instance(), &DolphinNewFileMenuObserver::itemCreated,
-            this, &DolphinView::observeCreatedItem);
+    connect(&DolphinNewFileMenuObserver::instance(), &DolphinNewFileMenuObserver::itemCreated, this, &DolphinView::observeCreatedItem);
 
     m_selectionChangedTimer = new QTimer(this);
     m_selectionChangedTimer->setSingleShot(true);
     m_selectionChangedTimer->setInterval(300);
-    connect(m_selectionChangedTimer, &QTimer::timeout,
-            this, &DolphinView::emitSelectionChangedSignal);
+    connect(m_selectionChangedTimer, &QTimer::timeout, this, &DolphinView::emitSelectionChangedSignal);
 
     m_model = new KFileItemModel(this);
     m_view = new DolphinItemListView();
-    m_view->setEnabledSelectionToggles(GeneralSettings::showSelectionToggle());
+    m_view->setEnabledSelectionToggles(DolphinItemListView::SelectionTogglesEnabled::FollowSetting);
     m_view->setVisibleRoles({"text"});
     applyModeToView();
 
-    KItemListController* controller = new KItemListController(m_model, m_view, this);
-    const int delay = GeneralSettings::autoExpandFolders() ? 750 : -1;
-    controller->setAutoActivationDelay(delay);
+    KItemListController *controller = new KItemListController(m_model, m_view, this);
+    controller->setAutoActivationEnabled(GeneralSettings::autoExpandFolders());
+    connect(controller, &KItemListController::doubleClickViewBackground, this, &DolphinView::doubleClickViewBackground);
 
     // The EnlargeSmallPreviews setting can only be changed after the model
     // has been set in the view by KItemListController.
@@ -124,9 +132,16 @@ DolphinView::DolphinView(const QUrl& url, QWidget* parent) :
 
     m_container = new KItemListContainer(controller, this);
     m_container->installEventFilter(this);
+#ifndef QT_NO_ACCESSIBILITY
+    m_view->setAccessibleParentsObject(m_container);
+#endif
     setFocusProxy(m_container);
-    connect(m_container->horizontalScrollBar(), &QScrollBar::valueChanged, this, [=] { hideToolTip(); });
-    connect(m_container->verticalScrollBar(), &QScrollBar::valueChanged, this, [=] { hideToolTip(); });
+    connect(m_container->horizontalScrollBar(), &QScrollBar::valueChanged, this, [this] {
+        hideToolTip();
+    });
+    connect(m_container->verticalScrollBar(), &QScrollBar::valueChanged, this, [this] {
+        hideToolTip();
+    });
 
     m_showLoadingPlaceholderTimer = new QTimer(this);
     m_showLoadingPlaceholderTimer->setInterval(500);
@@ -137,11 +152,13 @@ DolphinView::DolphinView(const QUrl& url, QWidget* parent) :
     // This is made using a heavily-modified QLabel rather than a KTitleWidget
     // because KTitleWidget can't be told to turn off mouse-selectable text
     m_placeholderLabel = new QLabel(this);
+    // Don't consume mouse events
+    m_placeholderLabel->setAttribute(Qt::WA_TransparentForMouseEvents);
+
     QFont placeholderLabelFont;
     // To match the size of a level 2 Heading/KTitleWidget
     placeholderLabelFont.setPointSize(qRound(placeholderLabelFont.pointSize() * 1.3));
     m_placeholderLabel->setFont(placeholderLabelFont);
-    m_placeholderLabel->setTextInteractionFlags(Qt::NoTextInteraction);
     m_placeholderLabel->setWordWrap(true);
     m_placeholderLabel->setAlignment(Qt::AlignCenter);
     // Match opacity of QML placeholder label component
@@ -172,42 +189,42 @@ DolphinView::DolphinView(const QUrl& url, QWidget* parent) :
     connect(controller, &KItemListController::increaseZoom, this, &DolphinView::slotIncreaseZoom);
     connect(controller, &KItemListController::decreaseZoom, this, &DolphinView::slotDecreaseZoom);
     connect(controller, &KItemListController::swipeUp, this, &DolphinView::slotSwipeUp);
-
-    connect(m_model, &KFileItemModel::directoryLoadingStarted,       this, &DolphinView::slotDirectoryLoadingStarted);
-    connect(m_model, &KFileItemModel::directoryLoadingCompleted,     this, &DolphinView::slotDirectoryLoadingCompleted);
-    connect(m_model, &KFileItemModel::directoryLoadingCanceled,      this, &DolphinView::slotDirectoryLoadingCanceled);
-    connect(m_model, &KFileItemModel::directoryLoadingProgress,   this, &DolphinView::directoryLoadingProgress);
-    connect(m_model, &KFileItemModel::directorySortingProgress,   this, &DolphinView::directorySortingProgress);
-    connect(m_model, &KFileItemModel::itemsChanged,
-            this, &DolphinView::slotItemsChanged);
-    connect(m_model, &KFileItemModel::itemsRemoved,    this, &DolphinView::itemCountChanged);
-    connect(m_model, &KFileItemModel::itemsInserted,   this, &DolphinView::itemCountChanged);
-    connect(m_model, &KFileItemModel::infoMessage,            this, &DolphinView::infoMessage);
-    connect(m_model, &KFileItemModel::errorMessage,           this, &DolphinView::errorMessage);
+    connect(controller, &KItemListController::selectionModeChangeRequested, this, &DolphinView::selectionModeChangeRequested);
+
+    connect(m_model, &KFileItemModel::directoryLoadingStarted, this, &DolphinView::slotDirectoryLoadingStarted);
+    connect(m_model, &KFileItemModel::directoryLoadingCompleted, this, &DolphinView::slotDirectoryLoadingCompleted);
+    connect(m_model, &KFileItemModel::directoryLoadingCanceled, this, &DolphinView::slotDirectoryLoadingCanceled);
+    connect(m_model, &KFileItemModel::directoryLoadingProgress, this, &DolphinView::directoryLoadingProgress);
+    connect(m_model, &KFileItemModel::directorySortingProgress, this, &DolphinView::directorySortingProgress);
+    connect(m_model, &KFileItemModel::itemsChanged, this, &DolphinView::slotItemsChanged);
+    connect(m_model, &KFileItemModel::itemsRemoved, this, &DolphinView::itemCountChanged);
+    connect(m_model, &KFileItemModel::itemsInserted, this, &DolphinView::itemCountChanged);
+    connect(m_model, &KFileItemModel::infoMessage, this, &DolphinView::infoMessage);
+    connect(m_model, &KFileItemModel::errorMessage, this, &DolphinView::errorMessage);
     connect(m_model, &KFileItemModel::directoryRedirection, this, &DolphinView::slotDirectoryRedirection);
-    connect(m_model, &KFileItemModel::urlIsFileError,            this, &DolphinView::urlIsFileError);
-    connect(m_model, &KFileItemModel::fileItemsChanged,            this, &DolphinView::fileItemsChanged);
+    connect(m_model, &KFileItemModel::urlIsFileError, this, &DolphinView::urlIsFileError);
+    connect(m_model, &KFileItemModel::fileItemsChanged, this, &DolphinView::fileItemsChanged);
+    connect(m_model, &KFileItemModel::currentDirectoryRemoved, this, &DolphinView::currentDirectoryRemoved);
 
-    connect(this, &DolphinView::itemCountChanged,
-            this, &DolphinView::updatePlaceholderLabel);
+    connect(this, &DolphinView::itemCountChanged, this, &DolphinView::updatePlaceholderLabel);
 
     m_view->installEventFilter(this);
-    connect(m_view, &DolphinItemListView::sortOrderChanged,
-            this, &DolphinView::slotSortOrderChangedByHeader);
-    connect(m_view, &DolphinItemListView::sortRoleChanged,
-            this, &DolphinView::slotSortRoleChangedByHeader);
-    connect(m_view, &DolphinItemListView::visibleRolesChanged,
-            this, &DolphinView::slotVisibleRolesChangedByHeader);
-    connect(m_view, &DolphinItemListView::roleEditingCanceled,
-            this, &DolphinView::slotRoleEditingCanceled);
-    connect(m_view->header(), &KItemListHeader::columnWidthChangeFinished,
-            this, &DolphinView::slotHeaderColumnWidthChangeFinished);
-    connect(m_view->header(), &KItemListHeader::sidePaddingChanged,
-            this, &DolphinView::slotSidePaddingWidthChanged);
-
-    KItemListSelectionManager* selectionManager = controller->selectionManager();
-    connect(selectionManager, &KItemListSelectionManager::selectionChanged,
-            this, &DolphinView::slotSelectionChanged);
+    connect(m_view, &DolphinItemListView::sortOrderChanged, this, &DolphinView::slotSortOrderChangedByHeader);
+    connect(m_view, &DolphinItemListView::sortRoleChanged, this, &DolphinView::slotSortRoleChangedByHeader);
+    connect(m_view, &DolphinItemListView::visibleRolesChanged, this, &DolphinView::slotVisibleRolesChangedByHeader);
+    connect(m_view, &DolphinItemListView::roleEditingCanceled, this, &DolphinView::slotRoleEditingCanceled);
+
+    connect(m_view, &DolphinItemListView::columnHovered, this, [this](int columnIndex) {
+        m_hoveredColumnHeaderIndex = columnIndex;
+    });
+    connect(m_view, &DolphinItemListView::columnUnHovered, this, [this](int /* columnIndex */) {
+        m_hoveredColumnHeaderIndex = std::nullopt;
+    });
+    connect(m_view->header(), &KItemListHeader::columnWidthChangeFinished, this, &DolphinView::slotHeaderColumnWidthChangeFinished);
+    connect(m_view->header(), &KItemListHeader::sidePaddingChanged, this, &DolphinView::slotSidePaddingWidthChanged);
+
+    KItemListSelectionManager *selectionManager = controller->selectionManager();
+    connect(selectionManager, &KItemListSelectionManager::selectionChanged, this, &DolphinView::slotSelectionChanged);
 
 #if HAVE_BALOO
     m_toolTipManager = new ToolTipManager(this);
@@ -218,7 +235,9 @@ DolphinView::DolphinView(const QUrl& url, QWidget* parent) :
     m_versionControlObserver->setView(this);
     m_versionControlObserver->setModel(m_model);
     connect(m_versionControlObserver, &VersionControlObserver::infoMessage, this, &DolphinView::infoMessage);
-    connect(m_versionControlObserver, &VersionControlObserver::errorMessage, this, &DolphinView::errorMessage);
+    connect(m_versionControlObserver, &VersionControlObserver::errorMessage, this, [this](const QString &message) {
+        Q_EMIT errorMessage(message, KIO::ERR_UNKNOWN);
+    });
     connect(m_versionControlObserver, &VersionControlObserver::operationCompletedMessage, this, &DolphinView::operationCompletedMessage);
 
     m_twoClicksRenamingTimer = new QTimer(this);
@@ -233,6 +252,7 @@ DolphinView::DolphinView(const QUrl& url, QWidget* parent) :
 
 DolphinView::~DolphinView()
 {
+    disconnect(m_container->controller(), &KItemListController::modelChanged, this, &DolphinView::slotModelChanged);
 }
 
 QUrl DolphinView::url() const
@@ -253,7 +273,6 @@ void DolphinView::setActive(bool active)
     if (active) {
         m_container->setFocus();
         Q_EMIT activated();
-        Q_EMIT writeStateChanged(m_isFolderWritable);
     }
 }
 
@@ -262,9 +281,13 @@ bool DolphinView::isActive() const
     return m_active;
 }
 
-void DolphinView::setMode(Mode mode)
+void DolphinView::setViewMode(Mode mode)
 {
     if (mode != m_mode) {
+        // Reset scrollbars before changing the view mode.
+        m_container->horizontalScrollBar()->setValue(0);
+        m_container->verticalScrollBar()->setValue(0);
+
         ViewProperties props(viewPropertiesUrl());
         props.setViewMode(mode);
 
@@ -276,11 +299,39 @@ void DolphinView::setMode(Mode mode)
     }
 }
 
-DolphinView::Mode DolphinView::mode() const
+DolphinView::Mode DolphinView::viewMode() const
 {
     return m_mode;
 }
 
+void DolphinView::setSelectionModeEnabled(const bool enabled)
+{
+    if (enabled) {
+        if (!m_proxyStyle) {
+            m_proxyStyle = std::make_unique<SelectionMode::SingleClickSelectionProxyStyle>();
+        }
+        setStyle(m_proxyStyle.get());
+        m_view->setStyle(m_proxyStyle.get());
+        m_view->setEnabledSelectionToggles(DolphinItemListView::SelectionTogglesEnabled::False);
+    } else {
+        setStyle(nullptr);
+        m_view->setStyle(nullptr);
+        m_view->setEnabledSelectionToggles(DolphinItemListView::SelectionTogglesEnabled::FollowSetting);
+    }
+    m_container->controller()->setSelectionModeEnabled(enabled);
+#ifndef QT_NO_ACCESSIBILITY
+    if (QAccessible::isActive()) {
+        auto accessibleViewInterface = static_cast<KItemListViewAccessible *>(QAccessible::queryAccessibleInterface(m_view));
+        accessibleViewInterface->announceSelectionModeEnabled(enabled);
+    }
+#endif
+}
+
+bool DolphinView::selectionMode() const
+{
+    return m_container->controller()->selectionMode();
+}
+
 void DolphinView::setPreviewsShown(bool show)
 {
     if (previewsShown() == show) {
@@ -335,9 +386,8 @@ void DolphinView::setGroupedSorting(bool grouped)
 
     ViewProperties props(viewPropertiesUrl());
     props.setGroupedSorting(grouped);
-    props.save();
 
-    m_container->controller()->model()->setGroupedSorting(grouped);
+    m_model->setGroupedSorting(grouped);
 
     Q_EMIT groupedSortingChanged(grouped);
 }
@@ -367,7 +417,7 @@ int DolphinView::itemsCount() const
 
 KFileItemList DolphinView::selectedItems() const
 {
-    const KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
+    const KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
 
     KFileItemList selectedItems;
     const auto items = selectionManager->selectedItems();
@@ -380,13 +430,14 @@ KFileItemList DolphinView::selectedItems() const
 
 int DolphinView::selectedItemsCount() const
 {
-    const KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
+    const KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
     return selectionManager->selectedItems().count();
 }
 
-void DolphinView::markUrlsAsSelected(const QList<QUrl>& urls)
+void DolphinView::markUrlsAsSelected(const QList<QUrl> &urls)
 {
     m_selectedUrls = urls;
+    m_selectJobCreatedItems = false;
 }
 
 void DolphinView::markUrlAsCurrent(const QUrl &url)
@@ -397,10 +448,8 @@ void DolphinView::markUrlAsCurrent(const QUrl &url)
 
 void DolphinView::selectItems(const QRegularExpression &regexp, bool enabled)
 {
-    const KItemListSelectionManager::SelectionMode mode = enabled
-                                                        ? KItemListSelectionManager::Select
-                                                        : KItemListSelectionManager::Deselect;
-    KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
+    const KItemListSelectionManager::SelectionMode mode = enabled ? KItemListSelectionManager::Select : KItemListSelectionManager::Deselect;
+    KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
 
     for (int index = 0; index < m_model->count(); index++) {
         const KFileItem item = m_model->fileItem(index);
@@ -429,23 +478,34 @@ int DolphinView::zoomLevel() const
     return m_view->zoomLevel();
 }
 
-void DolphinView::setSortRole(const QByteArray& role)
+void DolphinView::setSortRole(const QByteArray &role)
 {
     if (role != sortRole()) {
-        updateSortRole(role);
+        ViewProperties props(viewPropertiesUrl());
+        props.setSortRole(role);
+
+        KItemModelBase *model = m_container->controller()->model();
+        model->setSortRole(role);
+
+        Q_EMIT sortRoleChanged(role);
     }
 }
 
 QByteArray DolphinView::sortRole() const
 {
-    const KItemModelBase* model = m_container->controller()->model();
+    const KItemModelBase *model = m_container->controller()->model();
     return model->sortRole();
 }
 
 void DolphinView::setSortOrder(Qt::SortOrder order)
 {
     if (sortOrder() != order) {
-        updateSortOrder(order);
+        ViewProperties props(viewPropertiesUrl());
+        props.setSortOrder(order);
+
+        m_model->setSortOrder(order);
+
+        Q_EMIT sortOrderChanged(order);
     }
 }
 
@@ -478,7 +538,7 @@ bool DolphinView::sortHiddenLast() const
     return m_model->sortHiddenLast();
 }
 
-void DolphinView::setVisibleRoles(const QList<QByteArray>& roles)
+void DolphinView::setVisibleRoles(const QList<QByteArray> &roles)
 {
     const QList<QByteArray> previousRoles = roles;
 
@@ -517,8 +577,7 @@ void DolphinView::readSettings()
     m_view->readSettings();
     applyViewProperties();
 
-    const int delay = GeneralSettings::autoExpandFolders() ? 750 : -1;
-    m_container->controller()->setAutoActivationDelay(delay);
+    m_container->controller()->setAutoActivationEnabled(GeneralSettings::autoExpandFolders());
 
     const int newZoomLevel = m_view->zoomLevel();
     if (newZoomLevel != oldZoomLevel) {
@@ -532,7 +591,7 @@ void DolphinView::writeSettings()
     m_view->writeSettings();
 }
 
-void DolphinView::setNameFilter(const QString& nameFilter)
+void DolphinView::setNameFilter(const QString &nameFilter)
 {
     m_model->setNameFilter(nameFilter);
 }
@@ -542,7 +601,7 @@ QString DolphinView::nameFilter() const
     return m_model->nameFilter();
 }
 
-void DolphinView::setMimeTypeFilters(const QStringList& filters)
+void DolphinView::setMimeTypeFilters(const QStringList &filters)
 {
     return m_model->setMimeTypeFilters(filters);
 }
@@ -566,7 +625,7 @@ void DolphinView::requestStatusBarText()
 
         // Give a summary of the status of the selected files
         const KFileItemList list = selectedItems();
-        for (const KFileItem& item : list) {
+        for (const KFileItem &item : list) {
             if (item.isDir()) {
                 ++folderCount;
             } else {
@@ -587,16 +646,13 @@ void DolphinView::requestStatusBarText()
             return;
         }
 
-        m_statJobForStatusBarText = KIO::statDetails(m_model->rootItem().url(),
-                        KIO::StatJob::SourceSide, KIO::StatRecursiveSize, KIO::HideProgressInfo);
-        connect(m_statJobForStatusBarText, &KJob::result,
-                this, &DolphinView::slotStatJobResult);
+        m_statJobForStatusBarText = KIO::stat(m_model->rootItem().url(), KIO::StatJob::SourceSide, KIO::StatRecursiveSize, KIO::HideProgressInfo);
+        connect(m_statJobForStatusBarText, &KJob::result, this, &DolphinView::slotStatJobResult);
         m_statJobForStatusBarText->start();
     }
 }
 
-void DolphinView::emitStatusBarText(const int folderCount, const int fileCount,
-                                    KIO::filesize_t totalFileSize, const Selection selection)
+void DolphinView::emitStatusBarText(const int folderCount, const int fileCount, KIO::filesize_t totalFileSize, const Selection selection)
 {
     QString foldersText;
     QString filesText;
@@ -605,32 +661,28 @@ void DolphinView::emitStatusBarText(const int folderCount, const int fileCount,
     if (selection == HasSelection) {
         // At least 2 items are selected because the case of 1 selected item is handled in
         // DolphinView::requestStatusBarText().
-        foldersText = i18ncp("@info:status", "1 Folder selected", "%1 Folders selected", folderCount);
-        filesText = i18ncp("@info:status", "1 File selected", "%1 Files selected", fileCount);
+        foldersText = i18ncp("@info:status", "1 folder selected", "%1 folders selected", folderCount);
+        filesText = i18ncp("@info:status", "1 file selected", "%1 files selected", fileCount);
     } else {
-        foldersText = i18ncp("@info:status", "1 Folder", "%1 Folders", folderCount);
-        filesText = i18ncp("@info:status", "1 File", "%1 Files", fileCount);
+        foldersText = i18ncp("@info:status", "1 folder", "%1 folders", folderCount);
+        filesText = i18ncp("@info:status", "1 file", "%1 files", fileCount);
     }
 
     if (fileCount > 0 && folderCount > 0) {
-        summary = i18nc("@info:status folders, files (size)", "%1, %2 (%3)",
-                        foldersText, filesText,
-                        KFormat().formatByteSize(totalFileSize));
+        summary = i18nc("@info:status folders, files (size)", "%1, %2 (%3)", foldersText, filesText, KFormat().formatByteSize(totalFileSize));
     } else if (fileCount > 0) {
-        summary = i18nc("@info:status files (size)", "%1 (%2)",
-                        filesText,
-                        KFormat().formatByteSize(totalFileSize));
+        summary = i18nc("@info:status files (size)", "%1 (%2)", filesText, KFormat().formatByteSize(totalFileSize));
     } else if (folderCount > 0) {
         summary = foldersText;
     } else {
-        summary = i18nc("@info:status", "0 Folders, 0 Files");
+        summary = i18nc("@info:status", "0 folders, 0 files");
     }
     Q_EMIT statusBarTextChanged(summary);
 }
 
-QList<QAction*> DolphinView::versionControlActions(const KFileItemList& items) const
+QList<QAction *> DolphinView::versionControlActions(const KFileItemList &items) const
 {
-    QList<QAction*> actions;
+    QList<QAction *> actions;
 
     if (items.isEmpty()) {
         const KFileItem item = m_model->rootItem();
@@ -644,7 +696,7 @@ QList<QAction*> DolphinView::versionControlActions(const KFileItemList& items) c
     return actions;
 }
 
-void DolphinView::setUrl(const QUrl& url)
+void DolphinView::setUrl(const QUrl &url)
 {
     if (url == m_url) {
         return;
@@ -656,8 +708,7 @@ void DolphinView::setUrl(const QUrl& url)
 
     hideToolTip();
 
-    disconnect(m_view, &DolphinItemListView::roleEditingFinished,
-               this, &DolphinView::slotRoleEditingFinished);
+    disconnect(m_view, &DolphinItemListView::roleEditingFinished, this, &DolphinView::slotRoleEditingFinished);
 
     // It is important to clear the items from the model before
     // applying the view properties, otherwise expensive operations
@@ -672,18 +723,19 @@ void DolphinView::setUrl(const QUrl& url)
 
 void DolphinView::selectAll()
 {
-    KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
+    KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
     selectionManager->setSelected(0, m_model->count());
 }
 
 void DolphinView::invertSelection()
 {
-    KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
+    KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
     selectionManager->setSelected(0, m_model->count(), KItemListSelectionManager::Toggle);
 }
 
 void DolphinView::clearSelection()
 {
+    m_selectJobCreatedItems = false;
     m_selectedUrls.clear();
     m_container->controller()->selectionManager()->clearSelection();
 }
@@ -698,24 +750,39 @@ void DolphinView::renameSelectedItems()
     if (items.count() == 1 && GeneralSettings::renameInline()) {
         const int index = m_model->index(items.first());
 
-        QMetaObject::Connection * const connection = new QMetaObject::Connection;
-        *connection = connect(m_view, &KItemListView::scrollingStopped, this, [=](){
-            QObject::disconnect(*connection);
-            delete connection;
+        connect(
+            m_view,
+            &KItemListView::scrollingStopped,
+            this,
+            [this, index]() {
+                m_view->editRole(index, "text");
 
-            m_view->editRole(index, "text");
+                hideToolTip();
 
-            hideToolTip();
-
-            connect(m_view, &DolphinItemListView::roleEditingFinished,
-                    this, &DolphinView::slotRoleEditingFinished);
-        });
+                connect(m_view, &DolphinItemListView::roleEditingFinished, this, &DolphinView::slotRoleEditingFinished);
+            },
+            Qt::SingleShotConnection);
         m_view->scrollToItem(index);
 
     } else {
-        KIO::RenameFileDialog* dialog = new KIO::RenameFileDialog(items, this);
-        connect(dialog, &KIO::RenameFileDialog::renamingFinished,
-                this, &DolphinView::slotRenameDialogRenamingFinished);
+        KIO::RenameFileDialog *dialog = new KIO::RenameFileDialog(items, this);
+        connect(dialog, &KIO::RenameFileDialog::renamingFinished, this, [this, items](const QList<QUrl> &urls) {
+            // The model may have already been updated, so it's possible that we don't find the old items.
+            for (int i = 0; i < items.count(); ++i) {
+                const int index = m_model->index(items[i]);
+                if (index >= 0) {
+                    QHash<QByteArray, QVariant> data;
+                    data.insert("text", urls[i].fileName());
+                    m_model->setData(index, data);
+                }
+            }
+
+            forceUrlsSelection(urls.first(), urls);
+            updateSelectionState();
+        });
+        connect(dialog, &KIO::RenameFileDialog::error, this, [this](KJob *job) {
+            KMessageBox::error(this, job->errorString());
+        });
 
         dialog->open();
     }
@@ -729,63 +796,76 @@ void DolphinView::renameSelectedItems()
 void DolphinView::trashSelectedItems()
 {
     const QList<QUrl> list = simplifiedSelectedUrls();
-    KIO::JobUiDelegate uiDelegate;
-    uiDelegate.setWindow(window());
-    if (uiDelegate.askDeleteConfirmation(list, KIO::JobUiDelegate::Trash, KIO::JobUiDelegate::DefaultConfirmation)) {
-        KIO::Job* job = KIO::trash(list);
-        KIO::FileUndoManager::self()->recordJob(KIO::FileUndoManager::Trash, list, QUrl(QStringLiteral("trash:/")), job);
-        KJobWidgets::setWindow(job, this);
-        connect(job, &KIO::Job::result,
-                this, &DolphinView::slotTrashFileFinished);
-    }
+
+    using Iface = KIO::AskUserActionInterface;
+    auto *trashJob = new KIO::DeleteOrTrashJob(list, Iface::Trash, Iface::DefaultConfirmation, this);
+    connect(trashJob, &KJob::result, this, &DolphinView::slotTrashFileFinished);
+    m_selectNextItem = true;
+    trashJob->start();
 }
 
 void DolphinView::deleteSelectedItems()
 {
     const QList<QUrl> list = simplifiedSelectedUrls();
 
-    KIO::JobUiDelegate uiDelegate;
-    uiDelegate.setWindow(window());
-    if (uiDelegate.askDeleteConfirmation(list, KIO::JobUiDelegate::Delete, KIO::JobUiDelegate::DefaultConfirmation)) {
-        KIO::Job* job = KIO::del(list);
-        KJobWidgets::setWindow(job, this);
-        connect(job, &KIO::Job::result,
-                this, &DolphinView::slotDeleteFileFinished);
-    }
+    using Iface = KIO::AskUserActionInterface;
+    auto *trashJob = new KIO::DeleteOrTrashJob(list, Iface::Delete, Iface::DefaultConfirmation, this);
+    connect(trashJob, &KJob::result, this, &DolphinView::slotDeleteFileFinished);
+    m_selectNextItem = true;
+    trashJob->start();
 }
 
 void DolphinView::cutSelectedItemsToClipboard()
 {
-    QMimeData* mimeData = selectionMimeData();
+    QMimeData *mimeData = selectionMimeData();
     KIO::setClipboardDataCut(mimeData, true);
+    KUrlMimeData::exportUrlsToPortal(mimeData);
     QApplication::clipboard()->setMimeData(mimeData);
 }
 
 void DolphinView::copySelectedItemsToClipboard()
 {
-    QMimeData* mimeData = selectionMimeData();
+    QMimeData *mimeData = selectionMimeData();
+    KUrlMimeData::exportUrlsToPortal(mimeData);
     QApplication::clipboard()->setMimeData(mimeData);
 }
 
 void DolphinView::copySelectedItems(const KFileItemList &selection, const QUrl &destinationUrl)
 {
-    KIO::CopyJob* job = KIO::copy(selection.urlList(), destinationUrl, KIO::DefaultFlags);
+    if (selection.isEmpty() || !destinationUrl.isValid()) {
+        return;
+    }
+
+    m_clearSelectionBeforeSelectingNewItems = true;
+    m_markFirstNewlySelectedItemAsCurrent = true;
+    m_selectJobCreatedItems = true;
+
+    KIO::CopyJob *job = KIO::copy(selection.urlList(), destinationUrl, KIO::DefaultFlags);
     KJobWidgets::setWindow(job, this);
 
-    connect(job, &KIO::DropJob::result, this, &DolphinView::slotJobResult);
-    connect(job, &KIO::CopyJob::copyingDone, this, &DolphinView::slotCopyingDone);
+    connect(job, &KIO::CopyJob::result, this, &DolphinView::slotJobResult);
+    connect(job, &KIO::CopyJob::copying, this, &DolphinView::slotItemCreatedFromJob);
+    connect(job, &KIO::CopyJob::copyingDone, this, &DolphinView::slotItemCreatedFromJob);
     KIO::FileUndoManager::self()->recordCopyJob(job);
 }
 
 void DolphinView::moveSelectedItems(const KFileItemList &selection, const QUrl &destinationUrl)
 {
-    KIO::CopyJob* job = KIO::move(selection.urlList(), destinationUrl, KIO::DefaultFlags);
+    if (selection.isEmpty() || !destinationUrl.isValid()) {
+        return;
+    }
+
+    m_clearSelectionBeforeSelectingNewItems = true;
+    m_markFirstNewlySelectedItemAsCurrent = true;
+    m_selectJobCreatedItems = true;
+
+    KIO::CopyJob *job = KIO::move(selection.urlList(), destinationUrl, KIO::DefaultFlags);
     KJobWidgets::setWindow(job, this);
 
-    connect(job, &KIO::DropJob::result, this, &DolphinView::slotJobResult);
-    connect(job, &KIO::CopyJob::copyingDone, this, &DolphinView::slotCopyingDone);
+    connect(job, &KIO::CopyJob::result, this, &DolphinView::slotJobResult);
+    connect(job, &KIO::CopyJob::moving, this, &DolphinView::slotItemCreatedFromJob);
+    connect(job, &KIO::CopyJob::copyingDone, this, &DolphinView::slotItemCreatedFromJob);
     KIO::FileUndoManager::self()->recordCopyJob(job);
-
 }
 
 void DolphinView::paste()
@@ -810,11 +890,14 @@ void DolphinView::duplicateSelectedItems()
 
     const QMimeDatabase db;
 
+    m_clearSelectionBeforeSelectingNewItems = true;
+    m_markFirstNewlySelectedItemAsCurrent = true;
+    m_selectJobCreatedItems = true;
+
     // Duplicate all selected items and append "copy" to the end of the file name
     // but before the filename extension, if present
-    QList<QUrl> newSelection;
     for (const auto &item : itemList) {
-        const QUrl originalURL  = item.url();
+        const QUrl originalURL = item.url();
         const QString originalDirectoryPath = originalURL.adjusted(QUrl::RemoveFilename).path();
         const QString originalFileName = item.name();
 
@@ -825,7 +908,7 @@ void DolphinView::duplicateSelectedItems()
         // No extension; new filename is "<oldfilename> copy"
         if (extension.isEmpty()) {
             duplicateURL.setPath(originalDirectoryPath + i18nc("<filename> copy", "%1 copy", originalFileName));
-        // There's an extension; new filename is "<oldfilename> copy.<extension>"
+            // There's an extension; new filename is "<oldfilename> copy.<extension>"
         } else {
             // Need to add a dot since QMimeDatabase::suffixForFileName() doesn't include it
             extension = QLatin1String(".") + extension;
@@ -836,16 +919,15 @@ void DolphinView::duplicateSelectedItems()
             duplicateURL.setPath(originalDirectoryPath + i18nc("<filename> copy", "%1 copy", originalFilenameWithoutExtension) + originalExtension);
         }
 
-        KIO::CopyJob* job = KIO::copyAs(originalURL, duplicateURL);
+        KIO::CopyJob *job = KIO::copyAs(originalURL, duplicateURL);
+        job->setAutoRename(true);
         KJobWidgets::setWindow(job, this);
 
-        if (job) {
-            newSelection << duplicateURL;
-            KIO::FileUndoManager::self()->recordCopyJob(job);
-        }
+        connect(job, &KIO::CopyJob::result, this, &DolphinView::slotJobResult);
+        connect(job, &KIO::CopyJob::copyingDone, this, &DolphinView::slotItemCreatedFromJob);
+        connect(job, &KIO::CopyJob::copyingLinkDone, this, &DolphinView::slotItemLinkCreatedFromJob);
+        KIO::FileUndoManager::self()->recordCopyJob(job);
     }
-
-    forceUrlsSelection(newSelection.first(), newSelection);
 }
 
 void DolphinView::stopLoading()
@@ -860,7 +942,7 @@ void DolphinView::updatePalette()
         color.setAlpha(150);
     }
 
-    QWidget* viewport = m_container->viewport();
+    QWidget *viewport = m_container->viewport();
     if (viewport) {
         QPalette palette;
         palette.setColor(viewport->backgroundRole(), color);
@@ -876,7 +958,7 @@ void DolphinView::abortTwoClicksRenaming()
     m_twoClicksRenamingTimer->stop();
 }
 
-bool DolphinView::eventFilter(QObject* watched, QEvent* event)
+bool DolphinView::eventFilter(QObject *watched, QEvent *event)
 {
     switch (event->type()) {
     case QEvent::PaletteChange:
@@ -892,13 +974,18 @@ bool DolphinView::eventFilter(QObject* watched, QEvent* event)
     case QEvent::KeyPress:
         hideToolTip(ToolTipManager::HideBehavior::Instantly);
         if (GeneralSettings::useTabForSwitchingSplitView()) {
-            QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
+            QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
             if (keyEvent->key() == Qt::Key_Tab && keyEvent->modifiers() == Qt::NoModifier) {
                 Q_EMIT toggleActiveViewRequested();
                 return true;
             }
         }
         break;
+    case QEvent::KeyRelease:
+        if (static_cast<QKeyEvent *>(event)->key() == Qt::Key_Control) {
+            m_controlWheelAccumulatedDelta = 0;
+        }
+        break;
     case QEvent::FocusIn:
         if (watched == m_container) {
             setActive(true);
@@ -924,9 +1011,24 @@ bool DolphinView::eventFilter(QObject* watched, QEvent* event)
         }
         break;
 
-    case QEvent::ToolTip:
-        tryShowNameToolTip(event);
+    case QEvent::ToolTip: {
+        const auto helpEvent = static_cast<QHelpEvent *>(event);
+        if (tryShowNameToolTip(helpEvent)) {
+            return true;
+
+        } else if (m_hoveredColumnHeaderIndex) {
+            const auto rolesInfo = KFileItemModel::rolesInformation();
+            const auto visibleRole = m_visibleRoles.value(*m_hoveredColumnHeaderIndex);
 
+            for (const KFileItemModel::RoleInfo &info : rolesInfo) {
+                if (visibleRole == info.role) {
+                    QToolTip::showText(helpEvent->globalPos(), info.tooltip, this);
+                    return true;
+                }
+            }
+        }
+        break;
+    }
     default:
         break;
     }
@@ -934,26 +1036,32 @@ bool DolphinView::eventFilter(QObject* watched, QEvent* event)
     return QWidget::eventFilter(watched, event);
 }
 
-void DolphinView::wheelEvent(QWheelEvent* event)
+void DolphinView::wheelEvent(QWheelEvent *event)
 {
     if (event->modifiers().testFlag(Qt::ControlModifier)) {
-        const QPoint numDegrees = event->angleDelta() / 8;
-        const QPoint numSteps = numDegrees / 15;
+        m_controlWheelAccumulatedDelta += event->angleDelta().y();
+
+        if (m_controlWheelAccumulatedDelta <= -QWheelEvent::DefaultDeltasPerStep) {
+            slotDecreaseZoom();
+            m_controlWheelAccumulatedDelta += QWheelEvent::DefaultDeltasPerStep;
+        } else if (m_controlWheelAccumulatedDelta >= QWheelEvent::DefaultDeltasPerStep) {
+            slotIncreaseZoom();
+            m_controlWheelAccumulatedDelta -= QWheelEvent::DefaultDeltasPerStep;
+        }
 
-        setZoomLevel(zoomLevel() + numSteps.y());
         event->accept();
     } else {
         event->ignore();
     }
 }
 
-void DolphinView::hideEvent(QHideEvent* event)
+void DolphinView::hideEvent(QHideEvent *event)
 {
     hideToolTip();
     QWidget::hideEvent(event);
 }
 
-bool DolphinView::event(QEvent* event)
+bool DolphinView::event(QEvent *event)
 {
     if (event->type() == QEvent::WindowDeactivate) {
         /* See Bug 297355
@@ -993,8 +1101,14 @@ void DolphinView::slotItemsActivated(const KItemSet &indexes)
 
     if (indexes.count() > 5) {
         QString question = i18np("Are you sure you want to open 1 item?", "Are you sure you want to open %1 items?", indexes.count());
-        const int answer = KMessageBox::warningYesNo(this, question);
-        if (answer != KMessageBox::Yes) {
+        const int answer = KMessageBox::warningContinueCancel(
+            this,
+            question,
+            {},
+            KGuiItem(i18ncp("@action:button", "Open %1 Item", "Open %1 Items", indexes.count()), QStringLiteral("document-open")),
+            KStandardGuiItem::cancel(),
+            QStringLiteral("ConfirmOpenManyFolders"));
+        if (answer != KMessageBox::PrimaryAction && answer != KMessageBox::Continue) {
             return;
         }
     }
@@ -1004,7 +1118,7 @@ void DolphinView::slotItemsActivated(const KItemSet &indexes)
 
     for (int index : indexes) {
         KFileItem item = m_model->fileItem(index);
-        const QUrl& url = openItemAsFolderUrl(item);
+        const QUrl &url = openItemAsFolderUrl(item);
 
         if (!url.isEmpty()) {
             // Open folders in new tabs or in new windows depending on the modifier
@@ -1029,8 +1143,8 @@ void DolphinView::slotItemsActivated(const KItemSet &indexes)
 
 void DolphinView::slotItemMiddleClicked(int index)
 {
-    const KFileItem& item = m_model->fileItem(index);
-    const QUrl& url = openItemAsFolderUrl(item);
+    const KFileItem &item = m_model->fileItem(index);
+    const QUrl &url = openItemAsFolderUrl(item, GeneralSettings::browseThroughArchives());
     const auto modifiers = QGuiApplication::keyboardModifiers();
     if (!url.isEmpty()) {
         // keep in sync with KUrlNavigator::slotNavigatorButtonClicked
@@ -1046,33 +1160,38 @@ void DolphinView::slotItemMiddleClicked(int index)
         } else {
             Q_EMIT tabRequested(item.url());
         }
+    } else {
+        Q_EMIT fileMiddleClickActivated(item);
     }
 }
 
-void DolphinView::slotItemContextMenuRequested(int index, const QPointF& pos)
+void DolphinView::slotItemContextMenuRequested(int index, const QPointF &pos)
 {
     // Force emit of a selection changed signal before we request the
     // context menu, to update the edit-actions first. (See Bug 294013)
     if (m_selectionChangedTimer->isActive()) {
         emitSelectionChangedSignal();
     }
+    if (m_twoClicksRenamingTimer->isActive()) {
+        abortTwoClicksRenaming();
+    }
 
     const KFileItem item = m_model->fileItem(index);
     Q_EMIT requestContextMenu(pos.toPoint(), item, selectedItems(), url());
 }
 
-void DolphinView::slotViewContextMenuRequested(const QPointF& pos)
+void DolphinView::slotViewContextMenuRequested(const QPointF &pos)
 {
     Q_EMIT requestContextMenu(pos.toPoint(), KFileItem(), selectedItems(), url());
 }
 
-void DolphinView::slotHeaderContextMenuRequested(const QPointF& pos)
+void DolphinView::slotHeaderContextMenuRequested(const QPointF &pos)
 {
     ViewProperties props(viewPropertiesUrl());
 
-    QPointer<QMenu> menu = new QMenu(QApplication::activeWindow());
+    QPointer<QMenu> menu = new QMenu(this);
 
-    KItemListView* view = m_container->controller()->view();
+    KItemListView *view = m_container->controller()->view();
     const QList<QByteArray> visibleRolesSet = view->visibleRoles();
 
     bool indexingEnabled = false;
@@ -1082,18 +1201,18 @@ void DolphinView::slotHeaderContextMenuRequested(const QPointF& pos)
 #endif
 
     QString groupName;
-    QMenu* groupMenu = nullptr;
+    QMenu *groupMenu = nullptr;
 
     // Add all roles to the menu that can be shown or hidden by the user
     const QList<KFileItemModel::RoleInfo> rolesInfo = KFileItemModel::rolesInformation();
-    for (const KFileItemModel::RoleInfo& info : rolesInfo) {
+    for (const KFileItemModel::RoleInfo &info : rolesInfo) {
         if (info.role == "text") {
             // It should not be possible to hide the "text" role
             continue;
         }
 
         const QString text = m_model->roleDescription(info.role);
-        QAction* action = nullptr;
+        QAction *action = nullptr;
         if (info.group.isEmpty()) {
             action = menu->addAction(text);
         } else {
@@ -1108,35 +1227,34 @@ void DolphinView::slotHeaderContextMenuRequested(const QPointF& pos)
         action->setCheckable(true);
         action->setChecked(visibleRolesSet.contains(info.role));
         action->setData(info.role);
+        action->setToolTip(info.tooltip);
 
-        const bool enable = (!info.requiresBaloo && !info.requiresIndexer) ||
-                            (info.requiresBaloo) ||
-                            (info.requiresIndexer && indexingEnabled);
+        const bool enable = (!info.requiresBaloo && !info.requiresIndexer) || (info.requiresBaloo) || (info.requiresIndexer && indexingEnabled);
         action->setEnabled(enable);
     }
 
     menu->addSeparator();
 
-    QActionGroup* widthsGroup = new QActionGroup(menu);
+    QActionGroup *widthsGroup = new QActionGroup(menu);
     const bool autoColumnWidths = props.headerColumnWidths().isEmpty();
 
-    QAction* toggleSidePaddingAction = menu->addAction(i18nc("@action:inmenu", "Side Padding"));
+    QAction *toggleSidePaddingAction = menu->addAction(i18nc("@action:inmenu", "Side Padding"));
     toggleSidePaddingAction->setCheckable(true);
-    toggleSidePaddingAction->setChecked(view->header()->sidePadding() > 0);
+    toggleSidePaddingAction->setChecked(layoutDirection() == Qt::LeftToRight ? view->header()->leftPadding() > 0 : view->header()->rightPadding() > 0);
 
-    QAction* autoAdjustWidthsAction = menu->addAction(i18nc("@action:inmenu", "Automatic Column Widths"));
+    QAction *autoAdjustWidthsAction = menu->addAction(i18nc("@action:inmenu", "Automatic Column Widths"));
     autoAdjustWidthsAction->setCheckable(true);
     autoAdjustWidthsAction->setChecked(autoColumnWidths);
     autoAdjustWidthsAction->setActionGroup(widthsGroup);
 
-    QAction* customWidthsAction = menu->addAction(i18nc("@action:inmenu", "Custom Column Widths"));
+    QAction *customWidthsAction = menu->addAction(i18nc("@action:inmenu", "Custom Column Widths"));
     customWidthsAction->setCheckable(true);
     customWidthsAction->setChecked(!autoColumnWidths);
     customWidthsAction->setActionGroup(widthsGroup);
 
-    QAction* action = menu->exec(pos.toPoint());
+    QAction *action = menu->exec(pos.toPoint());
     if (menu && action) {
-        KItemListHeader* header = view->header();
+        KItemListHeader *header = view->header();
 
         if (action == autoAdjustWidthsAction) {
             // Clear the column-widths from the viewproperties and turn on
@@ -1149,13 +1267,17 @@ void DolphinView::slotHeaderContextMenuRequested(const QPointF& pos)
             QList<int> columnWidths;
             const auto visibleRoles = view->visibleRoles();
             columnWidths.reserve(visibleRoles.count());
-            for (const QByteArray& role : visibleRoles) {
+            for (const QByteArray &role : visibleRoles) {
                 columnWidths.append(header->columnWidth(role));
             }
             props.setHeaderColumnWidths(columnWidths);
             header->setAutomaticColumnResizing(false);
         } else if (action == toggleSidePaddingAction) {
-            header->setSidePadding(toggleSidePaddingAction->isChecked() ? 20 : 0);
+            if (toggleSidePaddingAction->isChecked()) {
+                header->setSidePadding(20, 20);
+            } else {
+                header->setSidePadding(0, 0);
+            }
         } else {
             // Show or hide the selected role
             const QByteArray selectedRole = action->data().toByteArray();
@@ -1174,7 +1296,7 @@ void DolphinView::slotHeaderContextMenuRequested(const QPointF& pos)
             if (!header->automaticColumnResizing()) {
                 const auto visibleRoles = view->visibleRoles();
                 columnWidths.reserve(visibleRoles.count());
-                for (const QByteArray& role : visibleRoles) {
+                for (const QByteArray &role : visibleRoles) {
                     columnWidths.append(header->columnWidth(role));
                 }
             }
@@ -1185,7 +1307,7 @@ void DolphinView::slotHeaderContextMenuRequested(const QPointF& pos)
     delete menu;
 }
 
-void DolphinView::slotHeaderColumnWidthChangeFinished(const QByteArray& role, qreal current)
+void DolphinView::slotHeaderColumnWidthChangeFinished(const QByteArray &role, qreal current)
 {
     const QList<QByteArray> visibleRoles = m_view->visibleRoles();
 
@@ -1194,8 +1316,8 @@ void DolphinView::slotHeaderColumnWidthChangeFinished(const QByteArray& role, qr
     if (columnWidths.count() != visibleRoles.count()) {
         columnWidths.clear();
         columnWidths.reserve(visibleRoles.count());
-        const KItemListHeader* header = m_view->header();
-        for (const QByteArray& role : visibleRoles) {
+        const KItemListHeader *header = m_view->header();
+        for (const QByteArray &role : visibleRoles) {
             const int width = header->columnWidth(role);
             columnWidths.append(width);
         }
@@ -1208,10 +1330,11 @@ void DolphinView::slotHeaderColumnWidthChangeFinished(const QByteArray& role, qr
     props.setHeaderColumnWidths(columnWidths);
 }
 
-void DolphinView::slotSidePaddingWidthChanged(qreal width)
+void DolphinView::slotSidePaddingWidthChanged(qreal leftPaddingWidth, qreal rightPaddingWidth)
 {
     ViewProperties props(viewPropertiesUrl());
-    DetailsModeSettings::setSidePadding(int(width));
+    DetailsModeSettings::setLeftPadding(int(leftPaddingWidth));
+    DetailsModeSettings::setRightPadding(int(rightPaddingWidth));
     m_view->writeSettings();
 }
 
@@ -1242,7 +1365,7 @@ void DolphinView::slotItemUnhovered(int index)
     Q_EMIT requestItemInfo(KFileItem());
 }
 
-void DolphinView::slotItemDropEvent(int index, QGraphicsSceneDragDropEvent* event)
+void DolphinView::slotItemDropEvent(int index, QGraphicsSceneDragDropEvent *event)
 {
     QUrl destUrl;
     KFileItem destItem = m_model->fileItem(index);
@@ -1256,11 +1379,7 @@ void DolphinView::slotItemDropEvent(int index, QGraphicsSceneDragDropEvent* even
         destUrl = destItem.mostLocalUrl();
     }
 
-    QDropEvent dropEvent(event->pos().toPoint(),
-                         event->possibleActions(),
-                         event->mimeData(),
-                         event->buttons(),
-                         event->modifiers());
+    QDropEvent dropEvent(event->pos().toPoint(), event->possibleActions(), event->mimeData(), event->buttons(), event->modifiers());
     dropUrls(destUrl, &dropEvent, this);
 
     setActive(true);
@@ -1268,7 +1387,7 @@ void DolphinView::slotItemDropEvent(int index, QGraphicsSceneDragDropEvent* even
 
 void DolphinView::dropUrls(const QUrl &destUrl, QDropEvent *dropEvent, QWidget *dropWidget)
 {
-    KIO::DropJob* job = DragAndDropHelper::dropUrls(destUrl, dropEvent, dropWidget);
+    KIO::DropJob *job = DragAndDropHelper::dropUrls(destUrl, dropEvent, dropWidget);
 
     if (job) {
         connect(job, &KIO::DropJob::result, this, &DolphinView::slotJobResult);
@@ -1277,23 +1396,33 @@ void DolphinView::dropUrls(const QUrl &destUrl, QDropEvent *dropEvent, QWidget *
             // Mark the dropped urls as selected.
             m_clearSelectionBeforeSelectingNewItems = true;
             m_markFirstNewlySelectedItemAsCurrent = true;
+            m_selectJobCreatedItems = true;
             connect(job, &KIO::DropJob::itemCreated, this, &DolphinView::slotItemCreated);
+            connect(job, &KIO::DropJob::copyJobStarted, this, [this](const KIO::CopyJob *copyJob) {
+                connect(copyJob, &KIO::CopyJob::copying, this, &DolphinView::slotItemCreatedFromJob);
+                connect(copyJob, &KIO::CopyJob::moving, this, &DolphinView::slotItemCreatedFromJob);
+                connect(copyJob, &KIO::CopyJob::linking, this, [this](KIO::Job *job, const QString &src, const QUrl &dest) {
+                    Q_UNUSED(job)
+                    Q_UNUSED(src)
+                    slotItemCreated(dest);
+                });
+            });
         }
     }
 }
 
-void DolphinView::slotModelChanged(KItemModelBase* current, KItemModelBase* previous)
+void DolphinView::slotModelChanged(KItemModelBase *current, KItemModelBase *previous)
 {
     if (previous != nullptr) {
-        Q_ASSERT(qobject_cast<KFileItemModel*>(previous));
-        KFileItemModel* fileItemModel = static_cast<KFileItemModel*>(previous);
+        Q_ASSERT(qobject_cast<KFileItemModel *>(previous));
+        KFileItemModel *fileItemModel = static_cast<KFileItemModel *>(previous);
         disconnect(fileItemModel, &KFileItemModel::directoryLoadingCompleted, this, &DolphinView::slotDirectoryLoadingCompleted);
         m_versionControlObserver->setModel(nullptr);
     }
 
     if (current) {
-        Q_ASSERT(qobject_cast<KFileItemModel*>(current));
-        KFileItemModel* fileItemModel = static_cast<KFileItemModel*>(current);
+        Q_ASSERT(qobject_cast<KFileItemModel *>(current));
+        KFileItemModel *fileItemModel = static_cast<KFileItemModel *>(current);
         connect(fileItemModel, &KFileItemModel::directoryLoadingCompleted, this, &DolphinView::slotDirectoryLoadingCompleted);
         m_versionControlObserver->setModel(fileItemModel);
     }
@@ -1324,36 +1453,66 @@ void DolphinView::slotSelectedItemTextPressed(int index)
     }
 }
 
-void DolphinView::slotCopyingDone(KIO::Job *, const QUrl &, const QUrl &to)
+void DolphinView::slotItemCreatedFromJob(KIO::Job *, const QUrl &, const QUrl &to)
+{
+    slotItemCreated(to);
+}
+
+void DolphinView::slotItemLinkCreatedFromJob(KIO::Job *, const QUrl &, const QString &, const QUrl &to)
 {
     slotItemCreated(to);
 }
 
-void DolphinView::slotItemCreated(const QUrl& url)
+void DolphinView::slotItemCreated(const QUrl &url)
 {
     if (m_markFirstNewlySelectedItemAsCurrent) {
         markUrlAsCurrent(url);
         m_markFirstNewlySelectedItemAsCurrent = false;
     }
-    m_selectedUrls << url;
+    if (m_selectJobCreatedItems && !m_selectedUrls.contains(url)) {
+        m_selectedUrls << url;
+    }
+}
+
+void DolphinView::onDirectoryLoadingCompletedAfterJob()
+{
+    // the model should now contain all the items created by the job
+    m_selectJobCreatedItems = true; // to make sure we overwrite selection
+    // update the view: scroll into View and selection
+    updateViewState();
+    m_selectJobCreatedItems = false;
+    m_selectedUrls.clear();
 }
 
 void DolphinView::slotJobResult(KJob *job)
 {
-    if (job->error()) {
-        Q_EMIT errorMessage(job->errorString());
+    if (job->error() && job->error() != KIO::ERR_USER_CANCELED) {
+        Q_EMIT errorMessage(job->errorString(), job->error());
+    }
+    if (!m_selectJobCreatedItems) {
+        m_selectedUrls.clear();
+        return;
     }
     if (!m_selectedUrls.isEmpty()) {
         m_selectedUrls = KDirModel::simplifiedUrlList(m_selectedUrls);
+
+        updateSelectionState();
+        if (!m_selectedUrls.isEmpty()) {
+            // not all urls were found, the model may not be up to date
+            connect(m_model, &KFileItemModel::directoryLoadingCompleted, this, &DolphinView::onDirectoryLoadingCompletedAfterJob, Qt::SingleShotConnection);
+        } else {
+            m_selectJobCreatedItems = false;
+            m_selectedUrls.clear();
+        }
     }
 }
 
-void DolphinView::slotSelectionChanged(const KItemSet& current, const KItemSet& previous)
+void DolphinView::slotSelectionChanged(const KItemSet &current, const KItemSet &previous)
 {
+    m_selectNextItem = false;
     const int currentCount = current.count();
     const int previousCount = previous.count();
-    const bool selectionStateChanged = (currentCount == 0 && previousCount  > 0) ||
-                                       (currentCount >  0 && previousCount == 0);
+    const bool selectionStateChanged = (currentCount == 0 && previousCount > 0) || (currentCount > 0 && previousCount == 0);
 
     // If nothing has been selected before and something got selected (or if something
     // was selected before and now nothing is selected) the selectionChangedSignal must
@@ -1375,11 +1534,10 @@ void DolphinView::slotStatJobResult(KJob *job)
     KIO::filesize_t totalFileSize = 0;
     bool countFileSize = true;
 
-    const auto entry =  static_cast<KIO::StatJob *>(job)->statResult();
+    const auto entry = static_cast<KIO::StatJob *>(job)->statResult();
     if (entry.contains(KIO::UDSEntry::UDS_RECURSIVE_SIZE)) {
         // We have a precomputed value.
-        totalFileSize = static_cast<KIO::filesize_t>(
-                                entry.numberValue(KIO::UDSEntry::UDS_RECURSIVE_SIZE));
+        totalFileSize = static_cast<KIO::filesize_t>(entry.numberValue(KIO::UDSEntry::UDS_RECURSIVE_SIZE));
         countFileSize = false;
     }
 
@@ -1398,27 +1556,6 @@ void DolphinView::slotStatJobResult(KJob *job)
     emitStatusBarText(folderCount, fileCount, totalFileSize, NoSelection);
 }
 
-void DolphinView::updateSortRole(const QByteArray& role)
-{
-    ViewProperties props(viewPropertiesUrl());
-    props.setSortRole(role);
-
-    KItemModelBase* model = m_container->controller()->model();
-    model->setSortRole(role);
-
-    Q_EMIT sortRoleChanged(role);
-}
-
-void DolphinView::updateSortOrder(Qt::SortOrder order)
-{
-    ViewProperties props(viewPropertiesUrl());
-    props.setSortOrder(order);
-
-    m_model->setSortOrder(order);
-
-    Q_EMIT sortOrderChanged(order);
-}
-
 void DolphinView::updateSortFoldersFirst(bool foldersFirst)
 {
     ViewProperties props(viewPropertiesUrl());
@@ -1439,7 +1576,6 @@ void DolphinView::updateSortHiddenLast(bool hiddenLast)
     Q_EMIT sortHiddenLastChanged(hiddenLast);
 }
 
-
 QPair<bool, QString> DolphinView::pasteInfo() const
 {
     const QMimeData *mimeData = QApplication::clipboard()->mimeData();
@@ -1463,7 +1599,17 @@ bool DolphinView::itemsExpandable() const
     return m_mode == DetailsView;
 }
 
-void DolphinView::restoreState(QDataStream& stream)
+bool DolphinView::isExpanded(const KFileItem &item) const
+{
+    Q_ASSERT(item.isDir());
+    Q_ASSERT(items().contains(item));
+    if (!itemsExpandable()) {
+        return false;
+    }
+    return m_model->isExpanded(m_model->index(item));
+}
+
+void DolphinView::restoreState(QDataStream &stream)
 {
     // Read the version number of the view state and check if the version is supported.
     quint32 version = 0;
@@ -1488,7 +1634,7 @@ void DolphinView::restoreState(QDataStream& stream)
     m_model->restoreExpandedDirectories(urls);
 }
 
-void DolphinView::saveState(QDataStream& stream)
+void DolphinView::saveState(QDataStream &stream)
 {
     stream << quint32(1); // View state version
 
@@ -1520,7 +1666,7 @@ KFileItem DolphinView::rootItem() const
     return m_model->rootItem();
 }
 
-void DolphinView::setViewPropertiesContext(const QString& context)
+void DolphinView::setViewPropertiesContext(const QString &context)
 {
     m_viewPropertiesContext = context;
 }
@@ -1530,7 +1676,7 @@ QString DolphinView::viewPropertiesContext() const
     return m_viewPropertiesContext;
 }
 
-QUrl DolphinView::openItemAsFolderUrl(const KFileItem& item, const bool browseThroughArchives)
+QUrl DolphinView::openItemAsFolderUrl(const KFileItem &item, const bool browseThroughArchives)
 {
     if (item.isNull()) {
         return QUrl();
@@ -1543,7 +1689,7 @@ QUrl DolphinView::openItemAsFolderUrl(const KFileItem& item, const bool browseTh
     }
 
     if (item.isMimeTypeKnown()) {
-        const QString& mimetype = item.mimetype();
+        const QString &mimetype = item.mimetype();
 
         if (browseThroughArchives && item.isFile() && url.isLocalFile()) {
             // Generic mechanism for redirecting to tar:/<path>/ when clicking on a tar file,
@@ -1551,7 +1697,7 @@ QUrl DolphinView::openItemAsFolderUrl(const KFileItem& item, const bool browseTh
             // The .protocol file specifies the mimetype that the kioslave handles.
             // Note that we don't use mimetype inheritance since we don't want to
             // open OpenDocument files as zip folders...
-            const QString& protocol = KProtocolManager::protocolForArchiveMimetype(mimetype);
+            const QString &protocol = KProtocolManager::protocolForArchiveMimetype(mimetype);
             if (!protocol.isEmpty()) {
                 url.setScheme(protocol);
                 return url;
@@ -1583,14 +1729,14 @@ void DolphinView::resetZoomLevel()
     setZoomLevel(ZoomLevelInfo::zoomLevelForIconSize(QSize(defaultIconSize, defaultIconSize)));
 }
 
-void DolphinView::observeCreatedItem(const QUrl& url)
+void DolphinView::observeCreatedItem(const QUrl &url)
 {
     if (m_active) {
         forceUrlsSelection(url, {url});
     }
 }
 
-void DolphinView::slotDirectoryRedirection(const QUrl& oldUrl, const QUrl& newUrl)
+void DolphinView::slotDirectoryRedirection(const QUrl &oldUrl, const QUrl &newUrl)
 {
     if (oldUrl.matches(url(), QUrl::StripTrailingSlash)) {
         Q_EMIT redirection(oldUrl, newUrl);
@@ -1598,10 +1744,48 @@ void DolphinView::slotDirectoryRedirection(const QUrl& oldUrl, const QUrl& newUr
     }
 }
 
+void DolphinView::updateSelectionState()
+{
+    if (!m_selectedUrls.isEmpty()) {
+        KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
+
+        const bool shouldScrollToCurrentItem = m_clearSelectionBeforeSelectingNewItems;
+        // if there is a selection already, leave it that way
+        // unless some drop/paste job are in the process of creating items
+        if (!selectionManager->hasSelection() || m_selectJobCreatedItems) {
+            if (m_clearSelectionBeforeSelectingNewItems) {
+                selectionManager->clearSelection();
+                m_clearSelectionBeforeSelectingNewItems = false;
+            }
+
+            KItemSet selectedItems = selectionManager->selectedItems();
+
+            QList<QUrl>::iterator it = m_selectedUrls.begin();
+            while (it != m_selectedUrls.end()) {
+                const int index = m_model->index(*it);
+                if (index >= 0) {
+                    selectedItems.insert(index);
+                    it = m_selectedUrls.erase(it);
+                } else {
+                    ++it;
+                }
+            }
+
+            if (!selectedItems.isEmpty()) {
+                selectionManager->beginAnchoredSelection(selectionManager->currentItem());
+                selectionManager->setSelectedItems(selectedItems);
+                if (shouldScrollToCurrentItem) {
+                    m_view->scrollToItem(selectedItems.first());
+                }
+            }
+        }
+    }
+}
+
 void DolphinView::updateViewState()
 {
     if (m_currentItemUrl != QUrl()) {
-        KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
+        KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
 
         // if there is a selection already, leave it that way
         if (!selectionManager->hasSelection()) {
@@ -1611,7 +1795,7 @@ void DolphinView::updateViewState()
 
                 // scroll to current item and reset the state
                 if (m_scrollToCurrentItem) {
-                    m_view->scrollToItem(currentIndex);
+                    m_view->scrollToItem(currentIndex, KItemListView::ViewItemPosition::Middle);
                     m_scrollToCurrentItem = false;
                 }
                 m_currentItemUrl = QUrl();
@@ -1632,35 +1816,7 @@ void DolphinView::updateViewState()
         m_container->verticalScrollBar()->setValue(y);
     }
 
-    if (!m_selectedUrls.isEmpty()) {
-        KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
-
-        // if there is a selection already, leave it that way
-        if (!selectionManager->hasSelection()) {
-            if (m_clearSelectionBeforeSelectingNewItems) {
-                selectionManager->clearSelection();
-                m_clearSelectionBeforeSelectingNewItems = false;
-            }
-
-            KItemSet selectedItems = selectionManager->selectedItems();
-
-            QList<QUrl>::iterator it = m_selectedUrls.begin();
-            while (it != m_selectedUrls.end()) {
-                const int index = m_model->index(*it);
-                if (index >= 0) {
-                    selectedItems.insert(index);
-                    it = m_selectedUrls.erase(it);
-                } else {
-                    ++it;
-                }
-            }
-
-            if (!selectedItems.isEmpty()) {
-                selectionManager->beginAnchoredSelection(selectionManager->currentItem());
-                selectionManager->setSelectedItems(selectedItems);
-            }
-        }
-    }
+    updateSelectionState();
 }
 
 void DolphinView::hideToolTip(const ToolTipManager::HideBehavior behavior)
@@ -1672,13 +1828,18 @@ void DolphinView::hideToolTip(const ToolTipManager::HideBehavior behavior)
         Q_UNUSED(behavior)
 #endif
     } else if (m_mode == DolphinView::IconsView) {
-       QToolTip::hideText();
+        QToolTip::hideText();
     }
 }
 
+bool DolphinView::handleSpaceAsNormalKey() const
+{
+    return !m_container->hasFocus() || m_container->controller()->isSearchAsYouTypeActive();
+}
+
 void DolphinView::slotTwoClicksRenamingTimerTimeout()
 {
-    const KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
+    const KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
 
     // verify that only one item is selected
     if (selectionManager->selectedItems().count() == 1) {
@@ -1692,35 +1853,65 @@ void DolphinView::slotTwoClicksRenamingTimerTimeout()
     }
 }
 
-void DolphinView::slotTrashFileFinished(KJob* job)
+void DolphinView::slotTrashFileFinished(KJob *job)
 {
     if (job->error() == 0) {
+        selectNextItem(); // Fixes BUG: 419914 via selecting next item
         Q_EMIT operationCompletedMessage(i18nc("@info:status", "Trash operation completed."));
     } else if (job->error() != KIO::ERR_USER_CANCELED) {
-        Q_EMIT errorMessage(job->errorString());
+        Q_EMIT errorMessage(job->errorString(), job->error());
     }
 }
 
-void DolphinView::slotDeleteFileFinished(KJob* job)
+void DolphinView::slotDeleteFileFinished(KJob *job)
 {
     if (job->error() == 0) {
+        selectNextItem(); // Fixes BUG: 419914 via selecting next item
         Q_EMIT operationCompletedMessage(i18nc("@info:status", "Delete operation completed."));
     } else if (job->error() != KIO::ERR_USER_CANCELED) {
-        Q_EMIT errorMessage(job->errorString());
+        Q_EMIT errorMessage(job->errorString(), job->error());
+    }
+}
+
+void DolphinView::selectNextItem()
+{
+    if (m_active && m_selectNextItem) {
+        KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
+        if (selectedItems().isEmpty()) {
+            Q_ASSERT_X(false, "DolphinView", "Selecting the next item failed.");
+            return;
+        }
+        const auto lastSelectedIndex = m_model->index(selectedItems().constLast());
+        if (lastSelectedIndex < 0) {
+            Q_ASSERT_X(false, "DolphinView", "Selecting the next item failed.");
+            return;
+        }
+        auto nextItem = lastSelectedIndex + 1;
+        if (nextItem >= itemsCount()) {
+            nextItem = lastSelectedIndex - selectedItemsCount();
+        }
+        if (nextItem >= 0) {
+            selectionManager->setSelected(nextItem, 1);
+            selectionManager->beginAnchoredSelection(nextItem);
+        }
+        m_selectNextItem = false;
     }
 }
 
-void DolphinView::slotRenamingResult(KJob* job)
+void DolphinView::slotRenamingResult(KJob *job)
 {
-    if (job->error()) {
+    // Change model data after renaming has succeeded. On failure we do nothing.
+    // If there is already an item with the newUrl, the copyjob will open a dialog for it, and
+    // KFileItemModel will update the data when the dir lister signals that the file name has changed.
+    if (!job->error()) {
         KIO::CopyJob *copyJob = qobject_cast<KIO::CopyJob *>(job);
         Q_ASSERT(copyJob);
         const QUrl newUrl = copyJob->destUrl();
+        const QUrl oldUrl = copyJob->srcUrls().at(0);
         const int index = m_model->index(newUrl);
-        if (index >= 0) {
+        if (m_model->index(oldUrl) == index) {
             QHash<QByteArray, QVariant> data;
-            const QUrl oldUrl = copyJob->srcUrls().at(0);
-            data.insert("text", oldUrl.fileName());
+            data.insert("text", newUrl.fileName());
             m_model->setData(index, data);
         }
     }
@@ -1728,7 +1919,7 @@ void DolphinView::slotRenamingResult(KJob* job)
 
 void DolphinView::slotDirectoryLoadingStarted()
 {
-    m_loading = true;
+    m_loadingState = LoadingState::Loading;
     updatePlaceholderLabel();
 
     // Disable the writestate temporary until it can be determined in a fast way
@@ -1743,7 +1934,7 @@ void DolphinView::slotDirectoryLoadingStarted()
 
 void DolphinView::slotDirectoryLoadingCompleted()
 {
-    m_loading = false;
+    m_loadingState = LoadingState::Completed;
 
     // Update the view-state. This has to be done asynchronously
     // because the view might not be in its final state yet.
@@ -1754,13 +1945,14 @@ void DolphinView::slotDirectoryLoadingCompleted()
 
     Q_EMIT directoryLoadingCompleted();
 
+    applyDynamicView();
     updatePlaceholderLabel();
     updateWritableState();
 }
 
 void DolphinView::slotDirectoryLoadingCanceled()
 {
-    m_loading = false;
+    m_loadingState = LoadingState::Canceled;
 
     updatePlaceholderLabel();
 
@@ -1783,7 +1975,7 @@ void DolphinView::slotSortOrderChangedByHeader(Qt::SortOrder current, Qt::SortOr
     Q_EMIT sortOrderChanged(current);
 }
 
-void DolphinView::slotSortRoleChangedByHeader(const QByteArray& current, const QByteArray& previous)
+void DolphinView::slotSortRoleChangedByHeader(const QByteArray &current, const QByteArray &previous)
 {
     Q_UNUSED(previous)
     Q_ASSERT(m_model->sortRole() == current);
@@ -1794,8 +1986,7 @@ void DolphinView::slotSortRoleChangedByHeader(const QByteArray& current, const Q
     Q_EMIT sortRoleChanged(current);
 }
 
-void DolphinView::slotVisibleRolesChangedByHeader(const QList<QByteArray>& current,
-                                                  const QList<QByteArray>& previous)
+void DolphinView::slotVisibleRolesChangedByHeader(const QList<QByteArray> &current, const QList<QByteArray> &previous)
 {
     Q_UNUSED(previous)
     Q_ASSERT(m_container->controller()->view()->visibleRoles() == current);
@@ -1812,14 +2003,12 @@ void DolphinView::slotVisibleRolesChangedByHeader(const QList<QByteArray>& curre
 
 void DolphinView::slotRoleEditingCanceled()
 {
-    disconnect(m_view, &DolphinItemListView::roleEditingFinished,
-               this, &DolphinView::slotRoleEditingFinished);
+    disconnect(m_view, &DolphinItemListView::roleEditingFinished, this, &DolphinView::slotRoleEditingFinished);
 }
 
-void DolphinView::slotRoleEditingFinished(int index, const QByteArray& role, const QVariant& value)
+void DolphinView::slotRoleEditingFinished(int index, const QByteArray &role, const QVariant &value)
 {
-    disconnect(m_view, &DolphinItemListView::roleEditingFinished,
-               this, &DolphinView::slotRoleEditingFinished);
+    disconnect(m_view, &DolphinItemListView::roleEditingFinished, this, &DolphinView::slotRoleEditingFinished);
 
     const KFileItemList items = selectedItems();
     if (items.count() != 1) {
@@ -1837,48 +2026,36 @@ void DolphinView::slotRoleEditingFinished(int index, const QByteArray& role, con
             newUrl.setPath(newUrl.path() + KIO::encodeFileName(newName));
 
 #ifndef Q_OS_WIN
-            //Confirm hiding file/directory by renaming inline
+            // Confirm hiding file/directory by renaming inline
             if (!hiddenFilesShown() && newName.startsWith(QLatin1Char('.')) && !oldItem.name().startsWith(QLatin1Char('.'))) {
-                KGuiItem yesGuiItem(KStandardGuiItem::yes());
-                yesGuiItem.setText(i18nc("@action:button", "Rename and Hide"));
-
-                const auto code = KMessageBox::questionYesNo(this,
-                                                             oldItem.isFile() ? i18n("Adding a dot to the beginning of this file's name will hide it from view.\n"
-                                                                                     "Do you still want to rename it?")
-                                                                              : i18n("Adding a dot to the beginning of this folder's name will hide it from view.\n"
-                                                                                     "Do you still want to rename it?"),
-                                                             oldItem.isFile() ? i18n("Hide this File?") : i18n("Hide this Folder?"),
-                                                             yesGuiItem,
-                                                             KStandardGuiItem::cancel(),
-                                                             QStringLiteral("ConfirmHide")
-                                                            );
-
-                if (code == KMessageBox::No) {
-                   return;
+                KGuiItem yesGuiItem(i18nc("@action:button", "Rename and Hide"), QStringLiteral("view-hidden"));
+
+                const auto code =
+                    KMessageBox::questionTwoActions(this,
+                                                    oldItem.isFile() ? i18n("Adding a dot to the beginning of this file's name will hide it from view.\n"
+                                                                            "Do you still want to rename it?")
+                                                                     : i18n("Adding a dot to the beginning of this folder's name will hide it from view.\n"
+                                                                            "Do you still want to rename it?"),
+                                                    oldItem.isFile() ? i18n("Hide this File?") : i18n("Hide this Folder?"),
+                                                    yesGuiItem,
+                                                    KStandardGuiItem::cancel(),
+                                                    QStringLiteral("ConfirmHide"));
+
+                if (code == KMessageBox::SecondaryAction) {
+                    return;
                 }
             }
 #endif
 
-            const bool newNameExistsAlready = (m_model->index(newUrl) >= 0);
-            if (!newNameExistsAlready && m_model->index(oldUrl) == index) {
-                // Only change the data in the model if no item with the new name
-                // is in the model yet. If there is an item with the new name
-                // already, calling KIO::CopyJob will open a dialog
-                // asking for a new name, and KFileItemModel will update the
-                // data when the dir lister signals that the file name has changed.
-                QHash<QByteArray, QVariant> data;
-                data.insert(role, retVal.newName);
-                m_model->setData(index, data);
-            }
-
-            KIO::Job * job = KIO::moveAs(oldUrl, newUrl);
+            KIO::Job *job = KIO::moveAs(oldUrl, newUrl);
             KJobWidgets::setWindow(job, this);
             KIO::FileUndoManager::self()->recordJob(KIO::FileUndoManager::Rename, {oldUrl}, newUrl, job);
             job->uiDelegate()->setAutoErrorHandlingEnabled(true);
 
-            forceUrlsSelection(newUrl, {newUrl});
+            if (m_model->index(newUrl) < 0) {
+                forceUrlsSelection(newUrl, {newUrl});
+                updateSelectionState();
 
-            if (!newNameExistsAlready) {
                 // Only connect the result signal if there is no item with the new name
                 // in the model yet, see bug 328262.
                 connect(job, &KJob::result, this, &DolphinView::slotRenamingResult);
@@ -1887,21 +2064,20 @@ void DolphinView::slotRoleEditingFinished(int index, const QByteArray& role, con
         if (retVal.direction != EditDone) {
             const short indexShift = retVal.direction == EditNext ? 1 : -1;
             m_container->controller()->selectionManager()->setSelected(index, 1, KItemListSelectionManager::Deselect);
-            m_container->controller()->selectionManager()->setSelected(index + indexShift, 1,
-                    KItemListSelectionManager::Select);
+            m_container->controller()->selectionManager()->setSelected(index + indexShift, 1, KItemListSelectionManager::Select);
             renameSelectedItems();
         }
     }
 }
 
-void DolphinView::loadDirectory(const QUrl& url, bool reload)
+void DolphinView::loadDirectory(const QUrl &url, bool reload)
 {
     if (!url.isValid()) {
         const QString location(url.toDisplayString(QUrl::PreferLocalFile));
         if (location.isEmpty()) {
-            Q_EMIT errorMessage(i18nc("@info:status", "The location is empty."));
+            Q_EMIT errorMessage(i18nc("@info:status", "The location is empty."), KIO::ERR_UNKNOWN);
         } else {
-            Q_EMIT errorMessage(i18nc("@info:status", "The location '%1' is invalid.", location));
+            Q_EMIT errorMessage(i18nc("@info:status", "The location '%1' is invalid.", location), KIO::ERR_UNKNOWN);
         }
         return;
     }
@@ -1919,7 +2095,7 @@ void DolphinView::applyViewProperties()
     applyViewProperties(props);
 }
 
-void DolphinView::applyViewProperties(const ViewProperties& props)
+void DolphinView::applyViewProperties(const ViewProperties &props)
 {
     m_view->beginTransaction();
 
@@ -1998,9 +2174,9 @@ void DolphinView::applyViewProperties(const ViewProperties& props)
         }
     }
 
-    KItemListView* itemListView = m_container->controller()->view();
+    KItemListView *itemListView = m_container->controller()->view();
     if (itemListView->isHeaderVisible()) {
-        KItemListHeader* header = itemListView->header();
+        KItemListHeader *header = itemListView->header();
         const QList<int> headerColumnWidths = props.headerColumnWidths();
         const int rolesCount = m_visibleRoles.count();
         if (headerColumnWidths.count() == rolesCount) {
@@ -2014,7 +2190,7 @@ void DolphinView::applyViewProperties(const ViewProperties& props)
         } else {
             header->setAutomaticColumnResizing(true);
         }
-        header->setSidePadding(DetailsModeSettings::sidePadding());
+        header->setSidePadding(DetailsModeSettings::leftPadding(), DetailsModeSettings::rightPadding());
     }
 
     m_view->endTransaction();
@@ -2023,20 +2199,83 @@ void DolphinView::applyViewProperties(const ViewProperties& props)
 void DolphinView::applyModeToView()
 {
     switch (m_mode) {
-    case IconsView:   m_view->setItemLayout(KFileItemListView::IconsLayout); break;
-    case CompactView: m_view->setItemLayout(KFileItemListView::CompactLayout); break;
-    case DetailsView: m_view->setItemLayout(KFileItemListView::DetailsLayout); break;
-    default: Q_ASSERT(false); break;
+    case IconsView:
+        m_view->setItemLayout(KFileItemListView::IconsLayout);
+        break;
+    case CompactView:
+        m_view->setItemLayout(KFileItemListView::CompactLayout);
+        break;
+    case DetailsView:
+        m_view->setItemLayout(KFileItemListView::DetailsLayout);
+        break;
+    default:
+        Q_ASSERT(false);
+        break;
+    }
+}
+
+void DolphinView::applyDynamicView()
+{
+    ViewProperties props(viewPropertiesUrl());
+    /* return early if:
+     * - dynamic view is not enabled
+     * - the current view mode is already Icon View
+     * - dynamic view has previously changed the view mode
+     */
+    if (!GeneralSettings::dynamicView() || m_mode == IconsView || props.dynamicViewPassed()) {
+        return;
+    }
+
+    uint imageAndVideoCount = 0;
+    uint checkedItems = 0;
+    const uint totalItems = itemsCount();
+    const KFileItemList itemList = items();
+    bool applyDynamicView = false;
+
+    for (const auto &file : itemList) {
+        ++checkedItems;
+        const QString type = file.mimetype().slice(0, 5);
+
+        if (type == "image" || type == "video") {
+            ++imageAndVideoCount;
+            // if 2/3 or more of the items are images/videos, dynamic view should be applied
+            applyDynamicView = imageAndVideoCount >= (totalItems * 2 / 3);
+            if (applyDynamicView) {
+                break;
+            }
+        } else if (checkedItems - imageAndVideoCount > totalItems / 3) {
+            // if more than a third of the checked files are not media files, return
+            return;
+        }
     }
+
+    if (!applyDynamicView) {
+        return;
+    }
+
+    props.setAutoSaveEnabled(!GeneralSettings::globalViewProps());
+    props.setDynamicViewPassed(true);
+    props.setViewMode(IconsView);
+    applyViewProperties(props);
 }
 
-void DolphinView::pasteToUrl(const QUrl& url)
+void DolphinView::pasteToUrl(const QUrl &url)
 {
     KIO::PasteJob *job = KIO::paste(QApplication::clipboard()->mimeData(), url);
     KJobWidgets::setWindow(job, this);
     m_clearSelectionBeforeSelectingNewItems = true;
     m_markFirstNewlySelectedItemAsCurrent = true;
+    m_selectJobCreatedItems = true;
     connect(job, &KIO::PasteJob::itemCreated, this, &DolphinView::slotItemCreated);
+    connect(job, &KIO::PasteJob::copyJobStarted, this, [this](const KIO::CopyJob *copyJob) {
+        connect(copyJob, &KIO::CopyJob::copying, this, &DolphinView::slotItemCreatedFromJob);
+        connect(copyJob, &KIO::CopyJob::moving, this, &DolphinView::slotItemCreatedFromJob);
+        connect(copyJob, &KIO::CopyJob::linking, this, [this](KIO::Job *job, const QString &src, const QUrl &dest) {
+            Q_UNUSED(job)
+            Q_UNUSED(src)
+            slotItemCreated(dest);
+        });
+    });
     connect(job, &KIO::PasteJob::result, this, &DolphinView::slotJobResult);
 }
 
@@ -2046,7 +2285,7 @@ QList<QUrl> DolphinView::simplifiedSelectedUrls() const
 
     const KFileItemList items = selectedItems();
     urls.reserve(items.count());
-    for (const KFileItem& item : items) {
+    for (const KFileItem &item : items) {
         urls.append(item.url());
     }
 
@@ -2058,9 +2297,9 @@ QList<QUrl> DolphinView::simplifiedSelectedUrls() const
     return urls;
 }
 
-QMimeData* DolphinView::selectionMimeData() const
+QMimeData *DolphinView::selectionMimeData() const
 {
-    const KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
+    const KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
     const KItemSet selectedIndexes = selectionManager->selectedItems();
 
     return m_model->createMimeData(selectedIndexes);
@@ -2087,6 +2326,27 @@ void DolphinView::updateWritableState()
     }
 }
 
+bool DolphinView::isFolderWritable() const
+{
+    return m_isFolderWritable;
+}
+
+int DolphinView::horizontalScrollBarHeight() const
+{
+    if (m_container && m_container->horizontalScrollBar() && m_container->horizontalScrollBar()->isVisible()) {
+        return m_container->horizontalScrollBar()->height();
+    }
+    return 0;
+}
+
+void DolphinView::setStatusBarOffset(int offset)
+{
+    KItemListView *view = m_container->controller()->view();
+    if (view) {
+        view->setStatusBarOffset(offset);
+    }
+}
+
 QUrl DolphinView::viewPropertiesUrl() const
 {
     if (m_viewPropertiesContext.isEmpty()) {
@@ -2099,12 +2359,7 @@ QUrl DolphinView::viewPropertiesUrl() const
     return url;
 }
 
-void DolphinView::slotRenameDialogRenamingFinished(const QList<QUrl>& urls)
-{
-    forceUrlsSelection(urls.first(), urls);
-}
-
-void DolphinView::forceUrlsSelection(const QUrl& current, const QList<QUrl>& selected)
+void DolphinView::forceUrlsSelection(const QUrl &current, const QList<QUrl> &selected)
 {
     clearSelection();
     m_clearSelectionBeforeSelectingNewItems = true;
@@ -2118,16 +2373,16 @@ void DolphinView::copyPathToClipboard()
     if (list.isEmpty()) {
         return;
     }
-    const KFileItem& item = list.at(0);
+    const KFileItem &item = list.at(0);
     QString path = item.localPath();
     if (path.isEmpty()) {
         path = item.url().toDisplayString();
     }
-    QClipboard* clipboard = QApplication::clipboard();
+    QClipboard *clipboard = QApplication::clipboard();
     if (clipboard == nullptr) {
         return;
     }
-    clipboard->setText(path);
+    clipboard->setText(QDir::toNativeSeparators(path));
 }
 
 void DolphinView::slotIncreaseZoom()
@@ -2147,25 +2402,37 @@ void DolphinView::slotSwipeUp()
 
 void DolphinView::showLoadingPlaceholder()
 {
-    m_placeholderLabel->setText(i18n("Loading..."));
+    m_placeholderLabel->setText(i18n("Loading…"));
     m_placeholderLabel->setVisible(true);
+#ifndef QT_NO_ACCESSIBILITY
+    if (QAccessible::isActive()) {
+        static_cast<KItemListViewAccessible *>(QAccessible::queryAccessibleInterface(m_view))->announceNewlyLoadedLocation(m_placeholderLabel->text());
+    }
+#endif
 }
 
 void DolphinView::updatePlaceholderLabel()
 {
     m_showLoadingPlaceholderTimer->stop();
     if (itemsCount() > 0) {
+#ifndef QT_NO_ACCESSIBILITY
+        if (QAccessible::isActive()) {
+            static_cast<KItemListViewAccessible *>(QAccessible::queryAccessibleInterface(m_view))->announceNewlyLoadedLocation(QString());
+        }
+#endif
         m_placeholderLabel->setVisible(false);
         return;
     }
 
-    if (m_loading) {
+    if (m_loadingState == LoadingState::Loading) {
         m_placeholderLabel->setVisible(false);
         m_showLoadingPlaceholderTimer->start();
         return;
     }
 
-    if (!nameFilter().isEmpty()) {
+    if (m_loadingState == LoadingState::Canceled) {
+        m_placeholderLabel->setText(i18n("Loading canceled"));
+    } else if (!nameFilter().isEmpty()) {
         m_placeholderLabel->setText(i18n("No items matching the filter"));
     } else if (m_url.scheme() == QLatin1String("baloosearch") || m_url.scheme() == QLatin1String("filenamesearch")) {
         m_placeholderLabel->setText(i18n("No items matching the search"));
@@ -2187,6 +2454,8 @@ void DolphinView::updatePlaceholderLabel()
         m_placeholderLabel->setText(i18n("No relevant network resources found"));
     } else if (m_url.scheme() == QLatin1String("mtp") && m_url.path() == QLatin1String("/")) {
         m_placeholderLabel->setText(i18n("No MTP-compatible devices found"));
+    } else if (m_url.scheme() == QLatin1String("afc") && m_url.path() == QLatin1String("/")) {
+        m_placeholderLabel->setText(i18n("No Apple devices found"));
     } else if (m_url.scheme() == QLatin1String("bluetooth")) {
         m_placeholderLabel->setText(i18n("No Bluetooth devices found"));
     } else {
@@ -2194,26 +2463,34 @@ void DolphinView::updatePlaceholderLabel()
     }
 
     m_placeholderLabel->setVisible(true);
+#ifndef QT_NO_ACCESSIBILITY
+    if (QAccessible::isActive()) {
+        static_cast<KItemListViewAccessible *>(QAccessible::queryAccessibleInterface(m_view))->announceNewlyLoadedLocation(m_placeholderLabel->text());
+    }
+#endif
 }
 
-void DolphinView::tryShowNameToolTip(QEvent* event)
+bool DolphinView::tryShowNameToolTip(QHelpEvent *event)
 {
     if (!GeneralSettings::showToolTips() && m_mode == DolphinView::IconsView) {
-        QHelpEvent *hoverEvent = reinterpret_cast<QHelpEvent *>(event);
-        const std::optional<int> index = m_view->itemAt(hoverEvent->pos());
+        const std::optional<int> index = m_view->itemAt(event->pos());
 
         if (!index.has_value()) {
-            return;
+            return false;
         }
 
         // Check whether the filename has been elided
         const bool isElided = m_view->isElided(index.value());
 
-        if(isElided) {
+        if (isElided) {
             const KFileItem item = m_model->fileItem(index.value());
             const QString text = item.text();
-            const QPoint pos = mapToGlobal(hoverEvent->pos());
-            QToolTip::showText(pos, text);
+            const QPoint pos = mapToGlobal(event->pos());
+            QToolTip::showText(pos, text, this);
+            return true;
         }
     }
+    return false;
 }
+
+#include "moc_dolphinview.cpp"