Adress the first round of Angelaccio's review comments

[dolphin.git] / src / dolphinmainwindow.cpp

diff --git a/src/dolphinmainwindow.cpp b/src/dolphinmainwindow.cpp
index afca88198e6fb84f5cc6bb653152914c28ee0d35..5e6b6e94a21c15d04d22ad2b4d67aa8a935622d7 100644 (file)
--- a/src/dolphinmainwindow.cpp
+++ b/src/dolphinmainwindow.cpp
@@ -1,26 +1,14 @@
-/***************************************************************************
- *   Copyright (C) 2006 by Peter Penz <peter.penz19@gmail.com>             *
- *   Copyright (C) 2006 by Stefan Monov <logixoul@gmail.com>               *
- *   Copyright (C) 2006 by Cvetoslav Ludmiloff <ludmiloff@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  *
- *   the Free Software Foundation; either version 2 of the License, or     *
- *   (at your option) any later version.                                   *
- *                                                                         *
- *   This program is distributed in the hope that it will be useful,       *
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
- *   GNU General Public License for more details.                          *
- *                                                                         *
- *   You should have received a copy of the GNU General Public License     *
- *   along with this program; if not, write to the                         *
- *   Free Software Foundation, Inc.,                                       *
- *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA            *
- ***************************************************************************/
+/*
+ * SPDX-FileCopyrightText: 2006 Peter Penz <peter.penz19@gmail.com>
+ * SPDX-FileCopyrightText: 2006 Stefan Monov <logixoul@gmail.com>
+ * SPDX-FileCopyrightText: 2006 Cvetoslav Ludmiloff <ludmiloff@gmail.com>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */

 
 #include "dolphinmainwindow.h"
 
 
 #include "dolphinmainwindow.h"
 

+#include "dolphinmainwindowadaptor.h"

 #include "config-terminal.h"
 #include "global.h"
 #include "dolphinbookmarkhandler.h"
 #include "config-terminal.h"
 #include "global.h"
 #include "dolphinbookmarkhandler.h"


@@ -43,28 +31,35 @@
 #include "views/draganddrophelper.h"
 #include "views/viewproperties.h"
 #include "views/dolphinnewfilemenuobserver.h"
 #include "views/draganddrophelper.h"
 #include "views/viewproperties.h"
 #include "views/dolphinnewfilemenuobserver.h"

+#include "views/dolphinurlnavigatorwidgetaction.h"

 #include "dolphin_generalsettings.h"
 
 #include <KActionCollection>
 #include <KActionMenu>
 #include <KAuthorized>
 #include <KConfig>
 #include "dolphin_generalsettings.h"
 
 #include <KActionCollection>
 #include <KActionMenu>
 #include <KAuthorized>
 #include <KConfig>

+#include <KConfigGui>

 #include <KDualAction>
 #include <KFileItemListProperties>
 #include <KHelpMenu>
 #include <KDualAction>
 #include <KFileItemListProperties>
 #include <KHelpMenu>

+#include <KIO/CommandLauncherJob>

 #include <KIO/JobUiDelegate>
 #include <KIO/OpenFileManagerWindowJob>
 #include <KIO/JobUiDelegate>
 #include <KIO/OpenFileManagerWindowJob>

+#include <KIO/OpenUrlJob>

 #include <KJobWidgets>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KJobWidgets>
 #include <KLocalizedString>
 #include <KMessageBox>

+#include <KMessageWidget>
+#include <KNS3/KMoreToolsMenuFactory>

 #include <KProtocolInfo>
 #include <KProtocolManager>
 #include <KProtocolInfo>
 #include <KProtocolManager>

-#include <KRun>

 #include <KShell>
 #include <KStandardAction>
 #include <KStartupInfo>
 #include <KShell>
 #include <KStandardAction>
 #include <KStartupInfo>

+#include <KSycoca>

 #include <KToggleAction>
 #include <KToolBar>
 #include <KToggleAction>
 #include <KToolBar>

+#include <KToolBarPopupAction>

 #include <KToolInvocation>
 #include <KUrlComboBox>
 #include <KUrlNavigator>
 #include <KToolInvocation>
 #include <KUrlComboBox>
 #include <KUrlNavigator>


@@ -77,7 +72,6 @@
 #include <QDialog>
 #include <QFileInfo>
 #include <QLineEdit>
 #include <QDialog>
 #include <QFileInfo>
 #include <QLineEdit>

-#include <QMenu>

 #include <QMenuBar>
 #include <QPushButton>
 #include <QShowEvent>
 #include <QMenuBar>
 #include <QPushButton>
 #include <QShowEvent>


@@ -90,10 +84,14 @@ namespace {
     // Used for GeneralSettings::version() to determine whether
     // an updated version of Dolphin is running.
     const int CurrentDolphinVersion = 200;
     // Used for GeneralSettings::version() to determine whether
     // an updated version of Dolphin is running.
     const int CurrentDolphinVersion = 200;

+    // The maximum number of entries in the back/forward popup menu
+    const int MaxNumberOfNavigationentries = 12;
+    // The maximum number of "Activate Tab" shortcuts
+    const int MaxActivateTabShortcuts = 9;

 }
 
 DolphinMainWindow::DolphinMainWindow() :
 }
 
 DolphinMainWindow::DolphinMainWindow() :

-    KXmlGuiWindow(nullptr, Qt::WindowContextHelpButtonHint),
+    KXmlGuiWindow(nullptr),

     m_newFileMenu(nullptr),
     m_helpMenu(nullptr),
     m_tabWidget(nullptr),
     m_newFileMenu(nullptr),
     m_helpMenu(nullptr),
     m_tabWidget(nullptr),


@@ -104,12 +102,20 @@ DolphinMainWindow::DolphinMainWindow() :
     m_bookmarkHandler(nullptr),
     m_controlButton(nullptr),
     m_updateToolBarTimer(nullptr),
     m_bookmarkHandler(nullptr),
     m_controlButton(nullptr),
     m_updateToolBarTimer(nullptr),

-    m_lastHandleUrlStatJob(nullptr),
+    m_lastHandleUrlOpenJob(nullptr),

     m_terminalPanel(nullptr),
     m_placesPanel(nullptr),
     m_terminalPanel(nullptr),
     m_placesPanel(nullptr),

-    m_tearDownFromPlacesRequested(false)
+    m_tearDownFromPlacesRequested(false),
+    m_backAction(nullptr),
+    m_forwardAction(nullptr)

 {
     Q_INIT_RESOURCE(dolphin);
 {
     Q_INIT_RESOURCE(dolphin);

+
+    new MainWindowAdaptor(this);
+
+#ifndef Q_OS_WIN
+       setWindowFlags(Qt::WindowContextHelpButtonHint);
+#endif

     setComponentName(QStringLiteral("dolphin"), QGuiApplication::applicationDisplayName());
     setObjectName(QStringLiteral("Dolphin#"));
 
     setComponentName(QStringLiteral("dolphin"), QGuiApplication::applicationDisplayName());
     setObjectName(QStringLiteral("Dolphin#"));
 


@@ -187,22 +193,45 @@ DolphinMainWindow::DolphinMainWindow() :
     toolBar()->installEventFilter(middleClickEventFilter);
 
     setupWhatsThis();
     toolBar()->installEventFilter(middleClickEventFilter);
 
     setupWhatsThis();

+
+    connect(KSycoca::self(), QOverload<>::of(&KSycoca::databaseChanged), this, &DolphinMainWindow::updateOpenPreferredSearchToolAction);
+
+    QTimer::singleShot(0, this, &DolphinMainWindow::updateOpenPreferredSearchToolAction);

 }
 
 DolphinMainWindow::~DolphinMainWindow()
 {
 }
 
 }
 
 DolphinMainWindow::~DolphinMainWindow()
 {
 }
 

-QVector<DolphinViewContainer*> DolphinMainWindow::viewContainers() const
+QVector<DolphinViewContainer *> DolphinMainWindow::activeViewContainers() const

 {
     QVector<DolphinViewContainer*> viewContainers;
 {
     QVector<DolphinViewContainer*> viewContainers;

-    viewContainers.reserve(m_tabWidget->count());
+

     for (int i = 0; i < m_tabWidget->count(); ++i) {
     for (int i = 0; i < m_tabWidget->count(); ++i) {

-        viewContainers << m_tabWidget->tabPageAt(i)->activeViewContainer();
+        DolphinTabPage *tabPage = m_tabWidget->tabPageAt(i);
+
+        viewContainers << tabPage->primaryViewContainer();
+        if (tabPage->splitViewEnabled()) {
+            viewContainers << tabPage->secondaryViewContainer();
+        }

     }
     return viewContainers;
 }
 
     }
     return viewContainers;
 }
 

+void DolphinMainWindow::setViewsWithInvalidPathsToHome()
+{
+    const QVector<DolphinViewContainer*> theViewContainers = viewContainers();
+    for (DolphinViewContainer *viewContainer : theViewContainers) {
+
+        // Only consider local dirs, not remote locations and abstract protocols
+        if (viewContainer->url().isLocalFile()) {
+            if (!QFileInfo::exists(viewContainer->url().toLocalFile())) {
+                viewContainer->setUrl(QUrl::fromLocalFile(QDir::homePath()));
+            }
+        }
+    }
+}
+

 void DolphinMainWindow::openDirectories(const QList<QUrl>& dirs, bool splitView)
 {
     m_tabWidget->openDirectories(dirs, splitView);
 void DolphinMainWindow::openDirectories(const QList<QUrl>& dirs, bool splitView)
 {
     m_tabWidget->openDirectories(dirs, splitView);


@@ -218,6 +247,16 @@ void DolphinMainWindow::openFiles(const QList<QUrl>& files, bool splitView)
     m_tabWidget->openFiles(files, splitView);
 }
 
     m_tabWidget->openFiles(files, splitView);
 }
 

