Let the user choose if folders are always shown first in the views of

[dolphin.git] / src / dolphincolumnwidget.cpp

diff --git a/src/dolphincolumnwidget.cpp b/src/dolphincolumnwidget.cpp
index 677215972d2b35aa027a6810c538a5e6edbdb72b..e85c9491bed721545f8ce3711ce6b3488c29e498 100644 (file)
--- a/src/dolphincolumnwidget.cpp
+++ b/src/dolphincolumnwidget.cpp
@@ -23,80 +23,83 @@
 #include "dolphincolumnview.h"
 #include "dolphincontroller.h"
 #include "dolphindirlister.h"
 #include "dolphincolumnview.h"
 #include "dolphincontroller.h"
 #include "dolphindirlister.h"

-#include "dolphinmodel.h"

 #include "dolphinsortfilterproxymodel.h"
 #include "dolphinsortfilterproxymodel.h"

-#include "dolphinsettings.h"
+#include "settings/dolphinsettings.h"
+#include "dolphinviewautoscroller.h"

 #include "dolphin_columnmodesettings.h"
 #include "dolphin_columnmodesettings.h"

+#include "dolphin_generalsettings.h"

 #include "draganddrophelper.h"
 #include "draganddrophelper.h"

+#include "folderexpander.h"
+#include "selectionmanager.h"
+#include "tooltips/tooltipmanager.h"

 
 

-#include <kcolorutils.h>

 #include <kcolorscheme.h>
 #include <kdirlister.h>
 #include <kfileitem.h>
 #include <kcolorscheme.h>
 #include <kdirlister.h>
 #include <kfileitem.h>

+#include <kfilepreviewgenerator.h>

 #include <kio/previewjob.h>
 #include <kiconeffect.h>
 #include <kio/previewjob.h>
 #include <kiconeffect.h>

-#include <kmimetyperesolver.h>
+#include <kjob.h>

 #include <konqmimedata.h>
 
 #include <konqmimedata.h>
 

-#include <QAbstractProxyModel>

 #include <QApplication>
 #include <QClipboard>
 #include <QApplication>
 #include <QClipboard>

+#include <QPainter>

 #include <QPoint>
 #include <QScrollBar>
 #include <QPoint>
 #include <QScrollBar>

-#include <QTimer>
-#include <QTimeLine>

 
 DolphinColumnWidget::DolphinColumnWidget(QWidget* parent,
                                          DolphinColumnView* columnView,
                                          const KUrl& url) :
     QListView(parent),
     m_active(true),
 
 DolphinColumnWidget::DolphinColumnWidget(QWidget* parent,
                                          DolphinColumnView* columnView,
                                          const KUrl& url) :
     QListView(parent),
     m_active(true),

-    m_showPreview(false),

     m_view(columnView),
     m_view(columnView),

+    m_selectionManager(0),
+    m_autoScroller(0),

     m_url(url),
     m_childUrl(),
     m_url(url),
     m_childUrl(),

-    m_viewOptions(),
+    m_font(),
+    m_decorationSize(),

     m_dirLister(0),
     m_dolphinModel(0),
     m_proxyModel(0),
     m_dirLister(0),
     m_dolphinModel(0),
     m_proxyModel(0),

