]> cloud.milkyroute.net Git - dolphin.git/blobdiff - src/dolphindetailsview.cpp
projects / dolphin.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
* Use Nepomuk for getting the meta data instead of KFileMetaInfo.
[dolphin.git] / src / dolphindetailsview.cpp
diff --git a/src/dolphindetailsview.cpp b/src/dolphindetailsview.cpp
index 9e1e0ab27020b988dc44c85ed6b7dabef78f3231..dd58e584248bbf57e73e1f722375bb9fb004783c 100644 (file)
--- a/src/dolphindetailsview.cpp
+++ b/src/dolphindetailsview.cpp
@@ -1,6 +1,6 @@
 /***************************************************************************
 /***************************************************************************
- *   Copyright (C) 2006 by Peter Penz                                      *
- *   peter.penz@gmx.at                                                     *
+ *   Copyright (C) 2006 by Peter Penz (peter.penz@gmx.at)                  *
+ *   Copyright (C) 2008 by Simon St. James (kdedevel@etotheipiplusone.com) *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
@@ -15,804 +15,965 @@
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
- *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA            *
  ***************************************************************************/
 
 #include "dolphindetailsview.h"
 
  ***************************************************************************/
 
 #include "dolphindetailsview.h"
 
-#include <qpainter.h>
-#include <qobject.h>
-#include <q3header.h>
-#include <qclipboard.h>
-#include <qpainter.h>
-//Added by qt3to4:
-#include <Q3ValueList>
-#include <QPixmap>
-#include <QDragMoveEvent>
-#include <QDropEvent>
-#include <QResizeEvent>
-#include <QMouseEvent>
-#include <QEvent>
-#include <QPaintEvent>
-#include <QStyleOptionFocusRect>
-#include <klocale.h>
-#include <kglobalsettings.h>
-#include <kicontheme.h>
-#include <qscrollbar.h>
-#include <qcursor.h>
-#include <qstyle.h>
-#include <assert.h>
-
-#include "dolphinview.h"
+#include "dolphinmodel.h"
+#include "dolphincontroller.h"
+#include "dolphinfileitemdelegate.h"
+#include "settings/dolphinsettings.h"
+#include "dolphinsortfilterproxymodel.h"
+#include "dolphinviewautoscroller.h"
+#include "draganddrophelper.h"
+#include "selectionmanager.h"
 #include "viewproperties.h"
 #include "viewproperties.h"
-#include "dolphin.h"
-#include "kiconeffect.h"
-#include "dolphinsettings.h"
-#include "dolphinstatusbar.h"
-#include "detailsmodesettings.h"
-
-DolphinDetailsView::DolphinDetailsView(DolphinView* parent) :
-    KFileDetailView(parent),
-    m_dolphinView(parent),
-    m_resizeTimer(0),
-    m_scrollTimer(0),
-    m_rubber(0)
-{
-    m_resizeTimer = new QTimer(this);
-    connect(m_resizeTimer, SIGNAL(timeout()),
-            this, SLOT(updateColumnsWidth()));
+#include "zoomlevelinfo.h"
+
+#include "dolphin_detailsmodesettings.h"
+#include "dolphin_generalsettings.h"
+
+#include <kdirmodel.h>
+#include <klocale.h>
+#include <kmenu.h>
+
+#include <QAbstractProxyModel>
+#include <QAction>
+#include <QApplication>
+#include <QHeaderView>
+#include <QRubberBand>
+#include <QPainter>
+#include <QScrollBar>
+
+DolphinDetailsView::DolphinDetailsView(QWidget* parent, DolphinController* controller) :
+    QTreeView(parent),
+    m_autoResize(true),
+    m_expandingTogglePressed(false),
+    m_keyPressed(false),
+    m_useDefaultIndexAt(true),
+    m_ignoreScrollTo(false),
+    m_controller(controller),
+    m_selectionManager(0),
+    m_autoScroller(0),
+    m_expandableFoldersAction(0),
+    m_font(),
+    m_decorationSize(),
+    m_band()
+{
+    const DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
+    Q_ASSERT(settings != 0);
+    Q_ASSERT(controller != 0);
 
 
+    setLayoutDirection(Qt::LeftToRight);
     setAcceptDrops(true);
     setAcceptDrops(true);
-    setSelectionMode(KFile::Extended);
-    setHScrollBarMode(Q3ScrollView::AlwaysOff);
-
-    setColumnAlignment(SizeColumn, Qt::AlignRight);
-    for (int i = DateColumn; i <= GroupColumn; ++i) {
-        setColumnAlignment(i, Qt::AlignHCenter);
-    }
-
-    Dolphin& dolphin = Dolphin::mainWin();
-
-    connect(this, SIGNAL(onItem(Q3ListViewItem*)),
-            this, SLOT(slotOnItem(Q3ListViewItem*)));
-    connect(this, SIGNAL(onViewport()),
-            this, SLOT(slotOnViewport()));
-    connect(this, SIGNAL(contextMenuRequested(Q3ListViewItem*, const QPoint&, int)),
-            this, SLOT(slotContextMenuRequested(Q3ListViewItem*, const QPoint&, int)));
-    connect(this, SIGNAL(selectionChanged()),
-            &dolphin, SLOT(slotSelectionChanged()));
-    connect(&dolphin, SIGNAL(activeViewChanged()),
-            this, SLOT(slotActivationUpdate()));
-    connect(this, SIGNAL(itemRenamed(Q3ListViewItem*, const QString&, int)),
-            this, SLOT(slotItemRenamed(Q3ListViewItem*, const QString&, int)));
-    connect(this, SIGNAL(dropped(QDropEvent*, const KUrl::List&, const KUrl&)),
-            parent, SLOT(slotUrlListDropped(QDropEvent*, const KUrl::List&, const KUrl&)));
-
-    QClipboard* clipboard = QApplication::clipboard();
-    connect(clipboard, SIGNAL(dataChanged()),
-            this, SLOT(slotUpdateDisabledItems()));
-
-    Q3Header* viewHeader = header();
-    viewHeader->setResizeEnabled(false);
-    viewHeader->setMovingEnabled(false);
-    connect(viewHeader, SIGNAL(clicked(int)),
-            this, SLOT(slotHeaderClicked(int)));
+    setSortingEnabled(true);
+    setUniformRowHeights(true);
+    setSelectionBehavior(SelectItems);
+    setDragDropMode(QAbstractItemView::DragDrop);
+    setDropIndicatorShown(false);
+    setAlternatingRowColors(true);
+    setRootIsDecorated(settings->expandableFolders());
+    setItemsExpandable(settings->expandableFolders());
+    setEditTriggers(QAbstractItemView::NoEditTriggers);
 
     setMouseTracking(true);
 
     setMouseTracking(true);
-    setDefaultRenameAction(Q3ListView::Accept);
-
-    refreshSettings();
+    m_autoScroller = new DolphinViewAutoScroller(this);
+
+    const ViewProperties props(controller->url());
+    setSortIndicatorSection(props.sorting());
+    setSortIndicatorOrder(props.sortOrder());
+
+    QHeaderView* headerView = header();
+    connect(headerView, SIGNAL(sectionClicked(int)),
+            this, SLOT(synchronizeSortingState(int)));
+    headerView->setContextMenuPolicy(Qt::CustomContextMenu);
+    connect(headerView, SIGNAL(customContextMenuRequested(const QPoint&)),
+            this, SLOT(configureSettings(const QPoint&)));
+    connect(headerView, SIGNAL(sectionResized(int, int, int)),
+            this, SLOT(slotHeaderSectionResized(int, int, int)));
+    connect(headerView, SIGNAL(sectionHandleDoubleClicked(int)),
+            this, SLOT(disableAutoResizing()));
+
+    connect(parent, SIGNAL(sortingChanged(DolphinView::Sorting)),
+            this, SLOT(setSortIndicatorSection(DolphinView::Sorting)));
+    connect(parent, SIGNAL(sortOrderChanged(Qt::SortOrder)),
+            this, SLOT(setSortIndicatorOrder(Qt::SortOrder)));
+
+    connect(this, SIGNAL(clicked(const QModelIndex&)),
+            controller, SLOT(requestTab(const QModelIndex&)));
+    if (KGlobalSettings::singleClick()) {
+        connect(this, SIGNAL(clicked(const QModelIndex&)),
+                controller, SLOT(triggerItem(const QModelIndex&)));
+    } else {
+        connect(this, SIGNAL(doubleClicked(const QModelIndex&)),
+                controller, SLOT(triggerItem(const QModelIndex&)));
+    }
+
+    if (DolphinSettings::instance().generalSettings()->showSelectionToggle()) {
+        m_selectionManager = new SelectionManager(this);
+        connect(m_selectionManager, SIGNAL(selectionChanged()),
+                this, SLOT(requestActivation()));
+        connect(m_controller, SIGNAL(urlChanged(const KUrl&)),
+                m_selectionManager, SLOT(reset()));
+    }
+
+    connect(this, SIGNAL(entered(const QModelIndex&)),
+            this, SLOT(slotEntered(const QModelIndex&)));
+    connect(this, SIGNAL(viewportEntered()),
+            controller, SLOT(emitViewportEntered()));
+    connect(controller, SIGNAL(zoomLevelChanged(int)),
+            this, SLOT(setZoomLevel(int)));
+    connect(controller->dolphinView(), SIGNAL(additionalInfoChanged()),
+            this, SLOT(updateColumnVisibility()));
+    connect(controller, SIGNAL(activationChanged(bool)),
+            this, SLOT(slotActivationChanged(bool)));
+
+    if (settings->useSystemFont()) {
+        m_font = KGlobalSettings::generalFont();
+    } else {
+        m_font = QFont(settings->fontFamily(),
+                       settings->fontSize(),
+                       settings->fontWeight(),
+                       settings->italicFont());
+    }
+
+    setVerticalScrollMode(QTreeView::ScrollPerPixel);
+    setHorizontalScrollMode(QTreeView::ScrollPerPixel);
+
+    const DolphinView* view = controller->dolphinView();
+    connect(view, SIGNAL(showPreviewChanged()),
+            this, SLOT(slotShowPreviewChanged()));
+
+    updateDecorationSize(view->showPreview());
+
+    setFocus();
+    viewport()->installEventFilter(this);
+
+    connect(KGlobalSettings::self(), SIGNAL(settingsChanged(int)),
+            this, SLOT(slotGlobalSettingsChanged(int)));
+
+    m_useDefaultIndexAt = false;
+
+    m_expandableFoldersAction = new QAction(i18nc("@option:check", "Expandable Folders"), this);
+    m_expandableFoldersAction->setCheckable(true);
+    connect(m_expandableFoldersAction, SIGNAL(toggled(bool)),
+            this, SLOT(setFoldersExpandable(bool)));
 }
 
 DolphinDetailsView::~DolphinDetailsView()
 {
 }
 
 DolphinDetailsView::~DolphinDetailsView()
 {
-    delete m_rubber;
-    m_rubber = 0;
 }
 
 }
 
