X-Git-Url: https://cloud.milkyroute.net/gitweb/dolphin.git/blobdiff_plain/8d44ebc1487b9dc714b085ee8d3733a187abf8bb..c8d8556950005dfd96ebdb41d2f43ad90356367c:/src/kitemviews/kitemlistview.cpp

diff --git a/src/kitemviews/kitemlistview.cpp b/src/kitemviews/kitemlistview.cpp
index 93baa1334..5dbc128b5 100644
--- a/src/kitemviews/kitemlistview.cpp
+++ b/src/kitemviews/kitemlistview.cpp
@@ -23,7 +23,6 @@
 #include "kitemlistview.h"
 
 #include "kitemlistcontroller.h"
-#include "kitemlistgroupheader.h"
 #include "kitemlistheader_p.h"
 #include "kitemlistrubberband_p.h"
 #include "kitemlistselectionmanager.h"
@@ -53,6 +52,7 @@ namespace {
 
 KItemListView::KItemListView(QGraphicsWidget* parent) :
     QGraphicsWidget(parent),
+    m_enabledSelectionToggles(false),
     m_grouped(false),
     m_activeTransactions(0),
     m_itemSize(),
@@ -118,7 +118,16 @@ void KItemListView::setScrollOrientation(Qt::Orientation orientation)
     m_layouter->setScrollOrientation(orientation);
     m_animation->setScrollOrientation(orientation);
     m_sizeHintResolver->clearCache();
-    updateLayout();
+
+    if (m_grouped) {
+        QMutableHashIterator<KItemListWidget*, KItemListGroupHeader*> it (m_visibleGroups);
+        while (it.hasNext()) {
+            it.next();
+            it.value()->setScrollOrientation(orientation);
+        }
+    }
+
+    doLayout(Animation);
 
     onScrollOrientationChanged(orientation, previousOrientation);
     emit scrollOrientationChanged(orientation, previousOrientation);
@@ -148,10 +157,9 @@ void KItemListView::setItemSize(const QSizeF& itemSize)
             m_layouter->setItemSize(itemSize);
         }
     }
-    setHeaderShown(emptySize);
 
     m_sizeHintResolver->clearCache();
-    updateLayout();
+    doLayout(Animation);
     onItemSizeChanged(itemSize, previousSize);
 }
 
@@ -173,10 +181,11 @@ void KItemListView::setScrollOffset(qreal offset)
 
     m_layouter->setScrollOffset(offset);
     m_animation->setScrollOffset(offset);
-    if (!m_layoutTimer->isActive()) {
-        doLayout(NoAnimation, 0, 0);
-        update();
-    }
+
+    // Don't check whether the m_layoutTimer is active: Changing the
+    // scroll offset must always trigger a synchronous layout, otherwise
+    // the smooth-scrolling might get jerky.
+    doLayout(NoAnimation);
     onScrollOffsetChanged(offset, previousOffset);
 }
 
@@ -192,14 +201,19 @@ qreal KItemListView::maximumScrollOffset() const
 
 void KItemListView::setItemOffset(qreal offset)
 {
+    if (m_layouter->itemOffset() == offset) {
+        return;
+    }
+
     m_layouter->setItemOffset(offset);
     if (m_header) {
         m_header->setPos(-offset, 0);
     }
-    if (!m_layoutTimer->isActive()) {
-        doLayout(NoAnimation, 0, 0);
-        update();
-    }
+
+    // Don't check whether the m_layoutTimer is active: Changing the
+    // item offset must always trigger a synchronous layout, otherwise
+    // the smooth-scrolling might get jerky.
+    doLayout(NoAnimation);
 }
 
 qreal KItemListView::itemOffset() const
@@ -235,7 +249,7 @@ void KItemListView::setVisibleRoles(const QList<QByteArray>& roles)
     }
 
     updateVisibleRolesSizes();
-    updateLayout();
+    doLayout(Animation);
 
     onVisibleRolesChanged(roles, previousRoles);
 }
@@ -264,6 +278,24 @@ bool KItemListView::autoScroll() const
     return m_autoScrollTimer != 0;
 }
 