-    m_dragging(false),
+    m_previewGenerator(0),
+    m_toolTipManager(0),

     m_dropRect()
 {
     setMouseTracking(true);
     m_dropRect()
 {
     setMouseTracking(true);

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

     setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
     setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

-    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
+    setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);

     setSelectionBehavior(SelectItems);
     setSelectionMode(QAbstractItemView::ExtendedSelection);
     setDragDropMode(QAbstractItemView::DragDrop);
     setDropIndicatorShown(false);
     setSelectionBehavior(SelectItems);
     setSelectionMode(QAbstractItemView::ExtendedSelection);
     setDragDropMode(QAbstractItemView::DragDrop);
     setDropIndicatorShown(false);

+    setSelectionRectVisible(true);
+    setEditTriggers(QAbstractItemView::NoEditTriggers);

 
 

-// TODO: Remove this check when 4.3.2 is released and KDE requires it... this
-//       check avoids a division by zero happening on versions before 4.3.1.
-//       Right now KDE in theory can be shipped with Qt 4.3.0 and above.
-//       ereslibre
-#if (QT_VERSION >= QT_VERSION_CHECK(4, 3, 2) || defined(QT_KDE_QT_COPY))

     setVerticalScrollMode(QListView::ScrollPerPixel);
     setHorizontalScrollMode(QListView::ScrollPerPixel);
     setVerticalScrollMode(QListView::ScrollPerPixel);
     setHorizontalScrollMode(QListView::ScrollPerPixel);

-#endif
+
+    m_autoScroller = new DolphinViewAutoScroller(this);

 
     // apply the column mode settings to the widget
     const ColumnModeSettings* settings = DolphinSettings::instance().columnModeSettings();
     Q_ASSERT(settings != 0);
 
 
     // apply the column mode settings to the widget
     const ColumnModeSettings* settings = DolphinSettings::instance().columnModeSettings();
     Q_ASSERT(settings != 0);
 

-    m_viewOptions = QListView::viewOptions();
-
-    QFont font(settings->fontFamily(), settings->fontSize());
-    font.setItalic(settings->italicFont());
-    font.setBold(settings->boldFont());
-    m_viewOptions.font = font;
+    if (settings->useSystemFont()) {
+        m_font = KGlobalSettings::generalFont();
+    } else {
+        m_font = QFont(settings->fontFamily(),
+                       settings->fontSize(),
+                       settings->fontWeight(),
+                       settings->italicFont());
+    }

 
     const int iconSize = settings->iconSize();
 
     const int iconSize = settings->iconSize();

-    m_viewOptions.decorationSize = QSize(iconSize, iconSize);
-
-    m_viewOptions.showDecorationSelected = true;
+    setDecorationSize(QSize(iconSize, iconSize));

 
     KFileItemDelegate* delegate = new KFileItemDelegate(this);
 
     KFileItemDelegate* delegate = new KFileItemDelegate(this);

+    delegate->setShowToolTipWhenElided(false);

     setItemDelegate(delegate);
 
     activate();
     setItemDelegate(delegate);
 
     activate();


@@ -106,15 +109,12 @@ DolphinColumnWidget::DolphinColumnWidget(QWidget* parent,
     connect(this, SIGNAL(entered(const QModelIndex&)),
             this, SLOT(slotEntered(const QModelIndex&)));
 
     connect(this, SIGNAL(entered(const QModelIndex&)),
             this, SLOT(slotEntered(const QModelIndex&)));
 

-    //m_dirLister = new DolphinDirLister(); TODO
-    m_dirLister = new KDirLister();
+    m_dirLister = new DolphinDirLister();

     m_dirLister->setAutoUpdate(true);
     m_dirLister->setAutoUpdate(true);

-    m_dirLister->setMainWindow(this);
+    m_dirLister->setMainWindow(window());

     m_dirLister->setDelayedMimeTypes(true);
     const bool showHiddenFiles = m_view->m_controller->dolphinView()->showHiddenFiles();
     m_dirLister->setShowingDotFiles(showHiddenFiles);
     m_dirLister->setDelayedMimeTypes(true);
     const bool showHiddenFiles = m_view->m_controller->dolphinView()->showHiddenFiles();
     m_dirLister->setShowingDotFiles(showHiddenFiles);

-    connect(m_dirLister, SIGNAL(newItems(const KFileItemList&)),
-            this, SLOT(generatePreviews(const KFileItemList&)));

 
     m_dolphinModel = new DolphinModel(this);
     m_dolphinModel->setDirLister(m_dirLister);
 
     m_dolphinModel = new DolphinModel(this);
     m_dolphinModel->setDirLister(m_dirLister);


@@ -122,37 +122,76 @@ DolphinColumnWidget::DolphinColumnWidget(QWidget* parent,
 
     m_proxyModel = new DolphinSortFilterProxyModel(this);
     m_proxyModel->setSourceModel(m_dolphinModel);
 
     m_proxyModel = new DolphinSortFilterProxyModel(this);
     m_proxyModel->setSourceModel(m_dolphinModel);

+    m_proxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
+    const DolphinView* dolphinView = m_view->m_controller->dolphinView();
+    m_proxyModel->setSorting(dolphinView->sorting());
+    m_proxyModel->setSortOrder(dolphinView->sortOrder());
+    m_proxyModel->setSortFoldersFirst(dolphinView->sortFoldersFirst());

 
     setModel(m_proxyModel);
 
     setModel(m_proxyModel);

-    new KMimeTypeResolver(this, m_dolphinModel);
+
+    if (DolphinSettings::instance().generalSettings()->showSelectionToggle()) {
+        m_selectionManager = new SelectionManager(this);
+        connect(m_selectionManager, SIGNAL(selectionChanged()),
+                this, SLOT(requestActivation()));
+        connect(m_view->m_controller, SIGNAL(urlChanged(const KUrl&)),
+                m_selectionManager, SLOT(reset()));
+    }
+
+    m_previewGenerator = new KFilePreviewGenerator(this);
+    m_previewGenerator->setPreviewShown(m_view->m_controller->dolphinView()->showPreview());
+
+    if (DolphinSettings::instance().generalSettings()->showToolTips()) {
+        m_toolTipManager = new ToolTipManager(this, m_proxyModel);
+    }

 
     m_dirLister->openUrl(url, KDirLister::NoFlags);
 
     m_dirLister->openUrl(url, KDirLister::NoFlags);

+
+    connect(KGlobalSettings::self(), SIGNAL(kdisplayFontChanged()),
+            this, SLOT(updateFont()));
+
+    FolderExpander* folderExpander = new FolderExpander(this, m_proxyModel);
+    folderExpander->setEnabled(DolphinSettings::instance().generalSettings()->autoExpandFolders());
+    connect (folderExpander, SIGNAL(enterDir(const QModelIndex&)),
+             m_view->m_controller, SLOT(triggerItem(const QModelIndex&)));

 }
 
 DolphinColumnWidget::~DolphinColumnWidget()
 {
 }
 
 DolphinColumnWidget::~DolphinColumnWidget()
 {

-    delete m_dirLister;
-    m_dirLister = 0;
+    delete m_proxyModel;
+    m_proxyModel = 0;
+    delete m_dolphinModel;
+    m_dolphinModel = 0;
+    m_dirLister = 0; // deleted by m_dolphinModel

 }
 
 void DolphinColumnWidget::setDecorationSize(const QSize& size)
 {
 }
 
 void DolphinColumnWidget::setDecorationSize(const QSize& size)
 {

-    m_viewOptions.decorationSize = size;
+    setIconSize(size);
+    m_decorationSize = size;

     doItemsLayout();
     doItemsLayout();

+    if (m_previewGenerator != 0) {
+        m_previewGenerator->updateIcons();
+    }
+    if (m_selectionManager != 0) {
+        m_selectionManager->reset();
+    }

 }
 
 void DolphinColumnWidget::setActive(bool active)
 {
 }
 
 void DolphinColumnWidget::setActive(bool active)
 {

-    if (m_active == active) {
-        return;
+    if (active && (m_view->focusProxy() != this)) {
+        m_view->setFocusProxy(this);

     }
 
     }
 

-    m_active = active;
+    if (m_active != active) {
+        m_active = active;

 
 

-    if (active) {
-        activate();
-    } else {
-        deactivate();
+        if (active) {
+            activate();
+        } else {
+            deactivate();
+        }

     }
 }
 
     }
 }
 


@@ -162,6 +201,21 @@ void DolphinColumnWidget::reload()
     m_dirLister->openUrl(m_url, KDirLister::Reload);
 }
 
     m_dirLister->openUrl(m_url, KDirLister::Reload);
 }
 