-void DolphinDetailsView::beginItemUpdates()
+bool DolphinDetailsView::event(QEvent* event)
 {
 {
-}
+    if (event->type() == QEvent::Polish) {
+        QHeaderView* headerView = header();
+        headerView->setResizeMode(QHeaderView::Interactive);
+        headerView->setMovable(false);
 
 
-void DolphinDetailsView::endItemUpdates()
-{
-    updateDisabledItems();
+        updateColumnVisibility();
 
 
-    // Restore the current item. Use the information stored in the history if
-    // available. Otherwise use the first item as current item.
-
-    const KFileListViewItem* item = static_cast<const KFileListViewItem*>(firstChild());
-    if (item != 0) {
-        setCurrentItem(item->fileInfo());
+        hideColumn(DolphinModel::Rating);
+        hideColumn(DolphinModel::Tags);
     }
 
     }
 
-    int index = 0;
-    const Q3ValueList<UrlNavigator::HistoryElem> history = m_dolphinView->urlHistory(index);
-    if (!history.isEmpty()) {
-        KFileView* fileView = static_cast<KFileView*>(this);
-        fileView->setCurrentItem(history[index].currentFileName());
-        setContentsPos(history[index].contentsX(), history[index].contentsY());
-    }
-
-    updateColumnsWidth();
+    return QTreeView::event(event);
 }
 
 }
 
-void DolphinDetailsView::insertItem(KFileItem* fileItem)
+QStyleOptionViewItem DolphinDetailsView::viewOptions() const
 {
 {
-    KFileView::insertItem(fileItem);
-
-    DolphinListViewItem* item = new DolphinListViewItem(static_cast<Q3ListView*>(this), fileItem);
-
-    QDir::SortFlags spec = KFileView::sorting();
-    if (spec & QDir::Time) {
-        item->setKey(sortingKey(fileItem->time(KIO::UDS_MODIFICATION_TIME),
-                                fileItem->isDir(),
-                                spec));
-    }
-    else if (spec & QDir::Size) {
-       item->setKey(sortingKey(fileItem->size(), fileItem->isDir(), spec));
-    }
-    else {
-       item->setKey(sortingKey(fileItem->text(), fileItem->isDir(), spec));
-    }
-
-    fileItem->setExtraData(this, item);
+    QStyleOptionViewItem viewOptions = QTreeView::viewOptions();
+    viewOptions.font = m_font;
+    viewOptions.showDecorationSelected = true;
+    viewOptions.decorationSize = m_decorationSize;
+    return viewOptions;
 }
 
 }
 
-bool DolphinDetailsView::isOnFilename(const Q3ListViewItem* item, const QPoint& pos) const
+void DolphinDetailsView::contextMenuEvent(QContextMenuEvent* event)
 {
 {
-    const QPoint absPos(mapToGlobal(QPoint(0, 0)));
-    return (pos.x() - absPos.x()) <= filenameWidth(item);
-}
+    QTreeView::contextMenuEvent(event);
 
 
-void DolphinDetailsView::refreshSettings()
-{
-    const DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
-    assert(settings != 0);
-
-    if (!settings->showGroup()) {
-        removeColumn(GroupColumn);
-    }
-    if (!settings->showOwner()) {
-        removeColumn(OwnerColumn);
-    }
-    if (!settings->showPermissions()) {
-        removeColumn(PermissionsColumn);
-    }
-    if (!settings->showDate()) {
-        removeColumn(DateColumn);
+    DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
+    m_expandableFoldersAction->setChecked(settings->expandableFolders());
+    m_controller->triggerContextMenuRequest(event->pos(),
+                                            QList<QAction*>() << m_expandableFoldersAction);
+}
+
+void DolphinDetailsView::mousePressEvent(QMouseEvent* event)
+{
+    m_controller->requestActivation();
+
+    const QModelIndex current = currentIndex();
+    QTreeView::mousePressEvent(event);
+
+    m_expandingTogglePressed = false;
+    const QModelIndex index = indexAt(event->pos());
+    const bool updateState = index.isValid() &&
+                             (index.column() == DolphinModel::Name) &&
+                             (event->button() == Qt::LeftButton);
+    if (updateState) {
+        // TODO: See comment in DolphinIconsView::mousePressEvent(). Only update
+        // the state if no expanding/collapsing area has been hit:
+        const QRect rect = visualRect(index);
+        if (event->pos().x() >= rect.x() + indentation()) {
+            setState(QAbstractItemView::DraggingState);
+        } else {
+            m_expandingTogglePressed = true;
+        }
     }
 
     }
 
-    QFont adjustedFont(font());
-    adjustedFont.setFamily(settings->fontFamily());
-    adjustedFont.setPointSize(settings->fontSize());
-    setFont(adjustedFont);
+    if (!index.isValid() || (index.column() != DolphinModel::Name)) {
+        // the mouse press is done somewhere outside the filename column
+        if (QApplication::mouseButtons() & Qt::MidButton) {
+            m_controller->replaceUrlByClipboard();
+        }
 
 
-    updateView(true);
-}
+        const Qt::KeyboardModifiers modifier = QApplication::keyboardModifiers();
+        if (!(modifier & Qt::ShiftModifier) && !(modifier & Qt::ControlModifier)) {
+            clearSelection();
+        }
 
 
-void DolphinDetailsView::zoomIn()
-{
-    if (isZoomInPossible()) {
-        DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
-        switch (settings->iconSize()) {
-            case K3Icon::SizeSmall:  settings->setIconSize(K3Icon::SizeMedium); break;
-            case K3Icon::SizeMedium: settings->setIconSize(K3Icon::SizeLarge); break;
-            default: assert(false); break;
+        // restore the current index, other columns are handled as viewport area.
+        // setCurrentIndex(...) implicitly calls scrollTo(...), which we want to ignore.
+        m_ignoreScrollTo = true;
+        selectionModel()->setCurrentIndex(current, QItemSelectionModel::Current);
+        m_ignoreScrollTo = false;
+
+        if ((event->button() == Qt::LeftButton) && !m_expandingTogglePressed) {
+            // Inform Qt about what we are doing - otherwise it starts dragging items around!
+            setState(DragSelectingState);
+            m_band.show = true;
+            // Incremental update data will not be useful - start from scratch.
+            m_band.ignoreOldInfo = true;
+            const QPoint scrollPos(horizontalScrollBar()->value(), verticalScrollBar()->value());
+            m_band.origin = event->pos()  + scrollPos;
+            m_band.destination = m_band.origin;
+            m_band.originalSelection = selectionModel()->selection();
         }
         }
-        ItemEffectsManager::zoomIn();
     }
 }
 
     }
 }
 