+void KItemListView::setEnabledSelectionToggles(bool enabled)
+{
+    if (m_enabledSelectionToggles != enabled) {
+        m_enabledSelectionToggles = enabled;
+
+        QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+        while (it.hasNext()) {
+            it.next();
+            it.value()->setEnabledSelectionToggle(enabled);
+        }
+    }
+}
+
+bool KItemListView::enabledSelectionToggles() const
+{
+    return m_enabledSelectionToggles;
+}
+
 KItemListController* KItemListView::controller() const
 {
     return m_controller;
@@ -306,7 +338,7 @@ void KItemListView::setStyleOption(const KItemListStyleOption& option)
     }
 
     m_sizeHintResolver->clearCache();
-    updateLayout();
+    doLayout(Animation);
     onStyleOptionChanged(option, previousOption);
 }
 
@@ -357,8 +389,14 @@ int KItemListView::itemAt(const QPointF& pos) const
 
 bool KItemListView::isAboveSelectionToggle(int index, const QPointF& pos) const
 {
-    Q_UNUSED(index);
-    Q_UNUSED(pos);
+    const KItemListWidget* widget = m_visibleItems.value(index);
+    if (widget) {
+        const QRectF selectionToggleRect = widget->selectionToggleRect();
+        if (!selectionToggleRect.isEmpty()) {
+            const QPointF mappedPos = widget->mapFromItem(this, pos);
+            return selectionToggleRect.contains(mappedPos);
+        }
+    }
     return false;
 }
 
@@ -397,14 +435,60 @@ QHash<QByteArray, QSizeF> KItemListView::visibleRolesSizes(const KItemRangeList&
     return QHash<QByteArray, QSizeF>();
 }
 
-QRectF KItemListView::itemBoundingRect(int index) const
+bool KItemListView::supportsItemExpanding() const
+{
+    return false;
+}
+
+QRectF KItemListView::itemRect(int index) const
 {
-    return m_layouter->itemBoundingRect(index);
+    return m_layouter->itemRect(index);
 }
 
-int KItemListView::itemsPerOffset() const
+QRectF KItemListView::itemContextRect(int index) const
 {
-    return m_layouter->itemsPerOffset();
+    QRectF contextRect;
+
+    const KItemListWidget* widget = m_visibleItems.value(index);
+    if (widget) {
+        contextRect = widget->iconRect() | widget->textRect();
+        contextRect.translate(itemRect(index).topLeft());
+    }
+
+    return contextRect;
+}
+
+void KItemListView::scrollToItem(int index)
+{
+    QRectF viewGeometry = geometry();
+    if (m_header) {
+        const qreal headerHeight = m_header->size().height();
+        viewGeometry.adjust(0, headerHeight, 0, 0);
+    }
+    const QRectF currentRect = itemRect(index);
+
+    if (!viewGeometry.contains(currentRect)) {
+        qreal newOffset = scrollOffset();
+        if (currentRect.top() < viewGeometry.top()) {
+            Q_ASSERT(scrollOrientation() == Qt::Vertical);
+            newOffset += currentRect.top() - viewGeometry.top();
+        } else if ((currentRect.bottom() > viewGeometry.bottom())) {
+            Q_ASSERT(scrollOrientation() == Qt::Vertical);
+            newOffset += currentRect.bottom() - viewGeometry.bottom();
+        } else if (currentRect.left() < viewGeometry.left()) {
+            if (scrollOrientation() == Qt::Horizontal) {
+                newOffset += currentRect.left() - viewGeometry.left();
+            }
+        } else if ((currentRect.right() > viewGeometry.right())) {
+            if (scrollOrientation() == Qt::Horizontal) {
+                newOffset += currentRect.right() - viewGeometry.right();
+            }
+        }
+
+        if (newOffset != scrollOffset()) {
+            emit scrollTo(newOffset);
+        }
+    }
 }
 
 void KItemListView::beginTransaction()
@@ -425,7 +509,7 @@ void KItemListView::endTransaction()
 
     if (m_activeTransactions == 0) {
         onTransactionEnd();
-        updateLayout();
+        doLayout(Animation);
     }
 }
 
@@ -446,10 +530,14 @@ void KItemListView::setHeaderShown(bool show)
         m_header->setVisibleRolesWidths(headerRolesWidths());
         m_header->setZValue(1);
 