+void DolphinColumnWidget::setSorting(DolphinView::Sorting sorting)
+{
+    m_proxyModel->setSorting(sorting);
+}
+
+void DolphinColumnWidget::setSortOrder(Qt::SortOrder order)
+{
+    m_proxyModel->setSortOrder(order);
+}
+
+void DolphinColumnWidget::setSortFoldersFirst(bool foldersFirst)
+{
+    m_proxyModel->setSortFoldersFirst(foldersFirst);
+}
+

 void DolphinColumnWidget::setShowHiddenFiles(bool show)
 {
     if (show != m_dirLister->showingDotFiles()) {
 void DolphinColumnWidget::setShowHiddenFiles(bool show)
 {
     if (show != m_dirLister->showingDotFiles()) {


@@ -173,20 +227,24 @@ void DolphinColumnWidget::setShowHiddenFiles(bool show)
 
 void DolphinColumnWidget::setShowPreview(bool show)
 {
 
 void DolphinColumnWidget::setShowPreview(bool show)
 {

-    if (show != m_showPreview) {
-        m_dirLister->stop();
-        m_dirLister->openUrl(m_url, KDirLister::Reload);
-    }
+    m_previewGenerator->setPreviewShown(show);
+
+    m_dirLister->stop();
+    m_dirLister->openUrl(m_url, KDirLister::Reload);

 }
 
 void DolphinColumnWidget::updateBackground()
 {
 }
 
 void DolphinColumnWidget::updateBackground()
 {

-    QColor color = KColorScheme(QPalette::Active, KColorScheme::View).background().color();
-    if (!m_active || !m_view->m_active) {
-        color.setAlpha(150);
-    }
+    // TODO: The alpha-value 150 is copied from DolphinView::setActive(). When
+    // cleaning up the cut-indication of DolphinColumnWidget with the code from
+    // DolphinView a common helper-class should be available which can be shared
+    // by all view implementations -> no hardcoded value anymore
+    const QPalette::ColorRole role = viewport()->backgroundRole();
+    QColor color = viewport()->palette().color(role);
+    color.setAlpha((m_active && m_view->m_active) ? 255 : 150);
+

     QPalette palette = viewport()->palette();
     QPalette palette = viewport()->palette();

-    palette.setColor(viewport()->backgroundRole(), color);
+    palette.setColor(role, color);

     viewport()->setPalette(palette);
 
     update();
     viewport()->setPalette(palette);
 
     update();


@@ -197,26 +255,73 @@ void DolphinColumnWidget::setNameFilter(const QString& nameFilter)
     m_proxyModel->setFilterRegExp(nameFilter);
 }
 
     m_proxyModel->setFilterRegExp(nameFilter);
 }
 

+void DolphinColumnWidget::editItem(const KFileItem& item)
+{
+    const QModelIndex dirIndex = m_dolphinModel->indexForItem(item);
+    const QModelIndex proxyIndex = m_proxyModel->mapFromSource(dirIndex);
+    if (proxyIndex.isValid()) {
+        edit(proxyIndex);
+    }
+}
+
+KFileItem DolphinColumnWidget::itemAt(const QPoint& pos) const
+{
+    KFileItem item;
+    const QModelIndex index = indexAt(pos);
+    if (index.isValid() && (index.column() == DolphinModel::Name)) {
+        const QModelIndex dolphinModelIndex = m_proxyModel->mapToSource(index);
+        item = m_dolphinModel->itemForIndex(dolphinModelIndex);
+    }
+    return item;
+}
+
+KFileItemList DolphinColumnWidget::selectedItems() const
+{
+    const QItemSelection selection = m_proxyModel->mapSelectionToSource(selectionModel()->selection());
+    KFileItemList itemList;
+
+    const QModelIndexList indexList = selection.indexes();
+    foreach (const QModelIndex &index, indexList) {
+        KFileItem item = m_dolphinModel->itemForIndex(index);
+        if (!item.isNull()) {
+            itemList.append(item);
+        }
+    }
+
+    return itemList;
+}
+
+QMimeData* DolphinColumnWidget::selectionMimeData() const
+{
+    const QItemSelection selection = m_proxyModel->mapSelectionToSource(selectionModel()->selection());
+    return m_dolphinModel->mimeData(selection.indexes());
+}
+
+QStyleOptionViewItem DolphinColumnWidget::viewOptions() const
+{
+    QStyleOptionViewItem viewOptions = QListView::viewOptions();
+    viewOptions.font = m_font;
+    viewOptions.decorationSize = m_decorationSize;
+    viewOptions.showDecorationSelected = true;
+    return viewOptions;
+}
+

 void DolphinColumnWidget::startDrag(Qt::DropActions supportedActions)
 {
 void DolphinColumnWidget::startDrag(Qt::DropActions supportedActions)
 {

-    DragAndDropHelper::startDrag(this, supportedActions);
+    DragAndDropHelper::instance().startDrag(this, supportedActions, m_view->m_controller);

 }
 
 void DolphinColumnWidget::dragEnterEvent(QDragEnterEvent* event)
 {
 }
 
 void DolphinColumnWidget::dragEnterEvent(QDragEnterEvent* event)
 {

-    if (event->mimeData()->hasUrls()) {
+    if (DragAndDropHelper::instance().isMimeDataSupported(event->mimeData())) {

         event->acceptProposedAction();
         event->acceptProposedAction();

+        requestActivation();

     }
     }

-
-    m_dragging = true;

 }
 
 void DolphinColumnWidget::dragLeaveEvent(QDragLeaveEvent* event)
 {
     QListView::dragLeaveEvent(event);
 }
 
 void DolphinColumnWidget::dragLeaveEvent(QDragLeaveEvent* event)
 {
     QListView::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);
 }
 


@@ -230,27 +335,27 @@ void DolphinColumnWidget::dragMoveEvent(QDragMoveEvent* event)
 
     m_dropRect.setSize(QSize()); // set as invalid
     if (index.isValid()) {
 
     m_dropRect.setSize(QSize()); // set as invalid
     if (index.isValid()) {

-        const KFileItem item = itemForIndex(index);
+        m_view->m_controller->setItemView(this);
+        const KFileItem item = m_view->m_controller->itemForIndex(index);

         if (!item.isNull() && item.isDir()) {
             m_dropRect = visualRect(index);
         }
     }
     setDirtyRegion(m_dropRect);
         if (!item.isNull() && item.isDir()) {
             m_dropRect = visualRect(index);
         }
     }
     setDirtyRegion(m_dropRect);

+
+    if (DragAndDropHelper::instance().isMimeDataSupported(event->mimeData())) {
+        // accept url drops, independently from the destination item
+        event->acceptProposedAction();
+    }

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

-    const KUrl::List urls = KUrl::List::fromMimeData(event->mimeData());
-    if (!urls.isEmpty()) {
-        const QModelIndex index = indexAt(event->pos());
-        const KFileItem item = itemForIndex(index);
-        m_view->m_controller->indicateDroppedUrls(urls,
-                                                  url(),
-                                                  item);
-        event->acceptProposedAction();
-    }
+    const QModelIndex index = indexAt(event->pos());
+    m_view->m_controller->setItemView(this);
+    const KFileItem item = m_view->m_controller->itemForIndex(index);
+    m_view->m_controller->indicateDroppedUrls(item, url(), event);

     QListView::dropEvent(event);
     QListView::dropEvent(event);

-    m_dragging = false;

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


@@ -262,49 +367,62 @@ void DolphinColumnWidget::paintEvent(QPaintEvent* event)
         if (proxyIndex.isValid() && !selectionModel()->isSelected(proxyIndex)) {
             const QRect itemRect = visualRect(proxyIndex);
             QPainter painter(viewport());
         if (proxyIndex.isValid() && !selectionModel()->isSelected(proxyIndex)) {
             const QRect itemRect = visualRect(proxyIndex);
             QPainter painter(viewport());

-            painter.save();
-

             QColor color = KColorScheme(QPalette::Active, KColorScheme::View).foreground().color();
             color.setAlpha(32);
             painter.setPen(Qt::NoPen);
             painter.setBrush(color);
             painter.drawRect(itemRect);
             QColor color = KColorScheme(QPalette::Active, KColorScheme::View).foreground().color();
             color.setAlpha(32);
             painter.setPen(Qt::NoPen);
             painter.setBrush(color);
             painter.drawRect(itemRect);

-
-            painter.restore();

         }
     }
 
     QListView::paintEvent(event);
         }
     }
 
     QListView::paintEvent(event);

-
-    // 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);
-        DragAndDropHelper::drawHoverIndication(viewport(), m_dropRect, brush);
-    }

 }
 
 void DolphinColumnWidget::mousePressEvent(QMouseEvent* event)
 {
 }
 
 void DolphinColumnWidget::mousePressEvent(QMouseEvent* event)
 {

-    m_view->m_controller->requestActivation();
-    if (!m_active) {
-        m_view->requestActivation(this);
-        m_view->m_controller->triggerUrlChangeRequest(m_url);
+    requestActivation();
+    if (!indexAt(event->pos()).isValid()) {
+        if (QApplication::mouseButtons() & Qt::MidButton) {
+            m_view->m_controller->replaceUrlByClipboard();
+        }
+    } else if (event->button() == Qt::LeftButton) {
+        // TODO: see comment in DolphinIconsView::mousePressEvent()
+        setState(QAbstractItemView::DraggingState);

     }
     }

-

     QListView::mousePressEvent(event);
 }
 
 void DolphinColumnWidget::keyPressEvent(QKeyEvent* event)
 {
     QListView::keyPressEvent(event);
     QListView::mousePressEvent(event);
 }
 
 void DolphinColumnWidget::keyPressEvent(QKeyEvent* event)
 {
     QListView::keyPressEvent(event);

+    requestActivation();
+
+    DolphinController* controller = m_view->m_controller;
+    controller->handleKeyPressEvent(event);
+    switch (event->key()) {
+    case Qt::Key_Right: {
+        // Special key handling for the column: A Key_Right should
+        // open a new column for the currently selected folder.
+        const QModelIndex index = currentIndex();
+        const KFileItem item = controller->itemForIndex(index);
+        if (!item.isNull() && item.isDir()) {
+            controller->emitItemTriggered(item);
+        }
+        break;
+    }
+
+    case Qt::Key_Escape:
+        selectionModel()->setCurrentIndex(selectionModel()->currentIndex(),
+                                          QItemSelectionModel::Current |
+                                          QItemSelectionModel::Clear);
+        break;
+
+    default:
+        break;
+    }

 
 

-    const QItemSelectionModel* selModel = selectionModel();
-    const QModelIndex currentIndex = selModel->currentIndex();
-    const bool trigger = currentIndex.isValid()
-                         && (event->key() == Qt::Key_Return)
-                         && (selModel->selectedIndexes().count() <= 1);
-    if (trigger) {
-        triggerItem(currentIndex);
+    if (m_toolTipManager != 0) {
+        m_toolTipManager->hideTip();

     }
 }
 
     }
 }
 


