* 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 0af2744b4e49930f60b952a8a16bebd8769f1b0f..dd58e584248bbf57e73e1f722375bb9fb004783c 100644 (file)
--- a/src/dolphindetailsview.cpp
+++ b/src/dolphindetailsview.cpp
@@ -23,8 +23,9 @@
 #include "dolphinmodel.h"
 #include "dolphincontroller.h"
 #include "dolphinfileitemdelegate.h"
 #include "dolphinmodel.h"
 #include "dolphincontroller.h"
 #include "dolphinfileitemdelegate.h"

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

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

+#include "dolphinviewautoscroller.h"

 #include "draganddrophelper.h"
 #include "selectionmanager.h"
 #include "viewproperties.h"
 #include "draganddrophelper.h"
 #include "selectionmanager.h"
 #include "viewproperties.h"


@@ -47,15 +48,18 @@
 
 DolphinDetailsView::DolphinDetailsView(QWidget* parent, DolphinController* controller) :
     QTreeView(parent),
 
 DolphinDetailsView::DolphinDetailsView(QWidget* parent, DolphinController* controller) :
     QTreeView(parent),

-       m_autoResize(true),
+    m_autoResize(true),

     m_expandingTogglePressed(false),
     m_keyPressed(false),
     m_useDefaultIndexAt(true),
     m_expandingTogglePressed(false),
     m_keyPressed(false),
     m_useDefaultIndexAt(true),

+    m_ignoreScrollTo(false),

     m_controller(controller),
     m_selectionManager(0),
     m_controller(controller),
     m_selectionManager(0),

+    m_autoScroller(0),
+    m_expandableFoldersAction(0),

     m_font(),
     m_decorationSize(),
     m_font(),
     m_decorationSize(),

-    m_band()   
+    m_band()

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


@@ -74,6 +78,7 @@ DolphinDetailsView::DolphinDetailsView(QWidget* parent, DolphinController* contr
     setEditTriggers(QAbstractItemView::NoEditTriggers);
 
     setMouseTracking(true);
     setEditTriggers(QAbstractItemView::NoEditTriggers);
 
     setMouseTracking(true);

+    m_autoScroller = new DolphinViewAutoScroller(this);

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


@@ -84,7 +89,7 @@ DolphinDetailsView::DolphinDetailsView(QWidget* parent, DolphinController* contr
             this, SLOT(synchronizeSortingState(int)));
     headerView->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(headerView, SIGNAL(customContextMenuRequested(const QPoint&)),
             this, SLOT(synchronizeSortingState(int)));
     headerView->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(headerView, SIGNAL(customContextMenuRequested(const QPoint&)),

-            this, SLOT(configureColumns(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)),
     connect(headerView, SIGNAL(sectionResized(int, int, int)),
             this, SLOT(slotHeaderSectionResized(int, int, int)));
     connect(headerView, SIGNAL(sectionHandleDoubleClicked(int)),


@@ -95,10 +100,8 @@ DolphinDetailsView::DolphinDetailsView(QWidget* parent, DolphinController* contr
     connect(parent, SIGNAL(sortOrderChanged(Qt::SortOrder)),
             this, SLOT(setSortIndicatorOrder(Qt::SortOrder)));
 
     connect(parent, SIGNAL(sortOrderChanged(Qt::SortOrder)),
             this, SLOT(setSortIndicatorOrder(Qt::SortOrder)));
 

-    // 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' and to handle the
-    // RETURN-key in keyPressEvent().
+    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&)));
     if (KGlobalSettings::singleClick()) {
         connect(this, SIGNAL(clicked(const QModelIndex&)),
                 controller, SLOT(triggerItem(const QModelIndex&)));


@@ -137,7 +140,7 @@ DolphinDetailsView::DolphinDetailsView(QWidget* parent, DolphinController* contr
 
     setVerticalScrollMode(QTreeView::ScrollPerPixel);
     setHorizontalScrollMode(QTreeView::ScrollPerPixel);
 
     setVerticalScrollMode(QTreeView::ScrollPerPixel);
     setHorizontalScrollMode(QTreeView::ScrollPerPixel);

-    
+

     const DolphinView* view = controller->dolphinView();
     connect(view, SIGNAL(showPreviewChanged()),
             this, SLOT(slotShowPreviewChanged()));
     const DolphinView* view = controller->dolphinView();
     connect(view, SIGNAL(showPreviewChanged()),
             this, SLOT(slotShowPreviewChanged()));


@@ -147,10 +150,15 @@ DolphinDetailsView::DolphinDetailsView(QWidget* parent, DolphinController* contr
     setFocus();
     viewport()->installEventFilter(this);
 
     setFocus();
     viewport()->installEventFilter(this);
 

-    connect(KGlobalSettings::self(), SIGNAL(kdisplayFontChanged()),
-            this, SLOT(updateFont()));
-            
+    connect(KGlobalSettings::self(), SIGNAL(settingsChanged(int)),
+            this, SLOT(slotGlobalSettingsChanged(int)));
+

     m_useDefaultIndexAt = false;
     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()


@@ -168,11 +176,6 @@ bool DolphinDetailsView::event(QEvent* event)
 
         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);


@@ -190,7 +193,11 @@ QStyleOptionViewItem DolphinDetailsView::viewOptions() const
 void DolphinDetailsView::contextMenuEvent(QContextMenuEvent* event)
 {
     QTreeView::contextMenuEvent(event);
 void DolphinDetailsView::contextMenuEvent(QContextMenuEvent* event)
 {
     QTreeView::contextMenuEvent(event);

-    m_controller->triggerContextMenuRequest(event->pos());
+
+    DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
+    m_expandableFoldersAction->setChecked(settings->expandableFolders());
+    m_controller->triggerContextMenuRequest(event->pos(),
+                                            QList<QAction*>() << m_expandableFoldersAction);

 }
 
 void DolphinDetailsView::mousePressEvent(QMouseEvent* event)
 }
 
 void DolphinDetailsView::mousePressEvent(QMouseEvent* event)


@@ -213,7 +220,6 @@ void DolphinDetailsView::mousePressEvent(QMouseEvent* event)
             setState(QAbstractItemView::DraggingState);
         } else {
             m_expandingTogglePressed = true;
             setState(QAbstractItemView::DraggingState);
         } else {
             m_expandingTogglePressed = true;

-            kDebug() << "m_expandingTogglePressed " << m_expandingTogglePressed;

         }
     }
 
         }
     }
 


