remove the asynchronous update of the zooming again, it decreases the "feeled" perfor...

[dolphin.git] / src / dolphindetailsview.cpp

diff --git a/src/dolphindetailsview.cpp b/src/dolphindetailsview.cpp
index 39783c9a9fadb0bb6ba79747c2be2ded47cbd477..79a1a106d04612ff7dab19a73b5440b05ff20189 100644 (file)
--- a/src/dolphindetailsview.cpp
+++ b/src/dolphindetailsview.cpp
@@ -24,10 +24,20 @@
 #include "dolphincontroller.h"
 #include "dolphinsettings.h"
 #include "dolphinsortfilterproxymodel.h"
 #include "dolphincontroller.h"
 #include "dolphinsettings.h"
 #include "dolphinsortfilterproxymodel.h"

+#include "draganddrophelper.h"
+#include "selectionmanager.h"

 #include "viewproperties.h"
 #include "viewproperties.h"

+#include "zoomlevelinfo.h"

 
 #include "dolphin_detailsmodesettings.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 <QApplication>
 #include <QHeaderView>
 #include <QRubberBand>


@@ -36,34 +46,49 @@
 
 DolphinDetailsView::DolphinDetailsView(QWidget* parent, DolphinController* controller) :
     QTreeView(parent),
 
 DolphinDetailsView::DolphinDetailsView(QWidget* parent, DolphinController* controller) :
     QTreeView(parent),

+       m_autoResize(true),
+    m_expandingTogglePressed(false),
+    m_keyPressed(false),

     m_controller(controller),
     m_controller(controller),

