KItemListView: add view position in scrollToItem()

[dolphin.git] / src / kitemviews / kitemlistcontroller.cpp

diff --git a/src/kitemviews/kitemlistcontroller.cpp b/src/kitemviews/kitemlistcontroller.cpp
index 54a856fb8052d1ce2bc145c698494852e0d6a248..0016bb22aeb4fdf27f4c999ff3d6b7719a287ec1 100644 (file)
--- a/src/kitemviews/kitemlistcontroller.cpp
+++ b/src/kitemviews/kitemlistcontroller.cpp
@@ -50,7 +50,7 @@ KItemListController::KItemListController(KItemModelBase *model, KItemListView *v
     , m_selectionManager(new KItemListSelectionManager(this))
     , m_keyboardManager(new KItemListKeyboardSearchManager(this))
     , m_pressedIndex(std::nullopt)
     , m_selectionManager(new KItemListSelectionManager(this))
     , m_keyboardManager(new KItemListKeyboardSearchManager(this))
     , m_pressedIndex(std::nullopt)

-    , m_pressedMousePos()
+    , m_pressedMouseGlobalPos()

     , m_autoActivationTimer(nullptr)
     , m_swipeGesture(Qt::CustomGesture)
     , m_twoFingerTapGesture(Qt::CustomGesture)
     , m_autoActivationTimer(nullptr)
     , m_swipeGesture(Qt::CustomGesture)
     , m_twoFingerTapGesture(Qt::CustomGesture)


@@ -186,11 +186,13 @@ KItemListController::MouseDoubleClickAction KItemListController::mouseDoubleClic
 
 int KItemListController::indexCloseToMousePressedPosition() const
 {
 
 int KItemListController::indexCloseToMousePressedPosition() const
 {

+    const QPointF pressedMousePos = m_view->transform().map(m_view->scene()->views().first()->mapFromGlobal(m_pressedMouseGlobalPos.toPoint()));
+

     QHashIterator<KItemListWidget *, KItemListGroupHeader *> it(m_view->m_visibleGroups);
     while (it.hasNext()) {
         it.next();
         KItemListGroupHeader *groupHeader = it.value();
     QHashIterator<KItemListWidget *, KItemListGroupHeader *> it(m_view->m_visibleGroups);
     while (it.hasNext()) {
         it.next();
         KItemListGroupHeader *groupHeader = it.value();

-        const QPointF mappedToGroup = groupHeader->mapFromItem(nullptr, m_pressedMousePos);
+        const QPointF mappedToGroup = groupHeader->mapFromItem(nullptr, pressedMousePos);

         if (groupHeader->contains(mappedToGroup)) {
             return it.key()->index();
         }
         if (groupHeader->contains(mappedToGroup)) {
             return it.key()->index();
         }


@@ -228,25 +230,43 @@ bool KItemListController::selectionMode() const
     return m_selectionMode;
 }
 
     return m_selectionMode;
 }
 

+bool KItemListController::isSearchAsYouTypeActive() const
+{
+    return m_keyboardManager->isSearchAsYouTypeActive();
+}
+

 bool KItemListController::keyPressEvent(QKeyEvent *event)
 {
     int index = m_selectionManager->currentItem();
     int key = event->key();
 bool KItemListController::keyPressEvent(QKeyEvent *event)
 {
     int index = m_selectionManager->currentItem();
     int key = event->key();

+    const bool shiftPressed = event->modifiers() & Qt::ShiftModifier;

 
     // Handle the expanding/collapsing of items
 
     // Handle the expanding/collapsing of items

-    if (m_view->supportsItemExpanding() && m_model->isExpandable(index)) {
-        if (key == Qt::Key_Right) {
-            if (m_model->setExpanded(index, true)) {
-                return true;
+    // expand / collapse all selected directories
+    if (m_view->supportsItemExpanding() && m_model->isExpandable(index) && (key == Qt::Key_Right || key == Qt::Key_Left)) {
+        const bool expandOrCollapse = key == Qt::Key_Right ? true : false;
+        bool shouldReturn = m_model->setExpanded(index, expandOrCollapse);
+
+        // edit in reverse to preserve index of the first handled items
+        const auto selectedItems = m_selectionManager->selectedItems();
+        for (auto it = selectedItems.rbegin(); it != selectedItems.rend(); ++it) {
+            shouldReturn |= m_model->setExpanded(*it, expandOrCollapse);
+            if (!shiftPressed) {
+                m_selectionManager->setSelected(*it);

             }
             }

-        } else if (key == Qt::Key_Left) {
-            if (m_model->setExpanded(index, false)) {
-                return true;
+        }
+        if (shouldReturn) {
+            // update keyboard anchors
+            if (shiftPressed) {
+                m_keyboardAnchorIndex = selectedItems.count() > 0 ? qMin(index, selectedItems.last()) : index;
+                m_keyboardAnchorPos = keyboardAnchorPos(m_keyboardAnchorIndex);

             }
             }

+
+            event->ignore();
+            return true;

         }
     }
 
         }
     }
 

-    const bool shiftPressed = event->modifiers() & Qt::ShiftModifier;

     const bool controlPressed = event->modifiers() & Qt::ControlModifier;
     const bool shiftOrControlPressed = shiftPressed || controlPressed;
     const bool navigationPressed = key == Qt::Key_Home || key == Qt::Key_End || key == Qt::Key_PageUp || key == Qt::Key_PageDown || key == Qt::Key_Up
     const bool controlPressed = event->modifiers() & Qt::ControlModifier;
     const bool shiftOrControlPressed = shiftPressed || controlPressed;
     const bool navigationPressed = key == Qt::Key_Home || key == Qt::Key_End || key == Qt::Key_PageUp || key == Qt::Key_PageDown || key == Qt::Key_Up


@@ -322,11 +342,17 @@ bool KItemListController::keyPressEvent(QKeyEvent *event)
 
     case Qt::Key_Up:
         updateKeyboardAnchor();
 
     case Qt::Key_Up:
         updateKeyboardAnchor();

+        if (shiftPressed && !m_selectionManager->isAnchoredSelectionActive() && m_selectionManager->isSelected(index)) {
+            m_selectionManager->beginAnchoredSelection(index);
+        }

         index = previousRowIndex(index);
         break;
 
     case Qt::Key_Down:
         updateKeyboardAnchor();
         index = previousRowIndex(index);
         break;
 
     case Qt::Key_Down:
         updateKeyboardAnchor();

+        if (shiftPressed && !m_selectionManager->isAnchoredSelectionActive() && m_selectionManager->isSelected(index)) {
+            m_selectionManager->beginAnchoredSelection(index);
+        }

         index = nextRowIndex(index);
         break;
 
         index = nextRowIndex(index);
         break;
 


@@ -439,10 +465,13 @@ bool KItemListController::keyPressEvent(QKeyEvent *event)
                 m_selectionManager->setSelected(index, 1, KItemListSelectionManager::Toggle);
                 m_selectionManager->beginAnchoredSelection(index);
                 break;
                 m_selectionManager->setSelected(index, 1, KItemListSelectionManager::Toggle);
                 m_selectionManager->beginAnchoredSelection(index);
                 break;

-            } else if (m_keyboardManager->addKeyBeginsNewSearch()) { // File names shouldn't start with a space,
-                // so we can use this press as a keyboard shortcut instead.
-                Q_EMIT selectionModeChangeRequested(!m_selectionMode);
-                break;
+            } else {
+                // Select the current item if it is not selected yet.
+                const int current = m_selectionManager->currentItem();
+                if (!m_selectionManager->isSelected(current)) {
+                    m_selectionManager->setSelected(current);
+                    break;
+                }

             }
         }
         Q_FALLTHROUGH(); // fall through to the default case and add the Space to the current search string.
             }
         }
         Q_FALLTHROUGH(); // fall through to the default case and add the Space to the current search string.


@@ -510,7 +539,7 @@ void KItemListController::slotChangeCurrentItem(const QString &text, bool search
             m_selectionManager->beginAnchoredSelection(index);
         }
 
             m_selectionManager->beginAnchoredSelection(index);
         }
 