@@ -228,9 +234,11 @@ void DolphinDetailsView::mousePressEvent(QMouseEvent* event)
             clearSelection();
         }
 
             clearSelection();
         }
 

-        // restore the current index, other columns are handled as viewport area
+        // 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);
         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!
 
         if ((event->button() == Qt::LeftButton) && !m_expandingTogglePressed) {
             // Inform Qt about what we are doing - otherwise it starts dragging items around!


@@ -238,12 +246,12 @@ void DolphinDetailsView::mousePressEvent(QMouseEvent* event)
             m_band.show = true;
             // Incremental update data will not be useful - start from scratch.
             m_band.ignoreOldInfo = true;
             m_band.show = true;
             // Incremental update data will not be useful - start from scratch.
             m_band.ignoreOldInfo = true;

-            const QPoint pos = contentsPos();

             const QPoint scrollPos(horizontalScrollBar()->value(), verticalScrollBar()->value());
             const QPoint scrollPos(horizontalScrollBar()->value(), verticalScrollBar()->value());

-            m_band.origin = event->pos() + pos + scrollPos;
+            m_band.origin = event->pos()  + scrollPos;

             m_band.destination = m_band.origin;
             m_band.destination = m_band.origin;

+            m_band.originalSelection = selectionModel()->selection();

         }
         }

-    } 
+    }

 }
 
 void DolphinDetailsView::mouseMoveEvent(QMouseEvent* event)
 }
 
 void DolphinDetailsView::mouseMoveEvent(QMouseEvent* event)