-    m_dragging(false),
+    m_selectionManager(0),
+    m_font(),
+    m_decorationSize(),

     m_showElasticBand(false),
     m_elasticBandOrigin(),
     m_elasticBandDestination()
 {
     m_showElasticBand(false),
     m_elasticBandOrigin(),
     m_elasticBandDestination()
 {

+    const DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
+    Q_ASSERT(settings != 0);

     Q_ASSERT(controller != 0);
 
     Q_ASSERT(controller != 0);
 

+    setLayoutDirection(Qt::LeftToRight);

     setAcceptDrops(true);
     setAcceptDrops(true);

-    setRootIsDecorated(false);

     setSortingEnabled(true);
     setUniformRowHeights(true);
     setSelectionBehavior(SelectItems);
     setDragDropMode(QAbstractItemView::DragDrop);
     setDropIndicatorShown(false);
     setAlternatingRowColors(true);
     setSortingEnabled(true);
     setUniformRowHeights(true);
     setSelectionBehavior(SelectItems);
     setDragDropMode(QAbstractItemView::DragDrop);
     setDropIndicatorShown(false);
     setAlternatingRowColors(true);

-    setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
-    setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
+    setRootIsDecorated(settings->expandableFolders());
+    setItemsExpandable(settings->expandableFolders());
+    setEditTriggers(QAbstractItemView::NoEditTriggers);

 
     setMouseTracking(true);
 
     setMouseTracking(true);

-    viewport()->setAttribute(Qt::WA_Hover);

 
     const ViewProperties props(controller->url());
     setSortIndicatorSection(props.sorting());
     setSortIndicatorOrder(props.sortOrder());
 
 
     const ViewProperties props(controller->url());
     setSortIndicatorSection(props.sorting());
     setSortIndicatorOrder(props.sortOrder());
 

-    connect(header(), SIGNAL(sectionClicked(int)),
+    QHeaderView* headerView = header();
+    connect(headerView, SIGNAL(sectionClicked(int)),

             this, SLOT(synchronizeSortingState(int)));
             this, SLOT(synchronizeSortingState(int)));

+    headerView->setContextMenuPolicy(Qt::CustomContextMenu);
+    connect(headerView, SIGNAL(customContextMenuRequested(const QPoint&)),
+            this, SLOT(configureColumns(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(sortingChanged(DolphinView::Sorting)),
             this, SLOT(setSortIndicatorSection(DolphinView::Sorting)));


@@ -76,32 +101,54 @@ DolphinDetailsView::DolphinDetailsView(QWidget* parent, DolphinController* contr
     // RETURN-key in keyPressEvent().
     if (KGlobalSettings::singleClick()) {
         connect(this, SIGNAL(clicked(const QModelIndex&)),
     // RETURN-key in keyPressEvent().
     if (KGlobalSettings::singleClick()) {
         connect(this, SIGNAL(clicked(const QModelIndex&)),

-                this, SLOT(slotItemActivated(const QModelIndex&)));
+                controller, SLOT(triggerItem(const QModelIndex&)));

     } else {
         connect(this, SIGNAL(doubleClicked(const QModelIndex&)),
     } else {
         connect(this, SIGNAL(doubleClicked(const QModelIndex&)),

-                this, SLOT(slotItemActivated(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(this, SIGNAL(entered(const QModelIndex&)),
             this, SLOT(slotEntered(const QModelIndex&)));
     connect(this, SIGNAL(viewportEntered()),
             controller, SLOT(emitViewportEntered()));

-    connect(controller, SIGNAL(zoomIn()),
-            this, SLOT(zoomIn()));
-    connect(controller, SIGNAL(zoomOut()),
-            this, SLOT(zoomOut()));
+    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());
+    }

 
 

-    // apply the details mode settings to the widget
-    const DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
-    Q_ASSERT(settings != 0);
+    setVerticalScrollMode(QTreeView::ScrollPerPixel);
+    setHorizontalScrollMode(QTreeView::ScrollPerPixel);
+    
+    const DolphinView* view = controller->dolphinView();
+    connect(view, SIGNAL(showPreviewChanged()),
+            this, SLOT(slotShowPreviewChanged()));

 
 

-    m_viewOptions = QTreeView::viewOptions();
+    updateDecorationSize(view->showPreview());

 
 

-    QFont font(settings->fontFamily(), settings->fontSize());
-    font.setItalic(settings->italicFont());
-    font.setBold(settings->boldFont());
-    m_viewOptions.font = font;
+    setFocus();
+    viewport()->installEventFilter(this);

 
 

-    updateDecorationSize();
+    connect(KGlobalSettings::self(), SIGNAL(kdisplayFontChanged()),
+            this, SLOT(updateFont()));

 }
 
 DolphinDetailsView::~DolphinDetailsView()
 }
 
 DolphinDetailsView::~DolphinDetailsView()


@@ -111,39 +158,19 @@ DolphinDetailsView::~DolphinDetailsView()
 bool DolphinDetailsView::event(QEvent* event)
 {
     if (event->type() == QEvent::Polish) {
 bool DolphinDetailsView::event(QEvent* event)
 {
     if (event->type() == QEvent::Polish) {

-        // Assure that by respecting the available width that:
-        // - the 'Name' column is stretched as large as possible
-        // - the remaining columns are as small as possible

         QHeaderView* headerView = header();
         QHeaderView* headerView = header();

-        headerView->setStretchLastSection(false);
-        headerView->setResizeMode(QHeaderView::ResizeToContents);
-        headerView->setResizeMode(0, QHeaderView::Stretch);
-
-        // hide columns if this is indicated by the settings
-        const DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
-        Q_ASSERT(settings != 0);
-        if (!settings->showDate()) {
-            hideColumn(DolphinModel::ModifiedTime);
-        }
-
-        if (!settings->showPermissions()) {
-            hideColumn(DolphinModel::Permissions);
-        }
-
-        if (!settings->showOwner()) {
-            hideColumn(DolphinModel::Owner);
-        }
-
-        if (!settings->showGroup()) {
-            hideColumn(DolphinModel::Group);
-        }
+        headerView->setResizeMode(QHeaderView::Interactive);
+        headerView->setMovable(false);

 
 

-        if (!settings->showType()) {
-            hideColumn(DolphinModel::Type);
-        }
+        updateColumnVisibility();

 
         hideColumn(DolphinModel::Rating);
         hideColumn(DolphinModel::Tags);
 
         hideColumn(DolphinModel::Rating);
         hideColumn(DolphinModel::Tags);

+    } else if (event->type() == QEvent::UpdateRequest) {
+        // a wheel movement will scroll 4 items
+        if (model()->rowCount() > 0) {
+            verticalScrollBar()->setSingleStep((sizeHintForRow(0) / 3) * 4);
+        }

     }
 
     return QTreeView::event(event);
     }
 
     return QTreeView::event(event);


@@ -151,7 +178,11 @@ bool DolphinDetailsView::event(QEvent* event)
 
 QStyleOptionViewItem DolphinDetailsView::viewOptions() const
 {
 
 QStyleOptionViewItem DolphinDetailsView::viewOptions() const
 {

-    return m_viewOptions;
+    QStyleOptionViewItem viewOptions = QTreeView::viewOptions();
+    viewOptions.font = m_font;
+    viewOptions.showDecorationSelected = true;
+    viewOptions.decorationSize = m_decorationSize;
+    return viewOptions;

 }
 
 void DolphinDetailsView::contextMenuEvent(QContextMenuEvent* event)
 }
 
 void DolphinDetailsView::contextMenuEvent(QContextMenuEvent* event)


@@ -162,19 +193,42 @@ void DolphinDetailsView::contextMenuEvent(QContextMenuEvent* event)
 
 void DolphinDetailsView::mousePressEvent(QMouseEvent* event)
 {
 
 void DolphinDetailsView::mousePressEvent(QMouseEvent* event)
 {

-    m_controller->triggerActivation();
+    m_controller->requestActivation();

 
 

+    const QModelIndex current = currentIndex();

     QTreeView::mousePressEvent(event);
 
     QTreeView::mousePressEvent(event);
 

+    m_expandingTogglePressed = false;

     const QModelIndex index = indexAt(event->pos());
     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;
+        }
+    }
+

     if (!index.isValid() || (index.column() != DolphinModel::Name)) {
     if (!index.isValid() || (index.column() != DolphinModel::Name)) {

+        if (QApplication::mouseButtons() & Qt::MidButton) {
+            m_controller->replaceUrlByClipboard();
+        }
+

         const Qt::KeyboardModifiers modifier = QApplication::keyboardModifiers();
         if (!(modifier & Qt::ShiftModifier) && !(modifier & Qt::ControlModifier)) {
             clearSelection();
         }
         const Qt::KeyboardModifiers modifier = QApplication::keyboardModifiers();
         if (!(modifier & Qt::ShiftModifier) && !(modifier & Qt::ControlModifier)) {
             clearSelection();
         }

+
+        // restore the current index, other columns are handled as viewport area
+        selectionModel()->setCurrentIndex(current, QItemSelectionModel::Current);

     }
 
     }
 

-    if (event->button() == Qt::LeftButton) {
+    if ((event->button() == Qt::LeftButton) && !m_expandingTogglePressed) {

         m_showElasticBand = true;
 
         const QPoint pos(contentsPos());
         m_showElasticBand = true;
 
         const QPoint pos(contentsPos());


@@ -187,21 +241,71 @@ void DolphinDetailsView::mousePressEvent(QMouseEvent* event)
 
 void DolphinDetailsView::mouseMoveEvent(QMouseEvent* event)
 {
 
 void DolphinDetailsView::mouseMoveEvent(QMouseEvent* event)
 {

-    QTreeView::mouseMoveEvent(event);

     if (m_showElasticBand) {
     if (m_showElasticBand) {

+        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
+            clearSelection();
+
+            const int nameColumnWidth = header()->sectionSize(DolphinModel::Name);
+            QRect selRect = QRect(m_elasticBandOrigin, m_elasticBandDestination).normalized();
+            const QRect nameColumnsRect(0, 0, nameColumnWidth, viewport()->height());
+            selRect = nameColumnsRect.intersected(selRect);
+
+            setSelection(selRect, QItemSelectionModel::Select);
+        }
+
+        // TODO: enable QTreeView::mouseMoveEvent(event) again, as soon
+        // as the Qt-issue #199631 has been fixed.
+        // QTreeView::mouseMoveEvent(event);
+        QAbstractItemView::mouseMoveEvent(event);

         updateElasticBand();
         updateElasticBand();

+    } else {
+        // TODO: enable QTreeView::mouseMoveEvent(event) again, as soon
+        // as the Qt-issue #199631 has been fixed.
+        // QTreeView::mouseMoveEvent(event);
+        QAbstractItemView::mouseMoveEvent(event);
+    }
+
+    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);

     }
 }
 
 void DolphinDetailsView::mouseReleaseEvent(QMouseEvent* event)
 {
     }
 }
 
 void DolphinDetailsView::mouseReleaseEvent(QMouseEvent* event)
 {

-    QTreeView::mouseReleaseEvent(event);
+    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_showElasticBand) {
         updateElasticBand();
         m_showElasticBand = false;
     }
 }
 
     if (m_showElasticBand) {
         updateElasticBand();
         m_showElasticBand = false;
     }
 }
 

+void DolphinDetailsView::startDrag(Qt::DropActions supportedActions)
+{
+    DragAndDropHelper::startDrag(this, supportedActions);
+    m_showElasticBand = false;
+}
+

 void DolphinDetailsView::dragEnterEvent(QDragEnterEvent* event)
 {
     if (event->mimeData()->hasUrls()) {
 void DolphinDetailsView::dragEnterEvent(QDragEnterEvent* event)
 {
     if (event->mimeData()->hasUrls()) {


@@ -212,15 +316,11 @@ void DolphinDetailsView::dragEnterEvent(QDragEnterEvent* event)
         updateElasticBand();
         m_showElasticBand = false;
     }
         updateElasticBand();
         m_showElasticBand = false;
     }

-    m_dragging = true;

 }
 
 void DolphinDetailsView::dragLeaveEvent(QDragLeaveEvent* event)
 {
     QTreeView::dragLeaveEvent(event);
 }
 
 void DolphinDetailsView::dragLeaveEvent(QDragLeaveEvent* event)
 {
     QTreeView::dragLeaveEvent(event);

-
-    // TODO: remove this code when the issue #160611 is solved in Qt 4.4
-    m_dragging = false;

     setDirtyRegion(m_dropRect);
 }
 
     setDirtyRegion(m_dropRect);
 }
 


@@ -231,27 +331,31 @@ void DolphinDetailsView::dragMoveEvent(QDragMoveEvent* event)
     // TODO: remove this code when the issue #160611 is solved in Qt 4.4
     setDirtyRegion(m_dropRect);
     const QModelIndex index = indexAt(event->pos());
     // 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)) {
-        m_dragging = false;
-    } else {
-        m_dragging = true;
-        m_dropRect = visualRect(index);
+    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);
     }
         setDirtyRegion(m_dropRect);
     }

+
+    if (event->mimeData()->hasUrls()) {
+        // accept url drops, independently from the destination item
+        event->acceptProposedAction();
+    }

 }
 
 void DolphinDetailsView::dropEvent(QDropEvent* event)
 {
 }
 
 void DolphinDetailsView::dropEvent(QDropEvent* event)
 {

-    const KUrl::List urls = KUrl::List::fromMimeData(event->mimeData());
-    if (!urls.isEmpty()) {
-        event->acceptProposedAction();
-        m_controller->indicateDroppedUrls(urls,
-                                          m_controller->url(),
-                                          indexAt(event->pos()),
-                                          event->source());
+    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);
     QTreeView::dropEvent(event);

-    m_dragging = false;

 }
 
 void DolphinDetailsView::paintEvent(QPaintEvent* event)
 }
 
 void DolphinDetailsView::paintEvent(QPaintEvent* event)


@@ -272,59 +376,69 @@ void DolphinDetailsView::paintEvent(QPaintEvent* event)
         style()->drawControl(QStyle::CE_RubberBand, &opt, &painter);
         painter.restore();
     }
         style()->drawControl(QStyle::CE_RubberBand, &opt, &painter);
         painter.restore();
     }

