src/dolphinmainwindow.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2006 by Peter Penz <peter.penz@gmx.at>                  *
   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 #include "dolphinviewactionhandler.h"
  24 #include "dolphindropcontroller.h"
  25
  26 #include <config-nepomuk.h>
  27
  28 #include "dolphinapplication.h"
  29 #include "dolphinnewmenu.h"
  30 #include "dolphinsettings.h"
  31 #include "dolphinsettingsdialog.h"
  32 #include "dolphinstatusbar.h"
  33 #include "dolphinviewcontainer.h"
  34 #include "infosidebarpage.h"
  35 #include "metadatawidget.h"
  36 #include "mainwindowadaptor.h"
  37 #include "terminalsidebarpage.h"
  38 #include "treeviewsidebarpage.h"
  39 #include "kurlnavigator.h"
  40 #include "viewpropertiesdialog.h"
  41 #include "viewproperties.h"
  42 #include "kfileplacesmodel.h"
  43 #include "kfileplacesview.h"
  44
  45 #include "dolphin_generalsettings.h"
  46 #include "dolphin_iconsmodesettings.h"
  47
  48 #include <kaction.h>
  49 #include <kactioncollection.h>
  50 #include <kconfig.h>
  51 #include <kdesktopfile.h>
  52 #include <kdeversion.h>
  53 #include <kfiledialog.h>
  54 #include <kglobal.h>
  55 #include <kicon.h>
  56 #include <kiconloader.h>
  57 #include <kio/netaccess.h>
  58 #include <kinputdialog.h>
  59 #include <klocale.h>
  60 #include <kmenu.h>
  61 #include <kmenubar.h>
  62 #include <kmessagebox.h>
  63 #include <konqmimedata.h>
  64 #include <kpropertiesdialog.h>
  65 #include <kprotocolinfo.h>
  66 #include <ktoggleaction.h>
  67 #include <krun.h>
  68 #include <kshell.h>
  69 #include <kstandarddirs.h>
  70 #include <kstatusbar.h>
  71 #include <kstandardaction.h>
  72 #include <kurl.h>
  73 #include <kurlcombobox.h>
  74
  75 #include <QKeyEvent>
  76 #include <QClipboard>
  77 #include <QLineEdit>
  78 #include <QSplitter>
  79 #include <QDockWidget>
  80
  81 DolphinMainWindow::DolphinMainWindow(int id) :
  82     KXmlGuiWindow(0),
  83     m_newMenu(0),
  84     m_showMenuBar(0),
  85     m_splitter(0),
  86     m_activeViewContainer(0),
  87     m_id(id)
  88 {
  89     setObjectName("Dolphin");
  90     m_viewContainer[PrimaryView] = 0;
  91     m_viewContainer[SecondaryView] = 0;
  92
  93     new MainWindowAdaptor(this);
  94     QDBusConnection::sessionBus().registerObject(QString("/dolphin/MainWindow%1").arg(m_id), this);
  95
  96     KonqFileUndoManager::incRef();
  97
  98     KonqFileUndoManager* undoManager = KonqFileUndoManager::self();
  99     undoManager->setUiInterface(new UndoUiInterface(this));
 100
 101     connect(undoManager, SIGNAL(undoAvailable(bool)),
 102             this, SLOT(slotUndoAvailable(bool)));
 103     connect(undoManager, SIGNAL(undoTextChanged(const QString&)),
 104             this, SLOT(slotUndoTextChanged(const QString&)));
 105     connect(DolphinSettings::instance().placesModel(), SIGNAL(errorMessage(const QString&)),
 106             this, SLOT(slotHandlePlacesError(const QString&)));
 107 }
 108
 109 DolphinMainWindow::~DolphinMainWindow()
 110 {
 111     KonqFileUndoManager::decRef();
 112     DolphinApplication::app()->removeMainWindow(this);
 113 }
 114
 115 void DolphinMainWindow::toggleViews()
 116 {
 117     if (m_viewContainer[SecondaryView] == 0) {
 118         return;
 119     }
 120
 121     // move secondary view from the last position of the splitter
 122     // to the first position
 123     m_splitter->insertWidget(0, m_viewContainer[SecondaryView]);
 124
 125     DolphinViewContainer* container = m_viewContainer[PrimaryView];
 126     m_viewContainer[PrimaryView] = m_viewContainer[SecondaryView];
 127     m_viewContainer[SecondaryView] = container;
 128 }
 129
 130 void DolphinMainWindow::slotDoingOperation(KonqFileUndoManager::CommandType commandType)
 131 {
 132     clearStatusBar();
 133     m_undoCommandTypes.append(commandType);
 134 }
 135
 136 void DolphinMainWindow::refreshViews()
 137 {
 138     Q_ASSERT(m_viewContainer[PrimaryView] != 0);
 139
 140     // remember the current active view, as because of
 141     // the refreshing the active view might change to
 142     // the secondary view
 143     DolphinViewContainer* activeViewContainer = m_activeViewContainer;
 144
 145     m_viewContainer[PrimaryView]->view()->refresh();
 146     if (m_viewContainer[SecondaryView] != 0) {
 147         m_viewContainer[SecondaryView]->view()->refresh();
 148     }
 149
 150     setActiveViewContainer(activeViewContainer);
 151 }
 152
 153 void DolphinMainWindow::dropUrls(const KUrl::List& urls,
 154                                  const KUrl& destination)
 155 {
 156     DolphinDropController dropController(this);
 157     connect(&dropController, SIGNAL(doingOperation(KonqFileUndoManager::CommandType)),
 158             this, SLOT(slotDoingOperation(KonqFileUndoManager::CommandType)));
 159     dropController.dropUrls(urls, destination);
 160 }
 161
 162 void DolphinMainWindow::changeUrl(const KUrl& url)
 163 {
 164     DolphinViewContainer* view = activeViewContainer();
 165     if (view != 0) {
 166         view->setUrl(url);
 167         updateEditActions();
 168         updateViewActions();
 169         updateGoActions();
 170         setCaption(url.fileName());
 171         emit urlChanged(url);
 172     }
 173 }
 174
 175 void DolphinMainWindow::changeSelection(const KFileItemList& selection)
 176 {
 177     activeViewContainer()->view()->changeSelection(selection);
 178 }
 179
 180 void DolphinMainWindow::slotSortingChanged(DolphinView::Sorting sorting)
 181 {
 182     QAction* action = 0;
 183     switch (sorting) {
 184     case DolphinView::SortByName:
 185         action = actionCollection()->action("sort_by_name");
 186         break;
 187     case DolphinView::SortBySize:
 188         action = actionCollection()->action("sort_by_size");
 189         break;
 190     case DolphinView::SortByDate:
 191         action = actionCollection()->action("sort_by_date");
 192         break;
 193     case DolphinView::SortByPermissions:
 194         action = actionCollection()->action("sort_by_permissions");
 195         break;
 196     case DolphinView::SortByOwner:
 197         action = actionCollection()->action("sort_by_owner");
 198         break;
 199     case DolphinView::SortByGroup:
 200         action = actionCollection()->action("sort_by_group");
 201         break;
 202     case DolphinView::SortByType:
 203         action = actionCollection()->action("sort_by_type");
 204         break;
 205 #ifdef HAVE_NEPOMUK
 206     case DolphinView::SortByRating:
 207         action = actionCollection()->action("sort_by_rating");
 208         break;
 209     case DolphinView::SortByTags:
 210         action = actionCollection()->action("sort_by_tags");
 211         break;
 212 #endif
 213     default:
 214         break;
 215     }
 216
 217     if (action != 0) {
 218         action->setChecked(true);
 219     }
 220 }
 221
 222 void DolphinMainWindow::slotSelectionChanged(const KFileItemList& selection)
 223 {
 224     updateEditActions();
 225
 226     Q_ASSERT(m_viewContainer[PrimaryView] != 0);
 227     int selectedUrlsCount = m_viewContainer[PrimaryView]->view()->selectedUrls().count();
 228     if (m_viewContainer[SecondaryView] != 0) {
 229         selectedUrlsCount += m_viewContainer[SecondaryView]->view()->selectedUrls().count();
 230     }
 231
 232     QAction* compareFilesAction = actionCollection()->action("compare_files");
 233     if (selectedUrlsCount == 2) {
 234         const bool kompareInstalled = !KGlobal::dirs()->findExe("kompare").isEmpty();
 235         compareFilesAction->setEnabled(selectedUrlsCount == 2 && kompareInstalled);
 236     } else {
 237         compareFilesAction->setEnabled(false);
 238     }
 239
 240     m_activeViewContainer->updateStatusBar();
 241
 242     emit selectionChanged(selection);
 243 }
 244
 245 void DolphinMainWindow::slotRequestItemInfo(const KFileItem& item)
 246 {
 247     emit requestItemInfo(item);
 248 }
 249
 250 void DolphinMainWindow::slotHistoryChanged()
 251 {
 252     updateHistory();
 253 }
 254
 255 void DolphinMainWindow::updateFilterBarAction(bool show)
 256 {
 257     QAction* showFilterBarAction = actionCollection()->action("show_filter_bar");
 258     showFilterBarAction->setChecked(show);
 259 }
 260
 261 void DolphinMainWindow::openNewMainWindow()
 262 {
 263     DolphinApplication::app()->createMainWindow()->show();
 264 }
 265
 266 void DolphinMainWindow::toggleActiveView()
 267 {
 268     if (m_viewContainer[SecondaryView] == 0) {
 269         // only one view is available
 270         return;
 271     }
 272
 273     Q_ASSERT(m_activeViewContainer != 0);
 274     Q_ASSERT(m_viewContainer[PrimaryView] != 0);
 275
 276     DolphinViewContainer* left  = m_viewContainer[PrimaryView];
 277     DolphinViewContainer* right = m_viewContainer[SecondaryView];
 278     setActiveViewContainer(m_activeViewContainer == right ? left : right);
 279 }
 280
 281 void DolphinMainWindow::closeEvent(QCloseEvent* event)
 282 {
 283     DolphinSettings& settings = DolphinSettings::instance();
 284     GeneralSettings* generalSettings = settings.generalSettings();
 285     generalSettings->setFirstRun(false);
 286
 287     settings.save();
 288
 289     KXmlGuiWindow::closeEvent(event);
 290 }
 291
 292 void DolphinMainWindow::saveProperties(KConfigGroup& group)
 293 {
 294     DolphinViewContainer* cont = m_viewContainer[PrimaryView];
 295     group.writeEntry("Primary Url", cont->url().url());
 296     group.writeEntry("Primary Editable Url", cont->isUrlEditable());
 297
 298     cont = m_viewContainer[SecondaryView];
 299     if (cont != 0) {
 300         group.writeEntry("Secondary Url", cont->url().url());
 301         group.writeEntry("Secondary Editable Url", cont->isUrlEditable());
 302     }
 303 }
 304
 305 void DolphinMainWindow::readProperties(const KConfigGroup& group)
 306 {
 307     DolphinViewContainer* cont = m_viewContainer[PrimaryView];
 308
 309     cont->setUrl(group.readEntry("Primary Url"));
 310     bool editable = group.readEntry("Primary Editable Url", false);
 311     cont->urlNavigator()->setUrlEditable(editable);
 312
 313     cont = m_viewContainer[SecondaryView];
 314     const QString secondaryUrl = group.readEntry("Secondary Url");
 315     if (!secondaryUrl.isEmpty()) {
 316         if (cont == 0) {
 317             // a secondary view should be shown, but no one is available
 318             // currently -> create a new view
 319             toggleSplitView();
 320             cont = m_viewContainer[SecondaryView];
 321             Q_ASSERT(cont != 0);
 322         }
 323
 324         cont->setUrl(secondaryUrl);
 325         bool editable = group.readEntry("Secondary Editable Url", false);
 326         cont->urlNavigator()->setUrlEditable(editable);
 327     } else if (cont != 0) {
 328         // no secondary view should be shown, but the default setting shows
 329         // one already -> close the view
 330         toggleSplitView();
 331     }
 332 }
 333
 334 void DolphinMainWindow::updateNewMenu()
 335 {
 336     m_newMenu->slotCheckUpToDate();
 337     m_newMenu->setPopupFiles(activeViewContainer()->url());
 338 }
 339
 340 void DolphinMainWindow::properties()
 341 {
 342     const KFileItemList list = m_activeViewContainer->view()->selectedItems();
 343
 344     KPropertiesDialog *dialog = new KPropertiesDialog(list, this);
 345     dialog->setAttribute(Qt::WA_DeleteOnClose);
 346     dialog->show();
 347     dialog->raise();
 348     dialog->activateWindow();
 349 }
 350
 351 void DolphinMainWindow::quit()
 352 {
 353     close();
 354 }
 355
 356 void DolphinMainWindow::slotHandlePlacesError(const QString &message)
 357 {
 358     if (!message.isEmpty()) {
 359         DolphinStatusBar* statusBar = m_activeViewContainer->statusBar();
 360         statusBar->setMessage(message, DolphinStatusBar::Error);
 361     }
 362 }
 363
 364 void DolphinMainWindow::slotUndoAvailable(bool available)
 365 {
 366     QAction* undoAction = actionCollection()->action(KStandardAction::stdName(KStandardAction::Undo));
 367     if (undoAction != 0) {
 368         undoAction->setEnabled(available);
 369     }
 370
 371     if (available && (m_undoCommandTypes.count() > 0)) {
 372         const KonqFileUndoManager::CommandType command = m_undoCommandTypes.takeFirst();
 373         DolphinStatusBar* statusBar = m_activeViewContainer->statusBar();
 374         switch (command) {
 375         case KonqFileUndoManager::COPY:
 376             statusBar->setMessage(i18nc("@info:status", "Copy operation completed."),
 377                                   DolphinStatusBar::OperationCompleted);
 378             break;
 379         case KonqFileUndoManager::MOVE:
 380             statusBar->setMessage(i18nc("@info:status", "Move operation completed."),
 381                                   DolphinStatusBar::OperationCompleted);
 382             break;
 383         case KonqFileUndoManager::LINK:
 384             statusBar->setMessage(i18nc("@info:status", "Link operation completed."),
 385                                   DolphinStatusBar::OperationCompleted);
 386             break;
 387         case KonqFileUndoManager::TRASH:
 388             statusBar->setMessage(i18nc("@info:status", "Move to trash operation completed."),
 389                                   DolphinStatusBar::OperationCompleted);
 390             break;
 391         case KonqFileUndoManager::RENAME:
 392             statusBar->setMessage(i18nc("@info:status", "Renaming operation completed."),
 393                                   DolphinStatusBar::OperationCompleted);
 394             break;
 395
 396         case KonqFileUndoManager::MKDIR:
 397             statusBar->setMessage(i18nc("@info:status", "Created folder."),
 398                                   DolphinStatusBar::OperationCompleted);
 399             break;
 400
 401         default:
 402             break;
 403         }
 404
 405     }
 406 }
 407
 408 void DolphinMainWindow::slotUndoTextChanged(const QString& text)
 409 {
 410     QAction* undoAction = actionCollection()->action(KStandardAction::stdName(KStandardAction::Undo));
 411     if (undoAction != 0) {
 412         undoAction->setText(text);
 413     }
 414 }
 415
 416 void DolphinMainWindow::undo()
 417 {
 418     clearStatusBar();
 419     KonqFileUndoManager::self()->undo();
 420 }
 421
 422 void DolphinMainWindow::cut()
 423 {
 424     m_activeViewContainer->view()->cutSelectedItems();
 425 }
 426
 427 void DolphinMainWindow::copy()
 428 {
 429     m_activeViewContainer->view()->copySelectedItems();
 430 }
 431
 432 void DolphinMainWindow::paste()
 433 {
 434     m_activeViewContainer->view()->paste();
 435 }
 436
 437 void DolphinMainWindow::updatePasteAction()
 438 {
 439     QAction* pasteAction = actionCollection()->action(KStandardAction::stdName(KStandardAction::Paste));
 440     if (pasteAction == 0) {
 441         return;
 442     }
 443
 444     QPair<bool, QString> pasteInfo = m_activeViewContainer->view()->pasteInfo();
 445     pasteAction->setEnabled(pasteInfo.first);
 446     pasteAction->setText(pasteInfo.second);
 447 }
 448
 449 void DolphinMainWindow::selectAll()
 450 {
 451     clearStatusBar();
 452
 453     // if the URL navigator is editable and focused, select the whole
 454     // URL instead of all items of the view
 455
 456     KUrlNavigator* urlNavigator = m_activeViewContainer->urlNavigator();
 457     QLineEdit* lineEdit = urlNavigator->editor()->lineEdit();
 458     const bool selectUrl = urlNavigator->isUrlEditable() &&
 459                            lineEdit->hasFocus();
 460     if (selectUrl) {
 461         lineEdit->selectAll();
 462     } else {
 463         m_activeViewContainer->view()->selectAll();
 464     }
 465 }
 466
 467 void DolphinMainWindow::invertSelection()
 468 {
 469     clearStatusBar();
 470     m_activeViewContainer->view()->invertSelection();
 471 }
 472
 473 void DolphinMainWindow::sortByName()
 474 {
 475     m_activeViewContainer->view()->setSorting(DolphinView::SortByName);
 476 }
 477
 478 void DolphinMainWindow::sortBySize()
 479 {
 480     m_activeViewContainer->view()->setSorting(DolphinView::SortBySize);
 481 }
 482
 483 void DolphinMainWindow::sortByDate()
 484 {
 485     m_activeViewContainer->view()->setSorting(DolphinView::SortByDate);
 486 }
 487
 488 void DolphinMainWindow::sortByPermissions()
 489 {
 490     m_activeViewContainer->view()->setSorting(DolphinView::SortByPermissions);
 491 }
 492
 493 void DolphinMainWindow::sortByOwner()
 494 {
 495     m_activeViewContainer->view()->setSorting(DolphinView::SortByOwner);
 496 }
 497
 498 void DolphinMainWindow::sortByGroup()
 499 {
 500     m_activeViewContainer->view()->setSorting(DolphinView::SortByGroup);
 501 }
 502
 503 void DolphinMainWindow::sortByType()
 504 {
 505     m_activeViewContainer->view()->setSorting(DolphinView::SortByType);
 506 }
 507
 508 void DolphinMainWindow::sortByRating()
 509 {
 510 #ifdef HAVE_NEPOMUK
 511     m_activeViewContainer->view()->setSorting(DolphinView::SortByRating);
 512 #endif
 513 }
 514
 515 void DolphinMainWindow::sortByTags()
 516 {
 517 #ifdef HAVE_NEPOMUK
 518     m_activeViewContainer->view()->setSorting(DolphinView::SortByTags);
 519 #endif
 520 }
 521
 522 void DolphinMainWindow::toggleSplitView()
 523 {
 524     if (m_viewContainer[SecondaryView] == 0) {
 525         // create a secondary view
 526         const int newWidth = (m_viewContainer[PrimaryView]->width() - m_splitter->handleWidth()) / 2;
 527
 528         const DolphinView* view = m_viewContainer[PrimaryView]->view();
 529         m_viewContainer[SecondaryView] = new DolphinViewContainer(this, 0, view->rootUrl());
 530         connectViewSignals(SecondaryView);
 531         m_splitter->addWidget(m_viewContainer[SecondaryView]);
 532         m_splitter->setSizes(QList<int>() << newWidth << newWidth);
 533         m_viewContainer[SecondaryView]->view()->reload();
 534         m_viewContainer[SecondaryView]->setActive(false);
 535         m_viewContainer[SecondaryView]->show();
 536     } else if (m_activeViewContainer == m_viewContainer[PrimaryView]) {
 537         // remove secondary view
 538         m_viewContainer[SecondaryView]->close();
 539         m_viewContainer[SecondaryView]->deleteLater();
 540         m_viewContainer[SecondaryView] = 0;
 541     } else {
 542         // The secondary view is active, hence from a users point of view
 543         // the content of the secondary view should be moved to the primary view.
 544         // From an implementation point of view it is more efficient to close
 545         // the primary view and exchange the internal pointers afterwards.
 546         m_viewContainer[PrimaryView]->close();
 547         m_viewContainer[PrimaryView]->deleteLater();
 548         m_viewContainer[PrimaryView] = m_viewContainer[SecondaryView];
 549         m_viewContainer[SecondaryView] = 0;
 550     }
 551
 552     setActiveViewContainer(m_viewContainer[PrimaryView]);
 553     updateViewActions();
 554     emit activeViewChanged(); // TODO unused; remove?
 555 }
 556
 557 void DolphinMainWindow::reloadView()
 558 {
 559     clearStatusBar();
 560     m_activeViewContainer->view()->reload();
 561 }
 562
 563 void DolphinMainWindow::stopLoading()
 564 {
 565 }
 566
 567 void DolphinMainWindow::toggleFilterBarVisibility(bool show)
 568 {
 569     m_activeViewContainer->showFilterBar(show);
 570 }
 571
 572 void DolphinMainWindow::toggleEditLocation()
 573 {
 574     clearStatusBar();
 575
 576     QAction* action = actionCollection()->action("editable_location");
 577     KUrlNavigator* urlNavigator = m_activeViewContainer->urlNavigator();
 578     urlNavigator->setUrlEditable(action->isChecked());
 579 }
 580
 581 void DolphinMainWindow::editLocation()
 582 {
 583     KUrlNavigator* navigator = m_activeViewContainer->urlNavigator();
 584     navigator->setUrlEditable(true);
 585     navigator->setFocus();
 586 }
 587
 588 void DolphinMainWindow::adjustViewProperties()
 589 {
 590     clearStatusBar();
 591     ViewPropertiesDialog dlg(m_activeViewContainer->view());
 592     dlg.exec();
 593 }
 594
 595 void DolphinMainWindow::goBack()
 596 {
 597     clearStatusBar();
 598     m_activeViewContainer->urlNavigator()->goBack();
 599 }
 600
 601 void DolphinMainWindow::goForward()
 602 {
 603     clearStatusBar();
 604     m_activeViewContainer->urlNavigator()->goForward();
 605 }
 606
 607 void DolphinMainWindow::goUp()
 608 {
 609     clearStatusBar();
 610     m_activeViewContainer->urlNavigator()->goUp();
 611 }
 612
 613 void DolphinMainWindow::goHome()
 614 {
 615     clearStatusBar();
 616     m_activeViewContainer->urlNavigator()->goHome();
 617 }
 618
 619 void DolphinMainWindow::findFile()
 620 {
 621     KRun::run("kfind", m_activeViewContainer->url(), this);
 622 }
 623
 624 void DolphinMainWindow::compareFiles()
 625 {
 626     // The method is only invoked if exactly 2 files have
 627     // been selected. The selected files may be:
 628     // - both in the primary view
 629     // - both in the secondary view
 630     // - one in the primary view and the other in the secondary
 631     //   view
 632     Q_ASSERT(m_viewContainer[PrimaryView] != 0);
 633
 634     KUrl urlA;
 635     KUrl urlB;
 636     KUrl::List urls = m_viewContainer[PrimaryView]->view()->selectedUrls();
 637
 638     switch (urls.count()) {
 639     case 0: {
 640         Q_ASSERT(m_viewContainer[SecondaryView] != 0);
 641         urls = m_viewContainer[SecondaryView]->view()->selectedUrls();
 642         Q_ASSERT(urls.count() == 2);
 643         urlA = urls[0];
 644         urlB = urls[1];
 645         break;
 646     }
 647
 648     case 1: {
 649         urlA = urls[0];
 650         Q_ASSERT(m_viewContainer[SecondaryView] != 0);
 651         urls = m_viewContainer[SecondaryView]->view()->selectedUrls();
 652         Q_ASSERT(urls.count() == 1);
 653         urlB = urls[0];
 654         break;
 655     }
 656
 657     case 2: {
 658         urlA = urls[0];
 659         urlB = urls[1];
 660         break;
 661     }
 662
 663     default: {
 664         // may not happen: compareFiles may only get invoked if 2
 665         // files are selected
 666         Q_ASSERT(false);
 667     }
 668     }
 669
 670     QString command("kompare -c \"");
 671     command.append(urlA.pathOrUrl());
 672     command.append("\" \"");
 673     command.append(urlB.pathOrUrl());
 674     command.append('\"');
 675     KRun::runCommand(command, "Kompare", "kompare", this);
 676
 677 }
 678
 679 void DolphinMainWindow::toggleShowMenuBar()
 680 {
 681     const bool visible = menuBar()->isVisible();
 682     menuBar()->setVisible(!visible);
 683 }
 684
 685 void DolphinMainWindow::editSettings()
 686 {
 687     DolphinSettingsDialog dialog(this);
 688     dialog.exec();
 689 }
 690
 691 void DolphinMainWindow::init()
 692 {
 693     // Check whether Dolphin runs the first time. If yes then
 694     // a proper default window size is given at the end of DolphinMainWindow::init().
 695     GeneralSettings* generalSettings = DolphinSettings::instance().generalSettings();
 696     const bool firstRun = generalSettings->firstRun();
 697     if (firstRun) {
 698         generalSettings->setViewPropsTimestamp(QDateTime::currentDateTime());
 699     }
 700
 701     setAcceptDrops(true);
 702
 703     m_splitter = new QSplitter(this);
 704
 705     DolphinSettings& settings = DolphinSettings::instance();
 706
 707     setupActions();
 708
 709     const KUrl& homeUrl = settings.generalSettings()->homeUrl();
 710     setCaption(homeUrl.fileName());
 711     m_actionHandler = new DolphinViewActionHandler(actionCollection(), this);
 712     connect(m_actionHandler, SIGNAL(actionBeingHandled()), SLOT(clearStatusBar()));
 713     ViewProperties props(homeUrl);
 714     m_viewContainer[PrimaryView] = new DolphinViewContainer(this,
 715                                                             m_splitter,
 716                                                             homeUrl);
 717
 718     m_activeViewContainer = m_viewContainer[PrimaryView];
 719     connectViewSignals(PrimaryView);
 720     DolphinView* view = m_viewContainer[PrimaryView]->view();
 721     view->reload();
 722     m_viewContainer[PrimaryView]->show();
 723     m_actionHandler->setCurrentView(view);
 724
 725     setCentralWidget(m_splitter);
 726     setupDockWidgets();
 727
 728     setupGUI(Keys | Save | Create | ToolBar);
 729     createGUI();
 730
 731     stateChanged("new_file");
 732     setAutoSaveSettings();
 733
 734     QClipboard* clipboard = QApplication::clipboard();
 735     connect(clipboard, SIGNAL(dataChanged()),
 736             this, SLOT(updatePasteAction()));
 737     updatePasteAction();
 738     updateGoActions();
 739
 740     if (generalSettings->splitView()) {
 741         toggleSplitView();
 742     }
 743     updateViewActions();
 744
 745     if (firstRun) {
 746         // assure a proper default size if Dolphin runs the first time
 747         resize(700, 500);
 748     }
 749
 750     emit urlChanged(homeUrl);
 751 }
 752
 753 void DolphinMainWindow::setActiveViewContainer(DolphinViewContainer* viewContainer)
 754 {
 755     Q_ASSERT(viewContainer != 0);
 756     Q_ASSERT((viewContainer == m_viewContainer[PrimaryView]) || (viewContainer == m_viewContainer[SecondaryView]));
 757     if (m_activeViewContainer == viewContainer) {
 758         return;
 759     }
 760
 761     m_activeViewContainer->setActive(false);
 762     m_activeViewContainer = viewContainer;
 763     m_activeViewContainer->setActive(true);
 764
 765     updateHistory();
 766     updateEditActions();
 767     updateViewActions();
 768     updateGoActions();
 769
 770     const KUrl& url = m_activeViewContainer->url();
 771     setCaption(url.fileName());
 772
 773     m_actionHandler->setCurrentView(viewContainer->view());
 774
 775     emit activeViewChanged(); // TODO unused; remove?
 776     emit urlChanged(url);
 777 }
 778
 779 void DolphinMainWindow::setupActions()
 780 {
 781     // setup 'File' menu
 782     m_newMenu = new DolphinNewMenu(this);
 783     KMenu* menu = m_newMenu->menu();
 784     menu->setTitle(i18nc("@title:menu", "Create New"));
 785     menu->setIcon(KIcon("document-new"));
 786     connect(menu, SIGNAL(aboutToShow()),
 787             this, SLOT(updateNewMenu()));
 788
 789     KAction* newWindow = actionCollection()->addAction("new_window");
 790     newWindow->setIcon(KIcon("window-new"));
 791     newWindow->setText(i18nc("@action:inmenu File", "New &Window"));
 792     newWindow->setShortcut(Qt::CTRL | Qt::Key_N);
 793     connect(newWindow, SIGNAL(triggered()), this, SLOT(openNewMainWindow()));
 794
 795     KAction* properties = actionCollection()->addAction("properties");
 796     properties->setText(i18nc("@action:inmenu File", "Properties"));
 797     properties->setShortcut(Qt::ALT | Qt::Key_Return);
 798     connect(properties, SIGNAL(triggered()), this, SLOT(properties()));
 799
 800     KStandardAction::quit(this, SLOT(quit()), actionCollection());
 801
 802     // setup 'Edit' menu
 803     KStandardAction::undo(this,
 804                           SLOT(undo()),
 805                           actionCollection());
 806
 807     //Need to remove shift+del from cut action, else the shortcut for deletejob
 808     //doesn't work
 809     KAction* cut = KStandardAction::cut(this, SLOT(cut()), actionCollection());
 810     KShortcut cutShortcut = cut->shortcut();
 811     cutShortcut.remove(Qt::SHIFT + Qt::Key_Delete, KShortcut::KeepEmpty);
 812     cut->setShortcut(cutShortcut);
 813     KStandardAction::copy(this, SLOT(copy()), actionCollection());
 814     KStandardAction::paste(this, SLOT(paste()), actionCollection());
 815
 816     KAction* selectAll = actionCollection()->addAction("select_all");
 817     selectAll->setText(i18nc("@action:inmenu Edit", "Select All"));
 818     selectAll->setShortcut(Qt::CTRL + Qt::Key_A);
 819     connect(selectAll, SIGNAL(triggered()), this, SLOT(selectAll()));
 820
 821     KAction* invertSelection = actionCollection()->addAction("invert_selection");
 822     invertSelection->setText(i18nc("@action:inmenu Edit", "Invert Selection"));
 823     invertSelection->setShortcut(Qt::CTRL | Qt::SHIFT | Qt::Key_A);
 824     connect(invertSelection, SIGNAL(triggered()), this, SLOT(invertSelection()));
 825
 826     // setup 'View' menu
 827
 828     //TODO
 829     //QActionGroup* sortActionGroup = DolphinView::createSortActionGroup(actionCollection());
 830     //connect(sortActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(sortActionGroupTriggered(QAction*)));
 831
 832     KToggleAction* sortByName = actionCollection()->add<KToggleAction>("sort_by_name");
 833     sortByName->setText(i18nc("@action:inmenu Sort By", "Name"));
 834     connect(sortByName, SIGNAL(triggered()), this, SLOT(sortByName()));
 835
 836     KToggleAction* sortBySize = actionCollection()->add<KToggleAction>("sort_by_size");
 837     sortBySize->setText(i18nc("@action:inmenu Sort By", "Size"));
 838     connect(sortBySize, SIGNAL(triggered()), this, SLOT(sortBySize()));
 839
 840     KToggleAction* sortByDate = actionCollection()->add<KToggleAction>("sort_by_date");
 841     sortByDate->setText(i18nc("@action:inmenu Sort By", "Date"));
 842     connect(sortByDate, SIGNAL(triggered()), this, SLOT(sortByDate()));
 843
 844     KToggleAction* sortByPermissions = actionCollection()->add<KToggleAction>("sort_by_permissions");
 845     sortByPermissions->setText(i18nc("@action:inmenu Sort By", "Permissions"));
 846     connect(sortByPermissions, SIGNAL(triggered()), this, SLOT(sortByPermissions()));
 847
 848     KToggleAction* sortByOwner = actionCollection()->add<KToggleAction>("sort_by_owner");
 849     sortByOwner->setText(i18nc("@action:inmenu Sort By", "Owner"));
 850     connect(sortByOwner, SIGNAL(triggered()), this, SLOT(sortByOwner()));
 851
 852     KToggleAction* sortByGroup = actionCollection()->add<KToggleAction>("sort_by_group");
 853     sortByGroup->setText(i18nc("@action:inmenu Sort By", "Group"));
 854     connect(sortByGroup, SIGNAL(triggered()), this, SLOT(sortByGroup()));
 855
 856     KToggleAction* sortByType = actionCollection()->add<KToggleAction>("sort_by_type");
 857     sortByType->setText(i18nc("@action:inmenu Sort By", "Type"));
 858     connect(sortByType, SIGNAL(triggered()), this, SLOT(sortByType()));
 859
 860     // TODO: Hided "sort by rating" and "sort by tags" as without caching the performance
 861     // is too slow currently (Nepomuk will support caching in future releases).
 862     //
 863     // KToggleAction* sortByRating = actionCollection()->add<KToggleAction>("sort_by_rating");
 864     // sortByRating->setText(i18nc("@action:inmenu Sort By", "Rating"));
 865     //
 866     // KToggleAction* sortByTags = actionCollection()->add<KToggleAction>("sort_by_tags");
 867     // sortByTags->setText(i18nc("@action:inmenu Sort By", "Tags"));
 868     //
 869 #ifdef HAVE_NEPOMUK
 870     // if (MetaDataWidget::metaDataAvailable()) {
 871     //     connect(sortByRating, SIGNAL(triggered()), this, SLOT(sortByRating()));
 872     //     connect(sortByTags, SIGNAL(triggered()), this, SLOT(sortByTags()));
 873     // }
 874     // else {
 875     //     sortByRating->setEnabled(false);
 876     //     sortByTags->setEnabled(false);
 877     // }
 878 #else
 879     // sortByRating->setEnabled(false);
 880     // sortByTags->setEnabled(false);
 881 #endif
 882
 883     QActionGroup* sortGroup = new QActionGroup(this);
 884     sortGroup->addAction(sortByName);
 885     sortGroup->addAction(sortBySize);
 886     sortGroup->addAction(sortByDate);
 887     sortGroup->addAction(sortByPermissions);
 888     sortGroup->addAction(sortByOwner);
 889     sortGroup->addAction(sortByGroup);
 890     sortGroup->addAction(sortByType);
 891
 892     // TODO: Hided "sort by rating" and "sort by tags" as without caching the performance
 893     // is too slow currently (Nepomuk will support caching in future releases).
 894     //sortGroup->addAction(sortByRating);
 895     //sortGroup->addAction(sortByTags);
 896
 897     KAction* split = actionCollection()->addAction("split_view");
 898     split->setShortcut(Qt::Key_F3);
 899     updateSplitAction();
 900     connect(split, SIGNAL(triggered()), this, SLOT(toggleSplitView()));
 901
 902     KAction* reload = actionCollection()->addAction("reload");
 903     reload->setText(i18nc("@action:inmenu View", "Reload"));
 904     reload->setShortcut(Qt::Key_F5);
 905     reload->setIcon(KIcon("view-refresh"));
 906     connect(reload, SIGNAL(triggered()), this, SLOT(reloadView()));
 907
 908     KAction* stop = actionCollection()->addAction("stop");
 909     stop->setText(i18nc("@action:inmenu View", "Stop"));
 910     stop->setIcon(KIcon("process-stop"));
 911     connect(stop, SIGNAL(triggered()), this, SLOT(stopLoading()));
 912
 913     // TODO: the URL navigator must emit a signal if the editable state has been
 914     // changed, so that the corresponding showFullLocation action is updated. Also
 915     // the naming "Show full Location" is currently confusing...
 916     KToggleAction* showFullLocation = actionCollection()->add<KToggleAction>("editable_location");
 917     showFullLocation->setText(i18nc("@action:inmenu Navigation Bar", "Show Full Location"));
 918     showFullLocation->setShortcut(Qt::CTRL | Qt::Key_L);
 919     connect(showFullLocation, SIGNAL(triggered()), this, SLOT(toggleEditLocation()));
 920
 921     KAction* editLocation = actionCollection()->addAction("edit_location");
 922     editLocation->setText(i18nc("@action:inmenu Navigation Bar", "Edit Location"));
 923     editLocation->setShortcut(Qt::Key_F6);
 924     connect(editLocation, SIGNAL(triggered()), this, SLOT(editLocation()));
 925
 926     KAction* adjustViewProps = actionCollection()->addAction("view_properties");
 927     adjustViewProps->setText(i18nc("@action:inmenu View", "Adjust View Properties..."));
 928     connect(adjustViewProps, SIGNAL(triggered()), this, SLOT(adjustViewProperties()));
 929
 930     // setup 'Go' menu
 931     KAction* backAction = KStandardAction::back(this, SLOT(goBack()), actionCollection());
 932     KShortcut backShortcut = backAction->shortcut();
 933     backShortcut.setAlternate(Qt::Key_Backspace);
 934     backAction->setShortcut(backShortcut);
 935
 936     KStandardAction::forward(this, SLOT(goForward()), actionCollection());
 937     KStandardAction::up(this, SLOT(goUp()), actionCollection());
 938     KStandardAction::home(this, SLOT(goHome()), actionCollection());
 939
 940     // setup 'Tools' menu
 941     QAction* findFile = actionCollection()->addAction("find_file");
 942     findFile->setText(i18nc("@action:inmenu Tools", "Find File..."));
 943     findFile->setShortcut(Qt::CTRL | Qt::Key_F);
 944     findFile->setIcon(KIcon("edit-find"));
 945     connect(findFile, SIGNAL(triggered()), this, SLOT(findFile()));
 946
 947     KToggleAction* showFilterBar = actionCollection()->add<KToggleAction>("show_filter_bar");
 948     showFilterBar->setText(i18nc("@action:inmenu Tools", "Show Filter Bar"));
 949     showFilterBar->setShortcut(Qt::CTRL | Qt::Key_I);
 950     connect(showFilterBar, SIGNAL(triggered(bool)), this, SLOT(toggleFilterBarVisibility(bool)));
 951
 952     KAction* compareFiles = actionCollection()->addAction("compare_files");
 953     compareFiles->setText(i18nc("@action:inmenu Tools", "Compare Files"));
 954     compareFiles->setIcon(KIcon("kompare"));
 955     compareFiles->setEnabled(false);
 956     connect(compareFiles, SIGNAL(triggered()), this, SLOT(compareFiles()));
 957
 958     // setup 'Settings' menu
 959     m_showMenuBar = KStandardAction::showMenubar(this, SLOT(toggleShowMenuBar()), actionCollection());
 960     KStandardAction::preferences(this, SLOT(editSettings()), actionCollection());
 961 }
 962
 963 void DolphinMainWindow::setupDockWidgets()
 964 {
 965     // setup "Information"
 966     QDockWidget* infoDock = new QDockWidget(i18nc("@title:window", "Information"));
 967     infoDock->setObjectName("infoDock");
 968     infoDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
 969     SidebarPage* infoWidget = new InfoSidebarPage(infoDock);
 970     infoDock->setWidget(infoWidget);
 971
 972     infoDock->toggleViewAction()->setText(i18nc("@title:window", "Information"));
 973     infoDock->toggleViewAction()->setShortcut(Qt::Key_F11);
 974     actionCollection()->addAction("show_info_panel", infoDock->toggleViewAction());
 975
 976     addDockWidget(Qt::RightDockWidgetArea, infoDock);
 977     connect(this, SIGNAL(urlChanged(KUrl)),
 978             infoWidget, SLOT(setUrl(KUrl)));
 979     connect(this, SIGNAL(selectionChanged(KFileItemList)),
 980             infoWidget, SLOT(setSelection(KFileItemList)));
 981     connect(this, SIGNAL(requestItemInfo(KFileItem)),
 982             infoWidget, SLOT(requestDelayedItemInfo(KFileItem)));
 983
 984     // setup "Tree View"
 985     QDockWidget* treeViewDock = new QDockWidget(i18nc("@title:window", "Folders"));
 986     treeViewDock->setObjectName("treeViewDock");
 987     treeViewDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
 988     TreeViewSidebarPage* treeWidget = new TreeViewSidebarPage(treeViewDock);
 989     treeViewDock->setWidget(treeWidget);
 990
 991     treeViewDock->toggleViewAction()->setText(i18nc("@title:window", "Folders"));
 992     treeViewDock->toggleViewAction()->setShortcut(Qt::Key_F7);
 993     actionCollection()->addAction("show_folders_panel", treeViewDock->toggleViewAction());
 994
 995     addDockWidget(Qt::LeftDockWidgetArea, treeViewDock);
 996     connect(this, SIGNAL(urlChanged(KUrl)),
 997             treeWidget, SLOT(setUrl(KUrl)));
 998     connect(treeWidget, SIGNAL(changeUrl(KUrl)),
 999             this, SLOT(changeUrl(KUrl)));
1000     connect(treeWidget, SIGNAL(changeSelection(KFileItemList)),
1001             this, SLOT(changeSelection(KFileItemList)));
1002     connect(treeWidget, SIGNAL(urlsDropped(KUrl::List, KUrl)),
1003             this, SLOT(dropUrls(KUrl::List, KUrl)));
1004
1005     // setup "Terminal"
1006     QDockWidget* terminalDock = new QDockWidget(i18nc("@title:window", "Terminal"));
1007     terminalDock->setObjectName("terminalDock");
1008     terminalDock->setAllowedAreas(Qt::TopDockWidgetArea | Qt::BottomDockWidgetArea);
1009     SidebarPage* terminalWidget = new TerminalSidebarPage(terminalDock);
1010     terminalDock->setWidget(terminalWidget);
1011
1012     connect(terminalWidget, SIGNAL(hideTerminalSidebarPage()), terminalDock, SLOT(hide()));
1013
1014     terminalDock->toggleViewAction()->setText(i18nc("@title:window", "Terminal"));
1015     terminalDock->toggleViewAction()->setShortcut(Qt::Key_F4);
1016     actionCollection()->addAction("show_terminal_panel", terminalDock->toggleViewAction());
1017
1018     addDockWidget(Qt::BottomDockWidgetArea, terminalDock);
1019     connect(this, SIGNAL(urlChanged(KUrl)),
1020             terminalWidget, SLOT(setUrl(KUrl)));
1021
1022     const bool firstRun = DolphinSettings::instance().generalSettings()->firstRun();
1023     if (firstRun) {
1024         infoDock->hide();
1025         treeViewDock->hide();
1026         terminalDock->hide();
1027     }
1028
1029     QDockWidget* placesDock = new QDockWidget(i18nc("@title:window", "Places"));
1030     placesDock->setObjectName("placesDock");
1031     placesDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
1032     KFilePlacesView* placesView = new KFilePlacesView(placesDock);
1033     placesDock->setWidget(placesView);
1034     placesView->setModel(DolphinSettings::instance().placesModel());
1035     placesView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
1036
1037     placesDock->toggleViewAction()->setText(i18nc("@title:window", "Places"));
1038     placesDock->toggleViewAction()->setShortcut(Qt::Key_F9);
1039     actionCollection()->addAction("show_places_panel", placesDock->toggleViewAction());
1040
1041     addDockWidget(Qt::LeftDockWidgetArea, placesDock);
1042     connect(placesView, SIGNAL(urlChanged(KUrl)),
1043             this, SLOT(changeUrl(KUrl)));
1044     connect(this, SIGNAL(urlChanged(KUrl)),
1045             placesView, SLOT(setUrl(KUrl)));
1046 }
1047
1048 void DolphinMainWindow::updateHistory()
1049 {
1050     const KUrlNavigator* urlNavigator = m_activeViewContainer->urlNavigator();
1051     const int index = urlNavigator->historyIndex();
1052
1053     QAction* backAction = actionCollection()->action("go_back");
1054     if (backAction != 0) {
1055         backAction->setEnabled(index < urlNavigator->historySize() - 1);
1056     }
1057
1058     QAction* forwardAction = actionCollection()->action("go_forward");
1059     if (forwardAction != 0) {
1060         forwardAction->setEnabled(index > 0);
1061     }
1062 }
1063
1064 void DolphinMainWindow::updateEditActions()
1065 {
1066     const KFileItemList list = m_activeViewContainer->view()->selectedItems();
1067     if (list.isEmpty()) {
1068         stateChanged("has_no_selection");
1069     } else {
1070         stateChanged("has_selection");
1071
1072         QAction* renameAction = actionCollection()->action("rename");
1073         if (renameAction != 0) {
1074             renameAction->setEnabled(true);
1075         }
1076
1077         bool enableMoveToTrash = true;
1078
1079         KFileItemList::const_iterator it = list.begin();
1080         const KFileItemList::const_iterator end = list.end();
1081         while (it != end) {
1082             const KUrl& url = (*it).url();
1083             // only enable the 'Move to Trash' action for local files
1084             if (!url.isLocalFile()) {
1085                 enableMoveToTrash = false;
1086             }
1087             ++it;
1088         }
1089
1090         QAction* moveToTrashAction = actionCollection()->action("move_to_trash");
1091         moveToTrashAction->setEnabled(enableMoveToTrash);
1092     }
1093     updatePasteAction();
1094 }
1095
1096 void DolphinMainWindow::updateViewActions()
1097 {
1098     m_actionHandler->updateViewActions();
1099
1100     const DolphinView* view = m_activeViewContainer->view();
1101     slotSortingChanged(view->sorting());
1102
1103     QAction* showFilterBarAction = actionCollection()->action("show_filter_bar");
1104     showFilterBarAction->setChecked(m_activeViewContainer->isFilterBarVisible());
1105
1106     updateSplitAction();
1107
1108     QAction* editableLocactionAction = actionCollection()->action("editable_location");
1109     const KUrlNavigator* urlNavigator = m_activeViewContainer->urlNavigator();
1110     editableLocactionAction->setChecked(urlNavigator->isUrlEditable());
1111 }
1112
1113 void DolphinMainWindow::updateGoActions()
1114 {
1115     QAction* goUpAction = actionCollection()->action(KStandardAction::stdName(KStandardAction::Up));
1116     const KUrl& currentUrl = m_activeViewContainer->url();
1117     goUpAction->setEnabled(currentUrl.upUrl() != currentUrl);
1118 }
1119
1120 void DolphinMainWindow::clearStatusBar()
1121 {
1122     m_activeViewContainer->statusBar()->clear();
1123 }
1124
1125 void DolphinMainWindow::connectViewSignals(int viewIndex)
1126 {
1127     DolphinViewContainer* container = m_viewContainer[viewIndex];
1128     connect(container, SIGNAL(showFilterBarChanged(bool)),
1129             this, SLOT(updateFilterBarAction(bool)));
1130
1131     DolphinView* view = container->view();
1132     connect(view, SIGNAL(sortingChanged(DolphinView::Sorting)),
1133             this, SLOT(slotSortingChanged(DolphinView::Sorting)));
1134     connect(view, SIGNAL(selectionChanged(KFileItemList)),
1135             this, SLOT(slotSelectionChanged(KFileItemList)));
1136     connect(view, SIGNAL(requestItemInfo(KFileItem)),
1137             this, SLOT(slotRequestItemInfo(KFileItem)));
1138     connect(view, SIGNAL(activated()),
1139             this, SLOT(toggleActiveView()));
1140     connect(view, SIGNAL(doingOperation(KonqFileUndoManager::CommandType)),
1141             this, SLOT(slotDoingOperation(KonqFileUndoManager::CommandType)));
1142
1143     const KUrlNavigator* navigator = container->urlNavigator();
1144     connect(navigator, SIGNAL(urlChanged(const KUrl&)),
1145             this, SLOT(changeUrl(const KUrl&)));
1146     connect(navigator, SIGNAL(historyChanged()),
1147             this, SLOT(slotHistoryChanged()));
1148 }
1149
1150 void DolphinMainWindow::updateSplitAction()
1151 {
1152     QAction* splitAction = actionCollection()->action("split_view");
1153     if (m_viewContainer[SecondaryView] != 0) {
1154         if (m_activeViewContainer == m_viewContainer[PrimaryView]) {
1155             splitAction->setText(i18nc("@action:intoolbar Close right view", "Close"));
1156             splitAction->setIcon(KIcon("view-right-close"));
1157         } else {
1158             splitAction->setText(i18nc("@action:intoolbar Close left view", "Close"));
1159             splitAction->setIcon(KIcon("view-left-close"));
1160         }
1161     } else {
1162         splitAction->setText(i18nc("@action:intoolbar Split view", "Split"));
1163         splitAction->setIcon(KIcon("view-right-new"));
1164     }
1165 }
1166
1167 DolphinMainWindow::UndoUiInterface::UndoUiInterface(DolphinMainWindow* mainWin) :
1168     KonqFileUndoManager::UiInterface(mainWin),
1169     m_mainWin(mainWin)
1170 {
1171     Q_ASSERT(m_mainWin != 0);
1172 }
1173
1174 DolphinMainWindow::UndoUiInterface::~UndoUiInterface()
1175 {
1176 }
1177
1178 void DolphinMainWindow::UndoUiInterface::jobError(KIO::Job* job)
1179 {
1180     DolphinStatusBar* statusBar = m_mainWin->activeViewContainer()->statusBar();
1181     statusBar->setMessage(job->errorString(), DolphinStatusBar::Error);
1182 }
1183
1184 #include "dolphinmainwindow.moc"