+bool DolphinMainWindow::isFoldersPanelEnabled() const
+{
+    return actionCollection()->action(QStringLiteral("show_folders_panel"))->isChecked();
+}
+
+bool DolphinMainWindow::isInformationPanelEnabled() const
+{
+    return actionCollection()->action(QStringLiteral("show_information_panel"))->isChecked();
+}
+

 void DolphinMainWindow::openFiles(const QStringList& files, bool splitView)
 {
     openFiles(QUrl::fromStringList(files), splitView);
 void DolphinMainWindow::openFiles(const QStringList& files, bool splitView)
 {
     openFiles(QUrl::fromStringList(files), splitView);


@@ -225,7 +264,8 @@ void DolphinMainWindow::openFiles(const QStringList& files, bool splitView)
 
 void DolphinMainWindow::activateWindow()
 {
 
 void DolphinMainWindow::activateWindow()
 {

-    KStartupInfo::setNewStartupId(window(), KStartupInfo::startupId());
+    window()->setAttribute(Qt::WA_NativeWindow, true);
+    KStartupInfo::setNewStartupId(window()->windowHandle(), KStartupInfo::startupId());

     KWindowSystem::activateWindow(window()->effectiveWinId());
 }
 
     KWindowSystem::activateWindow(window()->effectiveWinId());
 }
 


@@ -278,7 +318,7 @@ void DolphinMainWindow::changeUrl(const QUrl &url)
     updateViewActions();
     updateGoActions();
 
     updateViewActions();
     updateGoActions();
 

-    emit urlChanged(url);
+    Q_EMIT urlChanged(url);

 }
 
 void DolphinMainWindow::slotTerminalDirectoryChanged(const QUrl& url)
 }
 
 void DolphinMainWindow::slotTerminalDirectoryChanged(const QUrl& url)


@@ -313,12 +353,12 @@ void DolphinMainWindow::slotSelectionChanged(const KFileItemList& selection)
         compareFilesAction->setEnabled(false);
     }
 
         compareFilesAction->setEnabled(false);
     }
 

-    emit selectionChanged(selection);
+    Q_EMIT selectionChanged(selection);

 }
 
 void DolphinMainWindow::updateHistory()
 {
 }
 
 void DolphinMainWindow::updateHistory()
 {

-    const KUrlNavigator* urlNavigator = m_activeViewContainer->urlNavigator();
+    const KUrlNavigator *urlNavigator = m_activeViewContainer->urlNavigatorInternal();

     const int index = urlNavigator->historyIndex();
 
     QAction* backAction = actionCollection()->action(KStandardAction::name(KStandardAction::Back));
     const int index = urlNavigator->historyIndex();
 
     QAction* backAction = actionCollection()->action(KStandardAction::name(KStandardAction::Back));


@@ -399,7 +439,7 @@ void DolphinMainWindow::openInNewTab()
     const KFileItemList& list = m_activeViewContainer->view()->selectedItems();
     bool tabCreated = false;
 
     const KFileItemList& list = m_activeViewContainer->view()->selectedItems();
     bool tabCreated = false;
 

-    foreach (const KFileItem& item, list) {
+    for (const KFileItem& item : list) {

         const QUrl& url = DolphinView::openItemAsFolderUrl(item);
         if (!url.isEmpty()) {
             openNewTabAfterCurrentTab(url);
         const QUrl& url = DolphinView::openItemAsFolderUrl(item);
         if (!url.isEmpty()) {
             openNewTabAfterCurrentTab(url);


@@ -465,7 +505,10 @@ void DolphinMainWindow::closeEvent(QCloseEvent* event)
         closedByUser = false;
     }
 
         closedByUser = false;
     }
 

-    if (m_tabWidget->count() > 1 && GeneralSettings::confirmClosingMultipleTabs() && closedByUser) {
+    if (m_tabWidget->count() > 1
+        && GeneralSettings::confirmClosingMultipleTabs()
+        && !GeneralSettings::rememberOpenedTabs()
+        && closedByUser) {

         // Ask the user if he really wants to quit and close all tabs.
         // Open a confirmation dialog with 3 buttons:
         // QDialogButtonBox::Yes    -> Quit
         // Ask the user if he really wants to quit and close all tabs.
         // Open a confirmation dialog with 3 buttons:
         // QDialogButtonBox::Yes    -> Quit


@@ -509,7 +552,7 @@ void DolphinMainWindow::closeEvent(QCloseEvent* event)
         }
     }
 
         }
     }
 

-    if (m_terminalPanel->hasProgramRunning() && GeneralSettings::confirmClosingTerminalRunningProgram() && closedByUser) {
+    if (m_terminalPanel && m_terminalPanel->hasProgramRunning() && GeneralSettings::confirmClosingTerminalRunningProgram() && closedByUser) {

         // Ask if the user really wants to quit Dolphin with a program that is still running in the Terminal panel
         // Open a confirmation dialog with 3 buttons:
         // QDialogButtonBox::Yes    -> Quit
         // Ask if the user really wants to quit Dolphin with a program that is still running in the Terminal panel
         // Open a confirmation dialog with 3 buttons:
         // QDialogButtonBox::Yes    -> Quit


@@ -561,6 +604,14 @@ void DolphinMainWindow::closeEvent(QCloseEvent* event)
         }
     }
 
         }
     }
 

+    if (GeneralSettings::rememberOpenedTabs())  {
+        KConfigGui::setSessionConfig(QStringLiteral("dolphin"), QStringLiteral("dolphin"));
+        KConfig *config = KConfigGui::sessionConfig();
+        saveGlobalProperties(config);
+        savePropertiesInternal(config, 1);
+        config->sync();
+    }
+

     GeneralSettings::setVersion(CurrentDolphinVersion);
     GeneralSettings::self()->save();
 
     GeneralSettings::setVersion(CurrentDolphinVersion);
     GeneralSettings::self()->save();
 


@@ -581,13 +632,13 @@ void DolphinMainWindow::updateNewMenu()
 {
     m_newFileMenu->setViewShowsHiddenFiles(activeViewContainer()->view()->hiddenFilesShown());
     m_newFileMenu->checkUpToDate();
 {
     m_newFileMenu->setViewShowsHiddenFiles(activeViewContainer()->view()->hiddenFilesShown());
     m_newFileMenu->checkUpToDate();

-    m_newFileMenu->setPopupFiles(activeViewContainer()->url());
+    m_newFileMenu->setPopupFiles(QList<QUrl>() << activeViewContainer()->url());

 }
 
 void DolphinMainWindow::createDirectory()
 {
     m_newFileMenu->setViewShowsHiddenFiles(activeViewContainer()->view()->hiddenFilesShown());
 }
 
 void DolphinMainWindow::createDirectory()
 {
     m_newFileMenu->setViewShowsHiddenFiles(activeViewContainer()->view()->hiddenFilesShown());

-    m_newFileMenu->setPopupFiles(activeViewContainer()->url());
+    m_newFileMenu->setPopupFiles(QList<QUrl>() << activeViewContainer()->url());

     m_newFileMenu->createDirectory();
 }
 
     m_newFileMenu->createDirectory();
 }
 


@@ -626,12 +677,12 @@ void DolphinMainWindow::undo()
 
 void DolphinMainWindow::cut()
 {
 
 void DolphinMainWindow::cut()
 {

-    m_activeViewContainer->view()->cutSelectedItems();
+    m_activeViewContainer->view()->cutSelectedItemsToClipboard();

 }
 
 void DolphinMainWindow::copy()
 {
 }
 
 void DolphinMainWindow::copy()
 {

-    m_activeViewContainer->view()->copySelectedItems();
+    m_activeViewContainer->view()->copySelectedItemsToClipboard();

 }
 
 void DolphinMainWindow::paste()
 }
 
 void DolphinMainWindow::paste()


@@ -676,6 +727,56 @@ void DolphinMainWindow::slotToolBarActionMiddleClicked(QAction *action)
     }
 }
 
     }
 }
 

+void DolphinMainWindow::slotAboutToShowBackPopupMenu()
+{
+    const KUrlNavigator *urlNavigator = m_activeViewContainer->urlNavigatorInternal();
+    int entries = 0;
+    m_backAction->menu()->clear();
+    for (int i = urlNavigator->historyIndex() + 1; i < urlNavigator->historySize() && entries < MaxNumberOfNavigationentries; ++i, ++entries) {
+        QAction* action = new QAction(urlNavigator->locationUrl(i).toString(QUrl::PreferLocalFile), m_backAction->menu());
+        action->setData(i);
+        m_backAction->menu()->addAction(action);
+    }
+}
+
+void DolphinMainWindow::slotGoBack(QAction* action)
+{
+    int gotoIndex = action->data().value<int>();
+    const KUrlNavigator *urlNavigator = m_activeViewContainer->urlNavigatorInternal();
+    for (int i = gotoIndex - urlNavigator->historyIndex(); i > 0; --i) {
+        goBack();
+    }
+}
+
+void DolphinMainWindow::slotBackForwardActionMiddleClicked(QAction* action)
+{
+    if (action) {
+        const KUrlNavigator *urlNavigator = activeViewContainer()->urlNavigatorInternal();
+        openNewTabAfterCurrentTab(urlNavigator->locationUrl(action->data().value<int>()));
+    }
+}
+
+void DolphinMainWindow::slotAboutToShowForwardPopupMenu()
+{
+    const KUrlNavigator *urlNavigator = m_activeViewContainer->urlNavigatorInternal();
+    int entries = 0;
+    m_forwardAction->menu()->clear();
+    for (int i = urlNavigator->historyIndex() - 1; i >= 0 && entries < MaxNumberOfNavigationentries; --i, ++entries) {
+        QAction* action = new QAction(urlNavigator->locationUrl(i).toString(QUrl::PreferLocalFile), m_forwardAction->menu());
+        action->setData(i);
+        m_forwardAction->menu()->addAction(action);
+    }
+}
+
+void DolphinMainWindow::slotGoForward(QAction* action)
+{
+    int gotoIndex = action->data().value<int>();
+    const KUrlNavigator *urlNavigator = m_activeViewContainer->urlNavigatorInternal();
+    for (int i = urlNavigator->historyIndex() - gotoIndex; i > 0; --i) {
+        goForward();
+    }
+}
+

 void DolphinMainWindow::selectAll()
 {
     clearStatusBar();
 void DolphinMainWindow::selectAll()
 {
     clearStatusBar();


@@ -742,6 +843,62 @@ void DolphinMainWindow::showFilterBar()
     m_activeViewContainer->setFilterBarVisible(true);
 }
 
     m_activeViewContainer->setFilterBarVisible(true);
 }
 