-void DolphinDetailsView::zoomOut()
+void DolphinDetailsView::mouseMoveEvent(QMouseEvent* event)
 {
 {
-    if (isZoomOutPossible()) {
-        DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
-        switch (settings->iconSize()) {
-            case K3Icon::SizeLarge:  settings->setIconSize(K3Icon::SizeMedium); break;
-            case K3Icon::SizeMedium: settings->setIconSize(K3Icon::SizeSmall); break;
-            default: assert(false); break;
+    if (m_band.show) {
+        const QPoint mousePos = event->pos();
+        const QModelIndex index = indexAt(mousePos);
+        if (!index.isValid()) {
+            // the destination of the selection rectangle is above the viewport. In this
+            // case QTreeView does no selection at all, which is not the wanted behavior
+            // in Dolphin -> select all items within the elastic band rectangle
+            updateElasticBandSelection();
         }
         }
-        ItemEffectsManager::zoomOut();
+
+        // TODO: enable QTreeView::mouseMoveEvent(event) again, as soon
+        // as the Qt-issue #199631 has been fixed.
+        // QTreeView::mouseMoveEvent(event);
+        QAbstractItemView::mouseMoveEvent(event);
+        updateElasticBand();
+    } else {
+        // TODO: enable QTreeView::mouseMoveEvent(event) again, as soon
+        // as the Qt-issue #199631 has been fixed.
+        // QTreeView::mouseMoveEvent(event);
+        QAbstractItemView::mouseMoveEvent(event);
     }
     }
-}
 
 
-bool DolphinDetailsView::isZoomInPossible() const
-{
-    DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
-    return settings->iconSize() < K3Icon::SizeLarge;
+    if (m_expandingTogglePressed) {
+        // Per default QTreeView starts either a selection or a drag operation when dragging
+        // the expanding toggle button (Qt-issue - see TODO comment in DolphinIconsView::mousePressEvent()).
+        // Turn off this behavior in Dolphin to stay predictable:
+        clearSelection();
+        setState(QAbstractItemView::NoState);
+    }
 }
 
 }
 
-bool DolphinDetailsView::isZoomOutPossible() const
+void DolphinDetailsView::mouseReleaseEvent(QMouseEvent* event)
 {
 {
-    DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
-    return settings->iconSize() > K3Icon::SizeSmall;
+    const QModelIndex index = indexAt(event->pos());
+    if (index.isValid() && (index.column() == DolphinModel::Name)) {
+        QTreeView::mouseReleaseEvent(event);
+    } else {
+        // don't change the current index if the cursor is released
+        // above any other column than the name column, as the other
+        // columns act as viewport
+        const QModelIndex current = currentIndex();
+        QTreeView::mouseReleaseEvent(event);
+        selectionModel()->setCurrentIndex(current, QItemSelectionModel::Current);
+    }
+
+    m_expandingTogglePressed = false;
+    if (m_band.show) {
+        setState(NoState);
+        updateElasticBand();
+        m_band.show = false;
+    }
 }
 
 }
 
-void DolphinDetailsView::resizeContents(int width, int height)
+void DolphinDetailsView::startDrag(Qt::DropActions supportedActions)
 {
 {
-    KFileDetailView::resizeContents(width, height);
-
-    // When loading several 1000 items a punch of resize events
-    // drops in. As updating the column width is a quite expensive
-    // operation, this operation will be postponed until there is
-    // no resize event for at least 50 milliseconds.
-    m_resizeTimer->stop();
-    m_resizeTimer->start(50, true);
+    DragAndDropHelper::instance().startDrag(this, supportedActions, m_controller);
+    m_band.show = false;
 }
 
 }
 
-void DolphinDetailsView::slotOnItem(Q3ListViewItem* item)
+void DolphinDetailsView::dragEnterEvent(QDragEnterEvent* event)
 {
 {
-    if (isOnFilename(item, QCursor::pos())) {
-        activateItem(item);
-        KFileItem* fileItem = static_cast<KFileListViewItem*>(item)->fileInfo();
-        m_dolphinView->requestItemInfo(fileItem->url());
+    if (DragAndDropHelper::instance().isMimeDataSupported(event->mimeData())) {
+        event->acceptProposedAction();
     }
     }
-    else {
-        resetActivatedItem();
+
+    if (m_band.show) {
+        updateElasticBand();
+        m_band.show = false;
     }
 }
 
     }
 }
 
-void DolphinDetailsView::slotOnViewport()
+void DolphinDetailsView::dragLeaveEvent(QDragLeaveEvent* event)
 {
 {
-    resetActivatedItem();
-    m_dolphinView->requestItemInfo(KUrl());
+    QTreeView::dragLeaveEvent(event);
+    setDirtyRegion(m_dropRect);
 }
 
 }
 
-void DolphinDetailsView::setContextPixmap(void* context,
-                                        const QPixmap& pixmap)
+void DolphinDetailsView::dragMoveEvent(QDragMoveEvent* event)
 {
 {
-    reinterpret_cast<KFileListViewItem*>(context)->setPixmap(0, pixmap);
-}
+    QTreeView::dragMoveEvent(event);
 
 
-const QPixmap* DolphinDetailsView::contextPixmap(void* context)
-{
-    return reinterpret_cast<KFileListViewItem*>(context)->pixmap(0);
-}
+    // TODO: remove this code when the issue #160611 is solved in Qt 4.4
+    setDirtyRegion(m_dropRect);
+    const QModelIndex index = indexAt(event->pos());
+    if (index.isValid() && (index.column() == DolphinModel::Name)) {
+        const KFileItem item = m_controller->itemForIndex(index);
+        if (!item.isNull() && item.isDir()) {
+            m_dropRect = visualRect(index);
+        } else {
+            m_dropRect.setSize(QSize()); // set as invalid
+        }
+        setDirtyRegion(m_dropRect);
+    }
 
 
-void* DolphinDetailsView::firstContext()
-{
-    return reinterpret_cast<void*>(firstChild());
+    if (DragAndDropHelper::instance().isMimeDataSupported(event->mimeData())) {
+        // accept url drops, independently from the destination item
+        event->acceptProposedAction();
+    }
 }
 
 }
 
-void* DolphinDetailsView::nextContext(void* context)
+void DolphinDetailsView::dropEvent(QDropEvent* event)
 {
 {
-    KFileListViewItem* listViewItem = reinterpret_cast<KFileListViewItem*>(context);
-    return reinterpret_cast<void*>(listViewItem->nextSibling());
+    const QModelIndex index = indexAt(event->pos());
+    KFileItem item;
+    if (index.isValid() && (index.column() == DolphinModel::Name)) {
+        item = m_controller->itemForIndex(index);
+    }
+    m_controller->indicateDroppedUrls(item, m_controller->url(), event);
+    QTreeView::dropEvent(event);
 }
 
 }
 