-
-    // TODO: remove this code when the issue #160611 is solved in Qt 4.4
-    if (m_dragging) {
-        const QBrush& brush = m_viewOptions.palette.brush(QPalette::Normal, QPalette::Highlight);
-        DolphinController::drawHoverIndication(viewport(), m_dropRect, brush);
-    }

 }
 
 void DolphinDetailsView::keyPressEvent(QKeyEvent* event)
 {
 }
 
 void DolphinDetailsView::keyPressEvent(QKeyEvent* event)
 {

+    // 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);
+

     QTreeView::keyPressEvent(event);
     QTreeView::keyPressEvent(event);

+    m_controller->handleKeyPressEvent(event);
+}

 
 

-    const QItemSelectionModel* selModel = selectionModel();
-    const QModelIndex currentIndex = selModel->currentIndex();
-    const bool triggerItem = currentIndex.isValid()
-                             && (event->key() == Qt::Key_Return)
-                             && (selModel->selectedIndexes().count() <= 1);
-    if (triggerItem) {
-        m_controller->triggerItem(currentIndex);
-    }
+void DolphinDetailsView::keyReleaseEvent(QKeyEvent* event)
+{
+    QTreeView::keyReleaseEvent(event);
+    m_keyPressed = false;

 }
 
 void DolphinDetailsView::resizeEvent(QResizeEvent* event)
 {
 }
 
 void DolphinDetailsView::resizeEvent(QResizeEvent* event)
 {

+    if (m_autoResize) {
+        resizeColumns();
+    }

     QTreeView::resizeEvent(event);
     QTreeView::resizeEvent(event);

+}

 
 