+void DolphinMainWindow::toggleLocationInToolbar()
+{
+    // collect needed variables
+    QAction *locationInToolbarAction = actionCollection()->action(QStringLiteral("location_in_toolbar"));
+    const bool locationInToolbar = locationInToolbarAction->isChecked();
+    auto viewContainers = this->viewContainers();
+    auto urlNavigatorWidgetAction = static_cast<DolphinUrlNavigatorWidgetAction *>
+        (actionCollection()->action(QStringLiteral("url_navigator")));
+    const bool isEditable = m_activeViewContainer->urlNavigator()->isUrlEditable();
+    const QLineEdit *lineEdit = m_activeViewContainer->urlNavigator()->editor()->lineEdit();
+    const bool hasFocus = lineEdit->hasFocus();
+    const int cursorPosition = lineEdit->cursorPosition();
+    const int selectionStart = lineEdit->selectionStart();
+    const int selectionLength = lineEdit->selectionLength();
+
+    // prevent the switching if it would leave the user without a visible UrlNavigator
+    if (locationInToolbar && !toolBar()->actions().contains(urlNavigatorWidgetAction)) {
+        QAction *configureToolbars = actionCollection()->action(KStandardAction::name(KStandardAction::ConfigureToolbars));
+        KMessageWidget *messageWidget = m_activeViewContainer->showMessage(
+            xi18nc("@info 2 is the visible text on a button just below the message",
+            "The location could not be moved onto the toolbar because there is currently "
+            "no \"%1\" item on the toolbar. Select <interface>%2</interface> and add the "
+            "\"%1\" item. Then this will work.", urlNavigatorWidgetAction->iconText(),
+            configureToolbars->iconText()), DolphinViewContainer::Information);
+        messageWidget->addAction(configureToolbars);
+        messageWidget->addAction(locationInToolbarAction);
+        locationInToolbarAction->setChecked(false);
+        return;
+    }
+
+    // do the switching
+    GeneralSettings::setLocationInToolbar(locationInToolbar);
+    if (locationInToolbar) {
+        for (const auto viewContainer : viewContainers) {
+            viewContainer->disconnectUrlNavigator();
+        }
+        m_activeViewContainer->connectUrlNavigator(urlNavigatorWidgetAction->urlNavigator());
+    } else {
+        m_activeViewContainer->disconnectUrlNavigator();
+        for (const auto viewContainer : viewContainers) {
+            viewContainer->connectToInternalUrlNavigator();
+        }
+    }
+
+    urlNavigatorWidgetAction->setUrlNavigatorVisible(locationInToolbar);
+    m_activeViewContainer->urlNavigator()->setUrlEditable(isEditable);
+    if (hasFocus) { // the rest of this method is unneeded perfectionism
+        m_activeViewContainer->urlNavigator()->editor()->lineEdit()->setText(lineEdit->text());
+        m_activeViewContainer->urlNavigator()->editor()->lineEdit()->setFocus();
+        m_activeViewContainer->urlNavigator()->editor()->lineEdit()->setCursorPosition(cursorPosition);
+        if (selectionStart != -1) {
+            m_activeViewContainer->urlNavigator()->editor()->lineEdit()->setSelection(selectionStart, selectionLength);
+        }
+    }
+}
+

 void DolphinMainWindow::toggleEditLocation()
 {
     clearStatusBar();
 void DolphinMainWindow::toggleEditLocation()
 {
     clearStatusBar();


@@ -772,7 +929,8 @@ void DolphinMainWindow::replaceLocation()
 void DolphinMainWindow::togglePanelLockState()
 {
     const bool newLockState = !GeneralSettings::lockPanels();
 void DolphinMainWindow::togglePanelLockState()
 {
     const bool newLockState = !GeneralSettings::lockPanels();

-    foreach (QObject* child, children()) {
+    const auto childrenObjects = children();
+    for (QObject* child : childrenObjects) {

         DolphinDockWidget* dock = qobject_cast<DolphinDockWidget*>(child);
         if (dock) {
             dock->setLocked(newLockState);
         DolphinDockWidget* dock = qobject_cast<DolphinDockWidget*>(child);
         if (dock) {
             dock->setLocked(newLockState);


@@ -791,7 +949,7 @@ void DolphinMainWindow::slotTerminalPanelVisibilityChanged()
 
 void DolphinMainWindow::goBack()
 {
 
 void DolphinMainWindow::goBack()
 {

-    KUrlNavigator* urlNavigator = m_activeViewContainer->urlNavigator();
+    DolphinUrlNavigator *urlNavigator = m_activeViewContainer->urlNavigatorInternal();

     urlNavigator->goBack();
 
     if (urlNavigator->locationState().isEmpty()) {
     urlNavigator->goBack();
 
     if (urlNavigator->locationState().isEmpty()) {


@@ -818,14 +976,14 @@ void DolphinMainWindow::goHome()
 
 void DolphinMainWindow::goBackInNewTab()
 {
 
 void DolphinMainWindow::goBackInNewTab()
 {

-    KUrlNavigator* urlNavigator = activeViewContainer()->urlNavigator();
+    KUrlNavigator* urlNavigator = activeViewContainer()->urlNavigatorInternal();

     const int index = urlNavigator->historyIndex() + 1;
     openNewTabAfterCurrentTab(urlNavigator->locationUrl(index));
 }
 
 void DolphinMainWindow::goForwardInNewTab()
 {
     const int index = urlNavigator->historyIndex() + 1;
     openNewTabAfterCurrentTab(urlNavigator->locationUrl(index));
 }
 
 void DolphinMainWindow::goForwardInNewTab()
 {

-    KUrlNavigator* urlNavigator = activeViewContainer()->urlNavigator();
+    KUrlNavigator* urlNavigator = activeViewContainer()->urlNavigatorInternal();

     const int index = urlNavigator->historyIndex() - 1;
     openNewTabAfterCurrentTab(urlNavigator->locationUrl(index));
 }
     const int index = urlNavigator->historyIndex() - 1;
     openNewTabAfterCurrentTab(urlNavigator->locationUrl(index));
 }


@@ -858,7 +1016,10 @@ void DolphinMainWindow::compareFiles()
     command.append("\" \"");
     command.append(urlB.toDisplayString(QUrl::PreferLocalFile));
     command.append('\"');
     command.append("\" \"");
     command.append(urlB.toDisplayString(QUrl::PreferLocalFile));
     command.append('\"');

-    KRun::runCommand(command, QStringLiteral("Kompare"), QStringLiteral("kompare"), this);
+
+    KIO::CommandLauncherJob *job = new KIO::CommandLauncherJob(command, this);
+    job->setDesktopName(QStringLiteral("org.kde.kompare"));
+    job->start();

 }
 
 void DolphinMainWindow::toggleShowMenuBar()
 }
 
 void DolphinMainWindow::toggleShowMenuBar()


@@ -872,23 +1033,77 @@ void DolphinMainWindow::toggleShowMenuBar()
     }
 }
 
     }
 }
 

-void DolphinMainWindow::openTerminal()
+QPointer<QAction> DolphinMainWindow::preferredSearchTool()
+{
+    m_searchTools.clear();
+    KMoreToolsMenuFactory("dolphin/search-tools").fillMenuFromGroupingNames(
+        &m_searchTools, { "files-find" }, m_activeViewContainer->url()
+    );
+    QList<QAction*> actions = m_searchTools.actions();
+    if (actions.isEmpty()) {
+        return nullptr;
+    }
+    QAction* action = actions.first();
+    if (action->isSeparator()) {
+        return nullptr;
+    }
+    return action;
+}
+
+void DolphinMainWindow::updateOpenPreferredSearchToolAction()
+{
+    QAction* openPreferredSearchTool = actionCollection()->action(QStringLiteral("open_preferred_search_tool"));
+    if (!openPreferredSearchTool) {
+        return;
+    }
+    QPointer<QAction> tool = preferredSearchTool();
+    if (tool) {
+        openPreferredSearchTool->setVisible(true);
+        openPreferredSearchTool->setText(i18nc("@action:inmenu Tools", "Open %1", tool->text()));
+        openPreferredSearchTool->setIcon(tool->icon());
+    } else {
+        openPreferredSearchTool->setVisible(false);
+        // still visible in Shortcuts configuration window
+        openPreferredSearchTool->setText(i18nc("@action:inmenu Tools", "Open Preferred Search Tool"));
+        openPreferredSearchTool->setIcon(QIcon::fromTheme(QStringLiteral("search")));
+    }
+}
+
+void DolphinMainWindow::openPreferredSearchTool()

 {
 {

-    QString dir(QDir::homePath());
+    QPointer<QAction> tool = preferredSearchTool();
+    if (tool) {
+        tool->trigger();
+    }
+}

 
 

-    // If the given directory is not local, it can still be the URL of an
-    // ioslave using UDS_LOCAL_PATH which to be converted first.
-    KIO::StatJob* statJob = KIO::mostLocalUrl(m_activeViewContainer->url());
-    KJobWidgets::setWindow(statJob, this);
-    statJob->exec();
-    QUrl url = statJob->mostLocalUrl();
+void DolphinMainWindow::openTerminal()
+{
+    const QUrl url = m_activeViewContainer->url();

 
 

-    //If the URL is local after the above conversion, set the directory.

     if (url.isLocalFile()) {
     if (url.isLocalFile()) {

-        dir = url.toLocalFile();
+        KToolInvocation::invokeTerminal(QString(), url.toLocalFile());
+        return;

     }
 
     }
 

-    KToolInvocation::invokeTerminal(QString(), dir);
+     // Not a local file, with protocol Class ":local", try stat'ing
+    if (KProtocolInfo::protocolClass(url.scheme()) == QLatin1String(":local")) {
+        KIO::StatJob *job = KIO::mostLocalUrl(url);
+        KJobWidgets::setWindow(job, this);
+        connect(job, &KJob::result, this, [job]() {
+            QUrl statUrl;
+            if (!job->error()) {
+                statUrl = job->mostLocalUrl();
+            }
+
+            KToolInvocation::invokeTerminal(QString(), statUrl.isLocalFile() ? statUrl.toLocalFile() : QDir::homePath());
+        });
+
+        return;
+    }
+
+    // Nothing worked, just use $HOME
+    KToolInvocation::invokeTerminal(QString(), QDir::homePath());

 }
 
 void DolphinMainWindow::editSettings()
 }
 
 void DolphinMainWindow::editSettings()


@@ -900,6 +1115,7 @@ void DolphinMainWindow::editSettings()
         const QUrl url = container->url();
         DolphinSettingsDialog* settingsDialog = new DolphinSettingsDialog(url, this);
         connect(settingsDialog, &DolphinSettingsDialog::settingsChanged, this, &DolphinMainWindow::refreshViews);
         const QUrl url = container->url();
         DolphinSettingsDialog* settingsDialog = new DolphinSettingsDialog(url, this);
         connect(settingsDialog, &DolphinSettingsDialog::settingsChanged, this, &DolphinMainWindow::refreshViews);

+        connect(settingsDialog, &DolphinSettingsDialog::settingsChanged, &DolphinUrlNavigator::slotReadSettings);

         settingsDialog->setAttribute(Qt::WA_DeleteOnClose);
         settingsDialog->show();
         m_settingsDialog = settingsDialog;
         settingsDialog->setAttribute(Qt::WA_DeleteOnClose);
         settingsDialog->show();
         m_settingsDialog = settingsDialog;


@@ -910,34 +1126,31 @@ void DolphinMainWindow::editSettings()
 
 void DolphinMainWindow::handleUrl(const QUrl& url)
 {
 
 void DolphinMainWindow::handleUrl(const QUrl& url)
 {

-    delete m_lastHandleUrlStatJob;
-    m_lastHandleUrlStatJob = nullptr;
+    delete m_lastHandleUrlOpenJob;
+    m_lastHandleUrlOpenJob = nullptr;

 
     if (url.isLocalFile() && QFileInfo(url.toLocalFile()).isDir()) {
         activeViewContainer()->setUrl(url);
 
     if (url.isLocalFile() && QFileInfo(url.toLocalFile()).isDir()) {
         activeViewContainer()->setUrl(url);

-    } else if (KProtocolManager::supportsListing(url)) {
-        // stat the URL to see if it is a dir or not
-        m_lastHandleUrlStatJob = KIO::stat(url, KIO::HideProgressInfo);
-        if (m_lastHandleUrlStatJob->uiDelegate()) {
-            KJobWidgets::setWindow(m_lastHandleUrlStatJob, this);
-        }
-        connect(m_lastHandleUrlStatJob, &KIO::Job::result,
-                this, &DolphinMainWindow::slotHandleUrlStatFinished);
-

     } else {
     } else {

-        new KRun(url, this); // Automatically deletes itself after being finished
-    }
-}
-
-void DolphinMainWindow::slotHandleUrlStatFinished(KJob* job)
-{
-    m_lastHandleUrlStatJob = nullptr;
-    const KIO::UDSEntry entry = static_cast<KIO::StatJob*>(job)->statResult();
-    const QUrl url = static_cast<KIO::StatJob*>(job)->url();
-    if (entry.isDir()) {
-        activeViewContainer()->setUrl(url);
-    } else {
-        new KRun(url, this);  // Automatically deletes itself after being finished
+        m_lastHandleUrlOpenJob = new KIO::OpenUrlJob(url);
+        m_lastHandleUrlOpenJob->setUiDelegate(new KIO::JobUiDelegate(KJobUiDelegate::AutoHandlingEnabled, this));
+        m_lastHandleUrlOpenJob->setRunExecutables(true);
+
+        connect(m_lastHandleUrlOpenJob, &KIO::OpenUrlJob::mimeTypeFound, this,
+                [this, url](const QString &mimetype) {
+                    if (mimetype == QLatin1String("inode/directory")) {
+                        // If it's a dir, we'll take it from here
+                        m_lastHandleUrlOpenJob->kill();
+                        m_lastHandleUrlOpenJob = nullptr;
+                        activeViewContainer()->setUrl(url);
+                    }
+        });
+
+        connect(m_lastHandleUrlOpenJob, &KIO::OpenUrlJob::result, this, [this]() {
+            m_lastHandleUrlOpenJob = nullptr;
+        });
+
+        m_lastHandleUrlOpenJob->start();

     }
 }
 
     }
 }
 


@@ -994,18 +1207,18 @@ void DolphinMainWindow::updateControlMenu()
 
     KActionCollection* ac = actionCollection();
 
 
     KActionCollection* ac = actionCollection();
 

-    // Add "Create New" menu

     menu->addMenu(m_newFileMenu->menu());
     menu->addMenu(m_newFileMenu->menu());

+    addActionToMenu(ac->action(QStringLiteral("file_new")), menu);
+    addActionToMenu(ac->action(QStringLiteral("new_tab")), menu);
+    addActionToMenu(ac->action(QStringLiteral("closed_tabs")), menu);

 
     menu->addSeparator();
 
 
     menu->addSeparator();
 

-    // Overwrite Find action to Search action
-    QAction *searchAction = ac->action(KStandardAction::name(KStandardAction::Find));
-    searchAction->setText(i18n("Search..."));
-

     // Add "Edit" actions
     bool added = addActionToMenu(ac->action(KStandardAction::name(KStandardAction::Undo)), menu) |
     // Add "Edit" actions
     bool added = addActionToMenu(ac->action(KStandardAction::name(KStandardAction::Undo)), menu) |

-                 addActionToMenu(searchAction, menu) |
+                 addActionToMenu(ac->action(QString("copy_location")), menu) |
+                 addActionToMenu(ac->action(QStringLiteral("copy_to_inactive_split_view")), menu) |
+                 addActionToMenu(ac->action(QStringLiteral("move_to_inactive_split_view")), menu) |

                  addActionToMenu(ac->action(KStandardAction::name(KStandardAction::SelectAll)), menu) |
                  addActionToMenu(ac->action(QStringLiteral("invert_selection")), menu);
 
                  addActionToMenu(ac->action(KStandardAction::name(KStandardAction::SelectAll)), menu) |
                  addActionToMenu(ac->action(QStringLiteral("invert_selection")), menu);
 


@@ -1021,62 +1234,36 @@ void DolphinMainWindow::updateControlMenu()
         menu->addSeparator();
     }
 
         menu->addSeparator();
     }
 

-    added = addActionToMenu(ac->action(QStringLiteral("sort")), menu) |
-            addActionToMenu(ac->action(QStringLiteral("view_mode")), menu) |
-            addActionToMenu(ac->action(QStringLiteral("additional_info")), menu) |
-            addActionToMenu(ac->action(QStringLiteral("show_preview")), menu) |
+    added = addActionToMenu(ac->action(QStringLiteral("show_preview")), menu) |

             addActionToMenu(ac->action(QStringLiteral("show_in_groups")), menu) |
             addActionToMenu(ac->action(QStringLiteral("show_in_groups")), menu) |

-            addActionToMenu(ac->action(QStringLiteral("show_hidden_files")), menu);
-
-    if (added) {
-        menu->addSeparator();
-    }
-
-    added = addActionToMenu(ac->action(QStringLiteral("split_view")), menu) |
-            addActionToMenu(ac->action(KStandardAction::name(KStandardAction::Redisplay)), menu) |
+            addActionToMenu(ac->action(QStringLiteral("show_hidden_files")), menu) |
+            addActionToMenu(ac->action(QStringLiteral("additional_info")), menu) |

             addActionToMenu(ac->action(QStringLiteral("view_properties")), menu);
             addActionToMenu(ac->action(QStringLiteral("view_properties")), menu);

+

     if (added) {
         menu->addSeparator();
     }
 
     if (added) {
         menu->addSeparator();
     }
 

-    addActionToMenu(ac->action(QStringLiteral("panels")), menu);
-    QMenu* locationBarMenu = new QMenu(i18nc("@action:inmenu", "Location Bar"), menu);
-    locationBarMenu->addAction(ac->action(QStringLiteral("editable_location")));
-    locationBarMenu->addAction(ac->action(QStringLiteral("replace_location")));
-    menu->addMenu(locationBarMenu);
+    // Add a curated assortment of items from the "Tools" menu
+    addActionToMenu(ac->action(QStringLiteral("show_filter_bar")), menu);
+    addActionToMenu(ac->action(QStringLiteral("open_preferred_search_tool")), menu);
+    addActionToMenu(ac->action(QStringLiteral("open_terminal")), menu);

 
     menu->addSeparator();
 
 
     menu->addSeparator();
 

-    // Add "Go" menu
-    QMenu* goMenu = new QMenu(i18nc("@action:inmenu", "Go"), menu);
-    goMenu->addAction(ac->action(KStandardAction::name(KStandardAction::Back)));
-    goMenu->addAction(ac->action(KStandardAction::name(KStandardAction::Forward)));
-    goMenu->addAction(ac->action(KStandardAction::name(KStandardAction::Up)));
-    goMenu->addAction(ac->action(KStandardAction::name(KStandardAction::Home)));
-    goMenu->addAction(ac->action(QStringLiteral("closed_tabs")));
-    KActionMenu *bookmarkMenu = new KActionMenu(i18nc("@title:menu", "&Bookmarks"), goMenu);
-    m_bookmarkHandler->fillControlMenu(bookmarkMenu->menu(), ac);
-    goMenu->addAction(bookmarkMenu);
-    menu->addMenu(goMenu);
-
-    // Add "Tool" menu
-    QMenu* toolsMenu = new QMenu(i18nc("@action:inmenu", "Tools"), menu);
-    toolsMenu->addAction(ac->action(QStringLiteral("show_filter_bar")));
-    toolsMenu->addAction(ac->action(QStringLiteral("compare_files")));
-    toolsMenu->addAction(ac->action(QStringLiteral("open_terminal")));
-    toolsMenu->addAction(ac->action(QStringLiteral("change_remote_encoding")));
-    menu->addMenu(toolsMenu);
+    // Add "Show Panels" menu
+    addActionToMenu(ac->action(QStringLiteral("panels")), menu);

 
     // Add "Settings" menu entries
     addActionToMenu(ac->action(KStandardAction::name(KStandardAction::KeyBindings)), menu);
     addActionToMenu(ac->action(KStandardAction::name(KStandardAction::ConfigureToolbars)), menu);
     addActionToMenu(ac->action(KStandardAction::name(KStandardAction::Preferences)), menu);
 
     // Add "Settings" menu entries
     addActionToMenu(ac->action(KStandardAction::name(KStandardAction::KeyBindings)), menu);
     addActionToMenu(ac->action(KStandardAction::name(KStandardAction::ConfigureToolbars)), menu);
     addActionToMenu(ac->action(KStandardAction::name(KStandardAction::Preferences)), menu);

+    addActionToMenu(ac->action(KStandardAction::name(KStandardAction::ShowMenubar)), menu);

 
     // Add "Help" menu
 
     // Add "Help" menu

-    menu->addMenu(m_helpMenu->menu());
-
-    menu->addSeparator();
-    addActionToMenu(ac->action(KStandardAction::name(KStandardAction::ShowMenubar)), menu);
+    auto helpMenu = m_helpMenu->menu();
+    helpMenu->setIcon(QIcon::fromTheme(QStringLiteral("system-help")));
+    menu->addMenu(helpMenu);

 }
 
 void DolphinMainWindow::updateToolBar()
 }
 
 void DolphinMainWindow::updateToolBar()


@@ -1126,12 +1313,19 @@ void DolphinMainWindow::activeViewChanged(DolphinViewContainer* viewContainer)
         oldViewContainer->disconnect(this);
         oldViewContainer->view()->disconnect(this);
         oldViewContainer->urlNavigator()->disconnect(this);
         oldViewContainer->disconnect(this);
         oldViewContainer->view()->disconnect(this);
         oldViewContainer->urlNavigator()->disconnect(this);

+        if (GeneralSettings::locationInToolbar()) {
+            oldViewContainer->disconnectUrlNavigator();
+        }

 
         // except the requestItemInfo so that on hover the information panel can still be updated
         connect(oldViewContainer->view(), &DolphinView::requestItemInfo,
                 this, &DolphinMainWindow::requestItemInfo);
     }
 
 
         // except the requestItemInfo so that on hover the information panel can still be updated
         connect(oldViewContainer->view(), &DolphinView::requestItemInfo,
                 this, &DolphinMainWindow::requestItemInfo);
     }
 