@@ -303,13 +311,13 @@ void DolphinDetailsView::mouseReleaseEvent(QMouseEvent* event)
 
 void DolphinDetailsView::startDrag(Qt::DropActions supportedActions)
 {
 
 void DolphinDetailsView::startDrag(Qt::DropActions supportedActions)
 {

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

     m_band.show = false;
 }
 
 void DolphinDetailsView::dragEnterEvent(QDragEnterEvent* event)
 {
     m_band.show = false;
 }
 
 void DolphinDetailsView::dragEnterEvent(QDragEnterEvent* event)
 {

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

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


@@ -342,7 +350,7 @@ void DolphinDetailsView::dragMoveEvent(QDragMoveEvent* event)
         setDirtyRegion(m_dropRect);
     }
 
         setDirtyRegion(m_dropRect);
     }
 

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

         // accept url drops, independently from the destination item
         event->acceptProposedAction();
     }
         // accept url drops, independently from the destination item
         event->acceptProposedAction();
     }


@@ -398,10 +406,10 @@ void DolphinDetailsView::keyReleaseEvent(QKeyEvent* event)
 
 void DolphinDetailsView::resizeEvent(QResizeEvent* event)
 {
 
 void DolphinDetailsView::resizeEvent(QResizeEvent* event)
 {

+    QTreeView::resizeEvent(event);

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

-    QTreeView::resizeEvent(event);

 }
 
 void DolphinDetailsView::wheelEvent(QWheelEvent* event)
 }
 
 void DolphinDetailsView::wheelEvent(QWheelEvent* event)


@@ -416,12 +424,18 @@ void DolphinDetailsView::wheelEvent(QWheelEvent* event)
         return;
     }
 
         return;
     }
 

+    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::currentChanged(const QModelIndex& current, const QModelIndex& previous)
 {
     QTreeView::currentChanged(current, previous);
     QTreeView::wheelEvent(event);
 }
 
 void DolphinDetailsView::currentChanged(const QModelIndex& current, const QModelIndex& previous)
 {
     QTreeView::currentChanged(current, previous);

+    if (current.isValid() && !m_autoScroller->isActive()) {
+        scrollTo(current);
+    }

 
     // Stay consistent with QListView: When changing the current index by key presses,
     // also change the selection.
 
     // Stay consistent with QListView: When changing the current index by key presses,
     // also change the selection.


@@ -451,7 +465,7 @@ QModelIndex DolphinDetailsView::indexAt(const QPoint& point) const
     return isAboveEmptySpace ? QModelIndex() : index;
 }
 
     return isAboveEmptySpace ? QModelIndex() : index;
 }
 

-void DolphinDetailsView::setSelection(const QRect &rect, QItemSelectionModel::SelectionFlags command)
+void DolphinDetailsView::setSelection(const QRect& rect, QItemSelectionModel::SelectionFlags command)

 {
     // We must override setSelection() as Qt calls it internally and when this happens
     // we must ensure that the default indexAt() is used.
 {
     // We must override setSelection() as Qt calls it internally and when this happens
     // we must ensure that the default indexAt() is used.


@@ -460,22 +474,26 @@ void DolphinDetailsView::setSelection(const QRect &rect, QItemSelectionModel::Se
         QTreeView::setSelection(rect, command);
         m_useDefaultIndexAt = false;
     } else {
         QTreeView::setSelection(rect, command);
         m_useDefaultIndexAt = false;
     } else {

-

         // Use our own elastic band selection algorithm
         updateElasticBandSelection();
     }
 }
 
         // Use our own elastic band selection algorithm
         updateElasticBandSelection();
     }
 }
 

+void DolphinDetailsView::scrollTo(const QModelIndex & index, ScrollHint hint)
+{
+    if (!m_ignoreScrollTo) {
+        QTreeView::scrollTo(index, hint);
+    }
+}
+

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

-    QHeaderView* headerView = header();
-    headerView->setSortIndicator(sorting, headerView->sortIndicatorOrder());
+    header()->setSortIndicator(sorting, header()->sortIndicatorOrder());

 }
 
 void DolphinDetailsView::setSortIndicatorOrder(Qt::SortOrder sortOrder)
 {
 }
 
 void DolphinDetailsView::setSortIndicatorOrder(Qt::SortOrder sortOrder)
 {

-    QHeaderView* headerView = header();
-    headerView->setSortIndicator(headerView->sortIndicatorSection(), sortOrder);
+    header()->setSortIndicator(header()->sortIndicatorSection(), sortOrder);

 }
 
 void DolphinDetailsView::synchronizeSortingState(int column)
 }
 
 void DolphinDetailsView::synchronizeSortingState(int column)