-KFileItem* DolphinDetailsView::contextFileInfo(void* context)
+void DolphinDetailsView::paintEvent(QPaintEvent* event)
 {
 {
-    return reinterpret_cast<KFileListViewItem*>(context)->fileInfo();
-}
+    QTreeView::paintEvent(event);
+    if (m_band.show) {
+        // The following code has been taken from QListView
+        // and adapted to DolphinDetailsView.
+        // (C) 1992-2007 Trolltech ASA
+        QStyleOptionRubberBand opt;
+        opt.initFrom(this);
+        opt.shape = QRubberBand::Rectangle;
+        opt.opaque = false;
+        opt.rect = elasticBandRect();
 
 
+        QPainter painter(viewport());
+        painter.save();
+        style()->drawControl(QStyle::CE_RubberBand, &opt, &painter);
+        painter.restore();
+    }
+}
 
 
-void DolphinDetailsView::contentsDragMoveEvent(QDragMoveEvent* event)
+void DolphinDetailsView::keyPressEvent(QKeyEvent* event)
 {
 {
-    KFileDetailView::contentsDragMoveEvent(event);
-
-    // If a dragging is done above a directory, show the icon as 'active' for
-    // a visual feedback
-    KFileListViewItem* item = static_cast<KFileListViewItem*>(itemAt(event->pos()));
+    // If the Control modifier is pressed, a multiple selection
+    // is done and DolphinDetailsView::currentChanged() may not
+    // not change the selection in a custom way.
+    m_keyPressed = !(event->modifiers() & Qt::ControlModifier);
 
 
-    bool showActive = false;
-    if (item != 0) {
-        const KFileItem* fileInfo = item->fileInfo();
-        showActive = (fileInfo != 0) && fileInfo->isDir();
-    }
+    QTreeView::keyPressEvent(event);
+    m_controller->handleKeyPressEvent(event);
+}
 
 
-    if (showActive) {
-        slotOnItem(item);
-    }
-    else {
-        slotOnViewport();
-    }
+void DolphinDetailsView::keyReleaseEvent(QKeyEvent* event)
+{
+    QTreeView::keyReleaseEvent(event);
+    m_keyPressed = false;
 }
 
 void DolphinDetailsView::resizeEvent(QResizeEvent* event)
 {
 }
 
 void DolphinDetailsView::resizeEvent(QResizeEvent* event)
 {
-    KFileDetailView::resizeEvent(event);
-
-    // When loading several 1000 items a punch of resize events
-    // drops in. As updating the column width is a quite expensive
-    // operation, this operation will be postponed until there is
-    // no resize event for at least 50 milliseconds.
-    m_resizeTimer->stop();
-    m_resizeTimer->start(50, true);
-}
-
-bool DolphinDetailsView::acceptDrag(QDropEvent* event) const
-{
-    KUrl::List uriList = KUrl::List::fromMimeData( event->mimeData() );
-    bool accept = !uriList.isEmpty() &&
-                  (event->action() == QDropEvent::Copy ||
-                   event->action() == QDropEvent::Move ||
-                   event->action() == QDropEvent::Link);
-    if (accept) {
-        if (static_cast<const QWidget*>(event->source()) == this) {
-            KFileListViewItem* item = static_cast<KFileListViewItem*>(itemAt(event->pos()));
-            accept = (item != 0);
-            if (accept) {
-                KFileItem* fileItem = item->fileInfo();
-                accept = fileItem->isDir();
-            }
-        }
+    QTreeView::resizeEvent(event);
+    if (m_autoResize) {
+        resizeColumns();
     }
     }
-
-    return accept;
 }
 
 }
 
-void DolphinDetailsView::contentsDropEvent(QDropEvent* event)
+void DolphinDetailsView::wheelEvent(QWheelEvent* event)
 {
 {
-    // KFileDetailView::contentsDropEvent does not care whether the mouse
-    // cursor is above a filename or not, the destination Url is always
-    // the Url of the item. This is fixed here in a way that the destination
-    // Url is only the Url of the item if the cursor is above the filename.
-    const QPoint pos(QCursor::pos());
-    const QPoint viewportPos(viewport()->mapToGlobal(QPoint(0, 0)));
-    Q3ListViewItem* item = itemAt(QPoint(pos.x() - viewportPos.x(), pos.y() - viewportPos.y()));
-    if ((item == 0) || ((item != 0) && isOnFilename(item, pos))) {
-        // dropping is done on the viewport or directly above a filename
-        KFileDetailView::contentsDropEvent(event);
-        return;
+    if (m_selectionManager != 0) {
+        m_selectionManager->reset();
     }
 
     }
 
-    // Dropping is done above an item, but the mouse cursor is not above the file name.
-    // In this case the signals of the base implementation will be blocked and send
-    // in a corrected manner afterwards.
-    assert(item != 0);
-    const bool block = signalsBlocked();
-    blockSignals(true);
-    KFileDetailView::contentsDropEvent(event);
-    blockSignals(block);
-
-    if (!acceptDrag(event)) {
+    // let Ctrl+wheel events propagate to the DolphinView for icon zooming
+    if (event->modifiers() & Qt::ControlModifier) {
+        event->ignore();
         return;
     }
 
         return;
     }
 
-    emit dropped(event, 0);
-    KUrl::List urls = KUrl::List::fromMimeData( event->mimeData() );
-    if (!urls.isEmpty()) {
-        emit dropped(event, urls, KUrl());
-        sig->dropURLs(0, event, urls);
-    }
+    const int height = m_decorationSize.height();
+    const int step = (height >= KIconLoader::SizeHuge) ? height / 10 : (KIconLoader::SizeHuge - height) / 2;
+    verticalScrollBar()->setSingleStep(step);
+    QTreeView::wheelEvent(event);
 }
 
 }
 
-void DolphinDetailsView::contentsMousePressEvent(QMouseEvent* event)
+void DolphinDetailsView::currentChanged(const QModelIndex& current, const QModelIndex& previous)
 {
 {
-    if (m_rubber != 0) {
-        drawRubber();
-        delete m_rubber;
-        m_rubber = 0;
+    QTreeView::currentChanged(current, previous);
+    if (current.isValid() && !m_autoScroller->isActive()) {
+        scrollTo(current);
     }
 
     }
 
-    // Swallow the base implementation of the mouse press event
-    // if the mouse cursor is not above the filename. This prevents
-    // that the item gets selected and simulates an equal usability
-    // like in the icon view.
-    const QPoint pos(QCursor::pos());
-    const QPoint viewportPos(viewport()->mapToGlobal(QPoint(0, 0)));
-    Q3ListViewItem* item = itemAt(QPoint(pos.x() - viewportPos.x(), pos.y() - viewportPos.y()));
-    if ((item != 0) && isOnFilename(item, pos)) {
-        KFileDetailView::contentsMousePressEvent(event);
-    }
-    else if (event->button() == Qt::LeftButton) {
-        const Qt::KeyboardModifiers keyboardState = QApplication::keyboardModifiers();
-        const bool isSelectionActive = (keyboardState & Qt::ShiftModifier) ||
-                                       (keyboardState & Qt::ControlModifier);
-        if (!isSelectionActive) {
-            clearSelection();
-        }
-
-        assert(m_rubber == 0);
-        m_rubber = new QRect(event->x(), event->y(), 0, 0);
+    // Stay consistent with QListView: When changing the current index by key presses,
+    // also change the selection.
+    if (m_keyPressed) {
+        selectionModel()->select(current, QItemSelectionModel::ClearAndSelect);
     }
     }
-
-    resetActivatedItem();
-    emit signalRequestActivation();
-
-    m_dolphinView->statusBar()->clear();
 }
 
 }
 
-void DolphinDetailsView::contentsMouseMoveEvent(QMouseEvent* event)
+bool DolphinDetailsView::eventFilter(QObject* watched, QEvent* event)
 {
 {
-    if (m_rubber != 0) {
-        slotAutoScroll();
-        return;
+    if ((watched == viewport()) && (event->type() == QEvent::Leave)) {
+        // if the mouse is above an item and moved very fast outside the widget,
+        // no viewportEntered() signal might be emitted although the mouse has been moved
+        // above the viewport
+        m_controller->emitViewportEntered();
     }
 
     }
 
-    KFileDetailView::contentsMouseMoveEvent(event);
-
-    const QPoint& pos = event->globalPos();
-    const QPoint viewportPos = viewport()->mapToGlobal(QPoint(0, 0));
-    Q3ListViewItem* item = itemAt(QPoint(pos.x() - viewportPos.x(), pos.y() - viewportPos.y()));
-    if ((item != 0) && isOnFilename(item, pos)) {
-        activateItem(item);
-    }
-    else {
-        resetActivatedItem();
-    }
+    return QTreeView::eventFilter(watched, event);
 }
 
 }
 
-void DolphinDetailsView::contentsMouseReleaseEvent(QMouseEvent* event)
+QModelIndex DolphinDetailsView::indexAt(const QPoint& point) const
 {
 {
-    if (m_rubber != 0) {
-        drawRubber();
-        delete m_rubber;
-        m_rubber = 0;
-    }
-
-    if (m_scrollTimer != 0) {
-        disconnect(m_scrollTimer, SIGNAL(timeout()),
-                    this, SLOT(slotAutoScroll()));
-        m_scrollTimer->stop();
-        delete m_scrollTimer;
-        m_scrollTimer = 0;
-    }
-
-    KFileDetailView::contentsMouseReleaseEvent(event);
+    // the blank portion of the name column counts as empty space
+    const QModelIndex index = QTreeView::indexAt(point);
+    const bool isAboveEmptySpace  = !m_useDefaultIndexAt &&
+                                    (index.column() == KDirModel::Name) && !nameColumnRect(index).contains(point);
+    return isAboveEmptySpace ? QModelIndex() : index;
 }
 
 }
 