@@ -312,150 +430,153 @@ void DolphinColumnWidget::contextMenuEvent(QContextMenuEvent* event)
 {
     if (!m_active) {
         m_view->requestActivation(this);
 {
     if (!m_active) {
         m_view->requestActivation(this);

+        Q_ASSERT(m_view->m_controller->itemView() == this);

         m_view->m_controller->triggerUrlChangeRequest(m_url);
     }
         m_view->m_controller->triggerUrlChangeRequest(m_url);
     }

+    Q_ASSERT(m_active);

 
     QListView::contextMenuEvent(event);
 
     const QModelIndex index = indexAt(event->pos());
 
     QListView::contextMenuEvent(event);
 
     const QModelIndex index = indexAt(event->pos());

-    if (index.isValid() || m_active) {
-        // Only open a context menu above an item or if the mouse is above
-        // the active column.
-        const QPoint pos = m_view->viewport()->mapFromGlobal(event->globalPos());
-        m_view->m_controller->triggerContextMenuRequest(pos);
+    if (!index.isValid()) {
+        clearSelection();
+    }
+
+    if (m_toolTipManager != 0) {
+        m_toolTipManager->hideTip();

     }
     }

+
+    const QPoint pos = m_view->viewport()->mapFromGlobal(event->globalPos());
+    Q_ASSERT(m_view->m_controller->itemView() == this);
+    m_view->m_controller->triggerContextMenuRequest(pos);

 }
 
 }
 