-        m_view->scrollToItem(index);
+        m_view->scrollToItem(index, KItemListView::ViewItemPosition::Beginning);

     }
 }
 
     }
 }
 


@@ -534,7 +563,7 @@ void KItemListController::slotAutoActivationTimeout()
      *
      * See Bug 293200 and 305783
      */
      *
      * See Bug 293200 and 305783
      */

-    if (m_model->supportsDropping(index) && m_view->isUnderMouse()) {
+    if (m_view->isUnderMouse()) {

         if (m_view->supportsItemExpanding() && m_model->isExpandable(index)) {
             const bool expanded = m_model->isExpanded(index);
             m_model->setExpanded(index, !expanded);
         if (m_view->supportsItemExpanding() && m_model->isExpandable(index)) {
             const bool expanded = m_model->isExpanded(index);
             m_model->setExpanded(index, !expanded);


@@ -553,6 +582,7 @@ bool KItemListController::inputMethodEvent(QInputMethodEvent *event)
 bool KItemListController::mousePressEvent(QGraphicsSceneMouseEvent *event, const QTransform &transform)
 {
     m_mousePress = true;
 bool KItemListController::mousePressEvent(QGraphicsSceneMouseEvent *event, const QTransform &transform)
 {
     m_mousePress = true;

+    m_pressedMouseGlobalPos = event->screenPos();

 
     if (event->source() == Qt::MouseEventSynthesizedByQt && m_isTouchEvent) {
         return false;
 
     if (event->source() == Qt::MouseEventSynthesizedByQt && m_isTouchEvent) {
         return false;


@@ -562,8 +592,8 @@ bool KItemListController::mousePressEvent(QGraphicsSceneMouseEvent *event, const
         return false;
     }
 
         return false;
     }
 

-    m_pressedMousePos = transform.map(event->pos());
-    m_pressedIndex = m_view->itemAt(m_pressedMousePos);
+    const QPointF pressedMousePos = transform.map(event->pos());
+    m_pressedIndex = m_view->itemAt(pressedMousePos);

 
     const Qt::MouseButtons buttons = event->buttons();
 
 
     const Qt::MouseButtons buttons = event->buttons();
 


@@ -589,12 +619,11 @@ bool KItemListController::mouseMoveEvent(QGraphicsSceneMouseEvent *event, const
         return false;
     }
 
         return false;
     }
 

-    const QPointF pos = transform.map(event->pos());
-

     if (m_pressedIndex.has_value() && !m_view->rubberBand()->isActive()) {
         // Check whether a dragging should be started
         if (event->buttons() & Qt::LeftButton) {
     if (m_pressedIndex.has_value() && !m_view->rubberBand()->isActive()) {
         // Check whether a dragging should be started
         if (event->buttons() & Qt::LeftButton) {

-            if ((pos - m_pressedMousePos).manhattanLength() >= QApplication::startDragDistance()) {
+            const auto distance = (event->screenPos() - m_pressedMouseGlobalPos).manhattanLength();
+            if (distance >= QApplication::startDragDistance()) {

                 if (!m_selectionManager->isSelected(m_pressedIndex.value())) {
                     // Always assure that the dragged item gets selected. Usually this is already
                     // done on the mouse-press event, but when using the selection-toggle on a
                 if (!m_selectionManager->isSelected(m_pressedIndex.value())) {
                     // Always assure that the dragged item gets selected. Usually this is already
                     // done on the mouse-press event, but when using the selection-toggle on a


@@ -625,11 +654,6 @@ bool KItemListController::mouseMoveEvent(QGraphicsSceneMouseEvent *event, const
 
             if (m_view->scrollOrientation() == Qt::Vertical) {
                 endPos.ry() += m_view->scrollOffset();
 
             if (m_view->scrollOrientation() == Qt::Vertical) {
                 endPos.ry() += m_view->scrollOffset();

-                if (m_view->itemSize().width() < 0) {
-                    // Use a special rubberband for views that have only one column and
-                    // expand the rubberband to use the whole width of the view.
-                    endPos.setX(m_view->size().width());
-                }

             } else {
                 endPos.rx() += m_view->scrollOffset();
             }
             } else {
                 endPos.rx() += m_view->scrollOffset();
             }


@@ -738,6 +762,7 @@ bool KItemListController::dragMoveEvent(QGraphicsSceneDragDropEvent *event, cons
 
     const QPointF pos = transform.map(event->pos());
     KItemListWidget *newHoveredWidget = widgetForDropPos(pos);
 
     const QPointF pos = transform.map(event->pos());
     KItemListWidget *newHoveredWidget = widgetForDropPos(pos);

+    int index = -1;

 
     if (oldHoveredWidget != newHoveredWidget) {
         m_autoActivationTimer->stop();
 
     if (oldHoveredWidget != newHoveredWidget) {
         m_autoActivationTimer->stop();


@@ -755,25 +780,23 @@ bool KItemListController::dragMoveEvent(QGraphicsSceneDragDropEvent *event, cons
             droppingBetweenItems = (m_view->showDropIndicator(pos) >= 0);
         }
 
             droppingBetweenItems = (m_view->showDropIndicator(pos) >= 0);
         }
 

-        const int index = newHoveredWidget->index();
+        index = newHoveredWidget->index();

 
         if (m_model->isDir(index)) {
             hoveredDir = m_model->url(index);
         }
 
         if (!droppingBetweenItems) {
 
         if (m_model->isDir(index)) {
             hoveredDir = m_model->url(index);
         }
 
         if (!droppingBetweenItems) {

-            if (m_model->supportsDropping(index)) {
-                // Something has been dragged on an item.
-                m_view->hideDropIndicator();
-                if (!newHoveredWidget->isHovered()) {
-                    newHoveredWidget->setHovered(true);
-                    Q_EMIT itemHovered(index);
-                }
+            // Something has been dragged on an item.
+            m_view->hideDropIndicator();
+            if (!newHoveredWidget->isHovered()) {
+                newHoveredWidget->setHovered(true);
+                Q_EMIT itemHovered(index);
+            }

 
 

-                if (!m_autoActivationTimer->isActive() && m_autoActivationTimer->interval() >= 0) {
-                    m_autoActivationTimer->setProperty("index", index);
-                    m_autoActivationTimer->start();
-                }
+            if (!m_autoActivationTimer->isActive() && m_autoActivationTimer->interval() >= 0) {
+                m_autoActivationTimer->setProperty("index", index);
+                m_autoActivationTimer->start();

             }
         } else {
             m_autoActivationTimer->stop();
             }
         } else {
             m_autoActivationTimer->stop();


@@ -790,8 +813,13 @@ bool KItemListController::dragMoveEvent(QGraphicsSceneDragDropEvent *event, cons
         event->setDropAction(Qt::IgnoreAction);
         event->ignore();
     } else {
         event->setDropAction(Qt::IgnoreAction);
         event->ignore();
     } else {

-        event->setDropAction(event->proposedAction());
-        event->accept();
+        if (m_model->supportsDropping(index)) {
+            event->setDropAction(event->proposedAction());
+            event->accept();
+        } else {
+            event->setDropAction(Qt::IgnoreAction);
+            event->ignore();
+        }

     }
     return false;
 }
     }
     return false;
 }


@@ -1035,13 +1063,12 @@ void KItemListController::tapTriggered(QTapGesture *tap, const QTransform &trans
             m_view->m_tapAndHoldIndicator->setActive(false);
         }
 
             m_view->m_tapAndHoldIndicator->setActive(false);
         }
 

-        m_pressedMousePos = transform.map(tap->position());
-        m_pressedIndex = m_view->itemAt(m_pressedMousePos);
-
+        const QPointF pressedMousePos = transform.map(tap->position());
+        m_pressedIndex = m_view->itemAt(pressedMousePos);

         if (m_dragActionOrRightClick) {
             m_dragActionOrRightClick = false;
         } else {
         if (m_dragActionOrRightClick) {
             m_dragActionOrRightClick = false;
         } else {

-            onPress(tap->hotSpot().toPoint(), tap->position().toPoint(), Qt::NoModifier, Qt::LeftButton);
+            onPress(m_pressedMouseGlobalPos.toPoint(), tap->position().toPoint(), Qt::NoModifier, Qt::LeftButton);

             onRelease(transform.map(tap->position()), Qt::NoModifier, Qt::LeftButton, true);
         }
         m_isTouchEvent = false;
             onRelease(transform.map(tap->position()), Qt::NoModifier, Qt::LeftButton, true);
         }
         m_isTouchEvent = false;


@@ -1061,23 +1088,24 @@ void KItemListController::tapAndHoldTriggered(QGestureEvent *event, const QTrans
         if (m_pinchGestureInProgress) {
             return;
         }
         if (m_pinchGestureInProgress) {
             return;
         }

-        m_pressedMousePos = transform.map(event->mapToGraphicsScene(tap->position()));
-        m_pressedIndex = m_view->itemAt(m_pressedMousePos);
-
-        if (m_pressedIndex.has_value() && !m_selectionManager->isSelected(m_pressedIndex.value())) {
-            m_selectionManager->clearSelection();
-            m_selectionManager->setSelected(m_pressedIndex.value());
+        const QPointF pressedMousePos = transform.map(event->mapToGraphicsScene(tap->position()));
+        m_pressedIndex = m_view->itemAt(pressedMousePos);
+        if (m_pressedIndex.has_value()) {
+            if (!m_selectionManager->isSelected(m_pressedIndex.value())) {
+                m_selectionManager->clearSelection();
+                m_selectionManager->setSelected(m_pressedIndex.value());
+            }

             if (!m_selectionMode) {
                 Q_EMIT selectionModeChangeRequested(true);
             }
             if (!m_selectionMode) {
                 Q_EMIT selectionModeChangeRequested(true);
             }

-        } else if (!m_pressedIndex.has_value()) {
+        } else {

             m_selectionManager->clearSelection();
             startRubberBand();
         }
 
         Q_EMIT scrollerStop();
 
             m_selectionManager->clearSelection();
             startRubberBand();
         }
 
         Q_EMIT scrollerStop();
 

-        m_view->m_tapAndHoldIndicator->setStartPosition(m_pressedMousePos);
+        m_view->m_tapAndHoldIndicator->setStartPosition(pressedMousePos);

         m_view->m_tapAndHoldIndicator->setActive(true);
 
         m_dragActionOrRightClick = true;
         m_view->m_tapAndHoldIndicator->setActive(true);
 
         m_dragActionOrRightClick = true;


@@ -1152,8 +1180,8 @@ void KItemListController::twoFingerTapTriggered(QGestureEvent *event, const QTra
     }
 
     if (twoTap->state() == Qt::GestureStarted) {
     }
 
     if (twoTap->state() == Qt::GestureStarted) {

-        m_pressedMousePos = transform.map(twoTap->pos());
-        m_pressedIndex = m_view->itemAt(m_pressedMousePos);
+        const QPointF pressedMousePos = transform.map(twoTap->pos());
+        m_pressedIndex = m_view->itemAt(pressedMousePos);

         if (m_pressedIndex.has_value()) {
             onPress(twoTap->screenPos().toPoint(), twoTap->pos().toPoint(), Qt::ControlModifier, Qt::LeftButton);
             onRelease(transform.map(twoTap->pos()), Qt::ControlModifier, Qt::LeftButton, false);
         if (m_pressedIndex.has_value()) {
             onPress(twoTap->screenPos().toPoint(), twoTap->pos().toPoint(), Qt::ControlModifier, Qt::LeftButton);
             onRelease(transform.map(twoTap->pos()), Qt::ControlModifier, Qt::LeftButton, false);


@@ -1269,9 +1297,9 @@ void KItemListController::slotRubberBandChanged()
 
         const QRectF widgetRect = m_view->itemRect(index);
         if (widgetRect.intersects(rubberBandRect)) {
 
         const QRectF widgetRect = m_view->itemRect(index);
         if (widgetRect.intersects(rubberBandRect)) {

-            const QRectF iconRect = widget->iconRect().translated(widgetRect.topLeft());
-            const QRectF textRect = widget->textRect().translated(widgetRect.topLeft());
-            if (iconRect.intersects(rubberBandRect) || textRect.intersects(rubberBandRect)) {
+            // Select the full row intersecting with the rubberband rectangle
+            const QRectF selectionRect = widget->selectionRect().translated(widgetRect.topLeft());
+            if (selectionRect.intersects(rubberBandRect)) {

                 selectedItems.insert(index);
             }
         }
                 selectedItems.insert(index);
             }
         }


@@ -1502,14 +1530,16 @@ bool KItemListController::onPress(const QPoint &screenPos, const QPointF &pos, c
         return true;
     }
 
         return true;
     }
 

-    if (m_view->isAboveExpansionToggle(m_pressedIndex.value_or(-1), m_pressedMousePos)) {
+    const QPointF pressedMousePos = m_view->transform().map(pos);
+
+    if (m_view->isAboveExpansionToggle(m_pressedIndex.value_or(-1), pressedMousePos)) {

         m_selectionManager->endAnchoredSelection();
         m_selectionManager->setCurrentItem(m_pressedIndex.value());
         m_selectionManager->beginAnchoredSelection(m_pressedIndex.value());
         return true;
     }
 
         m_selectionManager->endAnchoredSelection();
         m_selectionManager->setCurrentItem(m_pressedIndex.value());
         m_selectionManager->beginAnchoredSelection(m_pressedIndex.value());
         return true;
     }
 

-    m_selectionTogglePressed = m_view->isAboveSelectionToggle(m_pressedIndex.value_or(-1), m_pressedMousePos);
+    m_selectionTogglePressed = m_view->isAboveSelectionToggle(m_pressedIndex.value_or(-1), pressedMousePos);

     if (m_selectionTogglePressed) {
         m_selectionManager->setSelected(m_pressedIndex.value(), 1, KItemListSelectionManager::Toggle);
         // The previous anchored selection has been finished already in
     if (m_selectionTogglePressed) {
         m_selectionManager->setSelected(m_pressedIndex.value(), 1, KItemListSelectionManager::Toggle);
         // The previous anchored selection has been finished already in


@@ -1575,7 +1605,7 @@ bool KItemListController::onPress(const QPoint &screenPos, const QPointF &pos, c
         //    clear the selection in mouseReleaseEvent(), unless the items are dragged.
         m_clearSelectionIfItemsAreNotDragged = true;
 
         //    clear the selection in mouseReleaseEvent(), unless the items are dragged.
         m_clearSelectionIfItemsAreNotDragged = true;
 

-        if (m_selectionManager->selectedItems().count() == 1 && m_view->isAboveText(m_pressedIndex.value_or(-1), m_pressedMousePos)) {
+        if (m_selectionManager->selectedItems().count() == 1 && m_view->isAboveText(m_pressedIndex.value_or(-1), pressedMousePos)) {

             Q_EMIT selectedItemTextPressed(m_pressedIndex.value_or(-1));
         }
     }
             Q_EMIT selectedItemTextPressed(m_pressedIndex.value_or(-1));
         }
     }


@@ -1677,7 +1707,8 @@ bool KItemListController::onPress(const QPoint &screenPos, const QPointF &pos, c
 
 bool KItemListController::onRelease(const QPointF &pos, const Qt::KeyboardModifiers modifiers, const Qt::MouseButtons buttons, bool touch)
 {
 
 bool KItemListController::onRelease(const QPointF &pos, const Qt::KeyboardModifiers modifiers, const Qt::MouseButtons buttons, bool touch)
 {

-    const bool isAboveSelectionToggle = m_view->isAboveSelectionToggle(m_pressedIndex.value_or(-1), m_pressedMousePos);
+    const QPointF pressedMousePos = pos;
+    const bool isAboveSelectionToggle = m_view->isAboveSelectionToggle(m_pressedIndex.value_or(-1), pressedMousePos);

     if (isAboveSelectionToggle) {
         m_selectionTogglePressed = false;
         return true;
     if (isAboveSelectionToggle) {
         m_selectionTogglePressed = false;
         return true;


@@ -1761,7 +1792,7 @@ bool KItemListController::onRelease(const QPointF &pos, const Qt::KeyboardModifi
         }
     }
 
         }
     }
 

-    m_pressedMousePos = QPointF();
+    m_pressedMouseGlobalPos = QPointF();

     m_pressedIndex = std::nullopt;
     m_clearSelectionIfItemsAreNotDragged = false;
     return false;
     m_pressedIndex = std::nullopt;
     m_clearSelectionIfItemsAreNotDragged = false;
     return false;


@@ -1770,14 +1801,9 @@ bool KItemListController::onRelease(const QPointF &pos, const Qt::KeyboardModifi
 void KItemListController::startRubberBand()
 {
     if (m_selectionBehavior == MultiSelection) {
 void KItemListController::startRubberBand()
 {
     if (m_selectionBehavior == MultiSelection) {

-        QPointF startPos = m_pressedMousePos;
+        QPoint startPos = m_view->transform().map(m_view->scene()->views().first()->mapFromGlobal(m_pressedMouseGlobalPos.toPoint()));

         if (m_view->scrollOrientation() == Qt::Vertical) {
             startPos.ry() += m_view->scrollOffset();
         if (m_view->scrollOrientation() == Qt::Vertical) {
             startPos.ry() += m_view->scrollOffset();

-            if (m_view->itemSize().width() < 0) {
-                // Use a special rubberband for views that have only one column and
-                // expand the rubberband to use the whole width of the view.
-                startPos.setX(0);
-            }

         } else {
             startPos.rx() += m_view->scrollOffset();
         }
         } else {
             startPos.rx() += m_view->scrollOffset();
         }


@@ -1800,3 +1826,5 @@ void KItemListController::slotStateChanged(QScroller::State newState)
         m_scrollerIsScrolling = false;
     }
 }
         m_scrollerIsScrolling = false;
     }
 }

+
+#include "moc_kitemlistcontroller.cpp"