-void DolphinDetailsView::paintEmptyArea(QPainter* painter, const QRect& rect)
+void DolphinDetailsView::setSelection(const QRect& rect, QItemSelectionModel::SelectionFlags command)
 {
 {
-    if (m_dolphinView->isActive()) {
-        KFileDetailView::paintEmptyArea(painter, rect);
-    }
-    else {
-        const QBrush brush(colorGroup().background());
-        painter->fillRect(rect, brush);
+    // We must override setSelection() as Qt calls it internally and when this happens
+    // we must ensure that the default indexAt() is used.
+    if (!m_band.show) {
+        m_useDefaultIndexAt = true;
+        QTreeView::setSelection(rect, command);
+        m_useDefaultIndexAt = false;
+    } else {
+        // Use our own elastic band selection algorithm
+        updateElasticBandSelection();
     }
 }
 
     }
 }
 
-void DolphinDetailsView::drawRubber()
+void DolphinDetailsView::scrollTo(const QModelIndex & index, ScrollHint hint)
 {
 {
-    // Parts of the following code have been taken
-    // from the class KonqBaseListViewWidget located in
-    // konqueror/listview/konq_listviewwidget.h of Konqueror.
-    // (Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
-    //  2001, 2002, 2004 Michael Brade <brade@kde.org>)
-    if (m_rubber == 0) {
-        return;
+    if (!m_ignoreScrollTo) {
+        QTreeView::scrollTo(index, hint);
     }
     }
-
-    QPainter p;
-    p.begin(viewport());
-    //p.setRasterOp(NotROP);
-    p.setPen(QPen(Qt::color0, 1));
-    p.setBrush(Qt::NoBrush);
-
-    QPoint point(m_rubber->x(), m_rubber->y());
-    point = contentsToViewport(point);
-    QStyleOptionFocusRect option;
-    option.initFrom(this);
-    option.rect = QRect(point.x(), point.y(), m_rubber->width(), m_rubber->height());
-    style()->drawPrimitive(QStyle::PE_FrameFocusRect, &option, &p);
-    p.end();
 }
 
 }
 
-void DolphinDetailsView::viewportPaintEvent(QPaintEvent* paintEvent)
+void DolphinDetailsView::setSortIndicatorSection(DolphinView::Sorting sorting)
 {
 {
-    drawRubber();
-    KFileDetailView::viewportPaintEvent(paintEvent);
-    drawRubber();
+    header()->setSortIndicator(sorting, header()->sortIndicatorOrder());
 }
 
 }
 
-void DolphinDetailsView::leaveEvent(QEvent* event)
+void DolphinDetailsView::setSortIndicatorOrder(Qt::SortOrder sortOrder)
 {
 {
-    KFileDetailView::leaveEvent(event);
-    slotOnViewport();
+    header()->setSortIndicator(header()->sortIndicatorSection(), sortOrder);
 }
 
 }
 
-void DolphinDetailsView::slotActivationUpdate()
+void DolphinDetailsView::synchronizeSortingState(int column)
 {
 {
-    update();
-
-    // TODO: there must be a simpler way to say
-    // "update all children"
-    const QList<QObject*> list = children();
-    if (list.isEmpty()) {
-        return;
-    }
+    // The sorting has already been changed in QTreeView if this slot is
+    // invoked, but Dolphin is not informed about this.
+    DolphinView::Sorting sorting = DolphinSortFilterProxyModel::sortingForColumn(column);
+    const Qt::SortOrder sortOrder = header()->sortIndicatorOrder();
+    m_controller->indicateSortingChange(sorting);
+    m_controller->indicateSortOrderChange(sortOrder);
+}
 
 
-    QListIterator<QObject*> it(list);
-    QObject* object = 0;
-    while (it.hasNext()) {
-        object = it.next();
-        if (object->inherits("QWidget")) {
-            QWidget* widget = static_cast<QWidget*>(object);
-            widget->update();
-        }
+void DolphinDetailsView::slotEntered(const QModelIndex& index)
+{
+    if (index.column() == DolphinModel::Name) {
+        m_controller->emitItemEntered(index);
+    } else {
+        m_controller->emitViewportEntered();
     }
 }
 
     }
 }
 
-void DolphinDetailsView::slotContextMenuRequested(Q3ListViewItem* item,
-                                                  const QPoint& pos,
-                                                  int /* col */)
+void DolphinDetailsView::updateElasticBand()
 {
 {
-    KFileItem* fileInfo = 0;
-    if ((item != 0) && isOnFilename(item, pos)) {
-        fileInfo = static_cast<KFileListViewItem*>(item)->fileInfo();
+    if (m_band.show) {
+        QRect dirtyRegion(elasticBandRect());
+        const QPoint scrollPos(horizontalScrollBar()->value(), verticalScrollBar()->value());
+        m_band.destination = viewport()->mapFromGlobal(QCursor::pos()) + scrollPos;
+        // Going above the (logical) top-left of the view causes complications during selection;
+        // we may as well prevent it.
+        if (m_band.destination.y() < 0) {
+            m_band.destination.setY(0);
+        }
+        if (m_band.destination.x() < 0) {
+            m_band.destination.setX(0);
+        }
+        dirtyRegion = dirtyRegion.united(elasticBandRect());
+        setDirtyRegion(dirtyRegion);
     }
     }
-    m_dolphinView->openContextMenu(fileInfo, pos);
-
 }
 
 }
 
-void DolphinDetailsView::slotUpdateDisabledItems()
+QRect DolphinDetailsView::elasticBandRect() const
 {
 {
-    updateDisabledItems();
+    const QPoint scrollPos(horizontalScrollBar()->value(), verticalScrollBar()->value());
+
+    const QPoint topLeft = m_band.origin - scrollPos;
+    const QPoint bottomRight = m_band.destination - scrollPos;
+    return QRect(topLeft, bottomRight).normalized();
 }
 
 }
 
-void DolphinDetailsView::slotAutoScroll()
+void DolphinDetailsView::setZoomLevel(int level)
 {
 {
-    // Parts of the following code have been taken
-    // from the class KonqBaseListViewWidget located in
-    // konqueror/listview/konq_listviewwidget.h of Konqueror.
-    // (Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
-    //  2001, 2002, 2004 Michael Brade <brade@kde.org>)
-
-    const QPoint pos(viewport()->mapFromGlobal(QCursor::pos()));
-    const QPoint vc(viewportToContents(pos));
+    const int size = ZoomLevelInfo::iconSizeForZoomLevel(level);
+    DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
 
 
-    if (vc == m_rubber->bottomRight()) {
-        return;
+    const bool showPreview = m_controller->dolphinView()->showPreview();
+    if (showPreview) {
+        settings->setPreviewSize(size);
+    } else {
+        settings->setIconSize(size);
     }
 
     }
 
-    drawRubber();
-
-    m_rubber->setBottomRight(vc);
+    updateDecorationSize(showPreview);
+}
 
 
-    Q3ListViewItem* item = itemAt(QPoint(0,0));
 
 
-    const bool block = signalsBlocked();
-    blockSignals(true);
+void DolphinDetailsView::slotShowPreviewChanged()
+{
+    const DolphinView* view = m_controller->dolphinView();
+    updateDecorationSize(view->showPreview());
+}
 
 
-    const QRect rubber(m_rubber->normalize());
-    const int bottom = contentsY() + visibleHeight() - 1;
+void DolphinDetailsView::configureSettings(const QPoint& pos)
+{
+    KMenu popup(this);
+    popup.addTitle(i18nc("@title:menu", "Columns"));
 
 
-    // select all items which intersect with the rubber, deselect all others
-    bool bottomReached = false;
-    while ((item != 0) && !bottomReached) {
-        QRect rect(itemRect(item));
-        rect.setWidth(filenameWidth(item));
-        rect = QRect(viewportToContents(rect.topLeft()),
-                     viewportToContents(rect.bottomRight()));
-        if (rect.isValid() && (rect.top() <= bottom)) {
-            const KFileItem* fileItem = static_cast<KFileListViewItem*>(item)->fileInfo();
-            setSelected(fileItem, rect.intersects(rubber));
-            item = item->itemBelow();
-        }
-        else {
-            bottomReached = true;
-        }
+    // add checkbox items for each column
+    QHeaderView* headerView = header();
+    for (int i = DolphinModel::Size; i <= DolphinModel::Type; ++i) {
+        const int logicalIndex = headerView->logicalIndex(i);
+        const QString text = model()->headerData(i, Qt::Horizontal).toString();
+        QAction* action = popup.addAction(text);
+        action->setCheckable(true);
+        action->setChecked(!headerView->isSectionHidden(logicalIndex));
+        action->setData(i);
     }
     }
+    popup.addSeparator();
+
+    QAction* activatedAction = popup.exec(header()->mapToGlobal(pos));
+    if (activatedAction != 0) {
+        const bool show = activatedAction->isChecked();
+        const int columnIndex = activatedAction->data().toInt();
 
 
-    blockSignals(block);
-    emit selectionChanged();
-
-    drawRubber();
-
-    // scroll the viewport if the top or bottom margin is reached
-    const int scrollMargin = 40;
-    ensureVisible(vc.x(), vc.y(), scrollMargin, scrollMargin);
-    const bool scroll = !QRect(scrollMargin,
-                               scrollMargin,
-                               viewport()->width()  - 2 * scrollMargin,
-                               viewport()->height() - 2 * scrollMargin).contains(pos);
-    if (scroll) {
-        if (m_scrollTimer == 0) {
-            m_scrollTimer = new QTimer( this );
-            connect(m_scrollTimer, SIGNAL(timeout()),
-                    this, SLOT(slotAutoScroll()));
-            m_scrollTimer->start(100, false);
+        KFileItemDelegate::InformationList list = m_controller->dolphinView()->additionalInfo();
+        const KFileItemDelegate::Information info = infoForColumn(columnIndex);
+        if (show) {
+            Q_ASSERT(!list.contains(info));
+            list.append(info);
+        } else {
+            Q_ASSERT(list.contains(info));
+            const int index = list.indexOf(info);
+            list.removeAt(index);
         }
         }
-    }
-    else if (m_scrollTimer != 0) {
-        disconnect(m_scrollTimer, SIGNAL(timeout()),
-                   this, SLOT(slotAutoScroll()));
-        m_scrollTimer->stop();
-        delete m_scrollTimer;
-        m_scrollTimer = 0;
+
+        m_controller->indicateAdditionalInfoChange(list);
+        setColumnHidden(columnIndex, !show);
+        resizeColumns();
     }
 }
 
     }
 }
 