-void DolphinColumnWidget::selectionChanged(const QItemSelection& selected, const QItemSelection& deselected)
+void DolphinColumnWidget::wheelEvent(QWheelEvent* event)

 {
 {

-    QListView::selectionChanged(selected, deselected);
+    if (m_selectionManager != 0) {
+        m_selectionManager->reset();
+    }

 
 

-    QItemSelectionModel* selModel = m_view->selectionModel();
-    selModel->select(selected, QItemSelectionModel::Select);
-    selModel->select(deselected, QItemSelectionModel::Deselect);
+    // let Ctrl+wheel events propagate to the DolphinView for icon zooming
+    if (event->modifiers() & Qt::ControlModifier) {
+        event->ignore();
+        return;
+    }
+
+    const int height = m_decorationSize.height();
+    const int step = (height >= KIconLoader::SizeHuge) ? height / 10 : (KIconLoader::SizeHuge - height) / 2;
+    verticalScrollBar()->setSingleStep(step);
+
+    QListView::wheelEvent(event);

 }
 
 }
 

-void DolphinColumnWidget::triggerItem(const QModelIndex& index)
+void DolphinColumnWidget::leaveEvent(QEvent* event)

 {
 {

-    const KFileItem item = itemForIndex(index);
-    m_view->m_controller->triggerItem(item);
+    QListView::leaveEvent(event);
+    // 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_view->m_controller->emitViewportEntered();

 }
 
 }
 