-    // assure that the width of the name-column does not get too small
-    const int minWidth = 120;
-    QHeaderView* headerView = header();
-    bool useFixedWidth = (headerView->sectionSize(KDirModel::Name) <= minWidth)
-                         && (headerView->resizeMode(0) != QHeaderView::Fixed);
-    if (useFixedWidth) {
-        // the current width of the name-column is too small, hence
-        // use a fixed size
-        headerView->setResizeMode(QHeaderView::Fixed);
-        headerView->setResizeMode(0, QHeaderView::Fixed);
-        headerView->resizeSection(KDirModel::Name, minWidth);
-    } else if (headerView->resizeMode(0) != QHeaderView::Stretch) {
-        // check whether there is enough available viewport width
-        // to automatically resize the columns
-        const int availableWidth = viewport()->width();
-
-        int headerWidth = 0;
-        const int count = headerView->count();
-        for (int i = 0; i < count; ++i) {
-            headerWidth += headerView->sectionSize(i);
-        }
+void DolphinDetailsView::wheelEvent(QWheelEvent* event)
+{
+    if (m_selectionManager != 0) {
+        m_selectionManager->reset();
+    }

 
 

-        if (headerWidth < availableWidth) {
-            headerView->setResizeMode(QHeaderView::ResizeToContents);
-            headerView->setResizeMode(0, QHeaderView::Stretch);
-        }
+    // let Ctrl+wheel events propagate to the DolphinView for icon zooming
+    if (event->modifiers() & Qt::ControlModifier) {
+        event->ignore();
+        return;

     }
     }

+
+    QTreeView::wheelEvent(event);
+}
+
+void DolphinDetailsView::currentChanged(const QModelIndex& current, const QModelIndex& previous)
+{
+    QTreeView::currentChanged(current, previous);
+
+    // Stay consistent with QListView: When changing the current index by key presses,
+    // also change the selection.
+    if (m_keyPressed) {
+        selectionModel()->select(current, QItemSelectionModel::ClearAndSelect);
+    }
+}
+
+bool DolphinDetailsView::eventFilter(QObject* watched, QEvent* event)
+{
+    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();
+    }
+
+    return QTreeView::eventFilter(watched, event);

 }
 
 void DolphinDetailsView::setSortIndicatorSection(DolphinView::Sorting sorting)
 }
 
 void DolphinDetailsView::setSortIndicatorSection(DolphinView::Sorting sorting)