-void DolphinDetailsView::updateColumnsWidth()
+void DolphinDetailsView::updateColumnVisibility()
 {
 {
-    const int columnCount = columns();
-    int requiredWidth = 0;
-    for (int i = 1; i < columnCount; ++i) {
-        // When a directory contains no items, a minimum width for
-        // the column must be available, so that the header is readable.
-        // TODO: use header data instead of the hardcoded 64 value...
-        int columnWidth = 64;
-        QFontMetrics fontMetrics(font());
-        for (Q3ListViewItem* item = firstChild(); item != 0; item = item->nextSibling()) {
-            const int width = item->width(fontMetrics, this, i);
-            if (width > columnWidth) {
-                columnWidth = width;
-            }
+    const KFileItemDelegate::InformationList list = m_controller->dolphinView()->additionalInfo();
+    for (int i = DolphinModel::Size; i <= DolphinModel::Type; ++i) {
+        const KFileItemDelegate::Information info = infoForColumn(i);
+        const bool hide = !list.contains(info);
+        if (isColumnHidden(i) != hide) {
+            setColumnHidden(i, hide);
         }
         }
-        columnWidth += 16;    // add custom margin
-        setColumnWidth(i, columnWidth);
-        requiredWidth += columnWidth;
     }
 
     }
 
-    // resize the first column in a way that the
-    // whole available width is used
-    int firstColumnWidth = visibleWidth() - requiredWidth;
-    if (firstColumnWidth < 128) {
-        firstColumnWidth = 128;
+    resizeColumns();
+}
+
+void DolphinDetailsView::slotHeaderSectionResized(int logicalIndex, int oldSize, int newSize)
+{
+    Q_UNUSED(logicalIndex);
+    Q_UNUSED(oldSize);
+    Q_UNUSED(newSize);
+    // If the user changes the size of the headers, the autoresize feature should be
+    // turned off. As there is no dedicated interface to find out whether the header
+    // section has been resized by the user or by a resize event, another approach is used.
+    // Attention: Take care when changing the if-condition to verify that there is no
+    // regression in combination with bug 178630 (see fix in comment #8).
+    if ((QApplication::mouseButtons() & Qt::LeftButton) && header()->underMouse()) {
+        disableAutoResizing();
     }
     }
-    setColumnWidth(0, firstColumnWidth);
 }
 
 }
 
-void DolphinDetailsView::slotItemRenamed(Q3ListViewItem* item,
-                                         const QString& name,
-                                         int /* column */)
+void DolphinDetailsView::slotActivationChanged(bool active)
 {
 {
-    KFileItem* fileInfo = static_cast<KFileListViewItem*>(item)->fileInfo();
-    m_dolphinView->rename(KUrl(fileInfo->url()), name);
+    setAlternatingRowColors(active);
 }
 
 }
 
-void DolphinDetailsView::slotHeaderClicked(int /* section */)
+void DolphinDetailsView::disableAutoResizing()
 {
 {
-    // The sorting has already been changed in QListView if this slot is
-    // invoked, but Dolphin was not informed about this (no signal is available
-    // which indicates a change of the sorting). This is bypassed by changing
-    // the sorting and sort order to a temporary other value and readjust it again.
-    const int column = sortColumn();
-    if (column <= DateColumn) {
-        DolphinView::Sorting sorting = DolphinView::SortByName;
-        switch (column) {
-            case SizeColumn: sorting = DolphinView::SortBySize; break;
-            case DateColumn: sorting = DolphinView::SortByDate; break;
-            case NameColumn:
-            default: break;
-        }
+    m_autoResize = false;
+}
 
 
-        const Qt::SortOrder currSortOrder = sortOrder();
+void DolphinDetailsView::requestActivation()
+{
+    m_controller->requestActivation();
+}
 
 
-        // temporary adjust the sorting and sort order to different values...
-        const DolphinView::Sorting tempSorting = (sorting == DolphinView::SortByName) ?
-                                                 DolphinView::SortBySize :
-                                                 DolphinView::SortByName;
-        m_dolphinView->setSorting(tempSorting);
-        const Qt::SortOrder tempSortOrder = (currSortOrder == Qt::Ascending) ?
-                                            Qt::Descending : Qt::Ascending;
-        m_dolphinView->setSortOrder(tempSortOrder);
+void DolphinDetailsView::slotGlobalSettingsChanged(int category)
+{
+    Q_UNUSED(category);
 
 
-        // ... so that setting them again results in storing the new setting.
-        m_dolphinView->setSorting(sorting);
-        m_dolphinView->setSortOrder(currSortOrder);
+    const DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
+    Q_ASSERT(settings != 0);
+    if (settings->useSystemFont()) {
+        m_font = KGlobalSettings::generalFont();
+    }
+    //Disconnect then reconnect, since the settings have been changed, the connection requirements may have also.
+    disconnect(this, SIGNAL(clicked(QModelIndex)), m_controller, SLOT(triggerItem(QModelIndex)));
+    disconnect(this, SIGNAL(doubleClicked(QModelIndex)), m_controller, SLOT(triggerItem(QModelIndex)));
+    if (KGlobalSettings::singleClick()) {
+        connect(this, SIGNAL(clicked(QModelIndex)), m_controller, SLOT(triggerItem(QModelIndex)));
+    } else {
+        connect(this, SIGNAL(doubleClicked(QModelIndex)), m_controller, SLOT(triggerItem(QModelIndex)));
     }
 }
 
     }
 }
 
