src/dolphinmainwindow.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2006 by Peter Penz <peter.penz19@gmail.com>             *
   3  *   Copyright (C) 2006 by Stefan Monov <logixoul@gmail.com>               *
   4  *   Copyright (C) 2006 by Cvetoslav Ludmiloff <ludmiloff@gmail.com>       *
   5  *                                                                         *
   6  *   This program is free software; you can redistribute it and/or modify  *
   7  *   it under the terms of the GNU General Public License as published by  *
   8  *   the Free Software Foundation; either version 2 of the License, or     *
   9  *   (at your option) any later version.                                   *
  10  *                                                                         *
  11  *   This program is distributed in the hope that it will be useful,       *
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  14  *   GNU General Public License for more details.                          *
  15  *                                                                         *
  16  *   You should have received a copy of the GNU General Public License     *
  17  *   along with this program; if not, write to the                         *
  18  *   Free Software Foundation, Inc.,                                       *
  19  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA            *
  20  ***************************************************************************/
  21
  22 #include "dolphinmainwindow.h"
  23
  24 #include "dolphinapplication.h"
  25 #include "dolphindockwidget.h"
  26 #include "dolphincontextmenu.h"
  27 #include "dolphinnewfilemenu.h"
  28 #include "dolphinrecenttabsmenu.h"
  29 #include "dolphintabbar.h"
  30 #include "dolphinviewcontainer.h"
  31 #include "dolphintabpage.h"
  32 #include "panels/folders/folderspanel.h"
  33 #include "panels/places/placespanel.h"
  34 #include "panels/information/informationpanel.h"
  35 #include "settings/dolphinsettingsdialog.h"
  36 #include "statusbar/dolphinstatusbar.h"
  37 #include "views/dolphinviewactionhandler.h"
  38 #include "views/dolphinremoteencoding.h"
  39 #include "views/draganddrophelper.h"
  40 #include "views/viewproperties.h"
  41 #include "views/dolphinnewfilemenuobserver.h"
  42
  43 #ifndef Q_OS_WIN
  44 #include "panels/terminal/terminalpanel.h"
  45 #endif
  46
  47 #include "dolphin_generalsettings.h"
  48
  49 #include <KAcceleratorManager>
  50 #include <KActionCollection>
  51 #include <KActionMenu>
  52 #include <KConfig>
  53 #include <KDesktopFile>
  54 #include <kdeversion.h>
  55 #include <kdualaction.h>
  56 #include <KFileDialog>
  57 #include <KGlobal>
  58 #include <KDialog>
  59 #include <KJobWidgets>
  60 #include <KLineEdit>
  61 #include <KToolBar>
  62 #include <KIconLoader>
  63 #include <KIO/NetAccess>
  64 #include <KIO/JobUiDelegate>
  65 #include <KInputDialog>
  66 #include <KLocale>
  67 #include <KProtocolManager>
  68 #include <KMenu>
  69 #include <KMenuBar>
  70 #include <KMessageBox>
  71 #include <KFileItemListProperties>
  72 #include <KProtocolInfo>
  73 #include <KRun>
  74 #include <KShell>
  75 #include <KStandardDirs>
  76 #include <kstatusbar.h>
  77 #include <KStandardAction>
  78 #include <KToggleAction>
  79 #include <KUrlNavigator>
  80 #include <KUrlComboBox>
  81 #include <KToolInvocation>
  82
  83 #include <QDesktopWidget>
  84 #include <QDBusMessage>
  85 #include <QKeyEvent>
  86 #include <QClipboard>
  87 #include <QToolButton>
  88 #include <QSplitter>
  89 #include <QTimer>
  90 #include <QPushButton>
  91
  92 namespace {
  93     // Used for GeneralSettings::version() to determine whether
  94     // an updated version of Dolphin is running.
  95     const int CurrentDolphinVersion = 200;
  96 };
  97
  98 DolphinMainWindow::DolphinMainWindow() :
  99     KXmlGuiWindow(0),
 100     m_newFileMenu(0),
 101     m_tabBar(0),
 102     m_activeViewContainer(0),
 103     m_centralWidgetLayout(0),
 104     m_tabIndex(-1),
 105     m_viewTab(),
 106     m_actionHandler(0),
 107     m_remoteEncoding(0),
 108     m_settingsDialog(),
 109     m_controlButton(0),
 110     m_updateToolBarTimer(0),
 111     m_lastHandleUrlStatJob(0)
 112 {
 113     setObjectName("Dolphin#");
 114
 115     connect(&DolphinNewFileMenuObserver::instance(), &DolphinNewFileMenuObserver::errorMessage,
 116             this, &DolphinMainWindow::showErrorMessage);
 117
 118     KIO::FileUndoManager* undoManager = KIO::FileUndoManager::self();
 119     undoManager->setUiInterface(new UndoUiInterface());
 120
 121     connect(undoManager, static_cast<void(KIO::FileUndoManager::*)(bool)>(&KIO::FileUndoManager::undoAvailable),
 122             this, &DolphinMainWindow::slotUndoAvailable);
 123     connect(undoManager, &KIO::FileUndoManager::undoTextChanged,
 124             this, &DolphinMainWindow::slotUndoTextChanged);
 125     connect(undoManager, &KIO::FileUndoManager::jobRecordingStarted,
 126             this, &DolphinMainWindow::clearStatusBar);
 127     connect(undoManager, &KIO::FileUndoManager::jobRecordingFinished,
 128             this, &DolphinMainWindow::showCommand);
 129
 130     GeneralSettings* generalSettings = GeneralSettings::self();
 131     const bool firstRun = (generalSettings->version() < 200);
 132     if (firstRun) {
 133         generalSettings->setViewPropsTimestamp(QDateTime::currentDateTime());
 134     }
 135
 136     setAcceptDrops(true);
 137
 138     setupActions();
 139
 140     m_actionHandler = new DolphinViewActionHandler(actionCollection(), this);
 141     connect(m_actionHandler, &DolphinViewActionHandler::actionBeingHandled, this, &DolphinMainWindow::clearStatusBar);
 142     connect(m_actionHandler, &DolphinViewActionHandler::createDirectory, this, &DolphinMainWindow::createDirectory);
 143
 144     m_remoteEncoding = new DolphinRemoteEncoding(this, m_actionHandler);
 145     connect(this, &DolphinMainWindow::urlChanged,
 146             m_remoteEncoding, &DolphinRemoteEncoding::slotAboutToOpenUrl);
 147
 148     m_tabBar = new DolphinTabBar(this);
 149     connect(m_tabBar, SIGNAL(currentChanged(int)),
 150             this, SLOT(setActiveTab(int)));
 151     connect(m_tabBar, SIGNAL(tabCloseRequested(int)),
 152             this, SLOT(closeTab(int)));
 153     connect(m_tabBar, SIGNAL(openNewActivatedTab(int)),
 154             this, SLOT(openNewActivatedTab(int)));
 155     connect(m_tabBar, SIGNAL(tabMoved(int,int)),
 156             this, SLOT(slotTabMoved(int,int)));
 157     connect(m_tabBar, SIGNAL(tabDropEvent(int,QDropEvent*)),
 158             this, SLOT(tabDropEvent(int,QDropEvent*)));
 159     connect(m_tabBar, SIGNAL(tabDetachRequested(int)),
 160             this, SLOT(detachTab(int)));
 161
 162     m_tabBar->blockSignals(true);  // signals get unblocked after at least 2 tabs are open
 163     m_tabBar->hide();
 164
 165     QWidget* centralWidget = new QWidget(this);
 166     m_centralWidgetLayout = new QVBoxLayout(centralWidget);
 167     m_centralWidgetLayout->setSpacing(0);
 168     m_centralWidgetLayout->setMargin(0);
 169     m_centralWidgetLayout->addWidget(m_tabBar);
 170
 171     setCentralWidget(centralWidget);
 172     setupDockWidgets();
 173
 174     setupGUI(Keys | Save | Create | ToolBar);
 175     stateChanged("new_file");
 176
 177     QClipboard* clipboard = QApplication::clipboard();
 178     connect(clipboard, &QClipboard::dataChanged,
 179             this, &DolphinMainWindow::updatePasteAction);
 180
 181     QAction* showFilterBarAction = actionCollection()->action("show_filter_bar");
 182     showFilterBarAction->setChecked(generalSettings->filterBar());
 183
 184     if (firstRun) {
 185         menuBar()->setVisible(false);
 186         // Assure a proper default size if Dolphin runs the first time
 187         resize(750, 500);
 188     }
 189
 190     const bool showMenu = !menuBar()->isHidden();
 191     QAction* showMenuBarAction = actionCollection()->action(KStandardAction::name(KStandardAction::ShowMenubar));
 192     showMenuBarAction->setChecked(showMenu);  // workaround for bug #171080
 193     if (!showMenu) {
 194         createControlButton();
 195     }
 196 }
 197
 198 DolphinMainWindow::~DolphinMainWindow()
 199 {
 200 }
 201
 202 void DolphinMainWindow::openDirectories(const QList<KUrl>& dirs)
 203 {
 204     const bool hasSplitView = GeneralSettings::splitView();
 205
 206     // Open each directory inside a new tab. If the "split view" option has been enabled,
 207     // always show two directories within one tab.
 208     QList<KUrl>::const_iterator it = dirs.constBegin();
 209     while (it != dirs.constEnd()) {
 210         const KUrl& primaryUrl = *(it++);
 211         if (hasSplitView && (it != dirs.constEnd())) {
 212             const KUrl& secondaryUrl = *(it++);
 213             openNewTab(primaryUrl, secondaryUrl);
 214         } else {
 215             openNewTab(primaryUrl);
 216         }
 217     }
 218 }
 219
 220 void DolphinMainWindow::openFiles(const QList<KUrl>& files)
 221 {
 222     if (files.isEmpty()) {
 223         return;
 224     }
 225
 226     // Get all distinct directories from 'files' and open a tab
 227     // for each directory. If the "split view" option is enabled, two
 228     // directories are shown inside one tab (see openDirectories()).
 229     QList<KUrl> dirs;
 230     foreach (const KUrl& url, files) {
 231         const KUrl dir(url.directory());
 232         if (!dirs.contains(dir)) {
 233             dirs.append(dir);
 234         }
 235     }
 236
 237     openDirectories(dirs);
 238
 239     // Select the files. Although the files can be split between several
 240     // tabs, there is no need to split 'files' accordingly, as
 241     // the DolphinView will just ignore invalid selections.
 242     foreach (DolphinTabPage* tabPage, m_viewTab) {
 243         tabPage->markUrlsAsSelected(files);
 244         tabPage->markUrlAsCurrent(files.first());
 245     }
 246 }
 247
 248 void DolphinMainWindow::showCommand(CommandType command)
 249 {
 250     DolphinStatusBar* statusBar = m_activeViewContainer->statusBar();
 251     switch (command) {
 252     case KIO::FileUndoManager::Copy:
 253         statusBar->setText(i18nc("@info:status", "Successfully copied."));
 254         break;
 255     case KIO::FileUndoManager::Move:
 256         statusBar->setText(i18nc("@info:status", "Successfully moved."));
 257         break;
 258     case KIO::FileUndoManager::Link:
 259         statusBar->setText(i18nc("@info:status", "Successfully linked."));
 260         break;
 261     case KIO::FileUndoManager::Trash:
 262         statusBar->setText(i18nc("@info:status", "Successfully moved to trash."));
 263         break;
 264     case KIO::FileUndoManager::Rename:
 265         statusBar->setText(i18nc("@info:status", "Successfully renamed."));
 266         break;
 267
 268     case KIO::FileUndoManager::Mkdir:
 269         statusBar->setText(i18nc("@info:status", "Created folder."));
 270         break;
 271
 272     default:
 273         break;
 274     }
 275 }
 276
 277 void DolphinMainWindow::pasteIntoFolder()
 278 {
 279     m_activeViewContainer->view()->pasteIntoFolder();
 280 }
 281
 282 void DolphinMainWindow::changeUrl(const KUrl& url)
 283 {
 284     if (!KProtocolManager::supportsListing(url)) {
 285         // The URL navigator only checks for validity, not
 286         // if the URL can be listed. An error message is
 287         // shown due to DolphinViewContainer::restoreView().
 288         return;
 289     }
 290
 291     DolphinViewContainer* view = activeViewContainer();
 292     if (view) {
 293         view->setUrl(url);
 294         updateEditActions();
 295         updatePasteAction();
 296         updateViewActions();
 297         updateGoActions();
 298         setUrlAsCaption(url);
 299
 300         const QString iconName = KIO::iconNameForUrl(url);
 301         m_tabBar->setTabIcon(m_tabIndex, QIcon::fromTheme(iconName));
 302         m_tabBar->setTabText(m_tabIndex, squeezedText(tabName(view->url())));
 303
 304         emit urlChanged(url);
 305     }
 306 }
 307
 308 void DolphinMainWindow::slotTerminalDirectoryChanged(const KUrl& url)
 309 {
 310     m_activeViewContainer->setAutoGrabFocus(false);
 311     changeUrl(url);
 312     m_activeViewContainer->setAutoGrabFocus(true);
 313 }
 314
 315 void DolphinMainWindow::slotEditableStateChanged(bool editable)
 316 {
 317     KToggleAction* editableLocationAction =
 318         static_cast<KToggleAction*>(actionCollection()->action("editable_location"));
 319     editableLocationAction->setChecked(editable);
 320 }
 321
 322 void DolphinMainWindow::slotSelectionChanged(const KFileItemList& selection)
 323 {
 324     updateEditActions();
 325
 326     const int selectedUrlsCount = m_viewTab.at(m_tabIndex)->selectedItemsCount();
 327
 328     QAction* compareFilesAction = actionCollection()->action("compare_files");
 329     if (selectedUrlsCount == 2) {
 330         compareFilesAction->setEnabled(isKompareInstalled());
 331     } else {
 332         compareFilesAction->setEnabled(false);
 333     }
 334
 335     emit selectionChanged(selection);
 336 }
 337
 338 void DolphinMainWindow::slotRequestItemInfo(const KFileItem& item)
 339 {
 340     emit requestItemInfo(item);
 341 }
 342
 343 void DolphinMainWindow::updateHistory()
 344 {
 345     const KUrlNavigator* urlNavigator = m_activeViewContainer->urlNavigator();
 346     const int index = urlNavigator->historyIndex();
 347
 348     QAction* backAction = actionCollection()->action("go_back");
 349     if (backAction) {
 350         backAction->setToolTip(i18nc("@info", "Go back"));
 351         backAction->setEnabled(index < urlNavigator->historySize() - 1);
 352     }
 353
 354     QAction* forwardAction = actionCollection()->action("go_forward");
 355     if (forwardAction) {
 356         forwardAction->setToolTip(i18nc("@info", "Go forward"));
 357         forwardAction->setEnabled(index > 0);
 358     }
 359 }
 360
 361 void DolphinMainWindow::updateFilterBarAction(bool show)
 362 {
 363     QAction* showFilterBarAction = actionCollection()->action("show_filter_bar");
 364     showFilterBarAction->setChecked(show);
 365 }
 366
 367 void DolphinMainWindow::openNewMainWindow()
 368 {
 369     KRun::run("dolphin %u", KUrl::List(), this);
 370 }
 371
 372 void DolphinMainWindow::openNewTab()
 373 {
 374     const bool isUrlEditable =  m_activeViewContainer->urlNavigator()->isUrlEditable();
 375
 376     openNewTab(m_activeViewContainer->url());
 377     m_tabBar->setCurrentIndex(m_viewTab.count() - 1);
 378
 379     // The URL navigator of the new tab should have the same editable state
 380     // as the current tab
 381     KUrlNavigator* navigator = m_activeViewContainer->urlNavigator();
 382     navigator->setUrlEditable(isUrlEditable);
 383
 384     if (isUrlEditable) {
 385         // If a new tab is opened and the URL is editable, assure that
 386         // the user can edit the URL without manually setting the focus
 387         navigator->setFocus();
 388     }
 389 }
 390
 391 void DolphinMainWindow::openNewTab(const KUrl& primaryUrl, const KUrl& secondaryUrl)
 392 {
 393     QWidget* focusWidget = QApplication::focusWidget();
 394
 395     DolphinTabPage* tabPage = new DolphinTabPage(primaryUrl, secondaryUrl, this);
 396     m_viewTab.append(tabPage);
 397
 398     connect(tabPage, SIGNAL(activeViewChanged()),
 399             this, SLOT(activeViewChanged()));
 400
 401     // The places-selector from the URL navigator should only be shown
 402     // if the places dock is invisible
 403     QDockWidget* placesDock = findChild<QDockWidget*>("placesDock");
 404     const bool placesSelectorVisible = !placesDock || !placesDock->isVisible();
 405     tabPage->setPlacesSelectorVisible(placesSelectorVisible);
 406
 407     DolphinViewContainer* primaryContainer = tabPage->primaryViewContainer();
 408     connectViewSignals(primaryContainer);
 409
 410     if (tabPage->splitViewEnabled()) {
 411         DolphinViewContainer* secondaryContainer = tabPage->secondaryViewContainer();
 412         connectViewSignals(secondaryContainer);
 413     }
 414
 415     tabPage->hide();
 416
 417     m_tabBar->addTab(QIcon::fromTheme(KIO::iconNameForUrl(primaryUrl)),
 418                      squeezedText(tabName(primaryUrl)));
 419
 420     if (m_viewTab.count() > 1) {
 421         actionCollection()->action("close_tab")->setEnabled(true);
 422         actionCollection()->action("activate_prev_tab")->setEnabled(true);
 423         actionCollection()->action("activate_next_tab")->setEnabled(true);
 424         m_tabBar->show();
 425         m_tabBar->blockSignals(false);
 426     }
 427
 428     if (focusWidget) {
 429         // The DolphinViewContainer grabbed the keyboard focus. As the tab is opened
 430         // in background, assure that the previous focused widget gets the focus back.
 431         focusWidget->setFocus();
 432     }
 433 }
 434
 435 void DolphinMainWindow::openNewActivatedTab(const KUrl& primaryUrl, const KUrl& secondaryUrl)
 436 {
 437     openNewTab(primaryUrl, secondaryUrl);
 438     setActiveTab(m_viewTab.count() - 1);
 439 }
 440
 441 void DolphinMainWindow::openNewActivatedTab(int index)
 442 {
 443     Q_ASSERT(index >= 0);
 444     const DolphinTabPage* tabPage = m_viewTab.at(index);
 445     openNewActivatedTab(tabPage->activeViewContainer()->url());
 446 }
 447
 448 void DolphinMainWindow::activateNextTab()
 449 {
 450     if (m_viewTab.count() >= 2) {
 451         const int tabIndex = (m_tabBar->currentIndex() + 1) % m_tabBar->count();
 452         setActiveTab(tabIndex);
 453     }
 454 }
 455
 456 void DolphinMainWindow::activatePrevTab()
 457 {
 458     if (m_viewTab.count() >= 2) {
 459         int tabIndex = m_tabBar->currentIndex() - 1;
 460         if (tabIndex == -1) {
 461             tabIndex = m_tabBar->count() - 1;
 462         }
 463         setActiveTab(tabIndex);
 464     }
 465 }
 466
 467 void DolphinMainWindow::openInNewTab()
 468 {
 469     const KFileItemList& list = m_activeViewContainer->view()->selectedItems();
 470     if (list.isEmpty()) {
 471         openNewTab(m_activeViewContainer->url());
 472     } else {
 473         foreach (const KFileItem& item, list) {
 474             const KUrl& url = DolphinView::openItemAsFolderUrl(item);
 475             if (!url.isEmpty()) {
 476                 openNewTab(url);
 477             }
 478         }
 479     }
 480 }
 481
 482 void DolphinMainWindow::openInNewWindow()
 483 {
 484     KUrl newWindowUrl;
 485
 486     const KFileItemList list = m_activeViewContainer->view()->selectedItems();
 487     if (list.isEmpty()) {
 488         newWindowUrl = m_activeViewContainer->url();
 489     } else if (list.count() == 1) {
 490         const KFileItem& item = list.first();
 491         newWindowUrl = DolphinView::openItemAsFolderUrl(item);
 492     }
 493
 494     if (!newWindowUrl.isEmpty()) {
 495         KRun::run("dolphin %u", QList<QUrl>() << newWindowUrl, this);
 496     }
 497 }
 498
 499 void DolphinMainWindow::showEvent(QShowEvent* event)
 500 {
 501     KXmlGuiWindow::showEvent(event);
 502
 503     if (!m_activeViewContainer && m_viewTab.count() > 0) {
 504         // If we have no active view container yet, we set the primary view container
 505         // of the first tab as active view container.
 506         setActiveTab(0);
 507     }
 508
 509     if (!event->spontaneous()) {
 510         m_activeViewContainer->view()->setFocus();
 511     }
 512 }
 513
 514 void DolphinMainWindow::closeEvent(QCloseEvent* event)
 515 {
 516     // Find out if Dolphin is closed directly by the user or
 517     // by the session manager because the session is closed
 518     bool closedByUser = true;
 519     DolphinApplication *application = qobject_cast<DolphinApplication*>(qApp);
 520     if (application && application->sessionSaving()) {
 521         closedByUser = false;
 522     }
 523
 524     if (m_viewTab.count() > 1 && GeneralSettings::confirmClosingMultipleTabs() && closedByUser) {
 525         // Ask the user if he really wants to quit and close all tabs.
 526         // Open a confirmation dialog with 3 buttons:
 527         // KDialog::Yes    -> Quit
 528         // KDialog::No     -> Close only the current tab
 529         // KDialog::Cancel -> do nothing
 530         QDialog *dialog = new QDialog(this, Qt::Dialog);
 531         dialog->setWindowTitle(i18nc("@title:window", "Confirmation"));
 532         dialog->setModal(true);
 533         QDialogButtonBox* buttons = new QDialogButtonBox(QDialogButtonBox::Yes | QDialogButtonBox::No | QDialogButtonBox::Cancel);
 534         KGuiItem::assign(buttons->button(QDialogButtonBox::Yes), KStandardGuiItem::quit());
 535         KGuiItem::assign(buttons->button(QDialogButtonBox::No), KGuiItem(i18n("C&lose Current Tab"), QIcon::fromTheme("tab-close")));
 536         KGuiItem::assign(buttons->button(QDialogButtonBox::Cancel), KStandardGuiItem::cancel());
 537         buttons->button(QDialogButtonBox::Yes)->setDefault(true);
 538
 539         bool doNotAskAgainCheckboxResult = false;
 540
 541         const int result = KMessageBox::createKMessageBox(dialog,
 542             buttons,
 543             QMessageBox::Warning,
 544             i18n("You have multiple tabs open in this window, are you sure you want to quit?"),
 545             QStringList(),
 546             i18n("Do not ask again"),
 547             &doNotAskAgainCheckboxResult,
 548             KMessageBox::Notify);
 549
 550         if (doNotAskAgainCheckboxResult) {
 551             GeneralSettings::setConfirmClosingMultipleTabs(false);
 552         }
 553
 554         switch (result) {
 555             case QDialogButtonBox::Yes:
 556                 // Quit
 557                 break;
 558             case QDialogButtonBox::No:
 559                 // Close only the current tab
 560                 closeTab();
 561             default:
 562                 event->ignore();
 563                 return;
 564         }
 565     }
 566
 567     GeneralSettings::setVersion(CurrentDolphinVersion);
 568     GeneralSettings::self()->writeConfig();
 569
 570     KXmlGuiWindow::closeEvent(event);
 571 }
 572
 573 void DolphinMainWindow::saveProperties(KConfigGroup& group)
 574 {
 575     const int tabCount = m_viewTab.count();
 576     group.writeEntry("Tab Count", tabCount);
 577     group.writeEntry("Active Tab Index", m_tabBar->currentIndex());
 578
 579     for (int i = 0; i < tabCount; ++i) {
 580         const DolphinTabPage* tabPage = m_viewTab.at(i);
 581         group.writeEntry("Tab " % QString::number(i), tabPage->saveState());
 582     }
 583 }
 584
 585 void DolphinMainWindow::readProperties(const KConfigGroup& group)
 586 {
 587     const int tabCount = group.readEntry("Tab Count", 1);
 588     for (int i = 0; i < tabCount; ++i) {
 589         const QByteArray state = group.readEntry("Tab " % QString::number(i), QByteArray());
 590         DolphinTabPage* tabPage = m_viewTab.at(i);
 591         tabPage->restoreState(state);
 592
 593         // openNewTab() needs to be called only tabCount - 1 times
 594         if (i != tabCount - 1) {
 595             openNewTab();
 596         }
 597     }
 598
 599     const int index = group.readEntry("Active Tab Index", 0);
 600     m_tabBar->setCurrentIndex(index);
 601 }
 602
 603 void DolphinMainWindow::updateNewMenu()
 604 {
 605     m_newFileMenu->setViewShowsHiddenFiles(activeViewContainer()->view()->hiddenFilesShown());
 606     m_newFileMenu->checkUpToDate();
 607     m_newFileMenu->setPopupFiles(activeViewContainer()->url());
 608 }
 609
 610 void DolphinMainWindow::createDirectory()
 611 {
 612     m_newFileMenu->setViewShowsHiddenFiles(activeViewContainer()->view()->hiddenFilesShown());
 613     m_newFileMenu->setPopupFiles(activeViewContainer()->url());
 614     m_newFileMenu->createDirectory();
 615 }
 616
 617 void DolphinMainWindow::quit()
 618 {
 619     close();
 620 }
 621
 622 void DolphinMainWindow::showErrorMessage(const QString& message)
 623 {
 624     m_activeViewContainer->showMessage(message, DolphinViewContainer::Error);
 625 }
 626
 627 void DolphinMainWindow::slotUndoAvailable(bool available)
 628 {
 629     QAction* undoAction = actionCollection()->action(KStandardAction::name(KStandardAction::Undo));
 630     if (undoAction) {
 631         undoAction->setEnabled(available);
 632     }
 633 }
 634
 635 void DolphinMainWindow::slotUndoTextChanged(const QString& text)
 636 {
 637     QAction* undoAction = actionCollection()->action(KStandardAction::name(KStandardAction::Undo));
 638     if (undoAction) {
 639         undoAction->setText(text);
 640     }
 641 }
 642
 643 void DolphinMainWindow::undo()
 644 {
 645     clearStatusBar();
 646     KIO::FileUndoManager::self()->uiInterface()->setParentWidget(this);
 647     KIO::FileUndoManager::self()->undo();
 648 }
 649
 650 void DolphinMainWindow::cut()
 651 {
 652     m_activeViewContainer->view()->cutSelectedItems();
 653 }
 654
 655 void DolphinMainWindow::copy()
 656 {
 657     m_activeViewContainer->view()->copySelectedItems();
 658 }
 659
 660 void DolphinMainWindow::paste()
 661 {
 662     m_activeViewContainer->view()->paste();
 663 }
 664
 665 void DolphinMainWindow::find()
 666 {
 667     m_activeViewContainer->setSearchModeEnabled(true);
 668 }
 669
 670 void DolphinMainWindow::updatePasteAction()
 671 {
 672     QAction* pasteAction = actionCollection()->action(KStandardAction::name(KStandardAction::Paste));
 673     QPair<bool, QString> pasteInfo = m_activeViewContainer->view()->pasteInfo();
 674     pasteAction->setEnabled(pasteInfo.first);
 675     pasteAction->setText(pasteInfo.second);
 676 }
 677
 678 void DolphinMainWindow::selectAll()
 679 {
 680     clearStatusBar();
 681
 682     // if the URL navigator is editable and focused, select the whole
 683     // URL instead of all items of the view
 684
 685     KUrlNavigator* urlNavigator = m_activeViewContainer->urlNavigator();
 686     QLineEdit* lineEdit = urlNavigator->editor()->lineEdit(); // krazy:exclude=qclasses
 687     const bool selectUrl = urlNavigator->isUrlEditable() &&
 688                            lineEdit->hasFocus();
 689     if (selectUrl) {
 690         lineEdit->selectAll();
 691     } else {
 692         m_activeViewContainer->view()->selectAll();
 693     }
 694 }
 695
 696 void DolphinMainWindow::invertSelection()
 697 {
 698     clearStatusBar();
 699     m_activeViewContainer->view()->invertSelection();
 700 }
 701
 702 void DolphinMainWindow::toggleSplitView()
 703 {
 704     DolphinTabPage* tabPage = m_viewTab.at(m_tabIndex);
 705     tabPage->setSplitViewEnabled(!tabPage->splitViewEnabled());
 706
 707     if (tabPage->splitViewEnabled()) {
 708         connectViewSignals(tabPage->secondaryViewContainer());
 709     }
 710
 711     updateViewActions();
 712 }
 713
 714 void DolphinMainWindow::reloadView()
 715 {
 716     clearStatusBar();
 717     m_activeViewContainer->view()->reload();
 718 }
 719
 720 void DolphinMainWindow::stopLoading()
 721 {
 722     m_activeViewContainer->view()->stopLoading();
 723 }
 724
 725 void DolphinMainWindow::enableStopAction()
 726 {
 727     actionCollection()->action("stop")->setEnabled(true);
 728 }
 729
 730 void DolphinMainWindow::disableStopAction()
 731 {
 732     actionCollection()->action("stop")->setEnabled(false);
 733 }
 734
 735 void DolphinMainWindow::showFilterBar()
 736 {
 737     m_activeViewContainer->setFilterBarVisible(true);
 738 }
 739
 740 void DolphinMainWindow::toggleEditLocation()
 741 {
 742     clearStatusBar();
 743
 744     QAction* action = actionCollection()->action("editable_location");
 745     KUrlNavigator* urlNavigator = m_activeViewContainer->urlNavigator();
 746     urlNavigator->setUrlEditable(action->isChecked());
 747 }
 748
 749 void DolphinMainWindow::replaceLocation()
 750 {
 751     KUrlNavigator* navigator = m_activeViewContainer->urlNavigator();
 752     navigator->setUrlEditable(true);
 753     navigator->setFocus();
 754
 755     // select the whole text of the combo box editor
 756     QLineEdit* lineEdit = navigator->editor()->lineEdit();  // krazy:exclude=qclasses
 757     lineEdit->selectAll();
 758 }
 759
 760 void DolphinMainWindow::togglePanelLockState()
 761 {
 762     const bool newLockState = !GeneralSettings::lockPanels();
 763     foreach (QObject* child, children()) {
 764         DolphinDockWidget* dock = qobject_cast<DolphinDockWidget*>(child);
 765         if (dock) {
 766             dock->setLocked(newLockState);
 767         }
 768     }
 769
 770     GeneralSettings::setLockPanels(newLockState);
 771 }
 772
 773 void DolphinMainWindow::slotPlacesPanelVisibilityChanged(bool visible)
 774 {
 775     foreach (DolphinTabPage* tabPage, m_viewTab) {
 776         // The Places selector in the location bar should be shown if and only if the Places panel is hidden.
 777         tabPage->setPlacesSelectorVisible(!visible);
 778     }
 779 }
 780
 781 void DolphinMainWindow::goBack()
 782 {
 783     KUrlNavigator* urlNavigator = m_activeViewContainer->urlNavigator();
 784     urlNavigator->goBack();
 785
 786     if (urlNavigator->locationState().isEmpty()) {
 787         // An empty location state indicates a redirection URL,
 788         // which must be skipped too
 789         urlNavigator->goBack();
 790     }
 791 }
 792
 793 void DolphinMainWindow::goForward()
 794 {
 795     m_activeViewContainer->urlNavigator()->goForward();
 796 }
 797
 798 void DolphinMainWindow::goUp()
 799 {
 800     m_activeViewContainer->urlNavigator()->goUp();
 801 }
 802
 803 void DolphinMainWindow::goHome()
 804 {
 805     m_activeViewContainer->urlNavigator()->goHome();
 806 }
 807
 808 void DolphinMainWindow::goBack(Qt::MouseButtons buttons)
 809 {
 810     // The default case (left button pressed) is handled in goBack().
 811     if (buttons == Qt::MidButton) {
 812         KUrlNavigator* urlNavigator = activeViewContainer()->urlNavigator();
 813         const int index = urlNavigator->historyIndex() + 1;
 814         openNewTab(urlNavigator->locationUrl(index));
 815     }
 816 }
 817
 818 void DolphinMainWindow::goForward(Qt::MouseButtons buttons)
 819 {
 820     // The default case (left button pressed) is handled in goForward().
 821     if (buttons == Qt::MidButton) {
 822         KUrlNavigator* urlNavigator = activeViewContainer()->urlNavigator();
 823         const int index = urlNavigator->historyIndex() - 1;
 824         openNewTab(urlNavigator->locationUrl(index));
 825     }
 826 }
 827
 828 void DolphinMainWindow::goUp(Qt::MouseButtons buttons)
 829 {
 830     // The default case (left button pressed) is handled in goUp().
 831     if (buttons == Qt::MidButton) {
 832         openNewTab(activeViewContainer()->url().upUrl());
 833     }
 834 }
 835
 836 void DolphinMainWindow::goHome(Qt::MouseButtons buttons)
 837 {
 838     // The default case (left button pressed) is handled in goHome().
 839     if (buttons == Qt::MidButton) {
 840         openNewTab(GeneralSettings::self()->homeUrl());
 841     }
 842 }
 843
 844 void DolphinMainWindow::compareFiles()
 845 {
 846     const KFileItemList items = m_viewTab.at(m_tabIndex)->selectedItems();
 847     if (items.count() != 2) {
 848         // The action is disabled in this case, but it could have been triggered
 849         // via D-Bus, see https://bugs.kde.org/show_bug.cgi?id=325517
 850         return;
 851     }
 852
 853     KUrl urlA = items.at(0).url();
 854     KUrl urlB = items.at(1).url();
 855
 856     QString command("kompare -c \"");
 857     command.append(urlA.pathOrUrl());
 858     command.append("\" \"");
 859     command.append(urlB.pathOrUrl());
 860     command.append('\"');
 861     KRun::runCommand(command, "Kompare", "kompare", this);
 862 }
 863
 864 void DolphinMainWindow::toggleShowMenuBar()
 865 {
 866     const bool visible = menuBar()->isVisible();
 867     menuBar()->setVisible(!visible);
 868     if (visible) {
 869         createControlButton();
 870     } else {
 871         deleteControlButton();
 872     }
 873 }
 874
 875 void DolphinMainWindow::openTerminal()
 876 {
 877     QString dir(QDir::homePath());
 878
 879     // If the given directory is not local, it can still be the URL of an
 880     // ioslave using UDS_LOCAL_PATH which to be converted first.
 881     KUrl url = KIO::NetAccess::mostLocalUrl(m_activeViewContainer->url(), this);
 882
 883     //If the URL is local after the above conversion, set the directory.
 884     if (url.isLocalFile()) {
 885         dir = url.toLocalFile();
 886     }
 887
 888     KToolInvocation::invokeTerminal(QString(), dir);
 889 }
 890
 891 void DolphinMainWindow::editSettings()
 892 {
 893     if (!m_settingsDialog) {
 894         DolphinViewContainer* container = activeViewContainer();
 895         container->view()->writeSettings();
 896
 897         const KUrl url = container->url();
 898         DolphinSettingsDialog* settingsDialog = new DolphinSettingsDialog(url, this);
 899         connect(settingsDialog, &DolphinSettingsDialog::settingsChanged, this, &DolphinMainWindow::refreshViews);
 900         settingsDialog->setAttribute(Qt::WA_DeleteOnClose);
 901         settingsDialog->show();
 902         m_settingsDialog = settingsDialog;
 903     } else {
 904         m_settingsDialog.data()->raise();
 905     }
 906 }
 907
 908 void DolphinMainWindow::setActiveTab(int index)
 909 {
 910     Q_ASSERT(index >= 0);
 911     Q_ASSERT(index < m_viewTab.count());
 912     if (index == m_tabIndex) {
 913         return;
 914     }
 915
 916     m_tabBar->setCurrentIndex(index);
 917
 918     // hide current tab content
 919     if (m_tabIndex >= 0) {
 920         DolphinTabPage* hiddenTabPage = m_viewTab.at(m_tabIndex);
 921         hiddenTabPage->hide();
 922         m_centralWidgetLayout->removeWidget(hiddenTabPage);
 923     }
 924
 925     // show active tab content
 926     m_tabIndex = index;
 927
 928     DolphinTabPage* tabPage = m_viewTab.at(index);
 929     m_centralWidgetLayout->addWidget(tabPage, 1);
 930     tabPage->show();
 931
 932     setActiveViewContainer(tabPage->activeViewContainer());
 933 }
 934
 935 void DolphinMainWindow::closeTab()
 936 {
 937     closeTab(m_tabBar->currentIndex());
 938 }
 939
 940 void DolphinMainWindow::closeTab(int index)
 941 {
 942     Q_ASSERT(index >= 0);
 943     Q_ASSERT(index < m_viewTab.count());
 944     if (m_viewTab.count() == 1) {
 945         // the last tab may never get closed
 946         return;
 947     }
 948
 949     if (index == m_tabIndex) {
 950         // The tab that should be closed is the active tab. Activate the
 951         // previous tab before closing the tab.
 952         m_tabBar->setCurrentIndex((index > 0) ? index - 1 : 1);
 953     }
 954
 955     DolphinTabPage* tabPage = m_viewTab.at(index);
 956
 957     if (tabPage->splitViewEnabled()) {
 958         emit rememberClosedTab(tabPage->primaryViewContainer()->url(),
 959                                tabPage->secondaryViewContainer()->url());
 960     } else {
 961         emit rememberClosedTab(tabPage->primaryViewContainer()->url(), KUrl());
 962     }
 963
 964     // delete tab
 965     m_viewTab.removeAt(index);
 966     tabPage->deleteLater();
 967
 968     m_tabBar->blockSignals(true);
 969     m_tabBar->removeTab(index);
 970
 971     if (m_tabIndex > index) {
 972         m_tabIndex--;
 973         Q_ASSERT(m_tabIndex >= 0);
 974     }
 975
 976     // if only one tab is left, also remove the tab entry so that
 977     // closing the last tab is not possible
 978     if (m_viewTab.count() < 2) {
 979         actionCollection()->action("close_tab")->setEnabled(false);
 980         actionCollection()->action("activate_prev_tab")->setEnabled(false);
 981         actionCollection()->action("activate_next_tab")->setEnabled(false);
 982         m_tabBar->hide();
 983     } else {
 984         m_tabBar->blockSignals(false);
 985     }
 986 }
 987
 988 void DolphinMainWindow::detachTab(int index)
 989 {
 990     Q_ASSERT(index >= 0);
 991
 992     const QString separator(QLatin1Char(' '));
 993     QString command = QLatin1String("dolphin");
 994
 995     const DolphinTabPage* tabPage = m_viewTab.at(index);
 996     command += separator + tabPage->primaryViewContainer()->url().url();
 997     if (tabPage->splitViewEnabled()) {
 998         command += separator + tabPage->secondaryViewContainer()->url().url();
 999         command += separator + QLatin1String("-split");
1000     }
1001
1002     KRun::runCommand(command, this);
1003
1004     closeTab(index);
1005 }
1006
1007 void DolphinMainWindow::slotTabMoved(int from, int to)
1008 {
1009     m_viewTab.move(from, to);
1010     m_tabIndex = m_tabBar->currentIndex();
1011 }
1012
1013 void DolphinMainWindow::handleUrl(const KUrl& url)
1014 {
1015     delete m_lastHandleUrlStatJob;
1016     m_lastHandleUrlStatJob = 0;
1017
1018     if (url.isLocalFile() && QFileInfo(url.toLocalFile()).isDir()) {
1019         activeViewContainer()->setUrl(url);
1020     } else if (KProtocolManager::supportsListing(url)) {
1021         // stat the URL to see if it is a dir or not
1022         m_lastHandleUrlStatJob = KIO::stat(url, KIO::HideProgressInfo);
1023         if (m_lastHandleUrlStatJob->ui()) {
1024             KJobWidgets::setWindow(m_lastHandleUrlStatJob, this);
1025         }
1026         connect(m_lastHandleUrlStatJob, &KIO::Job::result,
1027                 this, &DolphinMainWindow::slotHandleUrlStatFinished);
1028
1029     } else {
1030         new KRun(url, this); // Automatically deletes itself after being finished
1031     }
1032 }
1033
1034 void DolphinMainWindow::slotHandleUrlStatFinished(KJob* job)
1035 {
1036     m_lastHandleUrlStatJob = 0;
1037     const KIO::UDSEntry entry = static_cast<KIO::StatJob*>(job)->statResult();
1038     const KUrl url = static_cast<KIO::StatJob*>(job)->url();
1039     if (entry.isDir()) {
1040         activeViewContainer()->setUrl(url);
1041     } else {
1042         new KRun(url, this);  // Automatically deletes itself after being finished
1043     }
1044 }
1045
1046 void DolphinMainWindow::tabDropEvent(int tab, QDropEvent* event)
1047 {
1048     const KUrl::List urls = KUrl::List::fromMimeData(event->mimeData());
1049     if (!urls.isEmpty() && tab != -1) {
1050         const DolphinView* view = m_viewTab.at(tab)->activeViewContainer()->view();
1051
1052         QString error;
1053         DragAndDropHelper::dropUrls(view->rootItem(), view->url(), event, error);
1054         if (!error.isEmpty()) {
1055             activeViewContainer()->showMessage(error, DolphinViewContainer::Error);
1056         }
1057     }
1058 }
1059
1060 void DolphinMainWindow::slotWriteStateChanged(bool isFolderWritable)
1061 {
1062     newFileMenu()->setEnabled(isFolderWritable);
1063 }
1064
1065 void DolphinMainWindow::openContextMenu(const QPoint& pos,
1066                                         const KFileItem& item,
1067                                         const KUrl& url,
1068                                         const QList<QAction*>& customActions)
1069 {
1070     QWeakPointer<DolphinContextMenu> contextMenu = new DolphinContextMenu(this, pos, item, url);
1071     contextMenu.data()->setCustomActions(customActions);
1072     const DolphinContextMenu::Command command = contextMenu.data()->open();
1073
1074     switch (command) {
1075     case DolphinContextMenu::OpenParentFolderInNewWindow: {
1076
1077         KRun::run("dolphin %u", QList<QUrl>() << KIO::upUrl(item.url()), this);
1078         break;
1079     }
1080
1081     case DolphinContextMenu::OpenParentFolderInNewTab:
1082         openNewTab(KIO::upUrl(item.url()));
1083         break;
1084
1085     case DolphinContextMenu::None:
1086     default:
1087         break;
1088     }
1089
1090     delete contextMenu.data();
1091 }
1092
1093 void DolphinMainWindow::updateControlMenu()
1094 {
1095     KMenu* menu = qobject_cast<KMenu*>(sender());
1096     Q_ASSERT(menu);
1097
1098     // All actions get cleared by KMenu::clear(). The sub-menus are deleted
1099     // by connecting to the aboutToHide() signal from the parent-menu.
1100     menu->clear();
1101
1102     KActionCollection* ac = actionCollection();
1103
1104     // Add "Edit" actions
1105     bool added = addActionToMenu(ac->action(KStandardAction::name(KStandardAction::Undo)), menu) |
1106                  addActionToMenu(ac->action(KStandardAction::name(KStandardAction::Find)), menu) |
1107                  addActionToMenu(ac->action("select_all"), menu) |
1108                  addActionToMenu(ac->action("invert_selection"), menu);
1109
1110     if (added) {
1111         menu->addSeparator();
1112     }
1113
1114     // Add "View" actions
1115     if (!GeneralSettings::showZoomSlider()) {
1116         addActionToMenu(ac->action(KStandardAction::name(KStandardAction::ZoomIn)), menu);
1117         addActionToMenu(ac->action(KStandardAction::name(KStandardAction::ZoomOut)), menu);
1118         menu->addSeparator();
1119     }
1120
1121     added = addActionToMenu(ac->action("view_mode"), menu) |
1122             addActionToMenu(ac->action("sort"), menu) |
1123             addActionToMenu(ac->action("additional_info"), menu) |
1124             addActionToMenu(ac->action("show_preview"), menu) |
1125             addActionToMenu(ac->action("show_in_groups"), menu) |
1126             addActionToMenu(ac->action("show_hidden_files"), menu);
1127
1128     if (added) {
1129         menu->addSeparator();
1130     }
1131
1132     added = addActionToMenu(ac->action("split_view"), menu) |
1133             addActionToMenu(ac->action("reload"), menu) |
1134             addActionToMenu(ac->action("view_properties"), menu);
1135     if (added) {
1136         menu->addSeparator();
1137     }
1138
1139     addActionToMenu(ac->action("panels"), menu);
1140     KMenu* locationBarMenu = new KMenu(i18nc("@action:inmenu", "Location Bar"), menu);
1141     locationBarMenu->addAction(ac->action("editable_location"));
1142     locationBarMenu->addAction(ac->action("replace_location"));
1143     menu->addMenu(locationBarMenu);
1144
1145     menu->addSeparator();
1146
1147     // Add "Go" menu
1148     KMenu* goMenu = new KMenu(i18nc("@action:inmenu", "Go"), menu);
1149     connect(menu, &KMenu::aboutToHide, goMenu, &KMenu::deleteLater);
1150     goMenu->addAction(ac->action(KStandardAction::name(KStandardAction::Back)));
1151     goMenu->addAction(ac->action(KStandardAction::name(KStandardAction::Forward)));
1152     goMenu->addAction(ac->action(KStandardAction::name(KStandardAction::Up)));
1153     goMenu->addAction(ac->action(KStandardAction::name(KStandardAction::Home)));
1154     goMenu->addAction(ac->action("closed_tabs"));
1155     menu->addMenu(goMenu);
1156
1157     // Add "Tool" menu
1158     KMenu* toolsMenu = new KMenu(i18nc("@action:inmenu", "Tools"), menu);
1159     connect(menu, &KMenu::aboutToHide, toolsMenu, &KMenu::deleteLater);
1160     toolsMenu->addAction(ac->action("show_filter_bar"));
1161     toolsMenu->addAction(ac->action("compare_files"));
1162     toolsMenu->addAction(ac->action("open_terminal"));
1163     toolsMenu->addAction(ac->action("change_remote_encoding"));
1164     menu->addMenu(toolsMenu);
1165
1166     // Add "Settings" menu entries
1167     addActionToMenu(ac->action(KStandardAction::name(KStandardAction::KeyBindings)), menu);
1168     addActionToMenu(ac->action(KStandardAction::name(KStandardAction::ConfigureToolbars)), menu);
1169     addActionToMenu(ac->action(KStandardAction::name(KStandardAction::Preferences)), menu);
1170
1171     // Add "Help" menu
1172     KMenu* helpMenu = new KMenu(i18nc("@action:inmenu", "Help"), menu);
1173     connect(menu, &KMenu::aboutToHide, helpMenu, &KMenu::deleteLater);
1174     helpMenu->addAction(ac->action(KStandardAction::name(KStandardAction::HelpContents)));
1175     helpMenu->addAction(ac->action(KStandardAction::name(KStandardAction::WhatsThis)));
1176     helpMenu->addSeparator();
1177     helpMenu->addAction(ac->action(KStandardAction::name(KStandardAction::ReportBug)));
1178     helpMenu->addSeparator();
1179     helpMenu->addAction(ac->action(KStandardAction::name(KStandardAction::SwitchApplicationLanguage)));
1180     helpMenu->addSeparator();
1181     helpMenu->addAction(ac->action(KStandardAction::name(KStandardAction::AboutApp)));
1182     helpMenu->addAction(ac->action(KStandardAction::name(KStandardAction::AboutKDE)));
1183     menu->addMenu(helpMenu);
1184
1185     menu->addSeparator();
1186     addActionToMenu(ac->action(KStandardAction::name(KStandardAction::ShowMenubar)), menu);
1187 }
1188
1189 void DolphinMainWindow::updateToolBar()
1190 {
1191     if (!menuBar()->isVisible()) {
1192         createControlButton();
1193     }
1194 }
1195
1196 void DolphinMainWindow::slotControlButtonDeleted()
1197 {
1198     m_controlButton = 0;
1199     m_updateToolBarTimer->start();
1200 }
1201
1202 void DolphinMainWindow::slotPanelErrorMessage(const QString& error)
1203 {
1204     activeViewContainer()->showMessage(error, DolphinViewContainer::Error);
1205 }
1206
1207 void DolphinMainWindow::slotPlaceActivated(const KUrl& url)
1208 {
1209     DolphinViewContainer* view = activeViewContainer();
1210
1211     if (view->url() == url) {
1212         // We can end up here if the user clicked a device in the Places Panel
1213         // which had been unmounted earlier, see https://bugs.kde.org/show_bug.cgi?id=161385.
1214         reloadView();
1215     } else {
1216         changeUrl(url);
1217     }
1218 }
1219
1220 void DolphinMainWindow::activeViewChanged()
1221 {
1222     const DolphinTabPage* tabPage = m_viewTab.at(m_tabIndex);
1223     setActiveViewContainer(tabPage->activeViewContainer());
1224 }
1225
1226 void DolphinMainWindow::closedTabsCountChanged(unsigned int count)
1227 {
1228     actionCollection()->action("undo_close_tab")->setEnabled(count > 0);
1229 }
1230
1231 void DolphinMainWindow::setActiveViewContainer(DolphinViewContainer* viewContainer)
1232 {
1233     Q_ASSERT(viewContainer);
1234     Q_ASSERT((viewContainer == m_viewTab.at(m_tabIndex)->primaryViewContainer()) ||
1235              (viewContainer == m_viewTab.at(m_tabIndex)->secondaryViewContainer()));
1236     if (m_activeViewContainer == viewContainer) {
1237         return;
1238     }
1239
1240     m_activeViewContainer = viewContainer;
1241     m_actionHandler->setCurrentView(viewContainer->view());
1242
1243     updateHistory();
1244     updateEditActions();
1245     updatePasteAction();
1246     updateViewActions();
1247     updateGoActions();
1248
1249     const KUrl url = m_activeViewContainer->url();
1250     setUrlAsCaption(url);
1251     m_tabBar->setTabText(m_tabIndex, squeezedText(tabName(url)));
1252     m_tabBar->setTabIcon(m_tabIndex, QIcon::fromTheme(KIO::iconNameForUrl(url)));
1253
1254     emit urlChanged(url);
1255 }
1256
1257 void DolphinMainWindow::setupActions()
1258 {
1259     // setup 'File' menu
1260     m_newFileMenu = new DolphinNewFileMenu(actionCollection(), this);
1261     QMenu* menu = m_newFileMenu->menu();
1262     menu->setTitle(i18nc("@title:menu Create new folder, file, link, etc.", "Create New"));
1263     menu->setIcon(QIcon::fromTheme("document-new"));
1264     m_newFileMenu->setDelayed(false);
1265     connect(menu, &QMenu::aboutToShow,
1266             this, &DolphinMainWindow::updateNewMenu);
1267
1268     QAction* newWindow = actionCollection()->addAction("new_window");
1269     newWindow->setIcon(QIcon::fromTheme("window-new"));
1270     newWindow->setText(i18nc("@action:inmenu File", "New &Window"));
1271     newWindow->setShortcut(Qt::CTRL | Qt::Key_N);
1272     connect(newWindow, &QAction::triggered, this, &DolphinMainWindow::openNewMainWindow);
1273
1274     QAction* newTab = actionCollection()->addAction("new_tab");
1275     newTab->setIcon(QIcon::fromTheme("tab-new"));
1276     newTab->setText(i18nc("@action:inmenu File", "New Tab"));
1277     newTab->setShortcuts(QList<QKeySequence>() << QKeySequence(Qt::CTRL | Qt::Key_T) << QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_N));
1278     connect(newTab, &QAction::triggered, this, static_cast<void(DolphinMainWindow::*)()>(&DolphinMainWindow::openNewTab));
1279
1280     QAction* closeTab = actionCollection()->addAction("close_tab");
1281     closeTab->setIcon(QIcon::fromTheme("tab-close"));
1282     closeTab->setText(i18nc("@action:inmenu File", "Close Tab"));
1283     closeTab->setShortcut(Qt::CTRL | Qt::Key_W);
1284     closeTab->setEnabled(false);
1285     connect(closeTab, &QAction::triggered, this, static_cast<void(DolphinMainWindow::*)()>(&DolphinMainWindow::closeTab));
1286
1287     KStandardAction::quit(this, SLOT(quit()), actionCollection());
1288
1289     // setup 'Edit' menu
1290     KStandardAction::undo(this,
1291                           SLOT(undo()),
1292                           actionCollection());
1293
1294     // need to remove shift+del from cut action, else the shortcut for deletejob
1295     // doesn't work
1296     QAction* cut = KStandardAction::cut(this, SLOT(cut()), actionCollection());
1297     auto cutShortcuts = cut->shortcuts();
1298     cutShortcuts.removeAll(QKeySequence(Qt::SHIFT | Qt::Key_Delete));
1299     cut->setShortcuts(cutShortcuts);
1300     KStandardAction::copy(this, SLOT(copy()), actionCollection());
1301     QAction* paste = KStandardAction::paste(this, SLOT(paste()), actionCollection());
1302     // The text of the paste-action is modified dynamically by Dolphin
1303     // (e. g. to "Paste One Folder"). To prevent that the size of the toolbar changes
1304     // due to the long text, the text "Paste" is used:
1305     paste->setIconText(i18nc("@action:inmenu Edit", "Paste"));
1306
1307     KStandardAction::find(this, SLOT(find()), actionCollection());
1308
1309     QAction* selectAll = actionCollection()->addAction("select_all");
1310     selectAll->setText(i18nc("@action:inmenu Edit", "Select All"));
1311     selectAll->setShortcut(Qt::CTRL | Qt::Key_A);
1312     connect(selectAll, &QAction::triggered, this, &DolphinMainWindow::selectAll);
1313
1314     QAction* invertSelection = actionCollection()->addAction("invert_selection");
1315     invertSelection->setText(i18nc("@action:inmenu Edit", "Invert Selection"));
1316     invertSelection->setShortcut(Qt::CTRL | Qt::SHIFT | Qt::Key_A);
1317     connect(invertSelection, &QAction::triggered, this, &DolphinMainWindow::invertSelection);
1318
1319     // setup 'View' menu
1320     // (note that most of it is set up in DolphinViewActionHandler)
1321
1322     QAction* split = actionCollection()->addAction("split_view");
1323     split->setShortcut(Qt::Key_F3);
1324     connect(split, &QAction::triggered, this, &DolphinMainWindow::toggleSplitView);
1325
1326     QAction* reload = actionCollection()->addAction("reload");
1327     reload->setText(i18nc("@action:inmenu View", "Reload"));
1328     reload->setShortcut(Qt::Key_F5);
1329     reload->setIcon(QIcon::fromTheme("view-refresh"));
1330     connect(reload, &QAction::triggered, this, &DolphinMainWindow::reloadView);
1331
1332     QAction* stop = actionCollection()->addAction("stop");
1333     stop->setText(i18nc("@action:inmenu View", "Stop"));
1334     stop->setToolTip(i18nc("@info", "Stop loading"));
1335     stop->setIcon(QIcon::fromTheme("process-stop"));
1336     connect(stop, &QAction::triggered, this, &DolphinMainWindow::stopLoading);
1337
1338     KToggleAction* editableLocation = actionCollection()->add<KToggleAction>("editable_location");
1339     editableLocation->setText(i18nc("@action:inmenu Navigation Bar", "Editable Location"));
1340     editableLocation->setShortcut(Qt::Key_F6);
1341     connect(editableLocation, &KToggleAction::triggered, this, &DolphinMainWindow::toggleEditLocation);
1342
1343     QAction* replaceLocation = actionCollection()->addAction("replace_location");
1344     replaceLocation->setText(i18nc("@action:inmenu Navigation Bar", "Replace Location"));
1345     replaceLocation->setShortcut(Qt::CTRL | Qt::Key_L);
1346     connect(replaceLocation, &QAction::triggered, this, &DolphinMainWindow::replaceLocation);
1347
1348     // setup 'Go' menu
1349     QAction* backAction = KStandardAction::back(this, SLOT(goBack()), actionCollection());
1350     auto backShortcuts = backAction->shortcuts();
1351     backShortcuts.append(QKeySequence(Qt::Key_Backspace));
1352     backAction->setShortcuts(backShortcuts);
1353
1354     DolphinRecentTabsMenu* recentTabsMenu = new DolphinRecentTabsMenu(this);
1355     actionCollection()->addAction("closed_tabs", recentTabsMenu);
1356     connect(this, SIGNAL(rememberClosedTab(KUrl,KUrl)),
1357             recentTabsMenu, SLOT(rememberClosedTab(KUrl,KUrl)));
1358     connect(recentTabsMenu, SIGNAL(restoreClosedTab(KUrl,KUrl)),
1359             this, SLOT(openNewActivatedTab(KUrl,KUrl)));
1360     connect(recentTabsMenu, SIGNAL(closedTabsCountChanged(uint)),
1361             this, SLOT(closedTabsCountChanged(uint)));
1362
1363     QAction* undoCloseTab = actionCollection()->addAction("undo_close_tab");
1364     undoCloseTab->setText(i18nc("@action:inmenu File", "Undo close tab"));
1365     undoCloseTab->setShortcut(Qt::CTRL | Qt::SHIFT | Qt::Key_T);
1366     undoCloseTab->setIcon(QIcon::fromTheme("edit-undo"));
1367     undoCloseTab->setEnabled(false);
1368     connect(undoCloseTab, SIGNAL(triggered()), recentTabsMenu, SLOT(undoCloseTab()));
1369
1370     KStandardAction::forward(this, SLOT(goForward()), actionCollection());
1371     KStandardAction::up(this, SLOT(goUp()), actionCollection());
1372     KStandardAction::home(this, SLOT(goHome()), actionCollection());
1373
1374     // setup 'Tools' menu
1375     QAction* showFilterBar = actionCollection()->addAction("show_filter_bar");
1376     showFilterBar->setText(i18nc("@action:inmenu Tools", "Show Filter Bar"));
1377     showFilterBar->setIcon(QIcon::fromTheme("view-filter"));
1378     showFilterBar->setShortcut(Qt::CTRL | Qt::Key_I);
1379     connect(showFilterBar, &QAction::triggered, this, &DolphinMainWindow::showFilterBar);
1380
1381     QAction* compareFiles = actionCollection()->addAction("compare_files");
1382     compareFiles->setText(i18nc("@action:inmenu Tools", "Compare Files"));
1383     compareFiles->setIcon(QIcon::fromTheme("kompare"));
1384     compareFiles->setEnabled(false);
1385     connect(compareFiles, &QAction::triggered, this, &DolphinMainWindow::compareFiles);
1386
1387     QAction* openTerminal = actionCollection()->addAction("open_terminal");
1388     openTerminal->setText(i18nc("@action:inmenu Tools", "Open Terminal"));
1389     openTerminal->setIcon(QIcon::fromTheme("utilities-terminal"));
1390     openTerminal->setShortcut(Qt::SHIFT | Qt::Key_F4);
1391     connect(openTerminal, &QAction::triggered, this, &DolphinMainWindow::openTerminal);
1392
1393     // setup 'Settings' menu
1394     KToggleAction* showMenuBar = KStandardAction::showMenubar(0, 0, actionCollection());
1395     connect(showMenuBar, &KToggleAction::triggered,                   // Fixes #286822
1396             this, &DolphinMainWindow::toggleShowMenuBar, Qt::QueuedConnection);
1397     KStandardAction::preferences(this, SLOT(editSettings()), actionCollection());
1398
1399     // not in menu actions
1400     QList<QKeySequence> nextTabKeys;
1401     nextTabKeys.append(KStandardShortcut::tabNext().first()); //TODO: is this correct
1402     nextTabKeys.append(QKeySequence(Qt::CTRL | Qt::Key_Tab));
1403
1404     QList<QKeySequence> prevTabKeys;
1405     prevTabKeys.append(KStandardShortcut::tabPrev().first()); //TODO: is this correct
1406     prevTabKeys.append(QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_Tab));
1407
1408     QAction* activateNextTab = actionCollection()->addAction("activate_next_tab");
1409     activateNextTab->setIconText(i18nc("@action:inmenu", "Next Tab"));
1410     activateNextTab->setText(i18nc("@action:inmenu", "Activate Next Tab"));
1411     activateNextTab->setEnabled(false);
1412     connect(activateNextTab, &QAction::triggered, this, &DolphinMainWindow::activateNextTab);
1413     activateNextTab->setShortcuts(QApplication::isRightToLeft() ? prevTabKeys : nextTabKeys);
1414
1415     QAction* activatePrevTab = actionCollection()->addAction("activate_prev_tab");
1416     activatePrevTab->setIconText(i18nc("@action:inmenu", "Previous Tab"));
1417     activatePrevTab->setText(i18nc("@action:inmenu", "Activate Previous Tab"));
1418     activatePrevTab->setEnabled(false);
1419     connect(activatePrevTab, &QAction::triggered, this, &DolphinMainWindow::activatePrevTab);
1420     activatePrevTab->setShortcuts(QApplication::isRightToLeft() ? nextTabKeys : prevTabKeys);
1421
1422     // for context menu
1423     QAction* openInNewTab = actionCollection()->addAction("open_in_new_tab");
1424     openInNewTab->setText(i18nc("@action:inmenu", "Open in New Tab"));
1425     openInNewTab->setIcon(QIcon::fromTheme("tab-new"));
1426     connect(openInNewTab, &QAction::triggered, this, &DolphinMainWindow::openInNewTab);
1427
1428     QAction* openInNewTabs = actionCollection()->addAction("open_in_new_tabs");
1429     openInNewTabs->setText(i18nc("@action:inmenu", "Open in New Tabs"));
1430     openInNewTabs->setIcon(QIcon::fromTheme("tab-new"));
1431     connect(openInNewTabs, &QAction::triggered, this, &DolphinMainWindow::openInNewTab);
1432
1433     QAction* openInNewWindow = actionCollection()->addAction("open_in_new_window");
1434     openInNewWindow->setText(i18nc("@action:inmenu", "Open in New Window"));
1435     openInNewWindow->setIcon(QIcon::fromTheme("window-new"));
1436     connect(openInNewWindow, &QAction::triggered, this, &DolphinMainWindow::openInNewWindow);
1437 }
1438
1439 void DolphinMainWindow::setupDockWidgets()
1440 {
1441     const bool lock = GeneralSettings::lockPanels();
1442
1443     KDualAction* lockLayoutAction = actionCollection()->add<KDualAction>("lock_panels");
1444     lockLayoutAction->setActiveText(i18nc("@action:inmenu Panels", "Unlock Panels"));
1445     lockLayoutAction->setActiveIcon(QIcon::fromTheme("object-unlocked"));
1446     lockLayoutAction->setInactiveText(i18nc("@action:inmenu Panels", "Lock Panels"));
1447     lockLayoutAction->setInactiveIcon(QIcon::fromTheme("object-locked"));
1448     lockLayoutAction->setActive(lock);
1449     connect(lockLayoutAction, &KDualAction::triggered, this, &DolphinMainWindow::togglePanelLockState);
1450
1451     // Setup "Information"
1452     DolphinDockWidget* infoDock = new DolphinDockWidget(i18nc("@title:window", "Information"));
1453     infoDock->setLocked(lock);
1454     infoDock->setObjectName("infoDock");
1455     infoDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
1456     InformationPanel* infoPanel = new InformationPanel(infoDock);
1457     infoPanel->setCustomContextMenuActions(QList<QAction*>() << lockLayoutAction);
1458     connect(infoPanel, &InformationPanel::urlActivated, this, &DolphinMainWindow::handleUrl);
1459     infoDock->setWidget(infoPanel);
1460
1461     QAction* infoAction = infoDock->toggleViewAction();
1462     createPanelAction(QIcon::fromTheme("dialog-information"), Qt::Key_F11, infoAction, "show_information_panel");
1463
1464     addDockWidget(Qt::RightDockWidgetArea, infoDock);
1465     connect(this, &DolphinMainWindow::urlChanged,
1466             infoPanel, &InformationPanel::setUrl);
1467     connect(this, &DolphinMainWindow::selectionChanged,
1468             infoPanel, &InformationPanel::setSelection);
1469     connect(this, &DolphinMainWindow::requestItemInfo,
1470             infoPanel, &InformationPanel::requestDelayedItemInfo);
1471
1472     // Setup "Folders"
1473     DolphinDockWidget* foldersDock = new DolphinDockWidget(i18nc("@title:window", "Folders"));
1474     foldersDock->setLocked(lock);
1475     foldersDock->setObjectName("foldersDock");
1476     foldersDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
1477     FoldersPanel* foldersPanel = new FoldersPanel(foldersDock);
1478     foldersPanel->setCustomContextMenuActions(QList<QAction*>() << lockLayoutAction);
1479     foldersDock->setWidget(foldersPanel);
1480
1481     QAction* foldersAction = foldersDock->toggleViewAction();
1482     createPanelAction(QIcon::fromTheme("folder"), Qt::Key_F7, foldersAction, "show_folders_panel");
1483
1484     addDockWidget(Qt::LeftDockWidgetArea, foldersDock);
1485     connect(this, &DolphinMainWindow::urlChanged,
1486             foldersPanel, &FoldersPanel::setUrl);
1487     connect(foldersPanel, &FoldersPanel::folderActivated,
1488             this, &DolphinMainWindow::changeUrl);
1489     connect(foldersPanel, SIGNAL(folderMiddleClicked(KUrl)),
1490             this, SLOT(openNewTab(KUrl)));
1491     connect(foldersPanel, &FoldersPanel::errorMessage,
1492             this, &DolphinMainWindow::slotPanelErrorMessage);
1493
1494     // Setup "Terminal"
1495 #ifndef Q_OS_WIN
1496     DolphinDockWidget* terminalDock = new DolphinDockWidget(i18nc("@title:window Shell terminal", "Terminal"));
1497     terminalDock->setLocked(lock);
1498     terminalDock->setObjectName("terminalDock");
1499     terminalDock->setAllowedAreas(Qt::TopDockWidgetArea | Qt::BottomDockWidgetArea);
1500     TerminalPanel* terminalPanel = new TerminalPanel(terminalDock);
1501     terminalPanel->setCustomContextMenuActions(QList<QAction*>() << lockLayoutAction);
1502     terminalDock->setWidget(terminalPanel);
1503
1504     connect(terminalPanel, &TerminalPanel::hideTerminalPanel, terminalDock, &DolphinDockWidget::hide);
1505     connect(terminalPanel, &TerminalPanel::changeUrl, this, &DolphinMainWindow::slotTerminalDirectoryChanged);
1506     connect(terminalDock, &DolphinDockWidget::visibilityChanged,
1507             terminalPanel, &TerminalPanel::dockVisibilityChanged);
1508
1509     QAction* terminalAction = terminalDock->toggleViewAction();
1510     createPanelAction(QIcon::fromTheme("utilities-terminal"), Qt::Key_F4, terminalAction, "show_terminal_panel");
1511
1512     addDockWidget(Qt::BottomDockWidgetArea, terminalDock);
1513     connect(this, &DolphinMainWindow::urlChanged,
1514             terminalPanel, &TerminalPanel::setUrl);
1515 #endif
1516
1517     if (GeneralSettings::version() < 200) {
1518         infoDock->hide();
1519         foldersDock->hide();
1520 #ifndef Q_OS_WIN
1521         terminalDock->hide();
1522 #endif
1523     }
1524
1525     // Setup "Places"
1526     DolphinDockWidget* placesDock = new DolphinDockWidget(i18nc("@title:window", "Places"));
1527     placesDock->setLocked(lock);
1528     placesDock->setObjectName("placesDock");
1529     placesDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
1530
1531     PlacesPanel* placesPanel = new PlacesPanel(placesDock);
1532     placesPanel->setCustomContextMenuActions(QList<QAction*>() << lockLayoutAction);
1533     placesDock->setWidget(placesPanel);
1534
1535     QAction* placesAction = placesDock->toggleViewAction();
1536     createPanelAction(QIcon::fromTheme("bookmarks"), Qt::Key_F9, placesAction, "show_places_panel");
1537
1538     addDockWidget(Qt::LeftDockWidgetArea, placesDock);
1539     connect(placesPanel, &PlacesPanel::placeActivated,
1540             this, &DolphinMainWindow::slotPlaceActivated);
1541     connect(placesPanel, SIGNAL(placeMiddleClicked(KUrl)),
1542             this, SLOT(openNewTab(KUrl)));
1543     connect(placesPanel, &PlacesPanel::errorMessage,
1544             this, &DolphinMainWindow::slotPanelErrorMessage);
1545     connect(this, &DolphinMainWindow::urlChanged,
1546             placesPanel, &PlacesPanel::setUrl);
1547     connect(placesDock, &DolphinDockWidget::visibilityChanged,
1548             this, &DolphinMainWindow::slotPlacesPanelVisibilityChanged);
1549     connect(this, &DolphinMainWindow::settingsChanged,
1550             placesPanel, &PlacesPanel::readSettings);
1551
1552     // Add actions into the "Panels" menu
1553     KActionMenu* panelsMenu = new KActionMenu(i18nc("@action:inmenu View", "Panels"), this);
1554     actionCollection()->addAction("panels", panelsMenu);
1555     panelsMenu->setDelayed(false);
1556     const KActionCollection* ac = actionCollection();
1557     panelsMenu->addAction(ac->action("show_places_panel"));
1558     panelsMenu->addAction(ac->action("show_information_panel"));
1559     panelsMenu->addAction(ac->action("show_folders_panel"));
1560 #ifndef Q_OS_WIN
1561     panelsMenu->addAction(ac->action("show_terminal_panel"));
1562 #endif
1563     panelsMenu->addSeparator();
1564     panelsMenu->addAction(lockLayoutAction);
1565 }
1566
1567 void DolphinMainWindow::updateEditActions()
1568 {
1569     const KFileItemList list = m_activeViewContainer->view()->selectedItems();
1570     if (list.isEmpty()) {
1571         stateChanged("has_no_selection");
1572     } else {
1573         stateChanged("has_selection");
1574
1575         KActionCollection* col = actionCollection();
1576         QAction* renameAction      = col->action("rename");
1577         QAction* moveToTrashAction = col->action("move_to_trash");
1578         QAction* deleteAction      = col->action("delete");
1579         QAction* cutAction         = col->action(KStandardAction::name(KStandardAction::Cut));
1580         QAction* deleteWithTrashShortcut = col->action("delete_shortcut"); // see DolphinViewActionHandler
1581
1582         KFileItemListProperties capabilities(list);
1583         const bool enableMoveToTrash = capabilities.isLocal() && capabilities.supportsMoving();
1584
1585         renameAction->setEnabled(capabilities.supportsMoving());
1586         moveToTrashAction->setEnabled(enableMoveToTrash);
1587         deleteAction->setEnabled(capabilities.supportsDeleting());
1588         deleteWithTrashShortcut->setEnabled(capabilities.supportsDeleting() && !enableMoveToTrash);
1589         cutAction->setEnabled(capabilities.supportsMoving());
1590     }
1591 }
1592
1593 void DolphinMainWindow::updateViewActions()
1594 {
1595     m_actionHandler->updateViewActions();
1596
1597     QAction* showFilterBarAction = actionCollection()->action("show_filter_bar");
1598     showFilterBarAction->setChecked(m_activeViewContainer->isFilterBarVisible());
1599
1600     updateSplitAction();
1601
1602     QAction* editableLocactionAction = actionCollection()->action("editable_location");
1603     const KUrlNavigator* urlNavigator = m_activeViewContainer->urlNavigator();
1604     editableLocactionAction->setChecked(urlNavigator->isUrlEditable());
1605 }
1606
1607 void DolphinMainWindow::updateGoActions()
1608 {
1609     QAction* goUpAction = actionCollection()->action(KStandardAction::name(KStandardAction::Up));
1610     const KUrl currentUrl = m_activeViewContainer->url();
1611     goUpAction->setEnabled(currentUrl.upUrl() != currentUrl);
1612 }
1613
1614 void DolphinMainWindow::createControlButton()
1615 {
1616     if (m_controlButton) {
1617         return;
1618     }
1619     Q_ASSERT(!m_controlButton);
1620
1621     m_controlButton = new QToolButton(this);
1622     m_controlButton->setIcon(QIcon::fromTheme("applications-system"));
1623     m_controlButton->setText(i18nc("@action", "Control"));
1624     m_controlButton->setPopupMode(QToolButton::InstantPopup);
1625     m_controlButton->setToolButtonStyle(toolBar()->toolButtonStyle());
1626
1627     KMenu* controlMenu = new KMenu(m_controlButton);
1628     connect(controlMenu, &KMenu::aboutToShow, this, &DolphinMainWindow::updateControlMenu);
1629
1630     m_controlButton->setMenu(controlMenu);
1631
1632     toolBar()->addWidget(m_controlButton);
1633     connect(toolBar(), &KToolBar::iconSizeChanged,
1634             m_controlButton, &QToolButton::setIconSize);
1635     connect(toolBar(), &KToolBar::toolButtonStyleChanged,
1636             m_controlButton, &QToolButton::setToolButtonStyle);
1637
1638     // The added widgets are owned by the toolbar and may get deleted when e.g. the toolbar
1639     // gets edited. In this case we must add them again. The adding is done asynchronously by
1640     // m_updateToolBarTimer.
1641     connect(m_controlButton, &QToolButton::destroyed, this, &DolphinMainWindow::slotControlButtonDeleted);
1642     m_updateToolBarTimer = new QTimer(this);
1643     m_updateToolBarTimer->setInterval(500);
1644     connect(m_updateToolBarTimer, &QTimer::timeout, this, &DolphinMainWindow::updateToolBar);
1645 }
1646
1647 void DolphinMainWindow::deleteControlButton()
1648 {
1649     delete m_controlButton;
1650     m_controlButton = 0;
1651
1652     delete m_updateToolBarTimer;
1653     m_updateToolBarTimer = 0;
1654 }
1655
1656 bool DolphinMainWindow::addActionToMenu(QAction* action, KMenu* menu)
1657 {
1658     Q_ASSERT(action);
1659     Q_ASSERT(menu);
1660
1661     const KToolBar* toolBarWidget = toolBar();
1662     foreach (const QWidget* widget, action->associatedWidgets()) {
1663         if (widget == toolBarWidget) {
1664             return false;
1665         }
1666     }
1667
1668     menu->addAction(action);
1669     return true;
1670 }
1671
1672 void DolphinMainWindow::refreshViews()
1673 {
1674     foreach (DolphinTabPage* tabPage, m_viewTab) {
1675         tabPage->refreshViews();
1676     }
1677
1678     if (GeneralSettings::modifiedStartupSettings()) {
1679         // The startup settings have been changed by the user (see bug #254947).
1680         // Synchronize the split-view setting with the active view:
1681         const bool splitView = GeneralSettings::splitView();
1682         m_viewTab.at(m_tabIndex)->setSplitViewEnabled(splitView);
1683         updateSplitAction();
1684     }
1685
1686     emit settingsChanged();
1687 }
1688
1689 void DolphinMainWindow::clearStatusBar()
1690 {
1691     m_activeViewContainer->statusBar()->resetToDefaultText();
1692 }
1693
1694 void DolphinMainWindow::connectViewSignals(DolphinViewContainer* container)
1695 {
1696     connect(container, &DolphinViewContainer::showFilterBarChanged,
1697             this, &DolphinMainWindow::updateFilterBarAction);
1698     connect(container, &DolphinViewContainer::writeStateChanged,
1699             this, &DolphinMainWindow::slotWriteStateChanged);
1700
1701     const DolphinView* view = container->view();
1702     connect(view, &DolphinView::selectionChanged,
1703             this, &DolphinMainWindow::slotSelectionChanged);
1704     connect(view, &DolphinView::requestItemInfo,
1705             this, &DolphinMainWindow::slotRequestItemInfo);
1706     connect(view, SIGNAL(tabRequested(KUrl)),
1707             this, SLOT(openNewTab(KUrl)));
1708     connect(view, &DolphinView::requestContextMenu,
1709             this, &DolphinMainWindow::openContextMenu);
1710     connect(view, &DolphinView::directoryLoadingStarted,
1711             this, &DolphinMainWindow::enableStopAction);
1712     connect(view, &DolphinView::directoryLoadingCompleted,
1713             this, &DolphinMainWindow::disableStopAction);
1714     connect(view, &DolphinView::goBackRequested,
1715             this, static_cast<void(DolphinMainWindow::*)()>(&DolphinMainWindow::goBack));
1716     connect(view, &DolphinView::goForwardRequested,
1717             this, static_cast<void(DolphinMainWindow::*)()>(&DolphinMainWindow::goForward));
1718
1719     const KUrlNavigator* navigator = container->urlNavigator();
1720     connect(navigator, &KUrlNavigator::urlChanged,
1721             this, &DolphinMainWindow::changeUrl);
1722     connect(navigator, &KUrlNavigator::historyChanged,
1723             this, &DolphinMainWindow::updateHistory);
1724     connect(navigator, &KUrlNavigator::editableStateChanged,
1725             this, &DolphinMainWindow::slotEditableStateChanged);
1726     connect(navigator, SIGNAL(tabRequested(KUrl)),
1727             this, SLOT(openNewTab(KUrl)));
1728 }
1729
1730 void DolphinMainWindow::updateSplitAction()
1731 {
1732     QAction* splitAction = actionCollection()->action("split_view");
1733     const DolphinTabPage* tabPage = m_viewTab.at(m_tabIndex);
1734     if (tabPage->splitViewEnabled()) {
1735         if (tabPage->primaryViewActive()) {
1736             splitAction->setText(i18nc("@action:intoolbar Close left view", "Close"));
1737             splitAction->setToolTip(i18nc("@info", "Close left view"));
1738             splitAction->setIcon(KIcon("view-left-close"));
1739         } else {
1740             splitAction->setText(i18nc("@action:intoolbar Close right view", "Close"));
1741             splitAction->setToolTip(i18nc("@info", "Close right view"));
1742             splitAction->setIcon(KIcon("view-right-close"));
1743         }
1744     } else {
1745         splitAction->setText(i18nc("@action:intoolbar Split view", "Split"));
1746         splitAction->setToolTip(i18nc("@info", "Split view"));
1747         splitAction->setIcon(QIcon::fromTheme("view-right-new"));
1748     }
1749 }
1750
1751 QString DolphinMainWindow::tabName(const KUrl& url) const
1752 {
1753     QString name;
1754     if (url.equals(KUrl("file:///"))) {
1755         name = '/';
1756     } else {
1757         name = url.fileName();
1758         if (name.isEmpty()) {
1759             name = url.protocol();
1760         } else {
1761             // Make sure that a '&' inside the directory name is displayed correctly
1762             // and not misinterpreted as a keyboard shortcut in QTabBar::setTabText()
1763             name.replace('&', "&&");
1764         }
1765     }
1766     return name;
1767 }
1768
1769 bool DolphinMainWindow::isKompareInstalled() const
1770 {
1771     static bool initialized = false;
1772     static bool installed = false;
1773     if (!initialized) {
1774         // TODO: maybe replace this approach later by using a menu
1775         // plugin like kdiff3plugin.cpp
1776         installed = !KGlobal::dirs()->findExe("kompare").isEmpty();
1777         initialized = true;
1778     }
1779     return installed;
1780 }
1781
1782 void DolphinMainWindow::setUrlAsCaption(const KUrl& url)
1783 {
1784     QString caption;
1785     if (!url.isLocalFile()) {
1786         caption.append(url.protocol() + " - ");
1787         if (url.hasHost()) {
1788             caption.append(url.host() + " - ");
1789         }
1790     }
1791
1792     const QString fileName = url.fileName().isEmpty() ? "/" : url.fileName();
1793     caption.append(fileName);
1794
1795     setCaption(caption);
1796 }
1797
1798 QString DolphinMainWindow::squeezedText(const QString& text) const
1799 {
1800     const QFontMetrics fm = fontMetrics();
1801     return fm.elidedText(text, Qt::ElideMiddle, fm.maxWidth() * 10);
1802 }
1803
1804 void DolphinMainWindow::createPanelAction(const QIcon& icon,
1805                                           const QKeySequence& shortcut,
1806                                           QAction* dockAction,
1807                                           const QString& actionName)
1808 {
1809     QAction* panelAction = actionCollection()->addAction(actionName);
1810     panelAction->setCheckable(true);
1811     panelAction->setChecked(dockAction->isChecked());
1812     panelAction->setText(dockAction->text());
1813     panelAction->setIcon(icon);
1814     panelAction->setShortcut(shortcut);
1815
1816     connect(panelAction, &QAction::triggered, dockAction, &QAction::trigger);
1817     connect(dockAction, &QAction::toggled, panelAction, &QAction::setChecked);
1818 }
1819
1820 DolphinMainWindow::UndoUiInterface::UndoUiInterface() :
1821     KIO::FileUndoManager::UiInterface()
1822 {
1823 }
1824
1825 DolphinMainWindow::UndoUiInterface::~UndoUiInterface()
1826 {
1827 }
1828
1829 void DolphinMainWindow::UndoUiInterface::jobError(KIO::Job* job)
1830 {
1831     DolphinMainWindow* mainWin= qobject_cast<DolphinMainWindow *>(parentWidget());
1832     if (mainWin) {
1833         DolphinViewContainer* container = mainWin->activeViewContainer();
1834         container->showMessage(job->errorString(), DolphinViewContainer::Error);
1835     } else {
1836         KIO::FileUndoManager::UiInterface::jobError(job);
1837     }
1838 }
1839