-void DolphinColumnWidget::generatePreviews(const KFileItemList& items)
+void DolphinColumnWidget::selectionChanged(const QItemSelection& selected, const QItemSelection& deselected)

 {
 {

-    // TODO: same implementation as in DolphinView; create helper class
-    // for generatePreviews(), showPreview() and isCutItem()
+    QListView::selectionChanged(selected, deselected);

 
 

-    if (m_view->m_controller->dolphinView()->showPreview()) {
-        KIO::PreviewJob* job = KIO::filePreview(items, 128);
-        connect(job, SIGNAL(gotPreview(const KFileItem&, const QPixmap&)),
-                this, SLOT(showPreview(const KFileItem&, const QPixmap&)));
-    }
+    QItemSelectionModel* selModel = m_view->selectionModel();
+    selModel->select(selected, QItemSelectionModel::Select);
+    selModel->select(deselected, QItemSelectionModel::Deselect);

 }
 
 }
 

-void DolphinColumnWidget::showPreview(const KFileItem& item, const QPixmap& pixmap)
+void DolphinColumnWidget::currentChanged(const QModelIndex& current, const QModelIndex& previous)

 {
 {

-    // TODO: same implementation as in DolphinView; create helper class
-    // for generatePreviews(), showPreview() and isCutItem()
-
-    Q_ASSERT(!item.isNull());
-    if (item.url().directory() != m_dirLister->url().path()) {
-        // the preview job is still working on items of an older URL, hence
-        // the item is not part of the directory model anymore
-        return;
-    }
-
-    const QModelIndex idx = m_dolphinModel->indexForItem(item);
-    if (idx.isValid() && (idx.column() == 0)) {
-        const QMimeData* mimeData = QApplication::clipboard()->mimeData();
-        if (KonqMimeData::decodeIsCutSelection(mimeData) && isCutItem(item)) {
-            KIconEffect iconEffect;
-            const QPixmap cutPixmap = iconEffect.apply(pixmap, KIconLoader::Desktop, KIconLoader::DisabledState);
-            m_dolphinModel->setData(idx, QIcon(cutPixmap), Qt::DecorationRole);
-        } else {
-            m_dolphinModel->setData(idx, QIcon(pixmap), Qt::DecorationRole);
-        }
+    QListView::currentChanged(current, previous);
+    if (current.isValid() && !m_autoScroller->isActive()) {
+        scrollTo(current);

     }
 }
 
 void DolphinColumnWidget::slotEntered(const QModelIndex& index)
 {
     }
 }
 
 void DolphinColumnWidget::slotEntered(const QModelIndex& index)
 {

-    const QModelIndex dirIndex = m_proxyModel->mapToSource(index);
-    const KFileItem item = m_dolphinModel->itemForIndex(dirIndex);
-    m_view->m_controller->emitItemEntered(item);
+    m_view->m_controller->setItemView(this);
+    m_view->m_controller->emitItemEntered(index);

 }
 
 }
 

