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