+    if (GeneralSettings::locationInToolbar()) {
+        viewContainer->connectUrlNavigator(static_cast<DolphinUrlNavigatorWidgetAction *>
+            (actionCollection()->action(QStringLiteral("url_navigator")))->urlNavigator());
+    }

     connectViewSignals(viewContainer);
 
     m_actionHandler->setCurrentView(viewContainer->view());
     connectViewSignals(viewContainer);
 
     m_actionHandler->setCurrentView(viewContainer->view());


@@ -1144,19 +1338,23 @@ void DolphinMainWindow::activeViewChanged(DolphinViewContainer* viewContainer)
     updateSearchAction();
 
     const QUrl url = viewContainer->url();
     updateSearchAction();
 
     const QUrl url = viewContainer->url();

-    emit urlChanged(url);
+    Q_EMIT urlChanged(url);

 }
 
 void DolphinMainWindow::tabCountChanged(int count)
 {
     const bool enableTabActions = (count > 1);
 }
 
 void DolphinMainWindow::tabCountChanged(int count)
 {
     const bool enableTabActions = (count > 1);

+    for (int i = 0; i < MaxActivateTabShortcuts; ++i) {
+        actionCollection()->action(QStringLiteral("activate_tab_%1").arg(i))->setEnabled(enableTabActions);
+    }
+    actionCollection()->action(QStringLiteral("activate_last_tab"))->setEnabled(enableTabActions);

     actionCollection()->action(QStringLiteral("activate_next_tab"))->setEnabled(enableTabActions);
     actionCollection()->action(QStringLiteral("activate_prev_tab"))->setEnabled(enableTabActions);
 }
 
 void DolphinMainWindow::updateWindowTitle()
 {
     actionCollection()->action(QStringLiteral("activate_next_tab"))->setEnabled(enableTabActions);
     actionCollection()->action(QStringLiteral("activate_prev_tab"))->setEnabled(enableTabActions);
 }
 
 void DolphinMainWindow::updateWindowTitle()
 {

-    const QString newTitle = m_activeViewContainer->caption();
+    const QString newTitle = m_activeViewContainer->captionWindowTitle();

     if (windowTitle() != newTitle) {
         setWindowTitle(newTitle);
     }
     if (windowTitle() != newTitle) {
         setWindowTitle(newTitle);
     }


@@ -1164,7 +1362,11 @@ void DolphinMainWindow::updateWindowTitle()
 
 void DolphinMainWindow::slotStorageTearDownFromPlacesRequested(const QString& mountPath)
 {
 
 void DolphinMainWindow::slotStorageTearDownFromPlacesRequested(const QString& mountPath)
 {

-    if (m_terminalPanel->currentWorkingDirectory().startsWith(mountPath)) {
+    connect(m_placesPanel, &PlacesPanel::storageTearDownSuccessful, this, [this, mountPath]() {
+        setViewsToHomeIfMountPathOpen(mountPath);
+    });
+
+    if (m_terminalPanel && m_terminalPanel->currentWorkingDirectory().startsWith(mountPath)) {

         m_tearDownFromPlacesRequested = true;
         m_terminalPanel->goHome();
         // m_placesPanel->proceedWithTearDown() will be called in slotTerminalDirectoryChanged
         m_tearDownFromPlacesRequested = true;
         m_terminalPanel->goHome();
         // m_placesPanel->proceedWithTearDown() will be called in slotTerminalDirectoryChanged


@@ -1175,12 +1377,27 @@ void DolphinMainWindow::slotStorageTearDownFromPlacesRequested(const QString& mo
 
 void DolphinMainWindow::slotStorageTearDownExternallyRequested(const QString& mountPath)
 {
 
 void DolphinMainWindow::slotStorageTearDownExternallyRequested(const QString& mountPath)
 {

-    if (m_terminalPanel->currentWorkingDirectory().startsWith(mountPath)) {
+    connect(m_placesPanel, &PlacesPanel::storageTearDownSuccessful, this, [this, mountPath]() {
+        setViewsToHomeIfMountPathOpen(mountPath);
+    });
+
+    if (m_terminalPanel && m_terminalPanel->currentWorkingDirectory().startsWith(mountPath)) {

         m_tearDownFromPlacesRequested = false;
         m_terminalPanel->goHome();
     }
 }
 
         m_tearDownFromPlacesRequested = false;
         m_terminalPanel->goHome();
     }
 }
 

+void DolphinMainWindow::setViewsToHomeIfMountPathOpen(const QString& mountPath)
+{
+    const QVector<DolphinViewContainer*> theViewContainers = viewContainers();
+    for (DolphinViewContainer *viewContainer : theViewContainers) {
+        if (viewContainer && viewContainer->url().toLocalFile().startsWith(mountPath)) {
+            viewContainer->setUrl(QUrl::fromLocalFile(QDir::homePath()));
+        }
+    }
+    disconnect(m_placesPanel, &PlacesPanel::storageTearDownSuccessful, nullptr, nullptr);
+}
+

 void DolphinMainWindow::setupActions()
 {
     // setup 'File' menu
 void DolphinMainWindow::setupActions()
 {
     // setup 'File' menu


@@ -1212,6 +1429,7 @@ void DolphinMainWindow::setupActions()
 
     QAction* addToPlaces = actionCollection()->addAction(QStringLiteral("add_to_places"));
     addToPlaces->setIcon(QIcon::fromTheme(QStringLiteral("bookmark-new")));
 
     QAction* addToPlaces = actionCollection()->addAction(QStringLiteral("add_to_places"));
     addToPlaces->setIcon(QIcon::fromTheme(QStringLiteral("bookmark-new")));

+    addToPlaces->setText(i18nc("@action:inmenu Add current folder to places", "Add to Places"));

     addToPlaces->setWhatsThis(xi18nc("@info:whatsthis", "This adds the selected folder "
         "to the Places panel."));
     connect(addToPlaces, &QAction::triggered, this, &DolphinMainWindow::addToPlaces);
     addToPlaces->setWhatsThis(xi18nc("@info:whatsthis", "This adds the selected folder "
         "to the Places panel."));
     connect(addToPlaces, &QAction::triggered, this, &DolphinMainWindow::addToPlaces);


@@ -1259,6 +1477,24 @@ void DolphinMainWindow::setupActions()
         "If the items were added to the clipboard by the <emphasis>Cut</emphasis> "
         "action they are removed from their old location.") +  cutCopyPastePara);
 
         "If the items were added to the clipboard by the <emphasis>Cut</emphasis> "
         "action they are removed from their old location.") +  cutCopyPastePara);
 

+    QAction* copyToOtherViewAction = actionCollection()->addAction(QStringLiteral("copy_to_inactive_split_view"));
+    copyToOtherViewAction->setText(i18nc("@action:inmenu", "Copy to Inactive Split View"));
+    copyToOtherViewAction->setWhatsThis(xi18nc("@info:whatsthis Copy", "This copies the selected items from "
+        "the <emphasis>active</emphasis> view to the inactive split view."));
+    copyToOtherViewAction->setIcon(QIcon::fromTheme(QStringLiteral("edit-copy")));
+    copyToOtherViewAction->setIconText(i18nc("@action:inmenu Edit", "Copy to Inactive Split View"));
+    actionCollection()->setDefaultShortcut(copyToOtherViewAction, Qt::SHIFT + Qt::Key_F5 );
+    connect(copyToOtherViewAction, &QAction::triggered, m_tabWidget, &DolphinTabWidget::copyToInactiveSplitView);
+
+    QAction* moveToOtherViewAction = actionCollection()->addAction(QStringLiteral("move_to_inactive_split_view"));
+    moveToOtherViewAction->setText(i18nc("@action:inmenu", "Move to Inactive Split View"));
+    moveToOtherViewAction->setWhatsThis(xi18nc("@info:whatsthis Move", "This moves the selected items from "
+        "the <emphasis>active</emphasis> view to the inactive split view."));
+    moveToOtherViewAction->setIcon(QIcon::fromTheme(QStringLiteral("edit-cut")));
+    moveToOtherViewAction->setIconText(i18nc("@action:inmenu Edit", "Move to Inactive Split View"));
+    actionCollection()->setDefaultShortcut(moveToOtherViewAction, Qt::SHIFT + Qt::Key_F6 );
+    connect(moveToOtherViewAction, &QAction::triggered, m_tabWidget, &DolphinTabWidget::moveToInactiveSplitView);
+

     QAction *searchAction = KStandardAction::find(this, &DolphinMainWindow::find, actionCollection());
     searchAction->setText(i18n("Search..."));
     searchAction->setToolTip(i18nc("@info:tooltip", "Search for files and folders"));
     QAction *searchAction = KStandardAction::find(this, &DolphinMainWindow::find, actionCollection());
     searchAction->setText(i18n("Search..."));
     searchAction->setToolTip(i18nc("@info:tooltip", "Search for files and folders"));


@@ -1321,6 +1557,16 @@ void DolphinMainWindow::setupActions()
     stop->setIcon(QIcon::fromTheme(QStringLiteral("process-stop")));
     connect(stop, &QAction::triggered, this, &DolphinMainWindow::stopLoading);
 
     stop->setIcon(QIcon::fromTheme(QStringLiteral("process-stop")));
     connect(stop, &QAction::triggered, this, &DolphinMainWindow::stopLoading);
 

+    KToggleAction* locationInToolbar = actionCollection()->add<KToggleAction>(QStringLiteral("location_in_toolbar"));
+    locationInToolbar->setText(i18nc("@action:inmenu Navigation Bar", "Location in Toolbar"));
+    locationInToolbar->setWhatsThis(xi18nc("@info:whatsthis",
+        "This toggles between showing the <emphasis>path</emphasis> in the "
+        "<emphasis>Location Bar</emphasis> and in the <emphasis>Toolbar</emphasis>."));
+    actionCollection()->setDefaultShortcut(locationInToolbar, Qt::Key_F12);
+    locationInToolbar->setChecked(GeneralSettings::locationInToolbar());
+    connect(locationInToolbar, &KToggleAction::triggered, this, &DolphinMainWindow::toggleLocationInToolbar);
+    DolphinUrlNavigator::addToContextMenu(locationInToolbar);
+

     KToggleAction* editableLocation = actionCollection()->add<KToggleAction>(QStringLiteral("editable_location"));
     editableLocation->setText(i18nc("@action:inmenu Navigation Bar", "Editable Location"));
     editableLocation->setWhatsThis(xi18nc("@info:whatsthis",
     KToggleAction* editableLocation = actionCollection()->add<KToggleAction>(QStringLiteral("editable_location"));
     editableLocation->setText(i18nc("@action:inmenu Navigation Bar", "Editable Location"));
     editableLocation->setWhatsThis(xi18nc("@info:whatsthis",


@@ -1343,10 +1589,22 @@ void DolphinMainWindow::setupActions()
     connect(replaceLocation, &QAction::triggered, this, &DolphinMainWindow::replaceLocation);
 
     // setup 'Go' menu
     connect(replaceLocation, &QAction::triggered, this, &DolphinMainWindow::replaceLocation);
 
     // setup 'Go' menu

-    QAction* backAction = KStandardAction::back(this, &DolphinMainWindow::goBack, actionCollection());
-    auto backShortcuts = backAction->shortcuts();
+    {
+        QScopedPointer<QAction> backAction(KStandardAction::back(nullptr, nullptr, nullptr));
+        m_backAction = new KToolBarPopupAction(backAction->icon(), backAction->text(), actionCollection());
+        m_backAction->setObjectName(backAction->objectName());
+        m_backAction->setShortcuts(backAction->shortcuts());
+    }
+    m_backAction->setDelayed(true);
+    m_backAction->setStickyMenu(false);
+    connect(m_backAction, &QAction::triggered, this, &DolphinMainWindow::goBack);
+    connect(m_backAction->menu(), &QMenu::aboutToShow, this, &DolphinMainWindow::slotAboutToShowBackPopupMenu);
+    connect(m_backAction->menu(), &QMenu::triggered, this, &DolphinMainWindow::slotGoBack);
+    actionCollection()->addAction(m_backAction->objectName(), m_backAction);
+
+    auto backShortcuts = m_backAction->shortcuts();

     backShortcuts.append(QKeySequence(Qt::Key_Backspace));
     backShortcuts.append(QKeySequence(Qt::Key_Backspace));

-    actionCollection()->setDefaultShortcuts(backAction, backShortcuts);
+    actionCollection()->setDefaultShortcuts(m_backAction, backShortcuts);

 
     DolphinRecentTabsMenu* recentTabsMenu = new DolphinRecentTabsMenu(this);
     actionCollection()->addAction(QStringLiteral("closed_tabs"), recentTabsMenu);
 
     DolphinRecentTabsMenu* recentTabsMenu = new DolphinRecentTabsMenu(this);
     actionCollection()->addAction(QStringLiteral("closed_tabs"), recentTabsMenu);


@@ -1375,7 +1633,25 @@ void DolphinMainWindow::setupActions()
         "be undone will ask for your confirmation."));
     undoAction->setEnabled(false); // undo should be disabled by default
 
         "be undone will ask for your confirmation."));
     undoAction->setEnabled(false); // undo should be disabled by default
 

-    KStandardAction::forward(this, &DolphinMainWindow::goForward, actionCollection());
+    {
+        QScopedPointer<QAction> forwardAction(KStandardAction::forward(nullptr, nullptr, nullptr));
+        m_forwardAction = new KToolBarPopupAction(forwardAction->icon(), forwardAction->text(), actionCollection());
+        m_forwardAction->setObjectName(forwardAction->objectName());
+        m_forwardAction->setShortcuts(forwardAction->shortcuts());
+    }
+    m_forwardAction->setDelayed(true);
+    m_forwardAction->setStickyMenu(false);
+    connect(m_forwardAction, &QAction::triggered, this, &DolphinMainWindow::goForward);
+    connect(m_forwardAction->menu(), &QMenu::aboutToShow, this, &DolphinMainWindow::slotAboutToShowForwardPopupMenu);
+    connect(m_forwardAction->menu(), &QMenu::triggered, this, &DolphinMainWindow::slotGoForward);
+    actionCollection()->addAction(m_forwardAction->objectName(), m_forwardAction);
+    actionCollection()->setDefaultShortcuts(m_forwardAction, m_forwardAction->shortcuts());
+
+    // enable middle-click to open in a new tab
+    auto *middleClickEventFilter = new MiddleClickActionEventFilter(this);
+    connect(middleClickEventFilter, &MiddleClickActionEventFilter::actionMiddleClicked, this, &DolphinMainWindow::slotBackForwardActionMiddleClicked);
+    m_backAction->menu()->installEventFilter(middleClickEventFilter);
+    m_forwardAction->menu()->installEventFilter(middleClickEventFilter);

     KStandardAction::up(this, &DolphinMainWindow::goUp, actionCollection());
     QAction* homeAction = KStandardAction::home(this, &DolphinMainWindow::goHome, actionCollection());
     homeAction->setWhatsThis(xi18nc("@info:whatsthis", "Go to your "
     KStandardAction::up(this, &DolphinMainWindow::goUp, actionCollection());
     QAction* homeAction = KStandardAction::home(this, &DolphinMainWindow::goHome, actionCollection());
     homeAction->setWhatsThis(xi18nc("@info:whatsthis", "Go to your "


@@ -1400,7 +1676,15 @@ void DolphinMainWindow::setupActions()
     compareFiles->setEnabled(false);
     connect(compareFiles, &QAction::triggered, this, &DolphinMainWindow::compareFiles);
 
     compareFiles->setEnabled(false);
     connect(compareFiles, &QAction::triggered, this, &DolphinMainWindow::compareFiles);
 

-#ifdef HAVE_TERMINAL
+    QAction* openPreferredSearchTool = actionCollection()->addAction(QStringLiteral("open_preferred_search_tool"));
+    openPreferredSearchTool->setText(i18nc("@action:inmenu Tools", "Open Preferred Search Tool"));
+    openPreferredSearchTool->setWhatsThis(xi18nc("@info:whatsthis",
+        "<para>This opens a preferred search tool for the viewed location.</para>"
+        "<para>Use <emphasis>More Search Tools</emphasis> menu to configure it.</para>"));
+    openPreferredSearchTool->setIcon(QIcon::fromTheme(QStringLiteral("search")));
+    actionCollection()->setDefaultShortcut(openPreferredSearchTool, Qt::CTRL + Qt::SHIFT + Qt::Key_F);
+    connect(openPreferredSearchTool, &QAction::triggered, this, &DolphinMainWindow::openPreferredSearchTool);
+

     if (KAuthorized::authorize(QStringLiteral("shell_access"))) {
         QAction* openTerminal = actionCollection()->addAction(QStringLiteral("open_terminal"));
         openTerminal->setText(i18nc("@action:inmenu Tools", "Open Terminal"));
     if (KAuthorized::authorize(QStringLiteral("shell_access"))) {
         QAction* openTerminal = actionCollection()->addAction(QStringLiteral("open_terminal"));
         openTerminal->setText(i18nc("@action:inmenu Tools", "Open Terminal"));


@@ -1410,8 +1694,15 @@ void DolphinMainWindow::setupActions()
         openTerminal->setIcon(QIcon::fromTheme(QStringLiteral("dialog-scripts")));
         actionCollection()->setDefaultShortcut(openTerminal, Qt::SHIFT + Qt::Key_F4);
         connect(openTerminal, &QAction::triggered, this, &DolphinMainWindow::openTerminal);
         openTerminal->setIcon(QIcon::fromTheme(QStringLiteral("dialog-scripts")));
         actionCollection()->setDefaultShortcut(openTerminal, Qt::SHIFT + Qt::Key_F4);
         connect(openTerminal, &QAction::triggered, this, &DolphinMainWindow::openTerminal);

-    }
+
+#ifdef HAVE_TERMINAL
+        QAction* focusTerminalPanel = actionCollection()->addAction(QStringLiteral("focus_terminal_panel"));
+        focusTerminalPanel->setText(i18nc("@action:inmenu Tools", "Focus Terminal Panel"));
+        focusTerminalPanel->setIcon(QIcon::fromTheme(QStringLiteral("swap-panels")));
+        actionCollection()->setDefaultShortcut(focusTerminalPanel, Qt::CTRL + Qt::SHIFT + Qt::Key_F4);
+        connect(focusTerminalPanel, &QAction::triggered, this, &DolphinMainWindow::focusTerminalPanel);

 #endif
 #endif

+    }

 
     // setup 'Bookmarks' menu
     KActionMenu *bookmarkMenu = new KActionMenu(i18nc("@title:menu", "&Bookmarks"), this);
 
     // setup 'Bookmarks' menu
     KActionMenu *bookmarkMenu = new KActionMenu(i18nc("@title:menu", "&Bookmarks"), this);


@@ -1445,6 +1736,24 @@ void DolphinMainWindow::setupActions()
     QList<QKeySequence> prevTabKeys = KStandardShortcut::tabPrev();
     prevTabKeys.append(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_Tab));
 
     QList<QKeySequence> prevTabKeys = KStandardShortcut::tabPrev();
     prevTabKeys.append(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_Tab));
 

+    for (int i = 0; i < MaxActivateTabShortcuts; ++i) {
+        QAction* activateTab = actionCollection()->addAction(QStringLiteral("activate_tab_%1").arg(i));
+        activateTab->setText(i18nc("@action:inmenu", "Activate Tab %1", i + 1));
+        activateTab->setEnabled(false);
+        connect(activateTab, &QAction::triggered, this, [this, i]() { m_tabWidget->activateTab(i); });
+
+        // only add default shortcuts for the first 9 tabs regardless of MaxActivateTabShortcuts
+        if (i < 9) {
+            actionCollection()->setDefaultShortcut(activateTab, QStringLiteral("Alt+%1").arg(i + 1));
+        }
+    }
+
+    QAction* activateLastTab = actionCollection()->addAction(QStringLiteral("activate_last_tab"));
+    activateLastTab->setText(i18nc("@action:inmenu", "Activate Last Tab"));
+    activateLastTab->setEnabled(false);
+    connect(activateLastTab, &QAction::triggered, m_tabWidget, &DolphinTabWidget::activateLastTab);
+    actionCollection()->setDefaultShortcut(activateLastTab, Qt::ALT + Qt::Key_0);
+

     QAction* activateNextTab = actionCollection()->addAction(QStringLiteral("activate_next_tab"));
     activateNextTab->setIconText(i18nc("@action:inmenu", "Next Tab"));
     activateNextTab->setText(i18nc("@action:inmenu", "Activate Next Tab"));
     QAction* activateNextTab = actionCollection()->addAction(QStringLiteral("activate_next_tab"));
     activateNextTab->setIconText(i18nc("@action:inmenu", "Next Tab"));
     activateNextTab->setText(i18nc("@action:inmenu", "Activate Next Tab"));


@@ -1459,6 +1768,12 @@ void DolphinMainWindow::setupActions()
     connect(activatePrevTab, &QAction::triggered, m_tabWidget, &DolphinTabWidget::activatePrevTab);
     actionCollection()->setDefaultShortcuts(activatePrevTab, prevTabKeys);
 
     connect(activatePrevTab, &QAction::triggered, m_tabWidget, &DolphinTabWidget::activatePrevTab);
     actionCollection()->setDefaultShortcuts(activatePrevTab, prevTabKeys);
 

+    auto *urlNavigatorWidgetAction = new DolphinUrlNavigatorWidgetAction(this);
+    urlNavigatorWidgetAction->setText(i18nc("@action:inmenu auto-hide: "
+        "Depending on the settings this Widget is blank/invisible.",
+        "Url Navigator (auto-hide)"));
+    actionCollection()->addAction(QStringLiteral("url_navigator"), urlNavigatorWidgetAction);
+

     // for context menu
     QAction* showTarget = actionCollection()->addAction(QStringLiteral("show_target"));
     showTarget->setText(i18nc("@action:inmenu", "Show Target"));
     // for context menu
     QAction* showTarget = actionCollection()->addAction(QStringLiteral("show_target"));
     showTarget->setText(i18nc("@action:inmenu", "Show Target"));


@@ -1650,14 +1965,14 @@ void DolphinMainWindow::setupDockWidgets()
     connect(this, &DolphinMainWindow::urlChanged,
             m_placesPanel, &PlacesPanel::setUrl);
     connect(placesDock, &DolphinDockWidget::visibilityChanged,
     connect(this, &DolphinMainWindow::urlChanged,
             m_placesPanel, &PlacesPanel::setUrl);
     connect(placesDock, &DolphinDockWidget::visibilityChanged,

-            m_tabWidget, &DolphinTabWidget::slotPlacesPanelVisibilityChanged);
+            &DolphinUrlNavigator::slotPlacesPanelVisibilityChanged);

     connect(this, &DolphinMainWindow::settingsChanged,
         m_placesPanel, &PlacesPanel::readSettings);
     connect(m_placesPanel, &PlacesPanel::storageTearDownRequested,
             this, &DolphinMainWindow::slotStorageTearDownFromPlacesRequested);
     connect(m_placesPanel, &PlacesPanel::storageTearDownExternallyRequested,
             this, &DolphinMainWindow::slotStorageTearDownExternallyRequested);
     connect(this, &DolphinMainWindow::settingsChanged,
         m_placesPanel, &PlacesPanel::readSettings);
     connect(m_placesPanel, &PlacesPanel::storageTearDownRequested,
             this, &DolphinMainWindow::slotStorageTearDownFromPlacesRequested);
     connect(m_placesPanel, &PlacesPanel::storageTearDownExternallyRequested,
             this, &DolphinMainWindow::slotStorageTearDownExternallyRequested);

-    m_tabWidget->slotPlacesPanelVisibilityChanged(m_placesPanel->isVisible());
+    DolphinUrlNavigator::slotPlacesPanelVisibilityChanged(m_placesPanel->isVisible());

 
     auto actionShowAllPlaces = new QAction(QIcon::fromTheme(QStringLiteral("view-hidden")), i18nc("@item:inmenu", "Show Hidden Places"), this);
     actionShowAllPlaces->setCheckable(true);
 
     auto actionShowAllPlaces = new QAction(QIcon::fromTheme(QStringLiteral("view-hidden")), i18nc("@item:inmenu", "Show Hidden Places"), this);
     actionShowAllPlaces->setCheckable(true);


@@ -1721,12 +2036,20 @@ void DolphinMainWindow::updateFileAndEditActions()
 {
     const KFileItemList list = m_activeViewContainer->view()->selectedItems();
     const KActionCollection* col = actionCollection();
 {
     const KFileItemList list = m_activeViewContainer->view()->selectedItems();
     const KActionCollection* col = actionCollection();

+    KFileItemListProperties capabilitiesSource(list);
+

     QAction* addToPlacesAction = col->action(QStringLiteral("add_to_places"));
     QAction* addToPlacesAction = col->action(QStringLiteral("add_to_places"));

+    QAction* copyToOtherViewAction   = col->action(QStringLiteral("copy_to_inactive_split_view"));
+    QAction* moveToOtherViewAction   = col->action(QStringLiteral("move_to_inactive_split_view"));
+    QAction* copyLocation            = col->action(QString("copy_location"));

 
     if (list.isEmpty()) {
         stateChanged(QStringLiteral("has_no_selection"));
 
 
     if (list.isEmpty()) {
         stateChanged(QStringLiteral("has_no_selection"));
 

-        addToPlacesAction->setText(i18nc("@action:inmenu Add current folder to places", "Add '%1' to Places", m_activeViewContainer->placesText()));
+        addToPlacesAction->setEnabled(true);
+        copyToOtherViewAction->setEnabled(false);
+        moveToOtherViewAction->setEnabled(false);
+        copyLocation->setEnabled(false);

     } else {
         stateChanged(QStringLiteral("has_selection"));
 
     } else {
         stateChanged(QStringLiteral("has_selection"));
 


@@ -1736,24 +2059,41 @@ void DolphinMainWindow::updateFileAndEditActions()
         QAction* cutAction               = col->action(KStandardAction::name(KStandardAction::Cut));
         QAction* deleteWithTrashShortcut = col->action(QStringLiteral("delete_shortcut")); // see DolphinViewActionHandler
         QAction* showTarget              = col->action(QStringLiteral("show_target"));
         QAction* cutAction               = col->action(KStandardAction::name(KStandardAction::Cut));
         QAction* deleteWithTrashShortcut = col->action(QStringLiteral("delete_shortcut")); // see DolphinViewActionHandler
         QAction* showTarget              = col->action(QStringLiteral("show_target"));

+        QAction* duplicateAction         = col->action(QStringLiteral("duplicate")); // see DolphinViewActionHandler

 
         if (list.length() == 1 && list.first().isDir()) {
             addToPlacesAction->setEnabled(true);
 
         if (list.length() == 1 && list.first().isDir()) {
             addToPlacesAction->setEnabled(true);

-            addToPlacesAction->setText(i18nc("@action:inmenu Add current folder to places", "Add '%1' to Places", list.first().name()));

         } else {
             addToPlacesAction->setEnabled(false);
         } else {
             addToPlacesAction->setEnabled(false);

-            addToPlacesAction->setText(i18nc("@action:inmenu Add current folder to places", "Add to Places"));

         }
 
         }
 

-        KFileItemListProperties capabilities(list);
-        const bool enableMoveToTrash = capabilities.isLocal() && capabilities.supportsMoving();
+        if (m_tabWidget->currentTabPage()->splitViewEnabled()) {
+            DolphinTabPage* tabPage = m_tabWidget->currentTabPage();
+            KFileItem capabilitiesDestination;

 
 

-        renameAction->setEnabled(capabilities.supportsMoving());
+            if (tabPage->primaryViewActive()) {
+                capabilitiesDestination = tabPage->secondaryViewContainer()->url();
+            } else {
+                capabilitiesDestination = tabPage->primaryViewContainer()->url();
+            }
+
+            copyToOtherViewAction->setEnabled(capabilitiesDestination.isWritable());
+            moveToOtherViewAction->setEnabled(capabilitiesSource.supportsMoving() && capabilitiesDestination.isWritable());
+        } else {
+            copyToOtherViewAction->setEnabled(false);
+            moveToOtherViewAction->setEnabled(false);
+        }
+
+        const bool enableMoveToTrash = capabilitiesSource.isLocal() && capabilitiesSource.supportsMoving();
+
+        renameAction->setEnabled(capabilitiesSource.supportsMoving());

         moveToTrashAction->setEnabled(enableMoveToTrash);
         moveToTrashAction->setEnabled(enableMoveToTrash);

-        deleteAction->setEnabled(capabilities.supportsDeleting());
-        deleteWithTrashShortcut->setEnabled(capabilities.supportsDeleting() && !enableMoveToTrash);
-        cutAction->setEnabled(capabilities.supportsMoving());
+        deleteAction->setEnabled(capabilitiesSource.supportsDeleting());
+        deleteWithTrashShortcut->setEnabled(capabilitiesSource.supportsDeleting() && !enableMoveToTrash);
+        cutAction->setEnabled(capabilitiesSource.supportsMoving());
+        copyLocation->setEnabled(list.length() == 1);

         showTarget->setEnabled(list.length() == 1 && list.at(0).isLink());
         showTarget->setEnabled(list.length() == 1 && list.at(0).isLink());

+        duplicateAction->setEnabled(capabilitiesSource.supportsWriting());

     }
 }
 
     }
 }
 


@@ -1796,6 +2136,7 @@ void DolphinMainWindow::createControlButton()
     Q_ASSERT(!m_controlButton);
 
     m_controlButton = new QToolButton(this);
     Q_ASSERT(!m_controlButton);
 
     m_controlButton = new QToolButton(this);

+    m_controlButton->setAccessibleName(i18nc("@action:intoolbar", "Control"));

     m_controlButton->setIcon(QIcon::fromTheme(QStringLiteral("application-menu")));
     m_controlButton->setToolTip(i18nc("@action", "Show menu"));
     m_controlButton->setAttribute(Qt::WidgetAttribute::WA_CustomWhatsThis);
     m_controlButton->setIcon(QIcon::fromTheme(QStringLiteral("application-menu")));
     m_controlButton->setToolTip(i18nc("@action", "Show menu"));
     m_controlButton->setAttribute(Qt::WidgetAttribute::WA_CustomWhatsThis);


@@ -1835,7 +2176,8 @@ bool DolphinMainWindow::addActionToMenu(QAction* action, QMenu* menu)
     Q_ASSERT(menu);
 
     const KToolBar* toolBarWidget = toolBar();
     Q_ASSERT(menu);
 
     const KToolBar* toolBarWidget = toolBar();

-    foreach (const QWidget* widget, action->associatedWidgets()) {
+    const auto associatedWidgets = action->associatedWidgets();
+    for (const QWidget* widget : associatedWidgets) {

         if (widget == toolBarWidget) {
             return false;
         }
         if (widget == toolBarWidget) {
             return false;
         }


@@ -1858,7 +2200,7 @@ void DolphinMainWindow::refreshViews()
         updateWindowTitle();
     }
 
         updateWindowTitle();
     }
 

-    emit settingsChanged();
+    Q_EMIT settingsChanged();

 }
 
 void DolphinMainWindow::clearStatusBar()
 }
 
 void DolphinMainWindow::clearStatusBar()


@@ -1899,16 +2241,19 @@ void DolphinMainWindow::connectViewSignals(DolphinViewContainer* container)
             this, &DolphinMainWindow::goForward);
     connect(view, &DolphinView::urlActivated,
             this, &DolphinMainWindow::handleUrl);
             this, &DolphinMainWindow::goForward);
     connect(view, &DolphinView::urlActivated,
             this, &DolphinMainWindow::handleUrl);

+    connect(view, &DolphinView::goUpRequested,
+            this, &DolphinMainWindow::goUp);

 
     const KUrlNavigator* navigator = container->urlNavigator();
     connect(navigator, &KUrlNavigator::urlChanged,
             this, &DolphinMainWindow::changeUrl);
 
     const KUrlNavigator* navigator = container->urlNavigator();
     connect(navigator, &KUrlNavigator::urlChanged,
             this, &DolphinMainWindow::changeUrl);

-    connect(navigator, &KUrlNavigator::historyChanged,
-            this, &DolphinMainWindow::updateHistory);

     connect(navigator, &KUrlNavigator::editableStateChanged,
             this, &DolphinMainWindow::slotEditableStateChanged);
     connect(navigator, &KUrlNavigator::tabRequested,
             this, &DolphinMainWindow::openNewTabAfterLastTab);
     connect(navigator, &KUrlNavigator::editableStateChanged,
             this, &DolphinMainWindow::slotEditableStateChanged);
     connect(navigator, &KUrlNavigator::tabRequested,
             this, &DolphinMainWindow::openNewTabAfterLastTab);

+
+    connect(container->urlNavigatorInternal(), &KUrlNavigator::historyChanged,
+            this, &DolphinMainWindow::updateHistory);

 }
 
 void DolphinMainWindow::updateSplitAction()
 }
 
 void DolphinMainWindow::updateSplitAction()