-void DolphinColumnWidget::activate()
+void DolphinColumnWidget::slotClicked(const QModelIndex& index)

 {
 {

-    setFocus(Qt::OtherFocusReason);
-
-    // TODO: Connecting to the signal 'activated()' is not possible, as kstyle
-    // does not forward the single vs. doubleclick to it yet (KDE 4.1?). Hence it is
-    // necessary connecting the signal 'singleClick()' or 'doubleClick'.
+    DolphinController* controller = m_view->m_controller;

     if (KGlobalSettings::singleClick()) {
     if (KGlobalSettings::singleClick()) {

-        connect(this, SIGNAL(clicked(const QModelIndex&)),
-                this, SLOT(triggerItem(const QModelIndex&)));
+        controller->triggerItem(index);

     } else {
     } else {

-        connect(this, SIGNAL(doubleClicked(const QModelIndex&)),
-                this, SLOT(triggerItem(const QModelIndex&)));
+        // even when using double click, a directory should be opened
+        // after the first click
+        const KFileItem item = controller->itemForIndex(index);
+        if (!item.isNull() && item.isDir()) {
+            controller->triggerItem(index);
+        }

     }
     }

+}

 
 

-    if (!m_childUrl.isEmpty()) {
-        // assure that the current index is set on the index that represents
-        // the child URL
-        const QModelIndex dirIndex = m_dolphinModel->indexForUrl(m_childUrl);
-        const QModelIndex proxyIndex = m_proxyModel->mapFromSource(dirIndex);
-        selectionModel()->setCurrentIndex(proxyIndex, QItemSelectionModel::Current);
+void DolphinColumnWidget::slotDoubleClicked(const QModelIndex& index)
+{
+    if (!KGlobalSettings::singleClick()) {
+        m_view->m_controller->triggerItem(index);

     }
     }

+}

 
 

-    updateBackground();
+void DolphinColumnWidget::requestActivation()
+{
+    m_view->m_controller->setItemView(this);
+    m_view->m_controller->requestActivation();
+    if (!m_active) {
+        m_view->requestActivation(this);
+        m_view->m_controller->triggerUrlChangeRequest(m_url);
+        selectionModel()->clear();
+    }

 }
 
 }
 

