src/dolphinview.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2006 by Peter Penz <peter.penz@gmx.at>                  *
   3  *   Copyright (C) 2006 by Gregor Kališnik <gregor@podnapisi.net>          *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA            *
  19  ***************************************************************************/
  20
  21 #include "dolphinview.h"
  22
  23 #include <QApplication>
  24 #include <QClipboard>
  25 #include <QKeyEvent>
  26 #include <QItemSelection>
  27 #include <QBoxLayout>
  28 #include <QTimer>
  29 #include <QScrollBar>
  30
  31 #include <kactioncollection.h>
  32 #include <kcolorscheme.h>
  33 #include <kdirlister.h>
  34 #include <kfileitemdelegate.h>
  35 #include <kiconeffect.h>
  36 #include <klocale.h>
  37 #include <kio/deletejob.h>
  38 #include <kio/netaccess.h>
  39 #include <kio/previewjob.h>
  40 #include <kjob.h>
  41 #include <kmenu.h>
  42 #include <kmessagebox.h>
  43 #include <kmimetyperesolver.h>
  44 #include <konq_operations.h>
  45 #include <konqmimedata.h>
  46 #include <ktoggleaction.h>
  47 #include <kurl.h>
  48
  49 #include "dolphindropcontroller.h"
  50 #include "dolphinmodel.h"
  51 #include "dolphincolumnview.h"
  52 #include "dolphincontroller.h"
  53 #include "dolphinsortfilterproxymodel.h"
  54 #include "dolphindetailsview.h"
  55 #include "dolphiniconsview.h"
  56 #include "dolphinsettings.h"
  57 #include "dolphin_generalsettings.h"
  58 #include "iconmanager.h"
  59 #include "renamedialog.h"
  60 #include "tooltipmanager.h"
  61 #include "viewproperties.h"
  62
  63 DolphinView::DolphinView(QWidget* parent,
  64                          const KUrl& url,
  65                          KDirLister* dirLister,
  66                          DolphinModel* dolphinModel,
  67                          DolphinSortFilterProxyModel* proxyModel) :
  68     QWidget(parent),
  69     m_active(true),
  70     m_showPreview(false),
  71     m_loadingDirectory(false),
  72     m_storedCategorizedSorting(false),
  73     m_tabsForFiles(false),
  74     m_isContextMenuOpen(false),
  75     m_mode(DolphinView::IconsView),
  76     m_topLayout(0),
  77     m_controller(0),
  78     m_iconsView(0),
  79     m_detailsView(0),
  80     m_columnView(0),
  81     m_fileItemDelegate(0),
  82     m_selectionModel(0),
  83     m_dolphinModel(dolphinModel),
  84     m_dirLister(dirLister),
  85     m_proxyModel(proxyModel),
  86     m_iconManager(0),
  87     m_toolTipManager(0),
  88     m_rootUrl(),
  89     m_currentItemUrl()
  90 {
  91     m_topLayout = new QVBoxLayout(this);
  92     m_topLayout->setSpacing(0);
  93     m_topLayout->setMargin(0);
  94
  95     m_controller = new DolphinController(this);
  96     m_controller->setUrl(url);
  97
  98     connect(m_controller, SIGNAL(urlChanged(const KUrl&)),
  99             this, SIGNAL(urlChanged(const KUrl&)));
 100     connect(m_controller, SIGNAL(requestUrlChange(const KUrl&)),
 101             this, SLOT(slotRequestUrlChange(const KUrl&)));
 102
 103     connect(m_controller, SIGNAL(requestContextMenu(const QPoint&)),
 104             this, SLOT(openContextMenu(const QPoint&)));
 105     connect(m_controller, SIGNAL(urlsDropped(const KUrl::List&, const KUrl&, const KFileItem&)),
 106             this, SLOT(dropUrls(const KUrl::List&, const KUrl&, const KFileItem&)));
 107     connect(m_controller, SIGNAL(sortingChanged(DolphinView::Sorting)),
 108             this, SLOT(updateSorting(DolphinView::Sorting)));
 109     connect(m_controller, SIGNAL(sortOrderChanged(Qt::SortOrder)),
 110             this, SLOT(updateSortOrder(Qt::SortOrder)));
 111     connect(m_controller, SIGNAL(additionalInfoChanged(const KFileItemDelegate::InformationList&)),
 112             this, SLOT(updateAdditionalInfo(const KFileItemDelegate::InformationList&)));
 113     connect(m_controller, SIGNAL(itemTriggered(const KFileItem&)),
 114             this, SLOT(triggerItem(const KFileItem&)));
 115     connect(m_controller, SIGNAL(tabRequested(const KUrl&)),
 116             this, SIGNAL(tabRequested(const KUrl&)));
 117     connect(m_controller, SIGNAL(activated()),
 118             this, SLOT(activate()));
 119     connect(m_controller, SIGNAL(itemEntered(const KFileItem&)),
 120             this, SLOT(showHoverInformation(const KFileItem&)));
 121     connect(m_controller, SIGNAL(viewportEntered()),
 122             this, SLOT(clearHoverInformation()));
 123
 124     connect(m_dirLister, SIGNAL(redirection(KUrl, KUrl)),
 125             this, SLOT(slotRedirection(KUrl, KUrl)));
 126     connect(m_dirLister, SIGNAL(completed()),
 127             this, SLOT(restoreCurrentItem()));
 128
 129     applyViewProperties(url);
 130     m_topLayout->addWidget(itemView());
 131 }
 132
 133 DolphinView::~DolphinView()
 134 {
 135 }
 136
 137 const KUrl& DolphinView::url() const
 138 {
 139     return m_controller->url();
 140 }
 141
 142 KUrl DolphinView::rootUrl() const
 143 {
 144     return isColumnViewActive() ? m_columnView->rootUrl() : url();
 145 }
 146
 147 void DolphinView::setActive(bool active)
 148 {
 149     if (active == m_active) {
 150         return;
 151     }
 152
 153     m_active = active;
 154
 155     QColor color = KColorScheme(QPalette::Active, KColorScheme::View).background().color();
 156     if (active) {
 157         // TODO: emitting urlChanged() is a hack, as the URL hasn't really changed. It
 158         // bypasses the problem when having a split view and changing the active view to
 159         // update the some URL dependent states. A nicer approach should be no big deal...
 160         emit urlChanged(url());
 161         emit selectionChanged(selectedItems());
 162     } else {
 163         color.setAlpha(150);
 164     }
 165
 166     QWidget* viewport = itemView()->viewport();
 167     QPalette palette;
 168     palette.setColor(viewport->backgroundRole(), color);
 169     viewport->setPalette(palette);
 170
 171     update();
 172
 173     if (active) {
 174         itemView()->setFocus();
 175         emit activated();
 176     }
 177
 178     m_controller->indicateActivationChange(active);
 179 }
 180
 181 bool DolphinView::isActive() const
 182 {
 183     return m_active;
 184 }
 185
 186 void DolphinView::setMode(Mode mode)
 187 {
 188     if (mode == m_mode) {
 189         return; // the wished mode is already set
 190     }
 191
 192     m_mode = mode;
 193
 194     deleteView();
 195
 196     const KUrl viewPropsUrl = viewPropertiesUrl();
 197     ViewProperties props(viewPropsUrl);
 198     props.setViewMode(m_mode);
 199     createView();
 200
 201     // the file item delegate has been recreated, apply the current
 202     // additional information manually
 203     const KFileItemDelegate::InformationList infoList = props.additionalInfo();
 204     m_fileItemDelegate->setShowInformation(infoList);
 205     emit additionalInfoChanged();
 206
 207     // Not all view modes support categorized sorting. Adjust the sorting model
 208     // if changing the view mode results in a change of the categorized sorting
 209     // capabilities.
 210     m_storedCategorizedSorting = props.categorizedSorting();
 211     const bool categorized = m_storedCategorizedSorting && supportsCategorizedSorting();
 212     if (categorized != m_proxyModel->isCategorizedModel()) {
 213         m_proxyModel->setCategorizedModel(categorized);
 214         emit categorizedSortingChanged();
 215     }
 216
 217     emit modeChanged();
 218 }
 219
 220 DolphinView::Mode DolphinView::mode() const
 221 {
 222     return m_mode;
 223 }
 224
 225 bool DolphinView::showPreview() const
 226 {
 227     return m_showPreview;
 228 }
 229
 230 bool DolphinView::showHiddenFiles() const
 231 {
 232     return m_dirLister->showingDotFiles();
 233 }
 234
 235 bool DolphinView::categorizedSorting() const
 236 {
 237     // If all view modes would support categorized sorting, returning
 238     // m_proxyModel->isCategorizedModel() would be the way to go. As
 239     // currently only the icons view supports caterized sorting, we remember
 240     // the stored view properties state in m_storedCategorizedSorting and
 241     // return this state. The application takes care to disable the corresponding
 242     // checkbox by checking DolphinView::supportsCategorizedSorting() to indicate
 243     // that this setting is not applied to the current view mode.
 244     return m_storedCategorizedSorting;
 245 }
 246
 247 bool DolphinView::supportsCategorizedSorting() const
 248 {
 249     return m_iconsView != 0;
 250 }
 251
 252 void DolphinView::selectAll()
 253 {
 254     QAbstractItemView* view = itemView();
 255     // TODO: there seems to be a bug in QAbstractItemView::selectAll(); if
 256     // the Ctrl-key is pressed (e. g. for Ctrl+A), selectAll() inverts the
 257     // selection instead of selecting all items. This is bypassed for KDE 4.0
 258     // by invoking clearSelection() first.
 259     view->clearSelection();
 260     view->selectAll();
 261 }
 262
 263 void DolphinView::invertSelection()
 264 {
 265     if (isColumnViewActive()) {
 266         // QAbstractItemView does not offer a virtual method invertSelection()
 267         // as counterpart to QAbstractItemView::selectAll(). This makes it
 268         // necessary to delegate the inverting of the selection to the
 269         // column view, as only the selection of the active column should
 270         // get inverted.
 271         m_columnView->invertSelection();
 272     } else {
 273         QItemSelectionModel* selectionModel = itemView()->selectionModel();
 274         const QAbstractItemModel* itemModel = selectionModel->model();
 275
 276         const QModelIndex topLeft = itemModel->index(0, 0);
 277         const QModelIndex bottomRight = itemModel->index(itemModel->rowCount() - 1,
 278                                                          itemModel->columnCount() - 1);
 279
 280         const QItemSelection selection(topLeft, bottomRight);
 281         selectionModel->select(selection, QItemSelectionModel::Toggle);
 282     }
 283 }
 284
 285 bool DolphinView::hasSelection() const
 286 {
 287     return itemView()->selectionModel()->hasSelection();
 288 }
 289
 290 void DolphinView::clearSelection()
 291 {
 292     itemView()->selectionModel()->clear();
 293 }
 294
 295 KFileItemList DolphinView::selectedItems() const
 296 {
 297     const QAbstractItemView* view = itemView();
 298
 299     // Our view has a selection, we will map them back to the DolphinModel
 300     // and then fill the KFileItemList.
 301     Q_ASSERT((view != 0) && (view->selectionModel() != 0));
 302
 303     const QItemSelection selection = m_proxyModel->mapSelectionToSource(view->selectionModel()->selection());
 304     KFileItemList itemList;
 305
 306     const QModelIndexList indexList = selection.indexes();
 307     foreach (const QModelIndex &index, indexList) {
 308         KFileItem item = m_dolphinModel->itemForIndex(index);
 309         if (!item.isNull()) {
 310             itemList.append(item);
 311         }
 312     }
 313
 314     return itemList;
 315 }
 316
 317 KUrl::List DolphinView::selectedUrls() const
 318 {
 319     KUrl::List urls;
 320     const KFileItemList list = selectedItems();
 321     foreach (const KFileItem &item, list) {
 322         urls.append(item.url());
 323     }
 324     return urls;
 325 }
 326
 327 KFileItem DolphinView::fileItem(const QModelIndex& index) const
 328 {
 329     const QModelIndex dolphinModelIndex = m_proxyModel->mapToSource(index);
 330     return m_dolphinModel->itemForIndex(dolphinModelIndex);
 331 }
 332
 333 void DolphinView::setContentsPosition(int x, int y)
 334 {
 335     QAbstractItemView* view = itemView();
 336
 337     // the ColumnView takes care itself for the horizontal scrolling
 338     if (!isColumnViewActive()) {
 339         view->horizontalScrollBar()->setValue(x);
 340     }
 341     view->verticalScrollBar()->setValue(y);
 342
 343     m_loadingDirectory = false;
 344 }
 345
 346 QPoint DolphinView::contentsPosition() const
 347 {
 348     const int x = itemView()->horizontalScrollBar()->value();
 349     const int y = itemView()->verticalScrollBar()->value();
 350     return QPoint(x, y);
 351 }
 352
 353 void DolphinView::zoomIn()
 354 {
 355     m_controller->triggerZoomIn();
 356     m_iconManager->updatePreviews();
 357 }
 358
 359 void DolphinView::zoomOut()
 360 {
 361     m_controller->triggerZoomOut();
 362     m_iconManager->updatePreviews();
 363 }
 364
 365 bool DolphinView::isZoomInPossible() const
 366 {
 367     return m_controller->isZoomInPossible();
 368 }
 369
 370 bool DolphinView::isZoomOutPossible() const
 371 {
 372     return m_controller->isZoomOutPossible();
 373 }
 374
 375 void DolphinView::setSorting(Sorting sorting)
 376 {
 377     if (sorting != this->sorting()) {
 378         updateSorting(sorting);
 379     }
 380 }
 381
 382 DolphinView::Sorting DolphinView::sorting() const
 383 {
 384     return m_proxyModel->sorting();
 385 }
 386
 387 void DolphinView::setSortOrder(Qt::SortOrder order)
 388 {
 389     if (sortOrder() != order) {
 390         updateSortOrder(order);
 391     }
 392 }
 393
 394 Qt::SortOrder DolphinView::sortOrder() const
 395 {
 396     return m_proxyModel->sortOrder();
 397 }
 398
 399 void DolphinView::setAdditionalInfo(KFileItemDelegate::InformationList info)
 400 {
 401     const KUrl viewPropsUrl = viewPropertiesUrl();
 402     ViewProperties props(viewPropsUrl);
 403     props.setAdditionalInfo(info);
 404     m_fileItemDelegate->setShowInformation(info);
 405
 406     emit additionalInfoChanged();
 407
 408     if (itemView() != m_detailsView) {
 409         // the details view requires no reloading of the directory, as it maps
 410         // the file item delegate info to its columns internally
 411         loadDirectory(viewPropsUrl);
 412     }
 413 }
 414
 415 KFileItemDelegate::InformationList DolphinView::additionalInfo() const
 416 {
 417     return m_fileItemDelegate->showInformation();
 418 }
 419
 420 void DolphinView::reload()
 421 {
 422     setUrl(url());
 423     loadDirectory(url(), true);
 424 }
 425
 426 void DolphinView::refresh()
 427 {
 428     const bool oldActivationState = m_active;
 429     m_active = true;
 430
 431     createView();
 432     applyViewProperties(m_controller->url());
 433     reload();
 434
 435     setActive(oldActivationState);
 436 }
 437
 438 void DolphinView::updateView(const KUrl& url, const KUrl& rootUrl)
 439 {
 440     if (m_controller->url() == url) {
 441         return;
 442     }
 443
 444     m_controller->setUrl(url); // emits urlChanged, which we forward
 445
 446     if (!rootUrl.isEmpty() && rootUrl.isParentOf(url)) {
 447         applyViewProperties(rootUrl);
 448         loadDirectory(rootUrl);
 449         if (itemView() == m_columnView) {
 450             m_columnView->setRootUrl(rootUrl);
 451             m_columnView->showColumn(url);
 452         }
 453     } else {
 454         applyViewProperties(url);
 455         loadDirectory(url);
 456     }
 457
 458     emit startedPathLoading(url);
 459 }
 460
 461 void DolphinView::setNameFilter(const QString& nameFilter)
 462 {
 463     m_proxyModel->setFilterRegExp(nameFilter);
 464
 465     if (isColumnViewActive()) {
 466         // adjusting the directory lister is not enough in the case of the
 467         // column view, as each column has its own directory lister internally...
 468         m_columnView->setNameFilter(nameFilter);
 469     }
 470 }
 471
 472 void DolphinView::calculateItemCount(int& fileCount, int& folderCount)
 473 {
 474     foreach (const KFileItem &item, m_dirLister->items()) {
 475         if (item.isDir()) {
 476             ++folderCount;
 477         } else {
 478             ++fileCount;
 479         }
 480     }
 481 }
 482
 483 void DolphinView::setUrl(const KUrl& url)
 484 {
 485     // remember current item candidate (see restoreCurrentItem())
 486     m_currentItemUrl = url;
 487     updateView(url, KUrl());
 488 }
 489
 490 void DolphinView::changeSelection(const KFileItemList& selection)
 491 {
 492     clearSelection();
 493     if (selection.isEmpty()) {
 494         return;
 495     }
 496     const KUrl& baseUrl = url();
 497     KUrl url;
 498     QItemSelection new_selection;
 499     foreach(const KFileItem& item, selection) {
 500         url = item.url().upUrl();
 501         if (baseUrl.equals(url, KUrl::CompareWithoutTrailingSlash)) {
 502             QModelIndex index = m_proxyModel->mapFromSource(m_dolphinModel->indexForItem(item));
 503             new_selection.select(index, index);
 504         }
 505     }
 506     itemView()->selectionModel()->select(new_selection,
 507                                          QItemSelectionModel::ClearAndSelect
 508                                          | QItemSelectionModel::Current);
 509 }
 510
 511 void DolphinView::renameSelectedItems()
 512 {
 513     const KFileItemList items = selectedItems();
 514     if (items.count() > 1) {
 515         // More than one item has been selected for renaming. Open
 516         // a rename dialog and rename all items afterwards.
 517         RenameDialog dialog(this, items);
 518         if (dialog.exec() == QDialog::Rejected) {
 519             return;
 520         }
 521
 522         const QString newName = dialog.newName();
 523         if (newName.isEmpty()) {
 524             emit errorMessage(dialog.errorString());
 525         } else {
 526             // TODO: check how this can be integrated into KIO::FileUndoManager/KonqOperations
 527             // as one operation instead of n rename operations like it is done now...
 528             Q_ASSERT(newName.contains('#'));
 529
 530             // iterate through all selected items and rename them...
 531             int index = 1;
 532             foreach (const KFileItem &item, items) {
 533                 const KUrl& oldUrl = item.url();
 534                 QString number;
 535                 number.setNum(index++);
 536
 537                 QString name = newName;
 538                 name.replace('#', number);
 539
 540                 if (oldUrl.fileName() != name) {
 541                     KUrl newUrl = oldUrl;
 542                     newUrl.setFileName(name);
 543                     KonqOperations::rename(this, oldUrl, newUrl);
 544                     emit doingOperation(KIO::FileUndoManager::Rename);
 545                 }
 546             }
 547         }
 548     } else if (DolphinSettings::instance().generalSettings()->renameInline()) {
 549         Q_ASSERT(items.count() == 1);
 550
 551         if (isColumnViewActive()) {
 552             m_columnView->editItem(items.first());
 553         } else {
 554             const QModelIndex dirIndex = m_dolphinModel->indexForItem(items.first());
 555             const QModelIndex proxyIndex = m_proxyModel->mapFromSource(dirIndex);
 556             itemView()->edit(proxyIndex);
 557         }
 558     } else {
 559         Q_ASSERT(items.count() == 1);
 560
 561         RenameDialog dialog(this, items);
 562         if (dialog.exec() == QDialog::Rejected) {
 563             return;
 564         }
 565
 566         const QString& newName = dialog.newName();
 567         if (newName.isEmpty()) {
 568             emit errorMessage(dialog.errorString());
 569         } else {
 570             const KUrl& oldUrl = items.first().url();
 571             KUrl newUrl = oldUrl;
 572             newUrl.setFileName(newName);
 573             KonqOperations::rename(this, oldUrl, newUrl);
 574             emit doingOperation(KIO::FileUndoManager::Rename);
 575         }
 576     }
 577 }
 578
 579 void DolphinView::trashSelectedItems()
 580 {
 581     emit doingOperation(KIO::FileUndoManager::Trash);
 582     KonqOperations::del(this, KonqOperations::TRASH, selectedUrls());
 583 }
 584
 585 void DolphinView::deleteSelectedItems()
 586 {
 587     const KUrl::List list = selectedUrls();
 588     const bool del = KonqOperations::askDeleteConfirmation(list,
 589                      KonqOperations::DEL,
 590                      KonqOperations::DEFAULT_CONFIRMATION,
 591                      this);
 592
 593     if (del) {
 594         KIO::Job* job = KIO::del(list);
 595         connect(job, SIGNAL(result(KJob*)),
 596                 this, SLOT(slotDeleteFileFinished(KJob*)));
 597     }
 598 }
 599
 600 void DolphinView::cutSelectedItems()
 601 {
 602     QMimeData* mimeData = new QMimeData();
 603     const KUrl::List kdeUrls = selectedUrls();
 604     const KUrl::List mostLocalUrls;
 605     KonqMimeData::populateMimeData(mimeData, kdeUrls, mostLocalUrls, true);
 606     QApplication::clipboard()->setMimeData(mimeData);
 607 }
 608
 609 void DolphinView::copySelectedItems()
 610 {
 611     QMimeData* mimeData = new QMimeData();
 612     const KUrl::List kdeUrls = selectedUrls();
 613     const KUrl::List mostLocalUrls;
 614     KonqMimeData::populateMimeData(mimeData, kdeUrls, mostLocalUrls, false);
 615     QApplication::clipboard()->setMimeData(mimeData);
 616 }
 617
 618 void DolphinView::paste()
 619 {
 620     pasteToUrl(url());
 621 }
 622
 623 void DolphinView::pasteIntoFolder()
 624 {
 625     const KFileItemList items = selectedItems();
 626     if ((items.count() == 1) && items.first().isDir()) {
 627         pasteToUrl(items.first().url());
 628     }
 629 }
 630
 631 void DolphinView::setShowPreview(bool show)
 632 {
 633     if (m_showPreview == show) {
 634         return;
 635     }
 636
 637     const KUrl viewPropsUrl = viewPropertiesUrl();
 638     ViewProperties props(viewPropsUrl);
 639     props.setShowPreview(show);
 640
 641     m_showPreview = show;
 642     m_iconManager->setShowPreview(show);
 643     emit showPreviewChanged();
 644
 645     loadDirectory(viewPropsUrl);
 646 }
 647
 648 void DolphinView::setShowHiddenFiles(bool show)
 649 {
 650     if (m_dirLister->showingDotFiles() == show) {
 651         return;
 652     }
 653
 654     const KUrl viewPropsUrl = viewPropertiesUrl();
 655     ViewProperties props(viewPropsUrl);
 656     props.setShowHiddenFiles(show);
 657
 658     m_dirLister->setShowingDotFiles(show);
 659     emit showHiddenFilesChanged();
 660
 661     loadDirectory(viewPropsUrl);
 662 }
 663
 664 void DolphinView::setCategorizedSorting(bool categorized)
 665 {
 666     if (categorized == categorizedSorting()) {
 667         return;
 668     }
 669
 670     // setCategorizedSorting(true) may only get invoked
 671     // if the view supports categorized sorting
 672     Q_ASSERT(!categorized || supportsCategorizedSorting());
 673
 674     ViewProperties props(viewPropertiesUrl());
 675     props.setCategorizedSorting(categorized);
 676     props.save();
 677
 678     m_storedCategorizedSorting = categorized;
 679     m_proxyModel->setCategorizedModel(categorized);
 680
 681     emit categorizedSortingChanged();
 682 }
 683
 684 void DolphinView::toggleSortOrder()
 685 {
 686     const Qt::SortOrder order = (sortOrder() == Qt::AscendingOrder) ?
 687                                 Qt::DescendingOrder :
 688                                 Qt::AscendingOrder;
 689     setSortOrder(order);
 690 }
 691
 692 void DolphinView::toggleAdditionalInfo(QAction* action)
 693 {
 694     const KFileItemDelegate::Information info =
 695         static_cast<KFileItemDelegate::Information>(action->data().toInt());
 696
 697     KFileItemDelegate::InformationList list = additionalInfo();
 698
 699     const bool show = action->isChecked();
 700
 701     const int index = list.indexOf(info);
 702     const bool containsInfo = (index >= 0);
 703     if (show && !containsInfo) {
 704         list.append(info);
 705         setAdditionalInfo(list);
 706     } else if (!show && containsInfo) {
 707         list.removeAt(index);
 708         setAdditionalInfo(list);
 709         Q_ASSERT(list.indexOf(info) < 0);
 710     }
 711 }
 712
 713
 714 void DolphinView::mouseReleaseEvent(QMouseEvent* event)
 715 {
 716     QWidget::mouseReleaseEvent(event);
 717     setActive(true);
 718 }
 719
 720 void DolphinView::wheelEvent(QWheelEvent* event)
 721 {
 722     if (event->modifiers() & Qt::ControlModifier) {
 723         const int delta = event->delta();
 724         if ((delta > 0) && isZoomInPossible()) {
 725             zoomIn();
 726         } else if ((delta < 0) && isZoomOutPossible()) {
 727             zoomOut();
 728         }
 729         event->accept();
 730     }
 731 }
 732
 733 bool DolphinView::eventFilter(QObject* watched, QEvent* event)
 734 {
 735     if ((watched == itemView()) && (event->type() == QEvent::FocusIn)) {
 736         m_controller->requestActivation();
 737     }
 738
 739     return QWidget::eventFilter(watched, event);
 740 }
 741
 742 void DolphinView::activate()
 743 {
 744     setActive(true);
 745 }
 746
 747 void DolphinView::triggerItem(const KFileItem& item)
 748 {
 749     const Qt::KeyboardModifiers modifier = QApplication::keyboardModifiers();
 750     if ((modifier & Qt::ShiftModifier) || (modifier & Qt::ControlModifier)) {
 751         // items are selected by the user, hence don't trigger the
 752         // item specified by 'index'
 753         return;
 754     }
 755
 756     // TODO: the m_isContextMenuOpen check is a workaround for Qt-issue 207192
 757     if (item.isNull() || m_isContextMenuOpen) {
 758         return;
 759     }
 760
 761     if (m_toolTipManager != 0) {
 762         m_toolTipManager->hideTip();
 763     }
 764     emit itemTriggered(item); // caught by DolphinViewContainer or DolphinPart
 765 }
 766
 767 void DolphinView::emitSelectionChangedSignal()
 768 {
 769     emit selectionChanged(DolphinView::selectedItems());
 770 }
 771
 772 void DolphinView::openContextMenu(const QPoint& pos)
 773 {
 774     KFileItem item;
 775
 776     const QModelIndex index = itemView()->indexAt(pos);
 777     if (index.isValid() && (index.column() == DolphinModel::Name)) {
 778         item = fileItem(index);
 779     }
 780
 781     if (m_toolTipManager != 0) {
 782         m_toolTipManager->hideTip();
 783     }
 784
 785     m_isContextMenuOpen = true; // TODO: workaround for Qt-issue 207192
 786     emit requestContextMenu(item, url());
 787     m_isContextMenuOpen = false;
 788 }
 789
 790 void DolphinView::dropUrls(const KUrl::List& urls,
 791                            const KUrl& destPath,
 792                            const KFileItem& destItem)
 793 {
 794     Q_ASSERT(!urls.isEmpty());
 795     const KUrl& destination = !destItem.isNull() && destItem.isDir() ?
 796                               destItem.url() : destPath;
 797     const KUrl sourceDir = KUrl(urls.first().directory());
 798     if (sourceDir != destination) {
 799         dropUrls(urls, destination);
 800     }
 801 }
 802
 803 void DolphinView::dropUrls(const KUrl::List& urls,
 804                            const KUrl& destination)
 805 {
 806     DolphinDropController dropController(this);
 807     // forward doingOperation signal up to the mainwindow
 808     connect(&dropController, SIGNAL(doingOperation(KIO::FileUndoManager::CommandType)),
 809             this, SIGNAL(doingOperation(KIO::FileUndoManager::CommandType)));
 810     dropController.dropUrls(urls, destination);
 811 }
 812
 813 void DolphinView::updateSorting(DolphinView::Sorting sorting)
 814 {
 815     ViewProperties props(viewPropertiesUrl());
 816     props.setSorting(sorting);
 817
 818     m_proxyModel->setSorting(sorting);
 819
 820     emit sortingChanged(sorting);
 821 }
 822
 823 void DolphinView::updateSortOrder(Qt::SortOrder order)
 824 {
 825     ViewProperties props(viewPropertiesUrl());
 826     props.setSortOrder(order);
 827
 828     m_proxyModel->setSortOrder(order);
 829
 830     emit sortOrderChanged(order);
 831 }
 832
 833 void DolphinView::updateAdditionalInfo(const KFileItemDelegate::InformationList& info)
 834 {
 835     ViewProperties props(viewPropertiesUrl());
 836     props.setAdditionalInfo(info);
 837     props.save();
 838
 839     m_fileItemDelegate->setShowInformation(info);
 840
 841     emit additionalInfoChanged();
 842 }
 843
 844 void DolphinView::updateAdditionalInfoActions(KActionCollection* collection)
 845 {
 846     const bool enable = (m_mode == DolphinView::DetailsView) ||
 847                         (m_mode == DolphinView::IconsView);
 848
 849     QAction* showSizeInfo = collection->action("show_size_info");
 850     QAction* showDateInfo = collection->action("show_date_info");
 851     QAction* showPermissionsInfo = collection->action("show_permissions_info");
 852     QAction* showOwnerInfo = collection->action("show_owner_info");
 853     QAction* showGroupInfo = collection->action("show_group_info");
 854     QAction* showMimeInfo = collection->action("show_mime_info");
 855
 856     showSizeInfo->setChecked(false);
 857     showDateInfo->setChecked(false);
 858     showPermissionsInfo->setChecked(false);
 859     showOwnerInfo->setChecked(false);
 860     showGroupInfo->setChecked(false);
 861     showMimeInfo->setChecked(false);
 862
 863     showSizeInfo->setEnabled(enable);
 864     showDateInfo->setEnabled(enable);
 865     showPermissionsInfo->setEnabled(enable);
 866     showOwnerInfo->setEnabled(enable);
 867     showGroupInfo->setEnabled(enable);
 868     showMimeInfo->setEnabled(enable);
 869
 870     foreach (KFileItemDelegate::Information info, m_fileItemDelegate->showInformation()) {
 871         switch (info) {
 872         case KFileItemDelegate::Size:
 873             showSizeInfo->setChecked(true);
 874             break;
 875         case KFileItemDelegate::ModificationTime:
 876             showDateInfo->setChecked(true);
 877             break;
 878         case KFileItemDelegate::Permissions:
 879             showPermissionsInfo->setChecked(true);
 880             break;
 881         case KFileItemDelegate::Owner:
 882             showOwnerInfo->setChecked(true);
 883             break;
 884         case KFileItemDelegate::OwnerAndGroup:
 885             showGroupInfo->setChecked(true);
 886             break;
 887         case KFileItemDelegate::FriendlyMimeType:
 888             showMimeInfo->setChecked(true);
 889             break;
 890         default:
 891             break;
 892         }
 893     }
 894 }
 895
 896 QPair<bool, QString> DolphinView::pasteInfo() const
 897 {
 898     QPair<bool, QString> ret;
 899     QClipboard* clipboard = QApplication::clipboard();
 900     const QMimeData* mimeData = clipboard->mimeData();
 901
 902     KUrl::List urls = KUrl::List::fromMimeData(mimeData);
 903     if (!urls.isEmpty()) {
 904         ret.first = true;
 905         if (urls.count() == 1) {
 906             const KFileItem item(KFileItem::Unknown, KFileItem::Unknown, urls.first(), true);
 907             ret.second = item.isDir() ? i18nc("@action:inmenu", "Paste One Folder") :
 908                                         i18nc("@action:inmenu", "Paste One File");
 909
 910         } else {
 911             ret.second = i18ncp("@action:inmenu", "Paste One Item", "Paste %1 Items", urls.count());
 912         }
 913     } else {
 914         ret.first = false;
 915         ret.second = i18nc("@action:inmenu", "Paste");
 916     }
 917
 918     return ret;
 919 }
 920
 921 void DolphinView::setTabsForFilesEnabled(bool tabsForFiles)
 922 {
 923     m_tabsForFiles = tabsForFiles;
 924 }
 925
 926 bool DolphinView::isTabsForFilesEnabled() const
 927 {
 928     return m_tabsForFiles;
 929 }
 930
 931 void DolphinView::emitContentsMoved()
 932 {
 933     // only emit the contents moved signal if:
 934     // - no directory loading is ongoing (this would reset the contents position
 935     //   always to (0, 0))
 936     // - if the Column View is active: the column view does an automatic
 937     //   positioning during the loading operation, which must be remembered
 938     if (!m_loadingDirectory || isColumnViewActive()) {
 939         const QPoint pos(contentsPosition());
 940         emit contentsMoved(pos.x(), pos.y());
 941     }
 942 }
 943
 944 void DolphinView::showHoverInformation(const KFileItem& item)
 945 {
 946     emit requestItemInfo(item);
 947 }
 948
 949 void DolphinView::clearHoverInformation()
 950 {
 951     emit requestItemInfo(KFileItem());
 952 }
 953
 954 void DolphinView::slotDeleteFileFinished(KJob* job)
 955 {
 956     if (job->error() == 0) {
 957         emit operationCompletedMessage(i18nc("@info:status", "Delete operation completed."));
 958     } else {
 959         emit errorMessage(job->errorString());
 960     }
 961 }
 962
 963
 964 void DolphinView::restoreCurrentItem()
 965 {
 966     const QModelIndex dirIndex = m_dolphinModel->indexForUrl(m_currentItemUrl);
 967     if (dirIndex.isValid()) {
 968         const QModelIndex proxyIndex = m_proxyModel->mapFromSource(dirIndex);
 969         QAbstractItemView* view = itemView();
 970         const bool clearSelection = !hasSelection();
 971         view->setCurrentIndex(proxyIndex);
 972         if (clearSelection) {
 973             view->clearSelection();
 974         }
 975     }
 976 }
 977
 978 void DolphinView::loadDirectory(const KUrl& url, bool reload)
 979 {
 980     if (!url.isValid()) {
 981         const QString location(url.pathOrUrl());
 982         if (location.isEmpty()) {
 983             emit errorMessage(i18nc("@info:status", "The location is empty."));
 984         } else {
 985             emit errorMessage(i18nc("@info:status", "The location '%1' is invalid.", location));
 986         }
 987         return;
 988     }
 989
 990     m_loadingDirectory = true;
 991
 992     m_dirLister->stop();
 993     m_dirLister->openUrl(url, reload ? KDirLister::Reload : KDirLister::NoFlags);
 994
 995     if (isColumnViewActive()) {
 996         // adjusting the directory lister is not enough in the case of the
 997         // column view, as each column has its own directory lister internally...
 998         if (reload) {
 999             m_columnView->reload();
1000         } else {
1001             m_columnView->showColumn(url);
1002         }
1003     }
1004 }
1005
1006 KUrl DolphinView::viewPropertiesUrl() const
1007 {
1008     if (isColumnViewActive()) {
1009         return m_columnView->rootUrl();
1010     }
1011
1012     return url();
1013 }
1014
1015 void DolphinView::applyViewProperties(const KUrl& url)
1016 {
1017     if (isColumnViewActive() && rootUrl().isParentOf(url)) {
1018         // The column view is active, hence don't apply the view properties
1019         // of sub directories (represented by columns) to the view. The
1020         // view always represents the properties of the first column.
1021         return;
1022     }
1023
1024     const ViewProperties props(url);
1025
1026     const Mode mode = props.viewMode();
1027     if (m_mode != mode) {
1028         m_mode = mode;
1029         createView();
1030         emit modeChanged();
1031     }
1032     if (itemView() == 0) {
1033         createView();
1034     }
1035     Q_ASSERT(itemView() != 0);
1036     Q_ASSERT(m_fileItemDelegate != 0);
1037
1038     const bool showHiddenFiles = props.showHiddenFiles();
1039     if (showHiddenFiles != m_dirLister->showingDotFiles()) {
1040         m_dirLister->setShowingDotFiles(showHiddenFiles);
1041         emit showHiddenFilesChanged();
1042     }
1043
1044     m_storedCategorizedSorting = props.categorizedSorting();
1045     const bool categorized = m_storedCategorizedSorting && supportsCategorizedSorting();
1046     if (categorized != m_proxyModel->isCategorizedModel()) {
1047         m_proxyModel->setCategorizedModel(categorized);
1048         emit categorizedSortingChanged();
1049     }
1050
1051     const DolphinView::Sorting sorting = props.sorting();
1052     if (sorting != m_proxyModel->sorting()) {
1053         m_proxyModel->setSorting(sorting);
1054         emit sortingChanged(sorting);
1055     }
1056
1057     const Qt::SortOrder sortOrder = props.sortOrder();
1058     if (sortOrder != m_proxyModel->sortOrder()) {
1059         m_proxyModel->setSortOrder(sortOrder);
1060         emit sortOrderChanged(sortOrder);
1061     }
1062
1063     KFileItemDelegate::InformationList info = props.additionalInfo();
1064     if (info != m_fileItemDelegate->showInformation()) {
1065         m_fileItemDelegate->setShowInformation(info);
1066         emit additionalInfoChanged();
1067     }
1068
1069     const bool showPreview = props.showPreview();
1070     if (showPreview != m_showPreview) {
1071         m_showPreview = showPreview;
1072         m_iconManager->setShowPreview(showPreview);
1073         emit showPreviewChanged();
1074     }
1075 }
1076
1077 void DolphinView::createView()
1078 {
1079     deleteView();
1080     Q_ASSERT(m_iconsView == 0);
1081     Q_ASSERT(m_detailsView == 0);
1082     Q_ASSERT(m_columnView == 0);
1083
1084     QAbstractItemView* view = 0;
1085     switch (m_mode) {
1086     case IconsView: {
1087         m_iconsView = new DolphinIconsView(this, m_controller);
1088         view = m_iconsView;
1089         break;
1090     }
1091
1092     case DetailsView:
1093         m_detailsView = new DolphinDetailsView(this, m_controller);
1094         view = m_detailsView;
1095         break;
1096
1097     case ColumnView:
1098         m_columnView = new DolphinColumnView(this, m_controller);
1099         view = m_columnView;
1100         break;
1101     }
1102
1103     Q_ASSERT(view != 0);
1104     view->installEventFilter(this);
1105
1106     m_controller->setItemView(view);
1107
1108     m_fileItemDelegate = new KFileItemDelegate(view);
1109     view->setItemDelegate(m_fileItemDelegate);
1110
1111     view->setModel(m_proxyModel);
1112     if (m_selectionModel != 0) {
1113         view->setSelectionModel(m_selectionModel);
1114     } else {
1115         m_selectionModel = view->selectionModel();
1116     }
1117
1118     // reparent the selection model, as it should not be deleted
1119     // when deleting the model
1120     m_selectionModel->setParent(this);
1121
1122     view->setSelectionMode(QAbstractItemView::ExtendedSelection);
1123
1124     new KMimeTypeResolver(view, m_dolphinModel);
1125     m_iconManager = new IconManager(view, m_proxyModel);
1126     m_iconManager->setShowPreview(m_showPreview);
1127
1128     if (DolphinSettings::instance().generalSettings()->showToolTips()) {
1129         m_toolTipManager = new ToolTipManager(view, m_proxyModel);
1130     }
1131
1132     m_topLayout->insertWidget(1, view);
1133
1134     connect(view->selectionModel(), SIGNAL(selectionChanged(const QItemSelection&, const QItemSelection&)),
1135             this, SLOT(emitSelectionChangedSignal()));
1136     connect(view->verticalScrollBar(), SIGNAL(valueChanged(int)),
1137             this, SLOT(emitContentsMoved()));
1138     connect(view->horizontalScrollBar(), SIGNAL(valueChanged(int)),
1139             this, SLOT(emitContentsMoved()));
1140 }
1141
1142 void DolphinView::deleteView()
1143 {
1144     QAbstractItemView* view = itemView();
1145     if (view != 0) {
1146         m_topLayout->removeWidget(view);
1147         view->close();
1148         view->deleteLater();
1149         view = 0;
1150         m_iconsView = 0;
1151         m_detailsView = 0;
1152         m_columnView = 0;
1153         m_fileItemDelegate = 0;
1154         m_iconManager = 0;
1155         m_toolTipManager = 0;
1156     }
1157 }
1158
1159 QAbstractItemView* DolphinView::itemView() const
1160 {
1161     if (m_detailsView != 0) {
1162         return m_detailsView;
1163     } else if (m_columnView != 0) {
1164         return m_columnView;
1165     }
1166
1167     return m_iconsView;
1168 }
1169
1170 bool DolphinView::isCutItem(const KFileItem& item) const
1171 {
1172     const QMimeData* mimeData = QApplication::clipboard()->mimeData();
1173     const KUrl::List cutUrls = KUrl::List::fromMimeData(mimeData);
1174
1175     const KUrl& itemUrl = item.url();
1176     KUrl::List::const_iterator it = cutUrls.begin();
1177     const KUrl::List::const_iterator end = cutUrls.end();
1178     while (it != end) {
1179         if (*it == itemUrl) {
1180             return true;
1181         }
1182         ++it;
1183     }
1184
1185     return false;
1186 }
1187
1188 void DolphinView::pasteToUrl(const KUrl& url)
1189 {
1190     QClipboard* clipboard = QApplication::clipboard();
1191     const QMimeData* mimeData = clipboard->mimeData();
1192
1193     const KUrl::List sourceUrls = KUrl::List::fromMimeData(mimeData);
1194     if (KonqMimeData::decodeIsCutSelection(mimeData)) {
1195         KonqOperations::copy(this, KonqOperations::MOVE, sourceUrls, url);
1196         emit doingOperation(KIO::FileUndoManager::Move);
1197         clipboard->clear();
1198     } else {
1199         KonqOperations::copy(this, KonqOperations::COPY, sourceUrls, url);
1200         emit doingOperation(KIO::FileUndoManager::Copy);
1201     }
1202 }
1203
1204 void DolphinView::slotRequestUrlChange(const KUrl& url)
1205 {
1206     emit requestUrlChange(url);
1207     m_controller->setUrl(url);
1208 }
1209
1210 void DolphinView::slotRedirection(const KUrl& oldUrl, const KUrl& newUrl)
1211 {
1212     if (oldUrl == m_controller->url()) {
1213         m_controller->setUrl(newUrl);
1214     }
1215 }
1216
1217 #include "dolphinview.moc"