@@ -500,9 +518,17 @@ void DolphinDetailsView::slotEntered(const QModelIndex& index)
 void DolphinDetailsView::updateElasticBand()
 {
     if (m_band.show) {
 void DolphinDetailsView::updateElasticBand()
 {
     if (m_band.show) {

-        QRect dirtyRegion(elasticBandRect());        
+        QRect dirtyRegion(elasticBandRect());

         const QPoint scrollPos(horizontalScrollBar()->value(), verticalScrollBar()->value());
         m_band.destination = viewport()->mapFromGlobal(QCursor::pos()) + scrollPos;
         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);
     }
         dirtyRegion = dirtyRegion.united(elasticBandRect());
         setDirtyRegion(dirtyRegion);
     }


@@ -510,11 +536,10 @@ void DolphinDetailsView::updateElasticBand()
 
 QRect DolphinDetailsView::elasticBandRect() const
 {
 
 QRect DolphinDetailsView::elasticBandRect() const
 {

-    const QPoint pos(contentsPos());

     const QPoint scrollPos(horizontalScrollBar()->value(), verticalScrollBar()->value());
 
     const QPoint scrollPos(horizontalScrollBar()->value(), verticalScrollBar()->value());
 

-    const QPoint topLeft = m_band.origin - pos - scrollPos;
-    const QPoint bottomRight = m_band.destination - pos - scrollPos;
+    const QPoint topLeft = m_band.origin - scrollPos;
+    const QPoint bottomRight = m_band.destination - scrollPos;

     return QRect(topLeft, bottomRight).normalized();
 }
 
     return QRect(topLeft, bottomRight).normalized();
 }
 


@@ -522,14 +547,14 @@ void DolphinDetailsView::setZoomLevel(int level)
 {
     const int size = ZoomLevelInfo::iconSizeForZoomLevel(level);
     DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
 {
     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);
     }
     const bool showPreview = m_controller->dolphinView()->showPreview();
     if (showPreview) {
         settings->setPreviewSize(size);
     } else {
         settings->setIconSize(size);
     }

-    
+

     updateDecorationSize(showPreview);
 }
 
     updateDecorationSize(showPreview);
 }
 


@@ -540,11 +565,12 @@ void DolphinDetailsView::slotShowPreviewChanged()
     updateDecorationSize(view->showPreview());
 }
 
     updateDecorationSize(view->showPreview());
 }
 

-void DolphinDetailsView::configureColumns(const QPoint& pos)
+void DolphinDetailsView::configureSettings(const QPoint& pos)

 {
     KMenu popup(this);
     popup.addTitle(i18nc("@title:menu", "Columns"));
 
 {
     KMenu popup(this);
     popup.addTitle(i18nc("@title:menu", "Columns"));
 

+    // add checkbox items for each column

     QHeaderView* headerView = header();
     for (int i = DolphinModel::Size; i <= DolphinModel::Type; ++i) {
         const int logicalIndex = headerView->logicalIndex(i);
     QHeaderView* headerView = header();
     for (int i = DolphinModel::Size; i <= DolphinModel::Type; ++i) {
         const int logicalIndex = headerView->logicalIndex(i);


@@ -554,6 +580,7 @@ void DolphinDetailsView::configureColumns(const QPoint& pos)
         action->setChecked(!headerView->isSectionHidden(logicalIndex));
         action->setData(i);
     }
         action->setChecked(!headerView->isSectionHidden(logicalIndex));
         action->setData(i);
     }

+    popup.addSeparator();

 
     QAction* activatedAction = popup.exec(header()->mapToGlobal(pos));
     if (activatedAction != 0) {
 
     QAction* activatedAction = popup.exec(header()->mapToGlobal(pos));
     if (activatedAction != 0) {


@@ -573,6 +600,7 @@ void DolphinDetailsView::configureColumns(const QPoint& pos)
 
         m_controller->indicateAdditionalInfoChange(list);
         setColumnHidden(columnIndex, !show);
 
         m_controller->indicateAdditionalInfoChange(list);
         setColumnHidden(columnIndex, !show);

+        resizeColumns();

     }
 }
 
     }
 }
 