-        m_useHeaderWidths = false;
-
         connect(m_header, SIGNAL(visibleRoleWidthChanged(QByteArray,qreal,qreal)),
                 this, SLOT(slotVisibleRoleWidthChanged(QByteArray,qreal,qreal)));
+        connect(m_header, SIGNAL(sortOrderChanged(Qt::SortOrder,Qt::SortOrder)),
+                this, SIGNAL(sortOrderChanged(Qt::SortOrder,Qt::SortOrder)));
+        connect(m_header, SIGNAL(sortRoleChanged(QByteArray,QByteArray)),
+                this, SIGNAL(sortRoleChanged(QByteArray,QByteArray)));
+
+        m_useHeaderWidths = false;
 
         m_layouter->setHeaderHeight(m_header->size().height());
     } else if (!show && m_header) {
@@ -690,7 +778,6 @@ void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
 
         m_layouter->markAsDirty();
         if (m_model->count() == count && maximumScrollOffset() > size().height()) {
-            kDebug() << "Scrollbar required, skipping layout";
             const int scrollBarExtent = style()->pixelMetric(QStyle::PM_ScrollBarExtent);
             QSizeF layouterSize = m_layouter->size();
             if (scrollOrientation() == Qt::Vertical) {
@@ -703,7 +790,6 @@ void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
 
         if (!hasMultipleRanges) {
             doLayout(Animation, index, count);
-            update();
         }
     }
 
@@ -784,7 +870,6 @@ void KItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
         m_layouter->markAsDirty();
         if (!hasMultipleRanges) {
             doLayout(Animation, index, -count);
-            update();
         }
     }
 
@@ -799,6 +884,13 @@ void KItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
 
 void KItemListView::slotItemsMoved(const KItemRange& itemRange, const QList<int>& movedToIndexes)
 {
+    m_sizeHintResolver->itemsMoved(itemRange.index, itemRange.count);
+    m_layouter->markAsDirty();
+
+    if (m_controller) {
+        m_controller->selectionManager()->itemsMoved(itemRange, movedToIndexes);
+    }
+
     const int firstVisibleMovedIndex = qMax(firstVisibleIndex(), itemRange.index);
     const int lastVisibleMovedIndex = qMin(lastVisibleIndex(), itemRange.index + itemRange.count - 1);
 
@@ -806,12 +898,14 @@ void KItemListView::slotItemsMoved(const KItemRange& itemRange, const QList<int>
         KItemListWidget* widget = m_visibleItems.value(index);
         if (widget) {
             updateWidgetProperties(widget, index);
+            if (m_grouped) {
+                updateGroupHeaderForWidget(widget);
+            }
+            initializeItemListWidget(widget);
         }
     }
 
-    if (m_controller) {
-        m_controller->selectionManager()->itemsMoved(itemRange, movedToIndexes);
-    }
+    doLayout(NoAnimation);
 }
 
 void KItemListView::slotItemsChanged(const KItemRangeList& itemRanges,
@@ -829,6 +923,7 @@ void KItemListView::slotItemsChanged(const KItemRangeList& itemRanges,
         if (updateSizeHints) {
             m_sizeHintResolver->itemsChanged(index, count, roles);
             m_layouter->markAsDirty();
+
             if (!m_layoutTimer->isActive()) {
                 m_layoutTimer->start();
             }
@@ -843,6 +938,57 @@ void KItemListView::slotItemsChanged(const KItemRangeList& itemRanges,
             }
         }
 
+        if (m_grouped && roles.contains(m_model->sortRole())) {
+            // The sort-role has been changed which might result
+            // in modified group headers
+            updateVisibleGroupHeaders();
+            doLayout(NoAnimation);
+        }
+    }
+}
+
+void KItemListView::slotGroupedSortingChanged(bool current)
+{
+    m_grouped = current;
+    m_layouter->markAsDirty();
+
+    if (m_grouped) {
+        // Apply the height of the header to the layouter
+        const qreal groupHeaderHeight = m_styleOption.fontMetrics.height() +
+                                        m_styleOption.margin * 2;
+        m_layouter->setGroupHeaderHeight(groupHeaderHeight);
+
+        updateVisibleGroupHeaders();
+    } else {
+        // Clear all visible headers
+        QMutableHashIterator<KItemListWidget*, KItemListGroupHeader*> it (m_visibleGroups);
+        while (it.hasNext()) {
+            it.next();
+            recycleGroupHeaderForWidget(it.key());
+        }
+        Q_ASSERT(m_visibleGroups.isEmpty());
+    }
+
+    doLayout(Animation);
+}
+
+void KItemListView::slotSortOrderChanged(Qt::SortOrder current, Qt::SortOrder previous)
+{
+    Q_UNUSED(current);
+    Q_UNUSED(previous);
+    if (m_grouped) {
+        updateVisibleGroupHeaders();
+        doLayout(Animation);
+    }
+}
+
+void KItemListView::slotSortRoleChanged(const QByteArray& current, const QByteArray& previous)
+{
+    Q_UNUSED(current);
+    Q_UNUSED(previous);
+    if (m_grouped) {
+        updateVisibleGroupHeaders();
+        doLayout(Animation);
     }
 }
 
@@ -861,33 +1007,6 @@ void KItemListView::slotCurrentChanged(int current, int previous)
         Q_ASSERT(!currentWidget->isCurrent());
         currentWidget->setCurrent(true);
     }