-DolphinDetailsView::DolphinListViewItem::DolphinListViewItem(Q3ListView* parent,
-                                                             KFileItem* fileItem) :
-    KFileListViewItem(parent, fileItem)
+void DolphinDetailsView::updateElasticBandSelection()
 {
 {
-    const int iconSize = DolphinSettings::instance().detailsModeSettings()->iconSize();
-    KFileItem* info = fileInfo();
-    setPixmap(DolphinDetailsView::NameColumn, info->pixmap(iconSize));
+    if (!m_band.show) {
+        return;
+    }
 
 
-    // The base class KFileListViewItem represents the column 'Size' only as byte values.
-    // Adjust those values in a way that a mapping to GBytes, MBytes, KBytes and Bytes
-    // is done. As the file size for directories is useless (only the size of the directory i-node
-    // is given), it is removed completely.
-    if (fileItem->isDir()) {
-        setText(SizeColumn, " - ");
+    // Ensure the elastic band itself is up-to-date, in
+    // case we are being called due to e.g. a drag event.
+    updateElasticBand();
+
+    // Clip horizontally to the name column, as some filenames will be
+    // longer than the column.  We don't clip vertically as origin
+    // may be above or below the current viewport area.
+    const int nameColumnX = header()->sectionPosition(DolphinModel::Name);
+    const int nameColumnWidth = header()->sectionSize(DolphinModel::Name);
+    QRect selRect = elasticBandRect().normalized();
+    QRect nameColumnArea(nameColumnX, selRect.y(), nameColumnWidth, selRect.height());
+    selRect = nameColumnArea.intersect(selRect).normalized();
+    // Get the last elastic band rectangle, expressed in viewpoint coordinates.
+    const QPoint scrollPos(horizontalScrollBar()->value(), verticalScrollBar()->value());
+    QRect oldSelRect = QRect(m_band.lastSelectionOrigin - scrollPos, m_band.lastSelectionDestination - scrollPos).normalized();
+
+    if (selRect.isNull()) {
+        selectionModel()->select(m_band.originalSelection, QItemSelectionModel::ClearAndSelect);
+        m_band.ignoreOldInfo = true;
+        return;
+    }
+
+    if (!m_band.ignoreOldInfo) {
+        // Do some quick checks to see if we can rule out the need to
+        // update the selection.
+        Q_ASSERT(uniformRowHeights());
+        QModelIndex dummyIndex = model()->index(0, 0);
+        if (!dummyIndex.isValid()) {
+            // No items in the model presumably.
+            return;
+        }
+
+        // If the elastic band does not cover the same rows as before, we'll
+        // need to re-check, and also invalidate the old item distances.
+        const int rowHeight = QTreeView::rowHeight(dummyIndex);
+        const bool coveringSameRows =
+            (selRect.top()    / rowHeight == oldSelRect.top()    / rowHeight) &&
+            (selRect.bottom() / rowHeight == oldSelRect.bottom() / rowHeight);
+        if (coveringSameRows) {
+            // Covering the same rows, but have we moved far enough horizontally
+            // that we might have (de)selected some other items?
+            const bool itemSelectionChanged =
+                ((selRect.left() > oldSelRect.left()) &&
+                 (selRect.left() > m_band.insideNearestLeftEdge)) ||
+                ((selRect.left() < oldSelRect.left()) &&
+                 (selRect.left() <= m_band.outsideNearestLeftEdge)) ||
+                ((selRect.right() < oldSelRect.right()) &&
+                 (selRect.left() >= m_band.insideNearestRightEdge)) ||
+                ((selRect.right() > oldSelRect.right()) &&
+                 (selRect.right() >= m_band.outsideNearestRightEdge));
+
+            if (!itemSelectionChanged) {
+                return;
+            }
+        }
     }
     else {
     }
     else {
-        QString sizeText(KIO::convertSize(fileItem->size()));
-        sizeText.append(" ");
-        setText(SizeColumn, sizeText);
+        // This is the only piece of optimization data that needs to be explicitly
+        // discarded.
+        m_band.lastSelectionOrigin = QPoint();
+        m_band.lastSelectionDestination = QPoint();
+        oldSelRect = selRect;
+    }
+
+    // Do the selection from scratch. Force a update of the horizontal distances info.
+    m_band.insideNearestLeftEdge   = nameColumnX + nameColumnWidth + 1;
+    m_band.insideNearestRightEdge  = nameColumnX - 1;
+    m_band.outsideNearestLeftEdge  = nameColumnX - 1;
+    m_band.outsideNearestRightEdge = nameColumnX + nameColumnWidth + 1;
+
+    // Include the old selection rect as well, so we can deselect
+    // items that were inside it but not in the new selRect.
+    const QRect boundingRect = selRect.united(oldSelRect).normalized();
+    if (boundingRect.isNull()) {
+        return;
     }
 
     }
 
-    // Dolphin allows to remove specific columns, but the base class KFileListViewItem
-    // is not aware about this (or at least the class KFileDetailView does not react on
-    // QListView::remove()). Therefore the columns are rearranged here.
-    const DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
-    assert(settings != 0);
+    // Get the index of the item in this row in the name column.
+    // TODO - would this still work if the columns could be re-ordered?
+    QModelIndex startIndex = QTreeView::indexAt(boundingRect.topLeft());
+    if (startIndex.parent().isValid()) {
+        startIndex = startIndex.parent().child(startIndex.row(), KDirModel::Name);
+    } else {
+        startIndex = model()->index(startIndex.row(), KDirModel::Name);
+    }
+    if (!startIndex.isValid()) {
+        selectionModel()->select(m_band.originalSelection, QItemSelectionModel::ClearAndSelect);
+        m_band.ignoreOldInfo = true;
+        return;
+    }
 
 
-    int column_idx = DateColumn;    // the columns for 'name' and 'size' cannot get removed
-    for (int i = DolphinDetailsView::DateColumn; i <= DolphinDetailsView::GroupColumn; ++i) {
-        if (column_idx < i) {
-            setText(column_idx, text(i));
+   // Go through all indexes between the top and bottom of boundingRect, and
+   // update the selection.
+   const int verticalCutoff = boundingRect.bottom();
+   QModelIndex currIndex = startIndex;
+   QModelIndex lastIndex;
+   bool allItemsInBoundDone = false;
+
+   // Calling selectionModel()->select(...) for each item that needs to be
+   // toggled is slow as each call emits selectionChanged(...) so store them
+   // and do the selection toggle in one batch.
+   QItemSelection itemsToToggle;
+   // QItemSelection's deal with continuous ranges of indexes better than
+   // single indexes, so try to portion items that need to be toggled into ranges.
+   bool formingToggleIndexRange = false;
+   QModelIndex toggleIndexRangeBegin = QModelIndex();
+
+   do {
+       QRect currIndexRect = nameColumnRect(currIndex);
+
+        // Update some optimization info as we go.
+       const int cr = currIndexRect.right();
+       const int cl = currIndexRect.left();
+       const int sl = selRect.left();
+       const int sr = selRect.right();
+       // "The right edge of the name is outside of the rect but nearer than m_outsideNearestLeft", etc
+       if ((cr < sl && cr > m_band.outsideNearestLeftEdge)) {
+           m_band.outsideNearestLeftEdge = cr;
+       }
+       if ((cl > sr && cl < m_band.outsideNearestRightEdge)) {
+           m_band.outsideNearestRightEdge = cl;
+       }
+       if ((cl >= sl && cl <= sr && cl > m_band.insideNearestRightEdge)) {
+           m_band.insideNearestRightEdge = cl;
+       }
+       if ((cr >= sl && cr <= sr && cr < m_band.insideNearestLeftEdge)) {
+           m_band.insideNearestLeftEdge = cr;
+       }
+
+       bool currentlySelected = selectionModel()->isSelected(currIndex);
+       bool originallySelected = m_band.originalSelection.contains(currIndex);
+       bool intersectsSelectedRect = currIndexRect.intersects(selRect);
+       bool shouldBeSelected = (intersectsSelectedRect && !originallySelected) || (!intersectsSelectedRect && originallySelected);
+       bool needToToggleItem = (currentlySelected && !shouldBeSelected) || (!currentlySelected && shouldBeSelected);
+       if (needToToggleItem && !formingToggleIndexRange) {
+            toggleIndexRangeBegin = currIndex;
+            formingToggleIndexRange = true;
+       }
+
+       // NOTE: indexBelow actually walks up and down expanded trees for us.
+       QModelIndex nextIndex = indexBelow(currIndex);
+       allItemsInBoundDone = !nextIndex.isValid() || currIndexRect.top() > verticalCutoff;
+
+       const bool commitToggleIndexRange = formingToggleIndexRange &&
+                                           (!needToToggleItem ||
+                                            allItemsInBoundDone ||
+                                            currIndex.parent() != toggleIndexRangeBegin.parent());
+       if (commitToggleIndexRange) {
+           formingToggleIndexRange = false;
+            // If this is the last item in the bounds and it is also the beginning of a range,
+            // don't toggle lastIndex - it will already have been dealt with.
+           if (!allItemsInBoundDone || toggleIndexRangeBegin != currIndex) {
+               itemsToToggle.select(toggleIndexRangeBegin, lastIndex);
+           }
+            // Need to start a new range immediately with currIndex?
+           if (needToToggleItem) {
+               toggleIndexRangeBegin = currIndex;
+               formingToggleIndexRange = true;
+           }
+           if (allItemsInBoundDone && needToToggleItem) {
+                // Toggle the very last item in the bounds.
+               itemsToToggle.select(currIndex, currIndex);
+           }
+       }
+
+       // next item
+       lastIndex = currIndex;
+       currIndex = nextIndex;
+    } while (!allItemsInBoundDone);
+
+    selectionModel()->select(itemsToToggle, QItemSelectionModel::Toggle);
+
+    m_band.lastSelectionOrigin = m_band.origin;
+    m_band.lastSelectionDestination = m_band.destination;
+    m_band.ignoreOldInfo = false;
+}
+
+void DolphinDetailsView::setFoldersExpandable(bool expandable)
+{
+    if (!expandable) {
+        // collapse all expanded folders, as QTreeView::setItemsExpandable(false)
+        // does not do this task
+        const int rowCount = model()->rowCount();
+        for (int row = 0; row < rowCount; ++row) {
+            setExpanded(model()->index(row, 0), false);
         }
         }
+    }
+    DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
+    settings->setExpandableFolders(expandable);
+    setRootIsDecorated(expandable);
+    setItemsExpandable(expandable);
+}
 
 
-        bool inc = false;
-        switch (i) {
-            case DateColumn:        inc = settings->showDate(); break;
-            case PermissionsColumn: inc = settings->showPermissions(); break;
-            case OwnerColumn:       inc = settings->showOwner(); break;
-            case GroupColumn:       inc = settings->showGroup(); break;
-            default: break;
-        }
+void DolphinDetailsView::updateDecorationSize(bool showPreview)
+{
+    DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
+    const int iconSize = showPreview ? settings->previewSize() : settings->iconSize();
+    setIconSize(QSize(iconSize, iconSize));
+    m_decorationSize = QSize(iconSize, iconSize);
 
 
-        if (inc) {
-            ++column_idx;
-        }
+    if (m_selectionManager != 0) {
+        m_selectionManager->reset();
     }
     }
+
+    doItemsLayout();
 }
 
 }
 