@@ -351,83 +465,147 @@ void DolphinDetailsView::synchronizeSortingState(int column)
 
 void DolphinDetailsView::slotEntered(const QModelIndex& index)
 {
 
 void DolphinDetailsView::slotEntered(const QModelIndex& index)
 {

-    const QPoint pos = viewport()->mapFromGlobal(QCursor::pos());
-    const int nameColumnWidth = header()->sectionSize(DolphinModel::Name);
-    if (pos.x() < nameColumnWidth) {
+    if (index.column() == DolphinModel::Name) {

         m_controller->emitItemEntered(index);
         m_controller->emitItemEntered(index);

-    }
-    else {
+    } else {

         m_controller->emitViewportEntered();
     }
 }
 
 void DolphinDetailsView::updateElasticBand()
 {
         m_controller->emitViewportEntered();
     }
 }
 
 void DolphinDetailsView::updateElasticBand()
 {

-    Q_ASSERT(m_showElasticBand);
-    QRect dirtyRegion(elasticBandRect());
-    m_elasticBandDestination = viewport()->mapFromGlobal(QCursor::pos());
-    dirtyRegion = dirtyRegion.united(elasticBandRect());
-    setDirtyRegion(dirtyRegion);
+    if (m_showElasticBand) {
+        QRect dirtyRegion(elasticBandRect());
+        m_elasticBandDestination = viewport()->mapFromGlobal(QCursor::pos());
+        dirtyRegion = dirtyRegion.united(elasticBandRect());
+        setDirtyRegion(dirtyRegion);
+    }
+}
+
+QRect DolphinDetailsView::elasticBandRect() const
+{
+    const QPoint pos(contentsPos());
+    const QPoint topLeft(m_elasticBandOrigin.x() - pos.x(), m_elasticBandOrigin.y() - pos.y());
+    return QRect(topLeft, m_elasticBandDestination).normalized();

 }
 
 }
 

