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