@@ -2139,6 +2484,22 @@ bool DolphinMainWindow::eventFilter(QObject* obj, QEvent* event)
     return false;
 }
 
     return false;
 }
 

+void DolphinMainWindow::focusTerminalPanel()
+{
+    if (m_terminalPanel->isVisible()) {
+        if (m_terminalPanel->terminalHasFocus()) {
+            m_activeViewContainer->view()->setFocus(Qt::FocusReason::ShortcutFocusReason);
+            actionCollection()->action(QStringLiteral("focus_terminal_panel"))->setText(i18nc("@action:inmenu Tools", "Focus Terminal Panel"));
+        } else {
+            m_terminalPanel->setFocus(Qt::FocusReason::ShortcutFocusReason);
+            actionCollection()->action(QStringLiteral("focus_terminal_panel"))->setText(i18nc("@action:inmenu Tools", "Defocus Terminal Panel"));
+        }
+    } else {
+        actionCollection()->action(QStringLiteral("show_terminal_panel"))->trigger();
+        actionCollection()->action(QStringLiteral("focus_terminal_panel"))->setText(i18nc("@action:inmenu Tools", "Defocus Terminal Panel"));
+    }
+}
+

 DolphinMainWindow::UndoUiInterface::UndoUiInterface() :
     KIO::FileUndoManager::UiInterface()
 {
 DolphinMainWindow::UndoUiInterface::UndoUiInterface() :
     KIO::FileUndoManager::UiInterface()
 {