-DolphinDetailsView::DolphinListViewItem::~DolphinListViewItem()
+KFileItemDelegate::Information DolphinDetailsView::infoForColumn(int columnIndex) const
 {
 {
+    KFileItemDelegate::Information info = KFileItemDelegate::NoInformation;
+
+    switch (columnIndex) {
+    case DolphinModel::Size:         info = KFileItemDelegate::Size; break;
+    case DolphinModel::ModifiedTime: info = KFileItemDelegate::ModificationTime; break;
+    case DolphinModel::Permissions:  info = KFileItemDelegate::Permissions; break;
+    case DolphinModel::Owner:        info = KFileItemDelegate::Owner; break;
+    case DolphinModel::Group:        info = KFileItemDelegate::OwnerAndGroup; break;
+    case DolphinModel::Type:         info = KFileItemDelegate::FriendlyMimeType; break;
+    default: break;
+    }
+
+    return info;
 }
 
 }
 
-void DolphinDetailsView::DolphinListViewItem::paintCell(QPainter* painter,
-                                                        const QColorGroup& colorGroup,
-                                                        int column,
-                                                        int cellWidth,
-                                                        int alignment)
+void DolphinDetailsView::resizeColumns()
 {
 {
-    const Q3ListView* view = listView();
-    const bool isActive = view->parent() == Dolphin::mainWin().activeView();
-    if (isSelected()) {
-        // Per default the selection is drawn above the whole width of the item. As a consistent
-        // behavior with the icon view is wanted, only the the column containing the file name
-        // should be shown as selected.
-        QColorGroup defaultColorGroup(colorGroup);
-        const QColor highlightColor(isActive ? backgroundColor(column) : view->colorGroup().background());
-        defaultColorGroup.setColor(QColorGroup::Highlight , highlightColor);
-        defaultColorGroup.setColor(QColorGroup::HighlightedText, colorGroup.color(QColorGroup::Text));
-        KFileListViewItem::paintCell(painter, defaultColorGroup, column, cellWidth, alignment);
+    // Using the resize mode QHeaderView::ResizeToContents is too slow (it takes
+    // around 3 seconds for each (!) resize operation when having > 10000 items).
+    // This gets a problem especially when opening large directories, where several
+    // resize operations are received for showing the currently available items during
+    // loading (the application hangs around 20 seconds when loading > 10000 items).
 
 
-        if (column == 0) {
-            // draw the selection only on the first column
-            Q3ListView* parent = listView();
-            const int itemWidth = width(parent->fontMetrics(), parent, 0);
-            if (isActive) {
-                KFileListViewItem::paintCell(painter, colorGroup, column, itemWidth, alignment);
-            }
-            else {
-                Q3ListViewItem::paintCell(painter, colorGroup, column, itemWidth, alignment);
-            }
+    QHeaderView* headerView = header();
+    QFontMetrics fontMetrics(viewport()->font());
+
+    int columnWidth[KDirModel::ColumnCount];
+    columnWidth[KDirModel::Size] = fontMetrics.width("00000 Items");
+    columnWidth[KDirModel::ModifiedTime] = fontMetrics.width("0000-00-00 00:00");
+    columnWidth[KDirModel::Permissions] = fontMetrics.width("xxxxxxxxxx");
+    columnWidth[KDirModel::Owner] = fontMetrics.width("xxxxxxxxxx");
+    columnWidth[KDirModel::Group] = fontMetrics.width("xxxxxxxxxx");
+    columnWidth[KDirModel::Type] = fontMetrics.width("XXXX Xxxxxxx");
+
+    int requiredWidth = 0;
+    for (int i = KDirModel::Size; i <= KDirModel::Type; ++i) {
+        if (!isColumnHidden(i)) {
+            columnWidth[i] += 20; // provide a default gap
+            requiredWidth += columnWidth[i];
+            headerView->resizeSection(i, columnWidth[i]);
         }
     }
         }
     }
-    else {
-        if (isActive) {
-            KFileListViewItem::paintCell(painter, colorGroup, column, cellWidth, alignment);
-        }
-        else {
-            Q3ListViewItem::paintCell(painter, colorGroup, column, cellWidth, alignment);
+
+    // resize the name column in a way that the whole available width is used
+    columnWidth[KDirModel::Name] = viewport()->width() - requiredWidth;
+
+    const int minNameWidth = 300;
+    if (columnWidth[KDirModel::Name] < minNameWidth) {
+        columnWidth[KDirModel::Name] = minNameWidth;
+
+        // It might be possible that the name column width can be
+        // decreased without clipping any text. For performance
+        // reasons the exact necessary width for full visible names is
+        // only checked for up to 200 items:
+        const int rowCount = model()->rowCount();
+        if (rowCount > 0 && rowCount < 200) {
+            const int nameWidth = sizeHintForColumn(DolphinModel::Name);
+            if (nameWidth + requiredWidth <= viewport()->width()) {
+                columnWidth[KDirModel::Name] = viewport()->width() - requiredWidth;
+            } else if (nameWidth < minNameWidth) {
+                columnWidth[KDirModel::Name] = nameWidth;
+            }
         }
     }
 
         }
     }
 
-    if (column < listView()->columns() - 1) {
-        // draw a separator between columns
-        painter->setPen(KGlobalSettings::buttonBackground());
-        painter->drawLine(cellWidth - 1, 0, cellWidth - 1, height() - 1);
-    }
+    headerView->resizeSection(KDirModel::Name, columnWidth[KDirModel::Name]);
 }
 
 }
 
-void DolphinDetailsView::DolphinListViewItem::paintFocus(QPainter* painter,
-                                                         const QColorGroup& colorGroup,
-                                                         const QRect& rect)
+QRect DolphinDetailsView::nameColumnRect(const QModelIndex& index) const
 {
 {
-    // draw the focus consistently with the selection (see implementation notes
-    // in DolphinListViewItem::paintCell)
-    Q3ListView* parent = listView();
-    int visibleWidth = width(parent->fontMetrics(), parent, 0);
-    const int colWidth = parent->columnWidth(0);
-    if (visibleWidth > colWidth) {
-        visibleWidth = colWidth;
+    QRect rect = visualRect(index);
+    const KFileItem item = m_controller->itemForIndex(index);
+    if (!item.isNull()) {
+        const int width = DolphinFileItemDelegate::nameColumnWidth(item.text(), viewOptions());
+        rect.setWidth(width);
     }
 
     }
 
-    QRect focusRect(rect);
-    focusRect.setWidth(visibleWidth);
-
-    KFileListViewItem::paintFocus(painter, colorGroup, focusRect);
+    return rect;
 }
 
 }
 
-int DolphinDetailsView::filenameWidth(const Q3ListViewItem* item) const
+DolphinDetailsView::ElasticBand::ElasticBand() :
+    show(false),
+    origin(),
+    destination(),
+    lastSelectionOrigin(),
+    lastSelectionDestination(),
+    ignoreOldInfo(true),
+    outsideNearestLeftEdge(0),
+    outsideNearestRightEdge(0),
+    insideNearestLeftEdge(0),
+    insideNearestRightEdge(0)
 {
 {
-    assert(item != 0);
-
-    int visibleWidth = item->width(fontMetrics(), this, 0);
-    const int colWidth = columnWidth(0);
-    if (visibleWidth > colWidth) {
-        visibleWidth = colWidth;
-    }
-
-    return visibleWidth;
 }
 }
+
 #include "dolphindetailsview.moc"
 #include "dolphindetailsview.moc"