-void DolphinDetailsView::zoomIn()
+void DolphinDetailsView::setZoomLevel(int level)

 {
 {

-    if (isZoomInPossible()) {
-        DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
-        // TODO: get rid of K3Icon sizes
-        switch (settings->iconSize()) {
-        case K3Icon::SizeSmall:  settings->setIconSize(K3Icon::SizeMedium); break;
-        case K3Icon::SizeMedium: settings->setIconSize(K3Icon::SizeLarge); break;
-        default: Q_ASSERT(false); break;
+    const int size = ZoomLevelInfo::iconSizeForZoomLevel(level);
+    DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
+    
+    const bool showPreview = m_controller->dolphinView()->showPreview();
+    if (showPreview) {
+        settings->setPreviewSize(size);
+    } else {
+        settings->setIconSize(size);
+    }
+    
+    updateDecorationSize(showPreview);
+}
+
+
+void DolphinDetailsView::slotShowPreviewChanged()
+{
+    const DolphinView* view = m_controller->dolphinView();
+    updateDecorationSize(view->showPreview());
+}
+
+void DolphinDetailsView::configureColumns(const QPoint& pos)
+{
+    KMenu popup(this);
+    popup.addTitle(i18nc("@title:menu", "Columns"));
+
+    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);
+    }
+
+    QAction* activatedAction = popup.exec(header()->mapToGlobal(pos));
+    if (activatedAction != 0) {
+        const bool show = activatedAction->isChecked();
+        const int columnIndex = activatedAction->data().toInt();
+
+        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);

         }
         }

-        updateDecorationSize();
+
+        m_controller->indicateAdditionalInfoChange(list);
+        setColumnHidden(columnIndex, !show);

     }
 }
 
     }
 }
 

-void DolphinDetailsView::zoomOut()
+void DolphinDetailsView::updateColumnVisibility()

 {
 {

-    if (isZoomOutPossible()) {
-        DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
-        // TODO: get rid of K3Icon sizes
-        switch (settings->iconSize()) {
-        case K3Icon::SizeLarge:  settings->setIconSize(K3Icon::SizeMedium); break;
-        case K3Icon::SizeMedium: settings->setIconSize(K3Icon::SizeSmall); break;
-        default: Q_ASSERT(false); break;
+    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);

         }
         }

-        updateDecorationSize();

     }
     }