@@ -595,7 +623,12 @@ void DolphinDetailsView::slotHeaderSectionResized(int logicalIndex, int oldSize,
     Q_UNUSED(logicalIndex);
     Q_UNUSED(oldSize);
     Q_UNUSED(newSize);
     Q_UNUSED(logicalIndex);
     Q_UNUSED(oldSize);
     Q_UNUSED(newSize);

-    if (QApplication::mouseButtons() & Qt::LeftButton) {
+    // 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();
     }
 }
         disableAutoResizing();
     }
 }


@@ -615,14 +648,23 @@ void DolphinDetailsView::requestActivation()
     m_controller->requestActivation();
 }
 
     m_controller->requestActivation();
 }
 

-void DolphinDetailsView::updateFont()
+void DolphinDetailsView::slotGlobalSettingsChanged(int category)

 {
 {

+    Q_UNUSED(category);
+

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

-

     if (settings->useSystemFont()) {
         m_font = KGlobalSettings::generalFont();
     }
     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)));
+    }

 }
 
 void DolphinDetailsView::updateElasticBandSelection()
 }
 
 void DolphinDetailsView::updateElasticBandSelection()


@@ -641,63 +683,69 @@ void DolphinDetailsView::updateElasticBandSelection()
     const int nameColumnX = header()->sectionPosition(DolphinModel::Name);
     const int nameColumnWidth = header()->sectionSize(DolphinModel::Name);
     QRect selRect = elasticBandRect().normalized();
     const int nameColumnX = header()->sectionPosition(DolphinModel::Name);
     const int nameColumnWidth = header()->sectionSize(DolphinModel::Name);
     QRect selRect = elasticBandRect().normalized();

-    QRect nameColumnRect(nameColumnX, selRect.y(), nameColumnWidth, selRect.height());
-    selRect = nameColumnRect.intersect(selRect).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()) {
 
     if (selRect.isNull()) {

-        clearSelection();
+        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.
         return;
     }
 
     if (!m_band.ignoreOldInfo) {
         // Do some quick checks to see if we can rule out the need to
         // update the selection.

-        bool coveringSameRows = true; 

         Q_ASSERT(uniformRowHeights());
         Q_ASSERT(uniformRowHeights());

-        QModelIndex dummyIndex = model()->index(0, 0);        
+        QModelIndex dummyIndex = model()->index(0, 0);

         if (!dummyIndex.isValid()) {
             // No items in the model presumably.
             return;
         }
         if (!dummyIndex.isValid()) {
             // No items in the model presumably.
             return;
         }

-        const int rowHeight = QTreeView::rowHeight(dummyIndex);
-        
+

         // 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.
         // 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.

-        if (selRect.top() / rowHeight != m_band.oldSelectionRect.top() / rowHeight) {
-            coveringSameRows = false;
-        } else if (selRect.bottom() / rowHeight != m_band.oldSelectionRect.bottom() / rowHeight) {
-            coveringSameRows = false;
-        }
-        
+        const int rowHeight = QTreeView::rowHeight(dummyIndex);
+        const bool coveringSameRows =
+            (selRect.top()    / rowHeight == oldSelRect.top()    / rowHeight) &&
+            (selRect.bottom() / rowHeight == oldSelRect.bottom() / rowHeight);

         if (coveringSameRows) {
         if (coveringSameRows) {

-            // Covering the same rows, but have we moved far enough horizontally 
+            // Covering the same rows, but have we moved far enough horizontally

             // that we might have (de)selected some other items?
             // that we might have (de)selected some other items?

-            const QRect oldSelRect = m_band.oldSelectionRect;

             const bool itemSelectionChanged =
                 ((selRect.left() > oldSelRect.left()) &&
                  (selRect.left() > m_band.insideNearestLeftEdge)) ||
             const bool itemSelectionChanged =
                 ((selRect.left() > oldSelRect.left()) &&
                  (selRect.left() > m_band.insideNearestLeftEdge)) ||

-                ((selRect.left() < oldSelRect.left()) &&                
+                ((selRect.left() < oldSelRect.left()) &&

                  (selRect.left() <= m_band.outsideNearestLeftEdge)) ||
                 ((selRect.right() < oldSelRect.right()) &&
                  (selRect.left() >= m_band.insideNearestRightEdge)) ||
                 ((selRect.right() > oldSelRect.right()) &&
                  (selRect.left() <= m_band.outsideNearestLeftEdge)) ||
                 ((selRect.right() < oldSelRect.right()) &&
                  (selRect.left() >= m_band.insideNearestRightEdge)) ||
                 ((selRect.right() > oldSelRect.right()) &&

-                 (selRect.right() >= m_band.outsideNearestRightEdge)); 
+                 (selRect.right() >= m_band.outsideNearestRightEdge));

 
             if (!itemSelectionChanged) {
                 return;
             }
         }
     }
 
             if (!itemSelectionChanged) {
                 return;
             }
         }
     }