-
-    const QRectF viewGeometry = geometry();
-    const QRectF currentBoundingRect = itemBoundingRect(current);
-
-    if (!viewGeometry.contains(currentBoundingRect)) {
-        // Make sure that the new current item is fully visible in the view.
-        qreal newOffset = scrollOffset();
-        if (currentBoundingRect.top() < viewGeometry.top()) {
-            Q_ASSERT(scrollOrientation() == Qt::Vertical);
-            newOffset += currentBoundingRect.top() - viewGeometry.top();
-        } else if ((currentBoundingRect.bottom() > viewGeometry.bottom())) {
-            Q_ASSERT(scrollOrientation() == Qt::Vertical);
-            newOffset += currentBoundingRect.bottom() - viewGeometry.bottom();
-        } else if (currentBoundingRect.left() < viewGeometry.left()) {
-            if (scrollOrientation() == Qt::Horizontal) {
-                newOffset += currentBoundingRect.left() - viewGeometry.left();
-            }
-        } else if ((currentBoundingRect.right() > viewGeometry.right())) {
-            if (scrollOrientation() == Qt::Horizontal) {
-                newOffset += currentBoundingRect.right() - viewGeometry.right();
-            }
-        }
-
-        if (newOffset != scrollOffset()) {
-            emit scrollTo(newOffset);
-        }
-    }
 }
 
 void KItemListView::slotSelectionChanged(const QSet<int>& current, const QSet<int>& previous)
@@ -919,11 +1038,7 @@ void KItemListView::slotAnimationFinished(QGraphicsWidget* widget,
         // All KItemListWidgets that are animated by the DeleteAnimation are not maintained
         // by m_visibleWidgets and must be deleted manually after the animation has
         // been finished.
-        KItemListGroupHeader* header = m_visibleGroups.value(itemListWidget);
-        if (header) {
-            m_groupHeaderCreator->recycle(header);
-            m_visibleGroups.remove(itemListWidget);
-        }
+        recycleGroupHeaderForWidget(itemListWidget);
         m_widgetCreator->recycle(itemListWidget);
         break;
     }
@@ -947,7 +1062,7 @@ void KItemListView::slotAnimationFinished(QGraphicsWidget* widget,
 void KItemListView::slotLayoutTimerFinished()
 {
     m_layouter->setSize(geometry().size());
-    doLayout(Animation, 0, 0);
+    doLayout(Animation);
 }
 
 void KItemListView::slotRubberBandPosChanged()
@@ -1002,7 +1117,7 @@ void KItemListView::slotVisibleRoleWidthChanged(const QByteArray& role,
             widget->setVisibleRolesSizes(m_stretchedVisibleRolesSizes);
         }
 
-        updateLayout();
+        doLayout(Animation);
     }
 }
 