-void DolphinColumnWidget::deactivate()
+void DolphinColumnWidget::updateFont()

 {
 {

-    clearFocus();
+    const ColumnModeSettings* settings = DolphinSettings::instance().columnModeSettings();
+    Q_ASSERT(settings != 0);

 
 

-    // TODO: Connecting to the signal 'activated()' is not possible, as kstyle
-    // does not forward the single vs. doubleclick to it yet (KDE 4.1?). Hence it is
-    // necessary connecting the signal 'singleClick()' or 'doubleClick'.
-    if (KGlobalSettings::singleClick()) {
-        disconnect(this, SIGNAL(clicked(const QModelIndex&)),
-                   this, SLOT(triggerItem(const QModelIndex&)));
-    } else {
-        disconnect(this, SIGNAL(doubleClicked(const QModelIndex&)),
-                   this, SLOT(triggerItem(const QModelIndex&)));
+    if (settings->useSystemFont()) {
+        m_font = KGlobalSettings::generalFont();

     }
     }

-
-    selectionModel()->clear();
-    updateBackground();

 }
 
 }
 

-bool DolphinColumnWidget::isCutItem(const KFileItem& item) const
+void DolphinColumnWidget::activate()

 {
 {

-    // TODO: same implementation as in DolphinView; create helper class
-    // for generatePreviews(), showPreview() and isCutItem()
+    setFocus(Qt::OtherFocusReason);

 
 

-    const QMimeData* mimeData = QApplication::clipboard()->mimeData();
-    const KUrl::List cutUrls = KUrl::List::fromMimeData(mimeData);
+    connect(this, SIGNAL(clicked(const QModelIndex&)),
+            m_view->m_controller, SLOT(requestTab(const QModelIndex&)));
+    connect(this, SIGNAL(clicked(const QModelIndex&)),
+            this, SLOT(slotClicked(const QModelIndex&)));
+    connect(this, SIGNAL(doubleClicked(const QModelIndex&)),
+            this, SLOT(slotDoubleClicked(const QModelIndex&)));

 
 

-    const KUrl& itemUrl = item.url();
-    KUrl::List::const_iterator it = cutUrls.begin();
-    const KUrl::List::const_iterator end = cutUrls.end();
-    while (it != end) {
-        if (*it == itemUrl) {
-            return true;
-        }
-        ++it;
+    if (selectionModel() && selectionModel()->currentIndex().isValid()) {
+        selectionModel()->setCurrentIndex(selectionModel()->currentIndex(), QItemSelectionModel::SelectCurrent);

     }
 
     }
 

-    return false;
+    updateBackground();

 }
 
 }
 

-KFileItem DolphinColumnWidget::itemForIndex(const QModelIndex& index) const
+void DolphinColumnWidget::deactivate()

 {
 {

-    const QModelIndex dirIndex = m_proxyModel->mapToSource(index);
-    return m_dolphinModel->itemForIndex(dirIndex);
+    clearFocus();
+    disconnect(this, SIGNAL(clicked(const QModelIndex&)),
+               m_view->m_controller, SLOT(requestTab(const QModelIndex&)));
+    disconnect(this, SIGNAL(clicked(const QModelIndex&)),
+               this, SLOT(slotClicked(const QModelIndex&)));
+    disconnect(this, SIGNAL(doubleClicked(const QModelIndex&)),
+               this, SLOT(slotDoubleClicked(const QModelIndex&)));
+
+    const QModelIndex current = selectionModel()->currentIndex();
+    selectionModel()->clear();
+    selectionModel()->setCurrentIndex(current, QItemSelectionModel::NoUpdate);
+    updateBackground();

 }
 
 }
 

-

 #include "dolphincolumnwidget.moc"
 #include "dolphincolumnwidget.moc"