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 "dolphindropcontroller.h"
  24
  25 #include <config-nepomuk.h>
  26
  27 #include "dolphinapplication.h"
  28 #include "dolphinnewmenu.h"
  29 #include "dolphinsettings.h"
  30 #include "dolphinsettingsdialog.h"
  31 #include "dolphinstatusbar.h"
  32 #include "dolphinviewcontainer.h"
  33 #include "infosidebarpage.h"
  34 #include "metadatawidget.h"
  35 #include "mainwindowadaptor.h"
  36 #include "terminalsidebarpage.h"
  37 #include "treeviewsidebarpage.h"
  38 #include "kurlnavigator.h"
  39 #include "viewpropertiesdialog.h"
  40 #include "viewproperties.h"
  41 #include "kfileplacesmodel.h"
  42 #include "kfileplacesview.h"
  43
  44 #include "dolphin_generalsettings.h"
  45 #include "dolphin_iconsmodesettings.h"
  46
  47 #include <kaction.h>
  48 #include <kactioncollection.h>
  49 #include <kconfig.h>
  50 #include <kdesktopfile.h>
  51 #include <kdeversion.h>
  52 #include <kfiledialog.h>
  53 #include <kglobal.h>
  54 #include <kicon.h>
  55 #include <kiconloader.h>
  56 #include <kio/netaccess.h>
  57 #include <kinputdialog.h>
  58 #include <klocale.h>
  59 #include <kmenu.h>
  60 #include <kmenubar.h>
  61 #include <kmessagebox.h>
  62 #include <konqmimedata.h>
  63 #include <kpropertiesdialog.h>
  64 #include <kprotocolinfo.h>
  65 #include <ktoggleaction.h>
  66 #include <krun.h>
  67 #include <kshell.h>
  68 #include <kstandarddirs.h>
  69 #include <kstatusbar.h>
  70 #include <kstandardaction.h>
  71 #include <kurl.h>
  72 #include <kurlcombobox.h>
  73
  74 #include <QKeyEvent>
  75 #include <QClipboard>
  76 #include <QLineEdit>
  77 #include <QSplitter>
  78 #include <QDockWidget>
  79
  80 DolphinMainWindow::DolphinMainWindow(int id) :
  81     KXmlGuiWindow(0),
  82     m_newMenu(0),
  83     m_showMenuBar(0),
  84     m_splitter(0),
  85     m_activeViewContainer(0),
  86     m_id(id)
  87 {
  88     setObjectName("Dolphin");
  89     m_viewContainer[PrimaryView] = 0;
  90     m_viewContainer[SecondaryView] = 0;
  91
  92     new MainWindowAdaptor(this);
  93     QDBusConnection::sessionBus().registerObject(QString("/dolphin/MainWindow%1").arg(m_id), this);
  94
  95     KonqFileUndoManager::incRef();
  96
  97     KonqFileUndoManager* undoManager = KonqFileUndoManager::self();
  98     undoManager->setUiInterface(new UndoUiInterface(this));
  99
 100     connect(undoManager, SIGNAL(undoAvailable(bool)),
 101             this, SLOT(slotUndoAvailable(bool)));
 102     connect(undoManager, SIGNAL(undoTextChanged(const QString&)),
 103             this, SLOT(slotUndoTextChanged(const QString&)));
 104     connect(DolphinSettings::instance().placesModel(), SIGNAL(errorMessage(const QString&)),
 105             this, SLOT(slotHandlePlacesError(const QString&)));
 106 }
 107
 108 DolphinMainWindow::~DolphinMainWindow()
 109 {
 110     KonqFileUndoManager::decRef();
 111     DolphinApplication::app()->removeMainWindow(this);
 112 }
 113
 114 void DolphinMainWindow::toggleViews()
 115 {
 116     if (m_viewContainer[SecondaryView] == 0) {
 117         return;
 118     }
 119
 120     // move secondary view from the last position of the splitter
 121     // to the first position
 122     m_splitter->insertWidget(0, m_viewContainer[SecondaryView]);
 123
 124     DolphinViewContainer* container = m_viewContainer[PrimaryView];
 125     m_viewContainer[PrimaryView] = m_viewContainer[SecondaryView];
 126     m_viewContainer[SecondaryView] = container;
 127 }
 128
 129 void DolphinMainWindow::slotDoingOperation(KonqFileUndoManager::CommandType commandType)
 130 {
 131     clearStatusBar();
 132     m_undoCommandTypes.append(commandType);
 133 }
 134
 135 void DolphinMainWindow::refreshViews()
 136 {
 137     Q_ASSERT(m_viewContainer[PrimaryView] != 0);
 138
 139     // remember the current active view, as because of
 140     // the refreshing the active view might change to
 141     // the secondary view
 142     DolphinViewContainer* activeViewContainer = m_activeViewContainer;
 143
 144     m_viewContainer[PrimaryView]->view()->refresh();
 145     if (m_viewContainer[SecondaryView] != 0) {
 146         m_viewContainer[SecondaryView]->view()->refresh();
 147     }
 148
 149     setActiveViewContainer(activeViewContainer);
 150 }
 151
 152 void DolphinMainWindow::dropUrls(const KUrl::List& urls,
 153                                  const KUrl& destination)
 154 {
 155     DolphinDropController dropController(this);
 156     connect(&dropController, SIGNAL(doingOperation(KonqFileUndoManager::CommandType)),
 157             this, SLOT(slotDoingOperation(KonqFileUndoManager::CommandType)));
 158     dropController.dropUrls(urls, destination);
 159 }
 160
 161 void DolphinMainWindow::changeUrl(const KUrl& url)
 162 {
 163     DolphinViewContainer* view = activeViewContainer();
 164     if (view != 0) {
 165         view->setUrl(url);
 166         updateEditActions();
 167         updateViewActions();
 168         updateGoActions();
 169         setCaption(url.fileName());
 170         emit urlChanged(url);
 171     }
 172 }
 173
 174 void DolphinMainWindow::changeSelection(const KFileItemList& selection)
 175 {
 176     activeViewContainer()->view()->changeSelection(selection);
 177 }
 178
 179 void DolphinMainWindow::slotViewModeChanged()
 180 {
 181     updateViewActions();
 182 }
 183
 184 void DolphinMainWindow::slotShowPreviewChanged()
 185 {
 186     // It is not enough to update the 'Show Preview' action, also
 187     // the 'Zoom In' and 'Zoom Out' actions must be adapted.
 188     updateViewActions();
 189 }
 190
 191 void DolphinMainWindow::slotShowHiddenFilesChanged()
 192 {
 193     KToggleAction* showHiddenFilesAction =
 194         static_cast<KToggleAction*>(actionCollection()->action("show_hidden_files"));
 195     const DolphinView* view = m_activeViewContainer->view();
 196     showHiddenFilesAction->setChecked(view->showHiddenFiles());
 197 }
 198
 199 void DolphinMainWindow::slotCategorizedSortingChanged()
 200 {
 201     KToggleAction* showInGroupsAction =
 202         static_cast<KToggleAction*>(actionCollection()->action("show_in_groups"));
 203     const DolphinView* view = m_activeViewContainer->view();
 204     showInGroupsAction->setChecked(view->categorizedSorting());
 205     showInGroupsAction->setEnabled(view->supportsCategorizedSorting());
 206 }
 207
 208 void DolphinMainWindow::slotSortingChanged(DolphinView::Sorting sorting)
 209 {
 210     QAction* action = 0;
 211     switch (sorting) {
 212     case DolphinView::SortByName:
 213         action = actionCollection()->action("sort_by_name");
 214         break;
 215     case DolphinView::SortBySize:
 216         action = actionCollection()->action("sort_by_size");
 217         break;
 218     case DolphinView::SortByDate:
 219         action = actionCollection()->action("sort_by_date");
 220         break;
 221     case DolphinView::SortByPermissions:
 222         action = actionCollection()->action("sort_by_permissions");
 223         break;
 224     case DolphinView::SortByOwner:
 225         action = actionCollection()->action("sort_by_owner");
 226         break;
 227     case DolphinView::SortByGroup:
 228         action = actionCollection()->action("sort_by_group");
 229         break;
 230     case DolphinView::SortByType:
 231         action = actionCollection()->action("sort_by_type");
 232         break;
 233 #ifdef HAVE_NEPOMUK
 234     case DolphinView::SortByRating:
 235         action = actionCollection()->action("sort_by_rating");
 236         break;
 237     case DolphinView::SortByTags:
 238         action = actionCollection()->action("sort_by_tags");
 239         break;
 240 #endif
 241     default:
 242         break;
 243     }
 244
 245     if (action != 0) {
 246         KToggleAction* toggleAction = static_cast<KToggleAction*>(action);
 247         toggleAction->setChecked(true);
 248     }
 249 }
 250
 251 void DolphinMainWindow::slotSortOrderChanged(Qt::SortOrder order)
 252 {
 253     KToggleAction* descending = static_cast<KToggleAction*>(actionCollection()->action("descending"));
 254     const bool sortDescending = (order == Qt::DescendingOrder);
 255     descending->setChecked(sortDescending);
 256 }
 257
 258 void DolphinMainWindow::slotAdditionalInfoChanged(KFileItemDelegate::InformationList list)
 259 {
 260     QAction* showSizeInfo = actionCollection()->action("show_size_info");
 261     QAction* showDateInfo = actionCollection()->action("show_date_info");
 262     QAction* showPermissionsInfo = actionCollection()->action("show_permissions_info");
 263     QAction* showOwnerInfo = actionCollection()->action("show_owner_info");
 264     QAction* showGroupInfo = actionCollection()->action("show_group_info");
 265     QAction* showMimeInfo = actionCollection()->action("show_mime_info");
 266
 267     showSizeInfo->setChecked(false);
 268     showDateInfo->setChecked(false);
 269     showPermissionsInfo->setChecked(false);
 270     showOwnerInfo->setChecked(false);
 271     showGroupInfo->setChecked(false);
 272     showMimeInfo->setChecked(false);
 273
 274     const DolphinView* view = m_activeViewContainer->view();
 275
 276     const IconsModeSettings* settings = DolphinSettings::instance().iconsModeSettings();
 277     const bool enable = (view->mode() == DolphinView::DetailsView) ||
 278                          ((view->mode() == DolphinView::IconsView) && settings->showAdditionalInfo());
 279
 280     showSizeInfo->setEnabled(enable);
 281     showDateInfo->setEnabled(enable);
 282     showPermissionsInfo->setEnabled(enable);
 283     showOwnerInfo->setEnabled(enable);
 284     showGroupInfo->setEnabled(enable);
 285     showMimeInfo->setEnabled(enable);
 286
 287     foreach (KFileItemDelegate::Information info, list) {
 288         switch (info) {
 289         case KFileItemDelegate::Size:
 290             showSizeInfo->setChecked(true);
 291             break;
 292         case KFileItemDelegate::ModificationTime:
 293             showDateInfo->setChecked(true);
 294             break;
 295         case KFileItemDelegate::Permissions:
 296             showPermissionsInfo->setChecked(true);
 297             break;
 298         case KFileItemDelegate::Owner:
 299             showOwnerInfo->setChecked(true);
 300             break;
 301         case KFileItemDelegate::OwnerAndGroup:
 302             showGroupInfo->setChecked(true);
 303             break;
 304         case KFileItemDelegate::FriendlyMimeType:
 305             showMimeInfo->setChecked(true);
 306             break;
 307         default:
 308             break;
 309         }
 310     }
 311 }
 312
 313 void DolphinMainWindow::slotSelectionChanged(const KFileItemList& selection)
 314 {
 315     updateEditActions();
 316
 317     Q_ASSERT(m_viewContainer[PrimaryView] != 0);
 318     int selectedUrlsCount = m_viewContainer[PrimaryView]->view()->selectedUrls().count();
 319     if (m_viewContainer[SecondaryView] != 0) {
 320         selectedUrlsCount += m_viewContainer[SecondaryView]->view()->selectedUrls().count();
 321     }
 322
 323     QAction* compareFilesAction = actionCollection()->action("compare_files");
 324     if (selectedUrlsCount == 2) {
 325         const bool kompareInstalled = !KGlobal::dirs()->findExe("kompare").isEmpty();
 326         compareFilesAction->setEnabled(selectedUrlsCount == 2 && kompareInstalled);
 327     } else {
 328         compareFilesAction->setEnabled(false);
 329     }
 330
 331     m_activeViewContainer->updateStatusBar();
 332
 333     emit selectionChanged(selection);
 334 }
 335
 336 void DolphinMainWindow::slotRequestItemInfo(const KFileItem& item)
 337 {
 338     emit requestItemInfo(item);
 339 }
 340
 341 void DolphinMainWindow::slotHistoryChanged()
 342 {
 343     updateHistory();
 344 }
 345
 346 void DolphinMainWindow::updateFilterBarAction(bool show)
 347 {
 348     KToggleAction* showFilterBarAction =
 349         static_cast<KToggleAction*>(actionCollection()->action("show_filter_bar"));
 350     showFilterBarAction->setChecked(show);
 351 }
 352
 353 void DolphinMainWindow::openNewMainWindow()
 354 {
 355     DolphinApplication::app()->createMainWindow()->show();
 356 }
 357
 358 void DolphinMainWindow::toggleActiveView()
 359 {
 360     if (m_viewContainer[SecondaryView] == 0) {
 361         // only one view is available
 362         return;
 363     }
 364
 365     Q_ASSERT(m_activeViewContainer != 0);
 366     Q_ASSERT(m_viewContainer[PrimaryView] != 0);
 367
 368     DolphinViewContainer* left  = m_viewContainer[PrimaryView];
 369     DolphinViewContainer* right = m_viewContainer[SecondaryView];
 370     setActiveViewContainer(m_activeViewContainer == right ? left : right);
 371 }
 372
 373 void DolphinMainWindow::closeEvent(QCloseEvent* event)
 374 {
 375     DolphinSettings& settings = DolphinSettings::instance();
 376     GeneralSettings* generalSettings = settings.generalSettings();
 377     generalSettings->setFirstRun(false);
 378
 379     settings.save();
 380
 381     KXmlGuiWindow::closeEvent(event);
 382 }
 383
 384 void DolphinMainWindow::saveProperties(KConfigGroup& group)
 385 {
 386     DolphinViewContainer* cont = m_viewContainer[PrimaryView];
 387     group.writeEntry("Primary Url", cont->url().url());
 388     group.writeEntry("Primary Editable Url", cont->isUrlEditable());
 389
 390     cont = m_viewContainer[SecondaryView];
 391     if (cont != 0) {
 392         group.writeEntry("Secondary Url", cont->url().url());
 393         group.writeEntry("Secondary Editable Url", cont->isUrlEditable());
 394     }
 395 }
 396
 397 void DolphinMainWindow::readProperties(const KConfigGroup& group)
 398 {
 399     DolphinViewContainer* cont = m_viewContainer[PrimaryView];
 400
 401     cont->setUrl(group.readEntry("Primary Url"));
 402     bool editable = group.readEntry("Primary Editable Url", false);
 403     cont->urlNavigator()->setUrlEditable(editable);
 404
 405     cont = m_viewContainer[SecondaryView];
 406     const QString secondaryUrl = group.readEntry("Secondary Url");
 407     if (!secondaryUrl.isEmpty()) {
 408         if (cont == 0) {
 409             // a secondary view should be shown, but no one is available
 410             // currently -> create a new view
 411             toggleSplitView();
 412             cont = m_viewContainer[SecondaryView];
 413             Q_ASSERT(cont != 0);
 414         }
 415
 416         cont->setUrl(secondaryUrl);
 417         bool editable = group.readEntry("Secondary Editable Url", false);
 418         cont->urlNavigator()->setUrlEditable(editable);
 419     } else if (cont != 0) {
 420         // no secondary view should be shown, but the default setting shows
 421         // one already -> close the view
 422         toggleSplitView();
 423     }
 424 }
 425
 426 void DolphinMainWindow::updateNewMenu()
 427 {
 428     m_newMenu->slotCheckUpToDate();
 429     m_newMenu->setPopupFiles(activeViewContainer()->url());
 430 }
 431
 432 void DolphinMainWindow::rename()
 433 {
 434     clearStatusBar();
 435     m_activeViewContainer->view()->renameSelectedItems();
 436 }
 437
 438 void DolphinMainWindow::moveToTrash()
 439 {
 440     clearStatusBar();
 441
 442     DolphinView* view = m_activeViewContainer->view();
 443
 444     if (QApplication::keyboardModifiers() & Qt::ShiftModifier) {
 445         view->deleteSelectedItems();
 446     } else {
 447         view->trashSelectedItems();
 448     }
 449 }
 450
 451 void DolphinMainWindow::deleteItems()
 452 {
 453     clearStatusBar();
 454     m_activeViewContainer->view()->deleteSelectedItems();
 455 }
 456
 457 void DolphinMainWindow::properties()
 458 {
 459     const KFileItemList list = m_activeViewContainer->view()->selectedItems();
 460
 461     KPropertiesDialog *dialog = new KPropertiesDialog(list, this);
 462     dialog->setAttribute(Qt::WA_DeleteOnClose);
 463     dialog->show();
 464     dialog->raise();
 465     dialog->activateWindow();
 466 }
 467
 468 void DolphinMainWindow::quit()
 469 {
 470     close();
 471 }
 472
 473 void DolphinMainWindow::slotHandlePlacesError(const QString &message)
 474 {
 475     if (!message.isEmpty()) {
 476         DolphinStatusBar* statusBar = m_activeViewContainer->statusBar();
 477         statusBar->setMessage(message, DolphinStatusBar::Error);
 478     }
 479 }
 480
 481 void DolphinMainWindow::slotUndoAvailable(bool available)
 482 {
 483     QAction* undoAction = actionCollection()->action(KStandardAction::stdName(KStandardAction::Undo));
 484     if (undoAction != 0) {
 485         undoAction->setEnabled(available);
 486     }
 487
 488     if (available && (m_undoCommandTypes.count() > 0)) {
 489         const KonqFileUndoManager::CommandType command = m_undoCommandTypes.takeFirst();
 490         DolphinStatusBar* statusBar = m_activeViewContainer->statusBar();
 491         switch (command) {
 492         case KonqFileUndoManager::COPY:
 493             statusBar->setMessage(i18nc("@info:status", "Copy operation completed."),
 494                                   DolphinStatusBar::OperationCompleted);
 495             break;
 496         case KonqFileUndoManager::MOVE:
 497             statusBar->setMessage(i18nc("@info:status", "Move operation completed."),
 498                                   DolphinStatusBar::OperationCompleted);
 499             break;
 500         case KonqFileUndoManager::LINK:
 501             statusBar->setMessage(i18nc("@info:status", "Link operation completed."),
 502                                   DolphinStatusBar::OperationCompleted);
 503             break;
 504         case KonqFileUndoManager::TRASH:
 505             statusBar->setMessage(i18nc("@info:status", "Move to trash operation completed."),
 506                                   DolphinStatusBar::OperationCompleted);
 507             break;
 508         case KonqFileUndoManager::RENAME:
 509             statusBar->setMessage(i18nc("@info:status", "Renaming operation completed."),
 510                                   DolphinStatusBar::OperationCompleted);
 511             break;
 512
 513         case KonqFileUndoManager::MKDIR:
 514             statusBar->setMessage(i18nc("@info:status", "Created folder."),
 515                                   DolphinStatusBar::OperationCompleted);
 516             break;
 517
 518         default:
 519             break;
 520         }
 521
 522     }
 523 }
 524
 525 void DolphinMainWindow::slotUndoTextChanged(const QString& text)
 526 {
 527     QAction* undoAction = actionCollection()->action(KStandardAction::stdName(KStandardAction::Undo));
 528     if (undoAction != 0) {
 529         undoAction->setText(text);
 530     }
 531 }
 532
 533 void DolphinMainWindow::undo()
 534 {
 535     clearStatusBar();
 536     KonqFileUndoManager::self()->undo();
 537 }
 538
 539 void DolphinMainWindow::cut()
 540 {
 541     m_activeViewContainer->view()->cutSelectedItems();
 542 }
 543
 544 void DolphinMainWindow::copy()
 545 {
 546     m_activeViewContainer->view()->copySelectedItems();
 547 }
 548
 549 void DolphinMainWindow::paste()
 550 {
 551     m_activeViewContainer->view()->paste();
 552 }
 553
 554 void DolphinMainWindow::updatePasteAction()
 555 {
 556     QAction* pasteAction = actionCollection()->action(KStandardAction::stdName(KStandardAction::Paste));
 557     if (pasteAction == 0) {
 558         return;
 559     }
 560
 561     QPair<bool, QString> pasteInfo = m_activeViewContainer->view()->pasteInfo();
 562     pasteAction->setEnabled(pasteInfo.first);
 563     pasteAction->setText(pasteInfo.second);
 564 }
 565
 566 void DolphinMainWindow::selectAll()
 567 {
 568     clearStatusBar();
 569
 570     // if the URL navigator is editable and focused, select the whole
 571     // URL instead of all items of the view
 572
 573     KUrlNavigator* urlNavigator = m_activeViewContainer->urlNavigator();
 574     QLineEdit* lineEdit = urlNavigator->editor()->lineEdit();
 575     const bool selectUrl = urlNavigator->isUrlEditable() &&
 576                            lineEdit->hasFocus();
 577     if (selectUrl) {
 578         lineEdit->selectAll();
 579     } else {
 580         m_activeViewContainer->view()->selectAll();
 581     }
 582 }
 583
 584 void DolphinMainWindow::invertSelection()
 585 {
 586     clearStatusBar();
 587     m_activeViewContainer->view()->invertSelection();
 588 }
 589
 590 void DolphinMainWindow::setViewMode(QAction* action)
 591 {
 592     const DolphinView::Mode mode = action->data().value<DolphinView::Mode>();
 593     m_activeViewContainer->view()->setMode(mode);
 594 }
 595
 596 void DolphinMainWindow::sortByName()
 597 {
 598     m_activeViewContainer->view()->setSorting(DolphinView::SortByName);
 599 }
 600
 601 void DolphinMainWindow::sortBySize()
 602 {
 603     m_activeViewContainer->view()->setSorting(DolphinView::SortBySize);
 604 }
 605
 606 void DolphinMainWindow::sortByDate()
 607 {
 608     m_activeViewContainer->view()->setSorting(DolphinView::SortByDate);
 609 }
 610
 611 void DolphinMainWindow::sortByPermissions()
 612 {
 613     m_activeViewContainer->view()->setSorting(DolphinView::SortByPermissions);
 614 }
 615
 616 void DolphinMainWindow::sortByOwner()
 617 {
 618     m_activeViewContainer->view()->setSorting(DolphinView::SortByOwner);
 619 }
 620
 621 void DolphinMainWindow::sortByGroup()
 622 {
 623     m_activeViewContainer->view()->setSorting(DolphinView::SortByGroup);
 624 }
 625
 626 void DolphinMainWindow::sortByType()
 627 {
 628     m_activeViewContainer->view()->setSorting(DolphinView::SortByType);
 629 }
 630
 631 void DolphinMainWindow::sortByRating()
 632 {
 633 #ifdef HAVE_NEPOMUK
 634     m_activeViewContainer->view()->setSorting(DolphinView::SortByRating);
 635 #endif
 636 }
 637
 638 void DolphinMainWindow::sortByTags()
 639 {
 640 #ifdef HAVE_NEPOMUK
 641     m_activeViewContainer->view()->setSorting(DolphinView::SortByTags);
 642 #endif
 643 }
 644
 645 void DolphinMainWindow::toggleSortOrder()
 646 {
 647     DolphinView* view = m_activeViewContainer->view();
 648     const Qt::SortOrder order = (view->sortOrder() == Qt::AscendingOrder) ?
 649                                 Qt::DescendingOrder :
 650                                 Qt::AscendingOrder;
 651     view->setSortOrder(order);
 652 }
 653
 654 void DolphinMainWindow::toggleSortCategorization()
 655 {
 656     DolphinView* view = m_activeViewContainer->view();
 657     const bool categorizedSorting = view->categorizedSorting();
 658     view->setCategorizedSorting(!categorizedSorting);
 659 }
 660
 661 void DolphinMainWindow::toggleSizeInfo()
 662 {
 663     toggleAdditionalInfo("show_size_info", KFileItemDelegate::Size);
 664 }
 665
 666 void DolphinMainWindow::toggleDateInfo()
 667 {
 668     toggleAdditionalInfo("show_date_info", KFileItemDelegate::ModificationTime);
 669 }
 670
 671 void DolphinMainWindow::togglePermissionsInfo()
 672 {
 673     toggleAdditionalInfo("show_permissions_info", KFileItemDelegate::Permissions);
 674 }
 675
 676 void DolphinMainWindow::toggleOwnerInfo()
 677 {
 678     toggleAdditionalInfo("show_owner_info", KFileItemDelegate::Owner);
 679 }
 680
 681 void DolphinMainWindow::toggleGroupInfo()
 682 {
 683     toggleAdditionalInfo("show_group_info", KFileItemDelegate::OwnerAndGroup);
 684 }
 685
 686 void DolphinMainWindow::toggleMimeInfo()
 687 {
 688     toggleAdditionalInfo("show_mime_info", KFileItemDelegate::FriendlyMimeType);
 689 }
 690
 691 void DolphinMainWindow::toggleSplitView()
 692 {
 693     if (m_viewContainer[SecondaryView] == 0) {
 694         // create a secondary view
 695         const int newWidth = (m_viewContainer[PrimaryView]->width() - m_splitter->handleWidth()) / 2;
 696
 697         const DolphinView* view = m_viewContainer[PrimaryView]->view();
 698         m_viewContainer[SecondaryView] = new DolphinViewContainer(this, 0, view->rootUrl());
 699         connectViewSignals(SecondaryView);
 700         m_splitter->addWidget(m_viewContainer[SecondaryView]);
 701         m_splitter->setSizes(QList<int>() << newWidth << newWidth);
 702         m_viewContainer[SecondaryView]->view()->reload();
 703         m_viewContainer[SecondaryView]->setActive(false);
 704         m_viewContainer[SecondaryView]->show();
 705     } else if (m_activeViewContainer == m_viewContainer[PrimaryView]) {
 706         // remove secondary view
 707         m_viewContainer[SecondaryView]->close();
 708         m_viewContainer[SecondaryView]->deleteLater();
 709         m_viewContainer[SecondaryView] = 0;
 710     } else {
 711         // The secondary view is active, hence from a users point of view
 712         // the content of the secondary view should be moved to the primary view.
 713         // From an implementation point of view it is more efficient to close
 714         // the primary view and exchange the internal pointers afterwards.
 715         m_viewContainer[PrimaryView]->close();
 716         m_viewContainer[PrimaryView]->deleteLater();
 717         m_viewContainer[PrimaryView] = m_viewContainer[SecondaryView];
 718         m_viewContainer[SecondaryView] = 0;
 719     }
 720
 721     setActiveViewContainer(m_viewContainer[PrimaryView]);
 722     updateViewActions();
 723     emit activeViewChanged();
 724 }
 725
 726 void DolphinMainWindow::reloadView()
 727 {
 728     clearStatusBar();
 729     m_activeViewContainer->view()->reload();
 730 }
 731
 732 void DolphinMainWindow::stopLoading()
 733 {
 734 }
 735
 736 void DolphinMainWindow::togglePreview()
 737 {
 738     clearStatusBar();
 739
 740     const KToggleAction* showPreviewAction =
 741         static_cast<KToggleAction*>(actionCollection()->action("show_preview"));
 742     const bool show = showPreviewAction->isChecked();
 743     m_activeViewContainer->view()->setShowPreview(show);
 744 }
 745
 746 void DolphinMainWindow::toggleShowHiddenFiles()
 747 {
 748     clearStatusBar();
 749
 750     const KToggleAction* showHiddenFilesAction =
 751         static_cast<KToggleAction*>(actionCollection()->action("show_hidden_files"));
 752     const bool show = showHiddenFilesAction->isChecked();
 753     m_activeViewContainer->view()->setShowHiddenFiles(show);
 754 }
 755
 756 void DolphinMainWindow::toggleFilterBarVisibility()
 757 {
 758     const KToggleAction* showFilterBarAction =
 759         static_cast<KToggleAction*>(actionCollection()->action("show_filter_bar"));
 760     const bool show = showFilterBarAction->isChecked();
 761     m_activeViewContainer->showFilterBar(show);
 762 }
 763
 764 void DolphinMainWindow::zoomIn()
 765 {
 766     m_activeViewContainer->view()->zoomIn();
 767     updateViewActions();
 768 }
 769
 770 void DolphinMainWindow::zoomOut()
 771 {
 772     m_activeViewContainer->view()->zoomOut();
 773     updateViewActions();
 774 }
 775
 776 void DolphinMainWindow::toggleEditLocation()
 777 {
 778     clearStatusBar();
 779
 780     KToggleAction* action = static_cast<KToggleAction*>(actionCollection()->action("editable_location"));
 781
 782     bool editOrBrowse = action->isChecked();
 783     KUrlNavigator* urlNavigator = m_activeViewContainer->urlNavigator();
 784     urlNavigator->setUrlEditable(editOrBrowse);
 785 }
 786
 787 void DolphinMainWindow::editLocation()
 788 {
 789     KUrlNavigator* navigator = m_activeViewContainer->urlNavigator();
 790     navigator->setUrlEditable(true);
 791     navigator->setFocus();
 792 }
 793
 794 void DolphinMainWindow::adjustViewProperties()
 795 {
 796     clearStatusBar();
 797     ViewPropertiesDialog dlg(m_activeViewContainer->view());
 798     dlg.exec();
 799 }
 800
 801 void DolphinMainWindow::goBack()
 802 {
 803     clearStatusBar();
 804     m_activeViewContainer->urlNavigator()->goBack();
 805 }
 806
 807 void DolphinMainWindow::goForward()
 808 {
 809     clearStatusBar();
 810     m_activeViewContainer->urlNavigator()->goForward();
 811 }
 812
 813 void DolphinMainWindow::goUp()
 814 {
 815     clearStatusBar();
 816     m_activeViewContainer->urlNavigator()->goUp();
 817 }
 818
 819 void DolphinMainWindow::goHome()
 820 {
 821     clearStatusBar();
 822     m_activeViewContainer->urlNavigator()->goHome();
 823 }
 824
 825 void DolphinMainWindow::findFile()
 826 {
 827     KRun::run("kfind", m_activeViewContainer->url(), this);
 828 }
 829
 830 void DolphinMainWindow::compareFiles()
 831 {
 832     // The method is only invoked if exactly 2 files have
 833     // been selected. The selected files may be:
 834     // - both in the primary view
 835     // - both in the secondary view
 836     // - one in the primary view and the other in the secondary
 837     //   view
 838     Q_ASSERT(m_viewContainer[PrimaryView] != 0);
 839
 840     KUrl urlA;
 841     KUrl urlB;
 842     KUrl::List urls = m_viewContainer[PrimaryView]->view()->selectedUrls();
 843
 844     switch (urls.count()) {
 845     case 0: {
 846         Q_ASSERT(m_viewContainer[SecondaryView] != 0);
 847         urls = m_viewContainer[SecondaryView]->view()->selectedUrls();
 848         Q_ASSERT(urls.count() == 2);
 849         urlA = urls[0];
 850         urlB = urls[1];
 851         break;
 852     }
 853
 854     case 1: {
 855         urlA = urls[0];
 856         Q_ASSERT(m_viewContainer[SecondaryView] != 0);
 857         urls = m_viewContainer[SecondaryView]->view()->selectedUrls();
 858         Q_ASSERT(urls.count() == 1);
 859         urlB = urls[0];
 860         break;
 861     }
 862
 863     case 2: {
 864         urlA = urls[0];
 865         urlB = urls[1];
 866         break;
 867     }
 868
 869     default: {
 870         // may not happen: compareFiles may only get invoked if 2
 871         // files are selected
 872         Q_ASSERT(false);
 873     }
 874     }
 875
 876     QString command("kompare -c \"");
 877     command.append(urlA.pathOrUrl());
 878     command.append("\" \"");
 879     command.append(urlB.pathOrUrl());
 880     command.append('\"');
 881     KRun::runCommand(command, "Kompare", "kompare", this);
 882
 883 }
 884
 885 void DolphinMainWindow::toggleShowMenuBar()
 886 {
 887     const bool visible = menuBar()->isVisible();
 888     menuBar()->setVisible(!visible);
 889 }
 890
 891 void DolphinMainWindow::editSettings()
 892 {
 893     DolphinSettingsDialog dialog(this);
 894     dialog.exec();
 895 }
 896
 897 void DolphinMainWindow::init()
 898 {
 899     // Check whether Dolphin runs the first time. If yes then
 900     // a proper default window size is given at the end of DolphinMainWindow::init().
 901     GeneralSettings* generalSettings = DolphinSettings::instance().generalSettings();
 902     const bool firstRun = generalSettings->firstRun();
 903     if (firstRun) {
 904         generalSettings->setViewPropsTimestamp(QDateTime::currentDateTime());
 905     }
 906
 907     setAcceptDrops(true);
 908
 909     m_splitter = new QSplitter(this);
 910
 911     DolphinSettings& settings = DolphinSettings::instance();
 912
 913     setupActions();
 914
 915     const KUrl& homeUrl = settings.generalSettings()->homeUrl();
 916     setCaption(homeUrl.fileName());
 917     ViewProperties props(homeUrl);
 918     m_viewContainer[PrimaryView] = new DolphinViewContainer(this,
 919                                                             m_splitter,
 920                                                             homeUrl);
 921
 922     m_activeViewContainer = m_viewContainer[PrimaryView];
 923     connectViewSignals(PrimaryView);
 924     m_viewContainer[PrimaryView]->view()->reload();
 925     m_viewContainer[PrimaryView]->show();
 926
 927     setCentralWidget(m_splitter);
 928     setupDockWidgets();
 929
 930     setupGUI(Keys | Save | Create | ToolBar);
 931     createGUI();
 932
 933     stateChanged("new_file");
 934     setAutoSaveSettings();
 935
 936     QClipboard* clipboard = QApplication::clipboard();
 937     connect(clipboard, SIGNAL(dataChanged()),
 938             this, SLOT(updatePasteAction()));
 939     updatePasteAction();
 940     updateGoActions();
 941
 942     if (generalSettings->splitView()) {
 943         toggleSplitView();
 944     }
 945     updateViewActions();
 946
 947     if (firstRun) {
 948         // assure a proper default size if Dolphin runs the first time
 949         resize(700, 500);
 950     }
 951
 952     emit urlChanged(homeUrl);
 953 }
 954
 955 void DolphinMainWindow::setActiveViewContainer(DolphinViewContainer* view)
 956 {
 957     Q_ASSERT(view != 0);
 958     Q_ASSERT((view == m_viewContainer[PrimaryView]) || (view == m_viewContainer[SecondaryView]));
 959     if (m_activeViewContainer == view) {
 960         return;
 961     }
 962
 963     m_activeViewContainer->setActive(false);
 964     m_activeViewContainer = view;
 965     m_activeViewContainer->setActive(true);
 966
 967     updateHistory();
 968     updateEditActions();
 969     updateViewActions();
 970     updateGoActions();
 971
 972     const KUrl& url = m_activeViewContainer->url();
 973     setCaption(url.fileName());
 974
 975     emit activeViewChanged();
 976     emit urlChanged(url);
 977 }
 978
 979 void DolphinMainWindow::setupActions()
 980 {
 981     // setup 'File' menu
 982     m_newMenu = new DolphinNewMenu(this);
 983     KMenu* menu = m_newMenu->menu();
 984     menu->setTitle(i18nc("@title:menu", "Create New"));
 985     menu->setIcon(KIcon("document-new"));
 986     connect(menu, SIGNAL(aboutToShow()),
 987             this, SLOT(updateNewMenu()));
 988
 989     KAction* newWindow = actionCollection()->addAction("new_window");
 990     newWindow->setIcon(KIcon("window-new"));
 991     newWindow->setText(i18nc("@action:inmenu File", "New &Window"));
 992     newWindow->setShortcut(Qt::CTRL | Qt::Key_N);
 993     connect(newWindow, SIGNAL(triggered()), this, SLOT(openNewMainWindow()));
 994
 995     KAction* rename = DolphinView::createRenameAction(actionCollection());
 996     connect(rename, SIGNAL(triggered()), this, SLOT(rename()));
 997
 998     KAction* moveToTrash = DolphinView::createMoveToTrashAction(actionCollection());
 999     connect(moveToTrash, SIGNAL(triggered()), this, SLOT(moveToTrash()));
1000
1001     KAction* deleteAction = DolphinView::createDeleteAction(actionCollection());
1002     connect(deleteAction, SIGNAL(triggered()), this, SLOT(deleteItems()));
1003
1004     KAction* properties = actionCollection()->addAction("properties");
1005     properties->setText(i18nc("@action:inmenu File", "Properties"));
1006     properties->setShortcut(Qt::ALT | Qt::Key_Return);
1007     connect(properties, SIGNAL(triggered()), this, SLOT(properties()));
1008
1009     KStandardAction::quit(this, SLOT(quit()), actionCollection());
1010
1011     // setup 'Edit' menu
1012     KStandardAction::undo(this,
1013                           SLOT(undo()),
1014                           actionCollection());
1015
1016     //Need to remove shift+del from cut action, else the shortcut for deletejob
1017     //doesn't work
1018     KAction* cut = KStandardAction::cut(this, SLOT(cut()), actionCollection());
1019     KShortcut cutShortcut = cut->shortcut();
1020     cutShortcut.remove(Qt::SHIFT + Qt::Key_Delete, KShortcut::KeepEmpty);
1021     cut->setShortcut(cutShortcut);
1022     KStandardAction::copy(this, SLOT(copy()), actionCollection());
1023     KStandardAction::paste(this, SLOT(paste()), actionCollection());
1024
1025     KAction* selectAll = actionCollection()->addAction("select_all");
1026     selectAll->setText(i18nc("@action:inmenu Edit", "Select All"));
1027     selectAll->setShortcut(Qt::CTRL + Qt::Key_A);
1028     connect(selectAll, SIGNAL(triggered()), this, SLOT(selectAll()));
1029
1030     KAction* invertSelection = actionCollection()->addAction("invert_selection");
1031     invertSelection->setText(i18nc("@action:inmenu Edit", "Invert Selection"));
1032     invertSelection->setShortcut(Qt::CTRL | Qt::SHIFT | Qt::Key_A);
1033     connect(invertSelection, SIGNAL(triggered()), this, SLOT(invertSelection()));
1034
1035     // setup 'View' menu
1036     KStandardAction::zoomIn(this,
1037                             SLOT(zoomIn()),
1038                             actionCollection());
1039
1040     KStandardAction::zoomOut(this,
1041                              SLOT(zoomOut()),
1042                              actionCollection());
1043
1044
1045     KToggleAction* iconsView = DolphinView::iconsModeAction(actionCollection());
1046     KToggleAction* detailsView = DolphinView::detailsModeAction(actionCollection());
1047     KToggleAction* columnView = DolphinView::columnsModeAction(actionCollection());
1048
1049     QActionGroup* viewModeGroup = new QActionGroup(this);
1050     viewModeGroup->addAction(iconsView);
1051     viewModeGroup->addAction(detailsView);
1052     viewModeGroup->addAction(columnView);
1053     connect(viewModeGroup, SIGNAL(triggered(QAction*)), this, SLOT(setViewMode(QAction*)));
1054
1055     KToggleAction* sortByName = actionCollection()->add<KToggleAction>("sort_by_name");
1056     sortByName->setText(i18nc("@action:inmenu Sort By", "Name"));
1057     connect(sortByName, SIGNAL(triggered()), this, SLOT(sortByName()));
1058
1059     KToggleAction* sortBySize = actionCollection()->add<KToggleAction>("sort_by_size");
1060     sortBySize->setText(i18nc("@action:inmenu Sort By", "Size"));
1061     connect(sortBySize, SIGNAL(triggered()), this, SLOT(sortBySize()));
1062
1063     KToggleAction* sortByDate = actionCollection()->add<KToggleAction>("sort_by_date");
1064     sortByDate->setText(i18nc("@action:inmenu Sort By", "Date"));
1065     connect(sortByDate, SIGNAL(triggered()), this, SLOT(sortByDate()));
1066
1067     KToggleAction* sortByPermissions = actionCollection()->add<KToggleAction>("sort_by_permissions");
1068     sortByPermissions->setText(i18nc("@action:inmenu Sort By", "Permissions"));
1069     connect(sortByPermissions, SIGNAL(triggered()), this, SLOT(sortByPermissions()));
1070
1071     KToggleAction* sortByOwner = actionCollection()->add<KToggleAction>("sort_by_owner");
1072     sortByOwner->setText(i18nc("@action:inmenu Sort By", "Owner"));
1073     connect(sortByOwner, SIGNAL(triggered()), this, SLOT(sortByOwner()));
1074
1075     KToggleAction* sortByGroup = actionCollection()->add<KToggleAction>("sort_by_group");
1076     sortByGroup->setText(i18nc("@action:inmenu Sort By", "Group"));
1077     connect(sortByGroup, SIGNAL(triggered()), this, SLOT(sortByGroup()));
1078
1079     KToggleAction* sortByType = actionCollection()->add<KToggleAction>("sort_by_type");
1080     sortByType->setText(i18nc("@action:inmenu Sort By", "Type"));
1081     connect(sortByType, SIGNAL(triggered()), this, SLOT(sortByType()));
1082
1083     // TODO: Hided "sort by rating" and "sort by tags" as without caching the performance
1084     // is too slow currently (Nepomuk will support caching in future releases).
1085     //
1086     // KToggleAction* sortByRating = actionCollection()->add<KToggleAction>("sort_by_rating");
1087     // sortByRating->setText(i18nc("@action:inmenu Sort By", "Rating"));
1088     //
1089     // KToggleAction* sortByTags = actionCollection()->add<KToggleAction>("sort_by_tags");
1090     // sortByTags->setText(i18nc("@action:inmenu Sort By", "Tags"));
1091     //
1092 #ifdef HAVE_NEPOMUK
1093     // if (MetaDataWidget::metaDataAvailable()) {
1094     //     connect(sortByRating, SIGNAL(triggered()), this, SLOT(sortByRating()));
1095     //     connect(sortByTags, SIGNAL(triggered()), this, SLOT(sortByTags()));
1096     // }
1097     // else {
1098     //     sortByRating->setEnabled(false);
1099     //     sortByTags->setEnabled(false);
1100     // }
1101 #else
1102     // sortByRating->setEnabled(false);
1103     // sortByTags->setEnabled(false);
1104 #endif
1105
1106     QActionGroup* sortGroup = new QActionGroup(this);
1107     sortGroup->addAction(sortByName);
1108     sortGroup->addAction(sortBySize);
1109     sortGroup->addAction(sortByDate);
1110     sortGroup->addAction(sortByPermissions);
1111     sortGroup->addAction(sortByOwner);
1112     sortGroup->addAction(sortByGroup);
1113     sortGroup->addAction(sortByType);
1114
1115     // TODO: Hided "sort by rating" and "sort by tags" as without caching the performance
1116     // is too slow currently (Nepomuk will support caching in future releases).
1117     //sortGroup->addAction(sortByRating);
1118     //sortGroup->addAction(sortByTags);
1119
1120     KToggleAction* sortDescending = actionCollection()->add<KToggleAction>("descending");
1121     sortDescending->setText(i18nc("@action:inmenu Sort", "Descending"));
1122     connect(sortDescending, SIGNAL(triggered()), this, SLOT(toggleSortOrder()));
1123
1124     KToggleAction* showInGroups = actionCollection()->add<KToggleAction>("show_in_groups");
1125     showInGroups->setText(i18nc("@action:inmenu View", "Show in Groups"));
1126     connect(showInGroups, SIGNAL(triggered()), this, SLOT(toggleSortCategorization()));
1127
1128     KToggleAction* showSizeInfo = actionCollection()->add<KToggleAction>("show_size_info");
1129     showSizeInfo->setText(i18nc("@action:inmenu Additional information", "Size"));
1130     connect(showSizeInfo, SIGNAL(triggered()), this, SLOT(toggleSizeInfo()));
1131
1132     KToggleAction* showDateInfo = actionCollection()->add<KToggleAction>("show_date_info");
1133     showDateInfo->setText(i18nc("@action:inmenu Additional information", "Date"));
1134     connect(showDateInfo, SIGNAL(triggered()), this, SLOT(toggleDateInfo()));
1135
1136     KToggleAction* showPermissionsInfo = actionCollection()->add<KToggleAction>("show_permissions_info");
1137     showPermissionsInfo->setText(i18nc("@action:inmenu Additional information", "Permissions"));
1138     connect(showPermissionsInfo, SIGNAL(triggered()), this, SLOT(togglePermissionsInfo()));
1139
1140     KToggleAction* showOwnerInfo = actionCollection()->add<KToggleAction>("show_owner_info");
1141     showOwnerInfo->setText(i18nc("@action:inmenu Additional information", "Owner"));
1142     connect(showOwnerInfo, SIGNAL(triggered()), this, SLOT(toggleOwnerInfo()));
1143
1144     KToggleAction* showGroupInfo = actionCollection()->add<KToggleAction>("show_group_info");
1145     showGroupInfo->setText(i18nc("@action:inmenu Additional information", "Group"));
1146     connect(showGroupInfo, SIGNAL(triggered()), this, SLOT(toggleGroupInfo()));
1147
1148     KToggleAction* showMimeInfo = actionCollection()->add<KToggleAction>("show_mime_info");
1149     showMimeInfo->setText(i18nc("@action:inmenu Additional information", "Type"));
1150     connect(showMimeInfo, SIGNAL(triggered()), this, SLOT(toggleMimeInfo()));
1151
1152     KToggleAction* showPreview = actionCollection()->add<KToggleAction>("show_preview");
1153     showPreview->setText(i18nc("@action:intoolbar", "Preview"));
1154     showPreview->setIcon(KIcon("view-preview"));
1155     connect(showPreview, SIGNAL(triggered()), this, SLOT(togglePreview()));
1156
1157     KToggleAction* showHiddenFiles = actionCollection()->add<KToggleAction>("show_hidden_files");
1158     showHiddenFiles->setText(i18nc("@action:inmenu View", "Show Hidden Files"));
1159     showHiddenFiles->setShortcut(Qt::ALT | Qt::Key_Period);
1160     connect(showHiddenFiles, SIGNAL(triggered()), this, SLOT(toggleShowHiddenFiles()));
1161
1162     KAction* split = actionCollection()->addAction("split_view");
1163     split->setShortcut(Qt::Key_F10);
1164     updateSplitAction();
1165     connect(split, SIGNAL(triggered()), this, SLOT(toggleSplitView()));
1166
1167     KAction* reload = actionCollection()->addAction("reload");
1168     reload->setText(i18nc("@action:inmenu View", "Reload"));
1169     reload->setShortcut(Qt::Key_F5);
1170     reload->setIcon(KIcon("view-refresh"));
1171     connect(reload, SIGNAL(triggered()), this, SLOT(reloadView()));
1172
1173     KAction* stop = actionCollection()->addAction("stop");
1174     stop->setText(i18nc("@action:inmenu View", "Stop"));
1175     stop->setIcon(KIcon("process-stop"));
1176     connect(stop, SIGNAL(triggered()), this, SLOT(stopLoading()));
1177
1178     // TODO: the URL navigator must emit a signal if the editable state has been
1179     // changed, so that the corresponding showFullLocation action is updated. Also
1180     // the naming "Show full Location" is currently confusing...
1181     KToggleAction* showFullLocation = actionCollection()->add<KToggleAction>("editable_location");
1182     showFullLocation->setText(i18nc("@action:inmenu Navigation Bar", "Show Full Location"));
1183     showFullLocation->setShortcut(Qt::CTRL | Qt::Key_L);
1184     connect(showFullLocation, SIGNAL(triggered()), this, SLOT(toggleEditLocation()));
1185
1186     KAction* editLocation = actionCollection()->addAction("edit_location");
1187     editLocation->setText(i18nc("@action:inmenu Navigation Bar", "Edit Location"));
1188     editLocation->setShortcut(Qt::Key_F6);
1189     connect(editLocation, SIGNAL(triggered()), this, SLOT(editLocation()));
1190
1191     KAction* adjustViewProps = actionCollection()->addAction("view_properties");
1192     adjustViewProps->setText(i18nc("@action:inmenu View", "Adjust View Properties..."));
1193     connect(adjustViewProps, SIGNAL(triggered()), this, SLOT(adjustViewProperties()));
1194
1195     // setup 'Go' menu
1196     KAction* backAction = KStandardAction::back(this, SLOT(goBack()), actionCollection());
1197     KShortcut backShortcut = backAction->shortcut();
1198     backShortcut.setAlternate(Qt::Key_Backspace);
1199     backAction->setShortcut(backShortcut);
1200
1201     KStandardAction::forward(this, SLOT(goForward()), actionCollection());
1202     KStandardAction::up(this, SLOT(goUp()), actionCollection());
1203     KStandardAction::home(this, SLOT(goHome()), actionCollection());
1204
1205     // setup 'Tools' menu
1206     QAction* findFile = actionCollection()->addAction("find_file");
1207     findFile->setText(i18nc("@action:inmenu Tools", "Find File..."));
1208     findFile->setShortcut(Qt::CTRL | Qt::Key_F);
1209     findFile->setIcon(KIcon("edit-find"));
1210     connect(findFile, SIGNAL(triggered()), this, SLOT(findFile()));
1211
1212     KToggleAction* showFilterBar = actionCollection()->add<KToggleAction>("show_filter_bar");
1213     showFilterBar->setText(i18nc("@action:inmenu Tools", "Show Filter Bar"));
1214     showFilterBar->setShortcut(Qt::CTRL | Qt::Key_I);
1215     connect(showFilterBar, SIGNAL(triggered()), this, SLOT(toggleFilterBarVisibility()));
1216
1217     KAction* compareFiles = actionCollection()->addAction("compare_files");
1218     compareFiles->setText(i18nc("@action:inmenu Tools", "Compare Files"));
1219     compareFiles->setIcon(KIcon("kompare"));
1220     compareFiles->setEnabled(false);
1221     connect(compareFiles, SIGNAL(triggered()), this, SLOT(compareFiles()));
1222
1223     // setup 'Settings' menu
1224     m_showMenuBar = KStandardAction::showMenubar(this, SLOT(toggleShowMenuBar()), actionCollection());
1225     KStandardAction::preferences(this, SLOT(editSettings()), actionCollection());
1226 }
1227
1228 void DolphinMainWindow::setupDockWidgets()
1229 {
1230     // setup "Information"
1231     QDockWidget* infoDock = new QDockWidget(i18nc("@title:window", "Information"));
1232     infoDock->setObjectName("infoDock");
1233     infoDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
1234     SidebarPage* infoWidget = new InfoSidebarPage(infoDock);
1235     infoDock->setWidget(infoWidget);
1236
1237     infoDock->toggleViewAction()->setText(i18nc("@title:window", "Information"));
1238     infoDock->toggleViewAction()->setShortcut(Qt::Key_F11);
1239     actionCollection()->addAction("show_info_panel", infoDock->toggleViewAction());
1240
1241     addDockWidget(Qt::RightDockWidgetArea, infoDock);
1242     connect(this, SIGNAL(urlChanged(KUrl)),
1243             infoWidget, SLOT(setUrl(KUrl)));
1244     connect(this, SIGNAL(selectionChanged(KFileItemList)),
1245             infoWidget, SLOT(setSelection(KFileItemList)));
1246     connect(this, SIGNAL(requestItemInfo(KFileItem)),
1247             infoWidget, SLOT(requestDelayedItemInfo(KFileItem)));
1248
1249     // setup "Tree View"
1250     QDockWidget* treeViewDock = new QDockWidget(i18nc("@title:window", "Folders"));
1251     treeViewDock->setObjectName("treeViewDock");
1252     treeViewDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
1253     TreeViewSidebarPage* treeWidget = new TreeViewSidebarPage(treeViewDock);
1254     treeViewDock->setWidget(treeWidget);
1255
1256     treeViewDock->toggleViewAction()->setText(i18nc("@title:window", "Folders"));
1257     treeViewDock->toggleViewAction()->setShortcut(Qt::Key_F7);
1258     actionCollection()->addAction("show_folders_panel", treeViewDock->toggleViewAction());
1259
1260     addDockWidget(Qt::LeftDockWidgetArea, treeViewDock);
1261     connect(this, SIGNAL(urlChanged(KUrl)),
1262             treeWidget, SLOT(setUrl(KUrl)));
1263     connect(treeWidget, SIGNAL(changeUrl(KUrl)),
1264             this, SLOT(changeUrl(KUrl)));
1265     connect(treeWidget, SIGNAL(changeSelection(KFileItemList)),
1266             this, SLOT(changeSelection(KFileItemList)));
1267     connect(treeWidget, SIGNAL(urlsDropped(KUrl::List, KUrl)),
1268             this, SLOT(dropUrls(KUrl::List, KUrl)));
1269
1270     // setup "Terminal"
1271     QDockWidget* terminalDock = new QDockWidget(i18nc("@title:window", "Terminal"));
1272     terminalDock->setObjectName("terminalDock");
1273     terminalDock->setAllowedAreas(Qt::TopDockWidgetArea | Qt::BottomDockWidgetArea);
1274     SidebarPage* terminalWidget = new TerminalSidebarPage(terminalDock);
1275     terminalDock->setWidget(terminalWidget);
1276
1277     connect(terminalWidget, SIGNAL(hideTerminalSidebarPage()), terminalDock, SLOT(hide()));
1278
1279     terminalDock->toggleViewAction()->setText(i18nc("@title:window", "Terminal"));
1280     terminalDock->toggleViewAction()->setShortcut(Qt::Key_F4);
1281     actionCollection()->addAction("show_terminal_panel", terminalDock->toggleViewAction());
1282
1283     addDockWidget(Qt::BottomDockWidgetArea, terminalDock);
1284     connect(this, SIGNAL(urlChanged(KUrl)),
1285             terminalWidget, SLOT(setUrl(KUrl)));
1286
1287     const bool firstRun = DolphinSettings::instance().generalSettings()->firstRun();
1288     if (firstRun) {
1289         infoDock->hide();
1290         treeViewDock->hide();
1291         terminalDock->hide();
1292     }
1293
1294     QDockWidget* placesDock = new QDockWidget(i18nc("@title:window", "Places"));
1295     placesDock->setObjectName("placesDock");
1296     placesDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
1297     KFilePlacesView* placesView = new KFilePlacesView(placesDock);
1298     placesDock->setWidget(placesView);
1299     placesView->setModel(DolphinSettings::instance().placesModel());
1300     placesView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
1301
1302     placesDock->toggleViewAction()->setText(i18nc("@title:window", "Places"));
1303     placesDock->toggleViewAction()->setShortcut(Qt::Key_F9);
1304     actionCollection()->addAction("show_places_panel", placesDock->toggleViewAction());
1305
1306     addDockWidget(Qt::LeftDockWidgetArea, placesDock);
1307     connect(placesView, SIGNAL(urlChanged(KUrl)),
1308             this, SLOT(changeUrl(KUrl)));
1309     connect(this, SIGNAL(urlChanged(KUrl)),
1310             placesView, SLOT(setUrl(KUrl)));
1311 }
1312
1313 void DolphinMainWindow::updateHistory()
1314 {
1315     const KUrlNavigator* urlNavigator = m_activeViewContainer->urlNavigator();
1316     const int index = urlNavigator->historyIndex();
1317
1318     QAction* backAction = actionCollection()->action("go_back");
1319     if (backAction != 0) {
1320         backAction->setEnabled(index < urlNavigator->historySize() - 1);
1321     }
1322
1323     QAction* forwardAction = actionCollection()->action("go_forward");
1324     if (forwardAction != 0) {
1325         forwardAction->setEnabled(index > 0);
1326     }
1327 }
1328
1329 void DolphinMainWindow::updateEditActions()
1330 {
1331     const KFileItemList list = m_activeViewContainer->view()->selectedItems();
1332     if (list.isEmpty()) {
1333         stateChanged("has_no_selection");
1334     } else {
1335         stateChanged("has_selection");
1336
1337         QAction* renameAction = actionCollection()->action("rename");
1338         if (renameAction != 0) {
1339             renameAction->setEnabled(true);
1340         }
1341
1342         bool enableMoveToTrash = true;
1343
1344         KFileItemList::const_iterator it = list.begin();
1345         const KFileItemList::const_iterator end = list.end();
1346         while (it != end) {
1347             const KUrl& url = (*it).url();
1348             // only enable the 'Move to Trash' action for local files
1349             if (!url.isLocalFile()) {
1350                 enableMoveToTrash = false;
1351             }
1352             ++it;
1353         }
1354
1355         QAction* moveToTrashAction = actionCollection()->action("move_to_trash");
1356         moveToTrashAction->setEnabled(enableMoveToTrash);
1357     }
1358     updatePasteAction();
1359 }
1360
1361 void DolphinMainWindow::updateViewActions()
1362 {
1363     const DolphinView* view = m_activeViewContainer->view();
1364     QAction* zoomInAction = actionCollection()->action(KStandardAction::stdName(KStandardAction::ZoomIn));
1365     if (zoomInAction != 0) {
1366         zoomInAction->setEnabled(view->isZoomInPossible());
1367     }
1368
1369     QAction* zoomOutAction = actionCollection()->action(KStandardAction::stdName(KStandardAction::ZoomOut));
1370     if (zoomOutAction != 0) {
1371         zoomOutAction->setEnabled(view->isZoomOutPossible());
1372     }
1373
1374     QAction* action = actionCollection()->action(view->currentViewModeActionName());
1375     if (action != 0) {
1376         KToggleAction* toggleAction = static_cast<KToggleAction*>(action);
1377         toggleAction->setChecked(true);
1378     }
1379
1380     slotSortingChanged(view->sorting());
1381     slotSortOrderChanged(view->sortOrder());
1382     slotCategorizedSortingChanged();
1383     slotAdditionalInfoChanged(view->additionalInfo());
1384
1385     KToggleAction* showFilterBarAction =
1386         static_cast<KToggleAction*>(actionCollection()->action("show_filter_bar"));
1387     showFilterBarAction->setChecked(m_activeViewContainer->isFilterBarVisible());
1388
1389     KToggleAction* showPreviewAction =
1390         static_cast<KToggleAction*>(actionCollection()->action("show_preview"));
1391     showPreviewAction->setChecked(view->showPreview());
1392
1393     KToggleAction* showHiddenFilesAction =
1394         static_cast<KToggleAction*>(actionCollection()->action("show_hidden_files"));
1395     showHiddenFilesAction->setChecked(view->showHiddenFiles());
1396
1397     updateSplitAction();
1398
1399     KToggleAction* editableLocactionAction =
1400         static_cast<KToggleAction*>(actionCollection()->action("editable_location"));
1401     const KUrlNavigator* urlNavigator = m_activeViewContainer->urlNavigator();
1402     editableLocactionAction->setChecked(urlNavigator->isUrlEditable());
1403 }
1404
1405 void DolphinMainWindow::updateGoActions()
1406 {
1407     QAction* goUpAction = actionCollection()->action(KStandardAction::stdName(KStandardAction::Up));
1408     const KUrl& currentUrl = m_activeViewContainer->url();
1409     goUpAction->setEnabled(currentUrl.upUrl() != currentUrl);
1410 }
1411
1412 void DolphinMainWindow::clearStatusBar()
1413 {
1414     m_activeViewContainer->statusBar()->clear();
1415 }
1416
1417 void DolphinMainWindow::connectViewSignals(int viewIndex)
1418 {
1419     DolphinViewContainer* container = m_viewContainer[viewIndex];
1420     connect(container, SIGNAL(showFilterBarChanged(bool)),
1421             this, SLOT(updateFilterBarAction(bool)));
1422
1423     DolphinView* view = container->view();
1424     connect(view, SIGNAL(modeChanged()),
1425             this, SLOT(slotViewModeChanged()));
1426     connect(view, SIGNAL(showPreviewChanged()),
1427             this, SLOT(slotShowPreviewChanged()));
1428     connect(view, SIGNAL(showHiddenFilesChanged()),
1429             this, SLOT(slotShowHiddenFilesChanged()));
1430     connect(view, SIGNAL(categorizedSortingChanged()),
1431             this, SLOT(slotCategorizedSortingChanged()));
1432     connect(view, SIGNAL(sortingChanged(DolphinView::Sorting)),
1433             this, SLOT(slotSortingChanged(DolphinView::Sorting)));
1434     connect(view, SIGNAL(sortOrderChanged(Qt::SortOrder)),
1435             this, SLOT(slotSortOrderChanged(Qt::SortOrder)));
1436     connect(view, SIGNAL(additionalInfoChanged(KFileItemDelegate::InformationList)),
1437             this, SLOT(slotAdditionalInfoChanged(KFileItemDelegate::InformationList)));
1438     connect(view, SIGNAL(selectionChanged(KFileItemList)),
1439             this, SLOT(slotSelectionChanged(KFileItemList)));
1440     connect(view, SIGNAL(requestItemInfo(KFileItem)),
1441             this, SLOT(slotRequestItemInfo(KFileItem)));
1442     connect(view, SIGNAL(activated()),
1443             this, SLOT(toggleActiveView()));
1444     connect(view, SIGNAL(doingOperation(KonqFileUndoManager::CommandType)),
1445             this, SLOT(slotDoingOperation(KonqFileUndoManager::CommandType)));
1446
1447     const KUrlNavigator* navigator = container->urlNavigator();
1448     connect(navigator, SIGNAL(urlChanged(const KUrl&)),
1449             this, SLOT(changeUrl(const KUrl&)));
1450     connect(navigator, SIGNAL(historyChanged()),
1451             this, SLOT(slotHistoryChanged()));
1452 }
1453
1454 void DolphinMainWindow::updateSplitAction()
1455 {
1456     QAction* splitAction = actionCollection()->action("split_view");
1457     if (m_viewContainer[SecondaryView] != 0) {
1458         if (m_activeViewContainer == m_viewContainer[PrimaryView]) {
1459             splitAction->setText(i18nc("@action:intoolbar Close right view", "Close"));
1460             splitAction->setIcon(KIcon("view-right-close"));
1461         } else {
1462             splitAction->setText(i18nc("@action:intoolbar Close left view", "Close"));
1463             splitAction->setIcon(KIcon("view-left-close"));
1464         }
1465     } else {
1466         splitAction->setText(i18nc("@action:intoolbar Split view", "Split"));
1467         splitAction->setIcon(KIcon("view-right-new"));
1468     }
1469 }
1470
1471 void DolphinMainWindow::toggleAdditionalInfo(const char* actionName,
1472                                              KFileItemDelegate::Information info)
1473 {
1474     clearStatusBar();
1475
1476     DolphinView* view = m_activeViewContainer->view();
1477     KFileItemDelegate::InformationList list = view->additionalInfo();
1478
1479     const bool show = actionCollection()->action(actionName)->isChecked();
1480
1481     const int index = list.indexOf(info);
1482     const bool containsInfo = (index >= 0);
1483     if (show && !containsInfo) {
1484         list.append(info);
1485         view->setAdditionalInfo(list);
1486     } else if (!show && containsInfo) {
1487         list.removeAt(index);
1488         view->setAdditionalInfo(list);
1489         Q_ASSERT(list.indexOf(info) < 0);
1490     }
1491 }
1492
1493 DolphinMainWindow::UndoUiInterface::UndoUiInterface(DolphinMainWindow* mainWin) :
1494     KonqFileUndoManager::UiInterface(mainWin),
1495     m_mainWin(mainWin)
1496 {
1497     Q_ASSERT(m_mainWin != 0);
1498 }
1499
1500 DolphinMainWindow::UndoUiInterface::~UndoUiInterface()
1501 {
1502 }
1503
1504 void DolphinMainWindow::UndoUiInterface::jobError(KIO::Job* job)
1505 {
1506     DolphinStatusBar* statusBar = m_mainWin->activeViewContainer()->statusBar();
1507     statusBar->setMessage(job->errorString(), DolphinStatusBar::Error);
1508 }
1509
1510 #include "dolphinmainwindow.moc"