@@ -1056,7 +1171,9 @@ void KItemListView::triggerAutoScrolling()
     // the autoscrolling may not get skipped anymore until a new rubberband is created
     m_skipAutoScrollForRubberBand = false;
 
-    setScrollOffset(scrollOffset() + m_autoScrollIncrement);
+    const qreal maxVisibleOffset = qMax(qreal(0), maximumScrollOffset() - visibleSize);
+    const qreal newScrollOffset = qMin(scrollOffset() + m_autoScrollIncrement, maxVisibleOffset);
+    setScrollOffset(newScrollOffset);
 
    // Trigger the autoscroll timer which will periodically call
    // triggerAutoScrolling()
@@ -1102,11 +1219,17 @@ void KItemListView::setModel(KItemModelBase* model)
                    this,    SLOT(slotItemsRemoved(KItemRangeList)));
         disconnect(m_model, SIGNAL(itemsMoved(KItemRange,QList<int>)),
                    this,    SLOT(slotItemsMoved(KItemRange,QList<int>)));
+        disconnect(m_model, SIGNAL(groupedSortingChanged(bool)),
+                   this,    SLOT(slotGroupedSortingChanged(bool)));
+        disconnect(m_model, SIGNAL(sortOrderChanged(Qt::SortOrder,Qt::SortOrder)),
+                   this,    SLOT(slotSortOrderChanged(Qt::SortOrder,Qt::SortOrder)));
+        disconnect(m_model, SIGNAL(sortRoleChanged(QByteArray,QByteArray)),
+                   this,    SLOT(slotSortRoleChanged(QByteArray,QByteArray)));
     }
 
     m_model = model;
-    m_layouter->setModel(model);
-    m_grouped = !model->groupRole().isEmpty();
+    m_layouter->setModel(model);   
+    m_grouped = model->groupedSorting();
 
     if (m_model) {
         connect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
@@ -1117,6 +1240,12 @@ void KItemListView::setModel(KItemModelBase* model)
                 this,    SLOT(slotItemsRemoved(KItemRangeList)));
         connect(m_model, SIGNAL(itemsMoved(KItemRange,QList<int>)),
                 this,    SLOT(slotItemsMoved(KItemRange,QList<int>)));
+        connect(m_model, SIGNAL(groupedSortingChanged(bool)),
+                this,    SLOT(slotGroupedSortingChanged(bool)));
+        connect(m_model, SIGNAL(sortOrderChanged(Qt::SortOrder,Qt::SortOrder)),
+                this,    SLOT(slotSortOrderChanged(Qt::SortOrder,Qt::SortOrder)));
+        connect(m_model, SIGNAL(sortRoleChanged(QByteArray,QByteArray)),
+                this,    SLOT(slotSortRoleChanged(QByteArray,QByteArray)));
     }
 
     onModelChanged(model, previous);
@@ -1127,25 +1256,16 @@ KItemListRubberBand* KItemListView::rubberBand() const
     return m_rubberBand;
 }
 