+    else {
+        // 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.
 
     // Do the selection from scratch. Force a update of the horizontal distances info.

-    m_band.insideNearestLeftEdge   = nameColumnX + nameColumnWidth + 1;;
+    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.
     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(m_band.oldSelectionRect).normalized();
+    const QRect boundingRect = selRect.united(oldSelRect).normalized();

     if (boundingRect.isNull()) {
         return;
     }
     if (boundingRect.isNull()) {
         return;
     }


@@ -710,34 +758,37 @@ void DolphinDetailsView::updateElasticBandSelection()
     } else {
         startIndex = model()->index(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;
+    }

 
    // Go through all indexes between the top and bottom of boundingRect, and
    // update the selection.
 
    // Go through all indexes between the top and bottom of boundingRect, and
    // update the selection.

-   const int verticalCutoff = boundingRect.bottom();   
+   const int verticalCutoff = boundingRect.bottom();

    QModelIndex currIndex = startIndex;
    QModelIndex lastIndex;
    bool allItemsInBoundDone = false;
    QModelIndex currIndex = startIndex;
    QModelIndex lastIndex;
    bool allItemsInBoundDone = false;

-   
-   // Calling selectionModel()->select(...) for each item that needs to be 
+
+   // 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;
    // 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 
+   // 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 {
    // single indexes, so try to portion items that need to be toggled into ranges.
    bool formingToggleIndexRange = false;
    QModelIndex toggleIndexRangeBegin = QModelIndex();
 
    do {

-       QRect currIndexRect = visualRect(currIndex);
-       const QString name = m_controller->itemForIndex(currIndex).name();
-       currIndexRect.setWidth(DolphinFileItemDelegate::nameColumnWidth(name, viewOptions()));
+       QRect currIndexRect = nameColumnRect(currIndex);

 
 

-        // Update some optimisation info as we go.
+        // 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();
        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      
+       // "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 ((cr < sl && cr > m_band.outsideNearestLeftEdge)) {
            m_band.outsideNearestLeftEdge = cr;
        }


@@ -750,10 +801,12 @@ void DolphinDetailsView::updateElasticBandSelection()
        if ((cr >= sl && cr <= sr && cr < m_band.insideNearestLeftEdge)) {
            m_band.insideNearestLeftEdge = cr;
        }
        if ((cr >= sl && cr <= sr && cr < m_band.insideNearestLeftEdge)) {
            m_band.insideNearestLeftEdge = cr;
        }

-  
+

        bool currentlySelected = selectionModel()->isSelected(currIndex);
        bool currentlySelected = selectionModel()->isSelected(currIndex);

+       bool originallySelected = m_band.originalSelection.contains(currIndex);

        bool intersectsSelectedRect = currIndexRect.intersects(selRect);
        bool intersectsSelectedRect = currIndexRect.intersects(selRect);

-       bool needToToggleItem = (currentlySelected && !intersectsSelectedRect) || (!currentlySelected && intersectsSelectedRect);
+       bool shouldBeSelected = (intersectsSelectedRect && !originallySelected) || (!intersectsSelectedRect && originallySelected);
+       bool needToToggleItem = (currentlySelected && !shouldBeSelected) || (!currentlySelected && shouldBeSelected);

        if (needToToggleItem && !formingToggleIndexRange) {
             toggleIndexRangeBegin = currIndex;
             formingToggleIndexRange = true;
        if (needToToggleItem && !formingToggleIndexRange) {
             toggleIndexRangeBegin = currIndex;
             formingToggleIndexRange = true;


@@ -768,21 +821,51 @@ void DolphinDetailsView::updateElasticBandSelection()
                                             allItemsInBoundDone ||
                                             currIndex.parent() != toggleIndexRangeBegin.parent());
        if (commitToggleIndexRange) {
                                             allItemsInBoundDone ||
                                             currIndex.parent() != toggleIndexRangeBegin.parent());
        if (commitToggleIndexRange) {

-           itemsToToggle.select(toggleIndexRangeBegin, lastIndex );

            formingToggleIndexRange = false;
            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);
        }
 
        // next item
        lastIndex = currIndex;
        currIndex = nextIndex;
     } while (!allItemsInBoundDone);