+
+    resizeColumns();

 }
 
 }
 

-void DolphinDetailsView::slotItemActivated(const QModelIndex& index)
+void DolphinDetailsView::slotHeaderSectionResized(int logicalIndex, int oldSize, int newSize)

 {
 {

-    if (index.isValid() && (index.column() == KDirModel::Name)) {
-        m_controller->triggerItem(index);
-    } else {
-        clearSelection();
-        m_controller->emitItemEntered(index);
+    Q_UNUSED(logicalIndex);
+    Q_UNUSED(oldSize);
+    Q_UNUSED(newSize);
+    if (QApplication::mouseButtons() & Qt::LeftButton) {
+        disableAutoResizing();

     }
 }
 
     }
 }
 

-bool DolphinDetailsView::isZoomInPossible() const
+void DolphinDetailsView::slotActivationChanged(bool active)

 {
 {

-    DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
-    return settings->iconSize() < K3Icon::SizeLarge;
+    setAlternatingRowColors(active);

 }
 
 }
 

-bool DolphinDetailsView::isZoomOutPossible() const
+void DolphinDetailsView::disableAutoResizing()

 {
 {

-    DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
-    return settings->iconSize() > K3Icon::SizeSmall;
+    m_autoResize = false;
+}
+
+void DolphinDetailsView::requestActivation()
+{
+    m_controller->requestActivation();

 }
 
 }
 

-void DolphinDetailsView::updateDecorationSize()
+void DolphinDetailsView::updateFont()
+{
+    const DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
+    Q_ASSERT(settings != 0);
+
+    if (settings->useSystemFont()) {
+        m_font = KGlobalSettings::generalFont();
+    }
+}
+
+void DolphinDetailsView::updateDecorationSize(bool showPreview)

 {
     DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
 {
     DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();

-    const int iconSize = settings->iconSize();
-    m_viewOptions.decorationSize = QSize(iconSize, iconSize);
+    const int iconSize = showPreview ? settings->previewSize() : settings->iconSize();
+    setIconSize(QSize(iconSize, iconSize));
+    m_decorationSize = QSize(iconSize, iconSize);

 
 

-    m_controller->setZoomInPossible(isZoomInPossible());
-    m_controller->setZoomOutPossible(isZoomOutPossible());
+    if (m_selectionManager != 0) {
+        m_selectionManager->reset();
+    }

 
     doItemsLayout();
 }
 
     doItemsLayout();
 }


@@ -450,16 +628,57 @@ QPoint DolphinDetailsView::contentsPos() const
     return QPoint(0, y);
 }
 
     return QPoint(0, y);
 }
 

-QRect DolphinDetailsView::elasticBandRect() const
+KFileItemDelegate::Information DolphinDetailsView::infoForColumn(int columnIndex) const

 {
 {

-    const QPoint pos(contentsPos());
-    const QPoint topLeft(m_elasticBandOrigin.x() - pos.x(), m_elasticBandOrigin.y() - pos.y());
-    return QRect(topLeft, m_elasticBandDestination).normalized();
+    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;

 }
 
 }
 

-static bool isValidNameIndex(const QModelIndex& index)
+void DolphinDetailsView::resizeColumns()

 {
 {

-    return index.isValid() && (index.column() == KDirModel::Name);
+    // 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).
+
+    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]);
+        }
+    }
+
+    // resize the name column in a way that the whole available width is used
+    columnWidth[KDirModel::Name] = viewport()->width() - requiredWidth;
+    if (columnWidth[KDirModel::Name] < 120) {
+        columnWidth[KDirModel::Name] = 120;
+    }
+    headerView->resizeSection(KDirModel::Name, columnWidth[KDirModel::Name]);

 }
 
 #include "dolphindetailsview.moc"
 }
 
 #include "dolphindetailsview.moc"