-void KItemListView::updateLayout()
-{
-    doLayout(Animation, 0, 0);
-    update();
-}
-
 void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int changedCount)
 {
     if (m_layoutTimer->isActive()) {
-        kDebug() << "Stopping layout timer, synchronous layout requested";
         m_layoutTimer->stop();
     }
 
-    if (m_model->count() < 0 || m_activeTransactions > 0) {
+    if (!m_model || m_model->count() < 0 || m_activeTransactions > 0) {
         return;
     }
 
-    //markVisibleRolesSizesAsDirty();
-
     const int firstVisibleIndex = m_layouter->firstVisibleIndex();
     const int lastVisibleIndex = m_layouter->lastVisibleIndex();
     if (firstVisibleIndex < 0) {
@@ -1177,6 +1297,10 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
         if (invisible && !m_animation->isStarted(widget)) {
             widget->setVisible(false);
             reusableItems.append(index);
+
+            if (m_grouped) {
+                recycleGroupHeaderForWidget(widget);
+            }
         }
     }
 
@@ -1188,7 +1312,7 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
         bool applyNewPos = true;
         bool wasHidden = false;
 
-        const QRectF itemBounds = m_layouter->itemBoundingRect(i);
+        const QRectF itemBounds = m_layouter->itemRect(i);
         const QPointF newPos = itemBounds.topLeft();
         KItemListWidget* widget = m_visibleItems.value(i);
         if (!widget) {
@@ -1198,6 +1322,10 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
                 const int oldIndex = reusableItems.takeLast();
                 widget = m_visibleItems.value(oldIndex);
                 setWidgetIndex(widget, i);
+
+                if (m_grouped) {
+                    updateGroupHeaderForWidget(widget);
+                }
             } else {
                 // No reusable KItemListWidget instance is available, create a new one
                 widget = createWidget(i);
@@ -1206,14 +1334,15 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
 
             if (animate && changedCount < 0) {
                 // Items have been deleted, move the created item to the
-                // imaginary old position.
-                const QRectF itemBoundingRect = m_layouter->itemBoundingRect(i - changedCount);
-                if (itemBoundingRect.isEmpty()) {
+                // imaginary old position. They will get animated to the new position
+                // later.
+                const QRectF itemRect = m_layouter->itemRect(i - changedCount);
+                if (itemRect.isEmpty()) {
                     const QPointF invisibleOldPos = (scrollOrientation() == Qt::Vertical)
                                                     ? QPointF(0, size().height()) : QPointF(size().width(), 0);
                     widget->setPos(invisibleOldPos);
                 } else {
-                    widget->setPos(itemBoundingRect.topLeft());
+                    widget->setPos(itemRect.topLeft());
                 }
                 applyNewPos = false;
             }
@@ -1224,7 +1353,6 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
         if (animate) {
             const bool itemsRemoved = (changedCount < 0);
             const bool itemsInserted = (changedCount > 0);
-
             if (itemsRemoved && (i >= changedIndex + changedCount + 1)) {
                 // The item is located after the removed items. Animate the moving of the position.
                 m_animation->start(widget, KItemListViewAnimation::MovingAnimation, newPos);
@@ -1260,7 +1388,21 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
         widget->setVisible(true);
 
         if (widget->size() != itemBounds.size()) {
-            m_animation->start(widget, KItemListViewAnimation::ResizeAnimation, itemBounds.size());
+            // Resize the widget for the item to the changed size.
+            if (animate) {
+                // If a dynamic item size is used then no animation is done in the direction
+                // of the dynamic size.
+                if (m_itemSize.width() <= 0) {
+                    // The width is dynamic, apply the new width without animation.
+                    widget->resize(itemBounds.width(), widget->size().height());
+                } else if (m_itemSize.height() <= 0) {
+                    // The height is dynamic, apply the new height without animation.
+                    widget->resize(widget->size().width(), itemBounds.height());
+                }
+                m_animation->start(widget, KItemListViewAnimation::ResizeAnimation, itemBounds.size());
+            } else {
+                widget->resize(itemBounds.size());
+            }
         }
     }
 
@@ -1269,6 +1411,15 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
         recycleWidget(m_visibleItems.value(index));
     }
 
+    if (m_grouped) {
+        // Update the layout of all visible group headers
+        QHashIterator<KItemListWidget*, KItemListGroupHeader*> it(m_visibleGroups);
+        while (it.hasNext()) {
+            it.next();
+            updateGroupHeaderLayout(it.key());
+        }
+    }
+
     emitOffsetChanges();
 }
 
@@ -1308,12 +1459,7 @@ KItemListWidget* KItemListView::createWidget(int index)
     m_visibleItems.insert(index, widget);
 
     if (m_grouped) {
-        if (m_layouter->isFirstGroupItem(index)) {
-            KItemListGroupHeader* header = m_groupHeaderCreator->create(widget);
-            header->setPos(0, -50);
-            header->resize(50, 50);
-            m_visibleGroups.insert(widget, header);
-        }
+        updateGroupHeaderForWidget(widget);
     }
 
     initializeItemListWidget(widget);
@@ -1323,11 +1469,7 @@ KItemListWidget* KItemListView::createWidget(int index)
 void KItemListView::recycleWidget(KItemListWidget* widget)
 {
     if (m_grouped) {
-        KItemListGroupHeader* header = m_visibleGroups.value(widget);
-        if (header) {
-            m_groupHeaderCreator->recycle(header);
-            m_visibleGroups.remove(widget);
-        }
+        recycleGroupHeaderForWidget(widget);
     }
 
     m_visibleItems.remove(widget->index());
@@ -1336,26 +1478,6 @@ void KItemListView::recycleWidget(KItemListWidget* widget)
 
 void KItemListView::setWidgetIndex(KItemListWidget* widget, int index)
 {
-    if (m_grouped) {
-        bool createHeader = m_layouter->isFirstGroupItem(index);
-        KItemListGroupHeader* header = m_visibleGroups.value(widget);
-        if (header) {
-            if (createHeader) {
-                createHeader = false;
-            } else {
-                m_groupHeaderCreator->recycle(header);
-                m_visibleGroups.remove(widget);
-            }
-        }
-
-        if (createHeader) {
-            KItemListGroupHeader* header = m_groupHeaderCreator->create(widget);
-            header->setPos(0, -50);
-            header->resize(50, 50);
-            m_visibleGroups.insert(widget, header);
-        }
-    }
-
     const int oldIndex = widget->index();
     m_visibleItems.remove(oldIndex);
     updateWidgetProperties(widget, index);
@@ -1401,8 +1523,9 @@ void KItemListView::prepareLayoutForIncreasedItemCount(const QSizeF& size, SizeT
         for (int i = minFirst; i <= maxLast; ++i) {
             if (!m_visibleItems.contains(i)) {
                 KItemListWidget* widget = createWidget(i);
-                const QPointF pos = m_layouter->itemBoundingRect(i).topLeft();
-                widget->setPos(pos);
+                const QRectF itemRect = m_layouter->itemRect(i);
+                widget->setPos(itemRect.topLeft());
+                widget->resize(itemRect.size());
             }
         }
         setLayouterSize(size, sizeType);
@@ -1429,10 +1552,97 @@ void KItemListView::updateWidgetProperties(KItemListWidget* widget, int index)
     widget->setSelected(selectionManager->isSelected(index));
     widget->setHovered(false);
     widget->setAlternatingBackgroundColors(false);
+    widget->setEnabledSelectionToggle(enabledSelectionToggles());
     widget->setIndex(index);
     widget->setData(m_model->data(index));
 }
 
+void KItemListView::updateGroupHeaderForWidget(KItemListWidget* widget)
+{
+    Q_ASSERT(m_grouped);
+
+    const int index = widget->index();
+    if (!m_layouter->isFirstGroupItem(index)) {
+        // The widget does not represent the first item of a group
+        // and hence requires no header
+        recycleGroupHeaderForWidget(widget);
+        return;
+    }
+
+    const QList<QPair<int, QVariant> > groups = model()->groups();
+    if (groups.isEmpty()) {
+        return;
+    }
+
+    KItemListGroupHeader* header = m_visibleGroups.value(widget);
+    if (!header) {
+        header = m_groupHeaderCreator->create(this);
+        header->setParentItem(widget);
+        m_visibleGroups.insert(widget, header);
+    }
+    Q_ASSERT(header->parentItem() == widget);
+
+    // Determine the shown data for the header by doing a binary
+    // search in the groups-list
+    int min = 0;
+    int max = groups.count() - 1;
+    int mid = 0;
+    do {
+        mid = (min + max) / 2;
+        if (index > groups.at(mid).first) {
+            min = mid + 1;
+        } else {
+            max = mid - 1;
+        }
+    } while (groups.at(mid).first != index && min <= max);
+
+    header->setData(groups.at(mid).second);
+    header->setRole(model()->sortRole());
+    header->setStyleOption(m_styleOption);
+    header->setScrollOrientation(scrollOrientation());
+
+    header->show();
+}
+
+void KItemListView::updateGroupHeaderLayout(KItemListWidget* widget)
+{
+    KItemListGroupHeader* header = m_visibleGroups.value(widget);
+    Q_ASSERT(header);
+
+    const int index = widget->index();
+    const QRectF groupHeaderRect = m_layouter->groupHeaderRect(index);
+    const QRectF itemRect = m_layouter->itemRect(index);
+
+    // The group-header is a child of the itemlist widget. Translate the
+    // group header position to the relative position.
+    const QPointF groupHeaderPos(groupHeaderRect.x() - itemRect.x(),
+                                 - groupHeaderRect.height());
+    header->setPos(groupHeaderPos);
+    header->resize(groupHeaderRect.size());
+}
+
+void KItemListView::recycleGroupHeaderForWidget(KItemListWidget* widget)
+{
+    KItemListGroupHeader* header = m_visibleGroups.value(widget);
+    if (header) {
+        header->setParentItem(0);
+        m_groupHeaderCreator->recycle(header);
+        m_visibleGroups.remove(widget);
+    }
+}
+
+void KItemListView::updateVisibleGroupHeaders()
+{
+    Q_ASSERT(m_grouped);
+    m_layouter->markAsDirty();
+
+    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    while (it.hasNext()) {
+        it.next();
+        updateGroupHeaderForWidget(it.value());
+    }
+}
+
 QHash<QByteArray, qreal> KItemListView::headerRolesWidths() const
 {
     QHash<QByteArray, qreal> rolesWidths;
@@ -1460,17 +1670,18 @@ void KItemListView::updateVisibleRolesSizes(const KItemRangeList& itemRanges)
 
     if (itemCount == rangesItemCount) {
         m_visibleRolesSizes = visibleRolesSizes(itemRanges);
-
-        // Assure the the sizes are not smaller than the minimum defined by the header
-        // TODO: Currently only implemented for a top-aligned header
-        const qreal minHeaderRoleWidth = m_header->minimumRoleWidth();
-        QMutableHashIterator<QByteArray, QSizeF> it (m_visibleRolesSizes);
-        while (it.hasNext()) {
-            it.next();
-            const QSizeF& size = it.value();
-            if (size.width() < minHeaderRoleWidth) {
-                const QSizeF newSize(minHeaderRoleWidth, size.height());
-                m_visibleRolesSizes.insert(it.key(), newSize);
+        if (m_header) {
+            // Assure the the sizes are not smaller than the minimum defined by the header
+            // TODO: Currently only implemented for a top-aligned header
+            const qreal minHeaderRoleWidth = m_header->minimumRoleWidth();
+            QMutableHashIterator<QByteArray, QSizeF> it (m_visibleRolesSizes);
+            while (it.hasNext()) {
+                it.next();
+                const QSizeF& size = it.value();
+                if (size.width() < minHeaderRoleWidth) {
+                    const QSizeF newSize(minHeaderRoleWidth, size.height());
+                    m_visibleRolesSizes.insert(it.key(), newSize);
+                }
             }
         }
     } else {
@@ -1505,6 +1716,10 @@ void KItemListView::updateVisibleRolesSizes(const KItemRangeList& itemRanges)
 
 void KItemListView::updateVisibleRolesSizes()
 {
+    if (!m_model) {
+        return;
+    }
+
     const int itemCount = m_model->count();
     if (itemCount > 0) {
         updateVisibleRolesSizes(KItemRangeList() << KItemRange(0, itemCount));
@@ -1513,7 +1728,7 @@ void KItemListView::updateVisibleRolesSizes()
 
 void KItemListView::updateStretchedVisibleRolesSizes()
 {
-    if (!m_itemSize.isEmpty() || m_useHeaderWidths) {
+    if (!m_itemSize.isEmpty() || m_useHeaderWidths || m_visibleRoles.isEmpty()) {
         return;
     }
 
@@ -1522,7 +1737,7 @@ void KItemListView::updateStretchedVisibleRolesSizes()
     // size does not use the available view-size it the size of the
     // first role will get stretched.
     m_stretchedVisibleRolesSizes = m_visibleRolesSizes;
-    const QByteArray role = visibleRoles().first();
+    const QByteArray role = m_visibleRoles.first();
     QSizeF firstRoleSize = m_stretchedVisibleRolesSizes.value(role);
 
     QSizeF dynamicItemSize = m_itemSize;
@@ -1658,6 +1873,7 @@ KItemListWidgetCreatorBase::~KItemListWidgetCreatorBase()
 
 void KItemListWidgetCreatorBase::recycle(KItemListWidget* widget)
 {
+    widget->setParentItem(0);
     widget->setOpacity(1.0);
     pushRecycleableWidget(widget);
 }