-    
+

     selectionModel()->select(itemsToToggle, QItemSelectionModel::Toggle);
 
     selectionModel()->select(itemsToToggle, QItemSelectionModel::Toggle);
 

-    m_band.oldSelectionRect = selRect;
+    m_band.lastSelectionOrigin = m_band.origin;
+    m_band.lastSelectionDestination = m_band.destination;

     m_band.ignoreOldInfo = false;
 }
 
     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);
+}
+

 void DolphinDetailsView::updateDecorationSize(bool showPreview)
 {
     DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();
 void DolphinDetailsView::updateDecorationSize(bool showPreview)
 {
     DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings();


@@ -797,24 +880,6 @@ void DolphinDetailsView::updateDecorationSize(bool showPreview)
     doItemsLayout();
 }
 
     doItemsLayout();
 }
 

-QPoint DolphinDetailsView::contentsPos() const
-{
-    // implementation note: the horizonal position is ignored currently, as no
-    // horizontal scrolling is done anyway during a selection
-    const QScrollBar* scrollbar = verticalScrollBar();
-    Q_ASSERT(scrollbar != 0);
-
-    const int maxHeight = maximumViewportSize().height();
-    const int height = scrollbar->maximum() - scrollbar->minimum() + 1;
-    const int visibleHeight = model()->rowCount() + 1 - height;
-    if (visibleHeight <= 0) {
-        return QPoint(0, 0);
-    }
-
-    const int y = scrollbar->sliderPosition() * maxHeight / visibleHeight;
-    return QPoint(0, y);
-}
-

 KFileItemDelegate::Information DolphinDetailsView::infoForColumn(int columnIndex) const
 {
     KFileItemDelegate::Information info = KFileItemDelegate::NoInformation;
 KFileItemDelegate::Information DolphinDetailsView::infoForColumn(int columnIndex) const
 {
     KFileItemDelegate::Information info = KFileItemDelegate::NoInformation;


@@ -862,9 +927,26 @@ void DolphinDetailsView::resizeColumns()
 
     // resize the name column in a way that the whole available width is used
     columnWidth[KDirModel::Name] = viewport()->width() - requiredWidth;
 
     // 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;
+
+    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;
+            }
+        }

     }
     }

+

     headerView->resizeSection(KDirModel::Name, columnWidth[KDirModel::Name]);
 }
 
     headerView->resizeSection(KDirModel::Name, columnWidth[KDirModel::Name]);
 }
 


@@ -873,7 +955,7 @@ QRect DolphinDetailsView::nameColumnRect(const QModelIndex& index) const
     QRect rect = visualRect(index);
     const KFileItem item = m_controller->itemForIndex(index);
     if (!item.isNull()) {
     QRect rect = visualRect(index);
     const KFileItem item = m_controller->itemForIndex(index);
     if (!item.isNull()) {

-        const int width = DolphinFileItemDelegate::nameColumnWidth(item.name(), viewOptions());
+        const int width = DolphinFileItemDelegate::nameColumnWidth(item.text(), viewOptions());

         rect.setWidth(width);
     }
 
         rect.setWidth(width);
     }
 


@@ -884,7 +966,8 @@ DolphinDetailsView::ElasticBand::ElasticBand() :
     show(false),
     origin(),
     destination(),
     show(false),
     origin(),
     destination(),

-    oldSelectionRect(),
+    lastSelectionOrigin(),
+    lastSelectionDestination(),

     ignoreOldInfo(true),
     outsideNearestLeftEdge(0),
     outsideNearestRightEdge(0),
     ignoreOldInfo(true),
     outsideNearestLeftEdge(0),
     outsideNearestRightEdge(0),