Merge remote-tracking branch 'upstream/master' into work/zakharafoniam/useful-groups

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

diff --git a/src/kitemviews/kitemlistview.cpp b/src/kitemviews/kitemlistview.cpp
index f0647fb3eac23fc922532e447a4f20c541cbe3c1..45f5851bf5d6c2e06bd592c09350058fea35a2a8 100644 (file)
--- a/src/kitemviews/kitemlistview.cpp
+++ b/src/kitemviews/kitemlistview.cpp
@@ -1,24 +1,10 @@
-/***************************************************************************
- *   Copyright (C) 2011 by Peter Penz <peter.penz19@gmail.com>             *
- *                                                                         *
- *   Based on the Itemviews NG project from Trolltech Labs:                *
- *   http://qt.gitorious.org/qt-labs/itemviews-ng                          *
- *                                                                         *
- *   This program is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU General Public License as published by  *
- *   the Free Software Foundation; either version 2 of the License, or     *
- *   (at your option) any later version.                                   *
- *                                                                         *
- *   This program is distributed in the hope that it will be useful,       *
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
- *   GNU General Public License for more details.                          *
- *                                                                         *
- *   You should have received a copy of the GNU General Public License     *
- *   along with this program; if not, write to the                         *
- *   Free Software Foundation, Inc.,                                       *
- *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA            *
- ***************************************************************************/
+/*
+ * SPDX-FileCopyrightText: 2011 Peter Penz <peter.penz19@gmail.com>
+ *
+ * Based on the Itemviews NG project from Trolltech Labs
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */

 
 #include "kitemlistview.h"
 
 
 #include "kitemlistview.h"
 


@@ -38,87 +24,115 @@
 #include <QElapsedTimer>
 #include <QGraphicsSceneMouseEvent>
 #include <QGraphicsView>
 #include <QElapsedTimer>
 #include <QGraphicsSceneMouseEvent>
 #include <QGraphicsView>

+#include <QPropertyAnimation>

 #include <QStyleOptionRubberBand>
 #include <QTimer>
 #include <QStyleOptionRubberBand>
 #include <QTimer>

+#include <QVariantAnimation>

 
 

+namespace
+{
+// Time in ms until reaching the autoscroll margin triggers
+// an initial autoscrolling
+const int InitialAutoScrollDelay = 700;
+
+// Delay in ms for triggering the next autoscroll
+const int RepeatingAutoScrollDelay = 1000 / 60;

 
 

-namespace {
-    // Time in ms until reaching the autoscroll margin triggers
-    // an initial autoscrolling
-    const int InitialAutoScrollDelay = 700;
+// Copied from the Kirigami.Units.shortDuration
+const int RubberFadeSpeed = 150;

 
 

-    // Delay in ms for triggering the next autoscroll
-    const int RepeatingAutoScrollDelay = 1000 / 60;
+const char *RubberPropertyName = "_kitemviews_rubberBandPosition";

 }
 
 #ifndef QT_NO_ACCESSIBILITY
 }
 
 #ifndef QT_NO_ACCESSIBILITY

-QAccessibleInterface* accessibleInterfaceFactory(const QString& key, QObject* object)
+QAccessibleInterface *accessibleInterfaceFactory(const QString &key, QObject *object)

 {
     Q_UNUSED(key)
 
 {
     Q_UNUSED(key)
 

-    if (KItemListContainer* container = qobject_cast<KItemListContainer*>(object)) {
+    if (KItemListContainer *container = qobject_cast<KItemListContainer *>(object)) {
+        if (auto controller = container->controller(); controller) {
+            if (KItemListView *view = controller->view(); view && view->accessibleParent()) {
+                return view->accessibleParent();
+            }
+        }

         return new KItemListContainerAccessible(container);
         return new KItemListContainerAccessible(container);

-    } else if (KItemListView* view = qobject_cast<KItemListView*>(object)) {
-        return new KItemListViewAccessible(view);
+    } else if (KItemListView *view = qobject_cast<KItemListView *>(object)) {
+        return new KItemListViewAccessible(view, view->accessibleParent());

     }
 
     return nullptr;
 }
 #endif
 
     }
 
     return nullptr;
 }
 #endif
 

-KItemListView::KItemListView(QGraphicsWidget* parent) :
-    QGraphicsWidget(parent),
-    m_enabledSelectionToggles(false),
-    m_grouped(false),
-    m_supportsItemExpanding(false),
-    m_editingRole(false),
-    m_activeTransactions(0),
-    m_endTransactionAnimationHint(Animation),
-    m_itemSize(),
-    m_controller(nullptr),
-    m_model(nullptr),
-    m_visibleRoles(),
-    m_widgetCreator(nullptr),
-    m_groupHeaderCreator(nullptr),
-    m_styleOption(),
-    m_visibleItems(),
-    m_visibleGroups(),
-    m_visibleCells(),
-    m_sizeHintResolver(nullptr),
-    m_layouter(nullptr),
-    m_animation(nullptr),
-    m_layoutTimer(nullptr),
-    m_oldScrollOffset(0),
-    m_oldMaximumScrollOffset(0),
-    m_oldItemOffset(0),
-    m_oldMaximumItemOffset(0),
-    m_skipAutoScrollForRubberBand(false),
-    m_rubberBand(nullptr),
-    m_mousePos(),
-    m_autoScrollIncrement(0),
-    m_autoScrollTimer(nullptr),
-    m_header(nullptr),
-    m_headerWidget(nullptr),
-    m_dropIndicator()
+KItemListView::KItemListView(QGraphicsWidget *parent)
+    : QGraphicsWidget(parent)
+    , m_enabledSelectionToggles(false)
+    , m_grouped(false)
+    , m_highlightEntireRow(false)
+    , m_alternateBackgrounds(false)
+    , m_supportsItemExpanding(false)
+    , m_editingRole(false)
+    , m_activeTransactions(0)
+    , m_endTransactionAnimationHint(Animation)
+    , m_itemSize()
+    , m_controller(nullptr)
+    , m_model(nullptr)
+    , m_visibleRoles()
+    , m_widgetCreator(nullptr)
+    , m_groupHeaderCreator(nullptr)
+    , m_styleOption()
+    , m_visibleItems()
+    , m_visibleGroups()
+    , m_visibleCells()
+    , m_scrollBarExtent(0)
+    , m_layouter(nullptr)
+    , m_animation(nullptr)
+    , m_oldScrollOffset(0)
+    , m_oldMaximumScrollOffset(0)
+    , m_oldItemOffset(0)
+    , m_oldMaximumItemOffset(0)
+    , m_skipAutoScrollForRubberBand(false)
+    , m_rubberBand(nullptr)
+    , m_tapAndHoldIndicator(nullptr)
+    , m_mousePos()
+    , m_autoScrollIncrement(0)
+    , m_autoScrollTimer(nullptr)
+    , m_header(nullptr)
+    , m_headerWidget(nullptr)
+    , m_indicatorAnimation(nullptr)
+    , m_dropIndicator()
+    , m_sizeHintResolver(nullptr)

 {
     setAcceptHoverEvents(true);
 {
     setAcceptHoverEvents(true);

+    setAcceptTouchEvents(true);

 
     m_sizeHintResolver = new KItemListSizeHintResolver(this);
 
     m_layouter = new KItemListViewLayouter(m_sizeHintResolver, this);
 
     m_animation = new KItemListViewAnimation(this);
 
     m_sizeHintResolver = new KItemListSizeHintResolver(this);
 
     m_layouter = new KItemListViewLayouter(m_sizeHintResolver, this);
 
     m_animation = new KItemListViewAnimation(this);

-    connect(m_animation, &KItemListViewAnimation::finished,
-            this, &KItemListView::slotAnimationFinished);
-
-    m_layoutTimer = new QTimer(this);
-    m_layoutTimer->setInterval(300);
-    m_layoutTimer->setSingleShot(true);
-    connect(m_layoutTimer, &QTimer::timeout, this, &KItemListView::slotLayoutTimerFinished);
+    connect(m_animation, &KItemListViewAnimation::finished, this, &KItemListView::slotAnimationFinished);

 
     m_rubberBand = new KItemListRubberBand(this);
     connect(m_rubberBand, &KItemListRubberBand::activationChanged, this, &KItemListView::slotRubberBandActivationChanged);
 
 
     m_rubberBand = new KItemListRubberBand(this);
     connect(m_rubberBand, &KItemListRubberBand::activationChanged, this, &KItemListView::slotRubberBandActivationChanged);
 

+    m_tapAndHoldIndicator = new KItemListRubberBand(this);
+    m_indicatorAnimation = new QPropertyAnimation(m_tapAndHoldIndicator, "endPosition", this);
+    connect(m_tapAndHoldIndicator, &KItemListRubberBand::activationChanged, this, [this](bool active) {
+        if (active) {
+            m_indicatorAnimation->setDuration(150);
+            m_indicatorAnimation->setStartValue(QPointF(1, 1));
+            m_indicatorAnimation->setEndValue(QPointF(40, 40));
+            m_indicatorAnimation->start();
+        }
+        update();
+    });
+    connect(m_tapAndHoldIndicator, &KItemListRubberBand::endPositionChanged, this, [this]() {
+        if (m_tapAndHoldIndicator->isActive()) {
+            update();
+        }
+    });
+

     m_headerWidget = new KItemListHeaderWidget(this);
     m_headerWidget->setVisible(false);
 
     m_headerWidget = new KItemListHeaderWidget(this);
     m_headerWidget->setVisible(false);
 


@@ -127,7 +141,6 @@ KItemListView::KItemListView(QGraphicsWidget* parent) :
 #ifndef QT_NO_ACCESSIBILITY
     QAccessible::installFactory(accessibleInterfaceFactory);
 #endif
 #ifndef QT_NO_ACCESSIBILITY
     QAccessible::installFactory(accessibleInterfaceFactory);
 #endif

-

 }
 
 KItemListView::~KItemListView()
 }
 
 KItemListView::~KItemListView()


@@ -208,7 +221,7 @@ int KItemListView::maximumVisibleItems() const
     return m_layouter->maximumVisibleItems();
 }
 
     return m_layouter->maximumVisibleItems();
 }
 

-void KItemListView::setVisibleRoles(const QList<QByteArray>& roles)
+void KItemListView::setVisibleRoles(const QList<QByteArray> &roles)

 {
     const QList<QByteArray> previousRoles = m_visibleRoles;
     m_visibleRoles = roles;
 {
     const QList<QByteArray> previousRoles = m_visibleRoles;
     m_visibleRoles = roles;


@@ -223,7 +236,7 @@ void KItemListView::setVisibleRoles(const QList<QByteArray>& roles)
         if (!m_headerWidget->automaticColumnResizing()) {
             // The column-width of new roles are still 0. Apply the preferred
             // column-width as default with.
         if (!m_headerWidget->automaticColumnResizing()) {
             // The column-width of new roles are still 0. Apply the preferred
             // column-width as default with.

-            foreach (const QByteArray& role, m_visibleRoles) {
+            for (const QByteArray &role : std::as_const(m_visibleRoles)) {

                 if (m_headerWidget->columnWidth(role) == 0) {
                     const qreal width = m_headerWidget->preferredColumnWidth(role);
                     m_headerWidget->setColumnWidth(role, width);
                 if (m_headerWidget->columnWidth(role) == 0) {
                     const qreal width = m_headerWidget->preferredColumnWidth(role);
                     m_headerWidget->setColumnWidth(role, width);


@@ -234,14 +247,13 @@ void KItemListView::setVisibleRoles(const QList<QByteArray>& roles)
         }
     }
 
         }
     }
 

-    const bool alternateBackgroundsChanged = m_itemSize.isEmpty() &&
-                                             ((roles.count() > 1 && previousRoles.count() <= 1) ||
-                                              (roles.count() <= 1 && previousRoles.count() > 1));
+    const bool alternateBackgroundsChanged =
+        m_itemSize.isEmpty() && ((roles.count() > 1 && previousRoles.count() <= 1) || (roles.count() <= 1 && previousRoles.count() > 1));

 
 

-    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    QHashIterator<int, KItemListWidget *> it(m_visibleItems);

     while (it.hasNext()) {
         it.next();
     while (it.hasNext()) {
         it.next();

-        KItemListWidget* widget = it.value();
+        KItemListWidget *widget = it.value();

         widget->setVisibleRoles(roles);
         if (alternateBackgroundsChanged) {
             updateAlternateBackgroundForWidget(widget);
         widget->setVisibleRoles(roles);
         if (alternateBackgroundsChanged) {
             updateAlternateBackgroundForWidget(widget);


@@ -279,7 +291,7 @@ void KItemListView::setEnabledSelectionToggles(bool enabled)
     if (m_enabledSelectionToggles != enabled) {
         m_enabledSelectionToggles = enabled;
 
     if (m_enabledSelectionToggles != enabled) {
         m_enabledSelectionToggles = enabled;
 

-        QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+        QHashIterator<int, KItemListWidget *> it(m_visibleItems);

         while (it.hasNext()) {
             it.next();
             it.value()->setEnabledSelectionToggle(enabled);
         while (it.hasNext()) {
             it.next();
             it.value()->setEnabledSelectionToggle(enabled);


@@ -292,23 +304,23 @@ bool KItemListView::enabledSelectionToggles() const
     return m_enabledSelectionToggles;
 }
 
     return m_enabledSelectionToggles;
 }
 

-KItemListController* KItemListView::controller() const
+KItemListController *KItemListView::controller() const

 {
     return m_controller;
 }
 
 {
     return m_controller;
 }
 

-KItemModelBase* KItemListView::model() const
+KItemModelBase *KItemListView::model() const

 {
     return m_model;
 }
 
 {
     return m_model;
 }
 

-void KItemListView::setWidgetCreator(KItemListWidgetCreatorBase* widgetCreator)
+void KItemListView::setWidgetCreator(KItemListWidgetCreatorBase *widgetCreator)

 {
     delete m_widgetCreator;
     m_widgetCreator = widgetCreator;
 }
 
 {
     delete m_widgetCreator;
     m_widgetCreator = widgetCreator;
 }
 

-KItemListWidgetCreatorBase* KItemListView::widgetCreator() const
+KItemListWidgetCreatorBase *KItemListView::widgetCreator() const

 {
     if (!m_widgetCreator) {
         m_widgetCreator = defaultWidgetCreator();
 {
     if (!m_widgetCreator) {
         m_widgetCreator = defaultWidgetCreator();


@@ -316,13 +328,13 @@ KItemListWidgetCreatorBase* KItemListView::widgetCreator() const
     return m_widgetCreator;
 }
 
     return m_widgetCreator;
 }
 

-void KItemListView::setGroupHeaderCreator(KItemListGroupHeaderCreatorBase* groupHeaderCreator)
+void KItemListView::setGroupHeaderCreator(KItemListGroupHeaderCreatorBase *groupHeaderCreator)

 {
     delete m_groupHeaderCreator;
     m_groupHeaderCreator = groupHeaderCreator;
 }
 
 {
     delete m_groupHeaderCreator;
     m_groupHeaderCreator = groupHeaderCreator;
 }
 

-KItemListGroupHeaderCreatorBase* KItemListView::groupHeaderCreator() const
+KItemListGroupHeaderCreatorBase *KItemListView::groupHeaderCreator() const

 {
     if (!m_groupHeaderCreator) {
         m_groupHeaderCreator = defaultGroupHeaderCreator();
 {
     if (!m_groupHeaderCreator) {
         m_groupHeaderCreator = defaultGroupHeaderCreator();


@@ -330,22 +342,30 @@ KItemListGroupHeaderCreatorBase* KItemListView::groupHeaderCreator() const
     return m_groupHeaderCreator;
 }
 
     return m_groupHeaderCreator;
 }
 

-QSizeF KItemListView::itemSize() const
+#ifndef QT_NO_ACCESSIBILITY
+void KItemListView::setAccessibleParentsObject(KItemListContainer *accessibleParentsObject)

 {
 {

-    return m_itemSize;
+    Q_ASSERT(!m_accessibleParent);
+    m_accessibleParent = new KItemListContainerAccessible(accessibleParentsObject);
+}
+KItemListContainerAccessible *KItemListView::accessibleParent()
+{
+    Q_CHECK_PTR(m_accessibleParent); // We always want the accessibility tree/hierarchy to be complete.
+    return m_accessibleParent;

 }
 }

+#endif

 
 

-QSizeF KItemListView::itemSizeHint() const
+QSizeF KItemListView::itemSize() const

 {
 {

-    return m_sizeHintResolver->minSizeHint();
+    return m_itemSize;

 }
 
 }
 

-const KItemListStyleOption& KItemListView::styleOption() const
+const KItemListStyleOption &KItemListView::styleOption() const

 {
     return m_styleOption;
 }
 
 {
     return m_styleOption;
 }
 

-void KItemListView::setGeometry(const QRectF& rect)
+void KItemListView::setGeometry(const QRectF &rect)

 {
     QGraphicsWidget::setGeometry(rect);
 
 {
     QGraphicsWidget::setGeometry(rect);
 


@@ -359,34 +379,16 @@ void KItemListView::setGeometry(const QRectF& rect)
         if (m_headerWidget->automaticColumnResizing()) {
             applyAutomaticColumnWidths();
         } else {
         if (m_headerWidget->automaticColumnResizing()) {
             applyAutomaticColumnWidths();
         } else {

-            const qreal requiredWidth = columnWidthsSum();
-            const QSizeF dynamicItemSize(qMax(newSize.width(), requiredWidth),
-                                         m_itemSize.height());
+            const qreal requiredWidth = columnWidthsSum() + 2 * m_headerWidget->sidePadding();
+            const QSizeF dynamicItemSize(qMax(newSize.width(), requiredWidth), m_itemSize.height());

             m_layouter->setItemSize(dynamicItemSize);
         }
             m_layouter->setItemSize(dynamicItemSize);
         }

-
-        // Triggering a synchronous layout is fine from a performance point of view,
-        // as with dynamic item sizes no moving animation must be done.
-        m_layouter->setSize(newSize);
-        doLayout(NoAnimation);
-    } else {
-        const bool animate = !changesItemGridLayout(newSize,
-                                                    m_layouter->itemSize(),
-                                                    m_layouter->itemMargin());
-        m_layouter->setSize(newSize);
-
-        if (animate) {
-            // Trigger an asynchronous relayout with m_layoutTimer to prevent
-            // performance bottlenecks. If the timer is exceeded, an animated layout
-            // will be triggered.
-            if (!m_layoutTimer->isActive()) {
-                m_layoutTimer->start();
-            }
-        } else {
-            m_layoutTimer->stop();
-            doLayout(NoAnimation);
-        }

     }
     }

+
+    m_layouter->setSize(newSize);
+    // We don't animate the moving of the items here because
+    // it would look like the items are slow to find their position.
+    doLayout(NoAnimation);

 }
 
 qreal KItemListView::verticalPageStep() const
 }
 
 qreal KItemListView::verticalPageStep() const


@@ -398,29 +400,33 @@ qreal KItemListView::verticalPageStep() const
     return size().height() - headerHeight;
 }
 
     return size().height() - headerHeight;
 }
 

-int KItemListView::itemAt(const QPointF& pos) const
+std::optional<int> KItemListView::itemAt(const QPointF &pos) const

 {
 {

-    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    if (headerBoundaries().contains(pos)) {
+        return std::nullopt;
+    }
+
+    QHashIterator<int, KItemListWidget *> it(m_visibleItems);

     while (it.hasNext()) {
         it.next();
 
     while (it.hasNext()) {
         it.next();
 

-        const KItemListWidget* widget = it.value();
+        const KItemListWidget *widget = it.value();

         const QPointF mappedPos = widget->mapFromItem(this, pos);
         const QPointF mappedPos = widget->mapFromItem(this, pos);

-        if (widget->contains(mappedPos)) {
+        if (widget->contains(mappedPos) || widget->selectionRect().contains(mappedPos)) {

             return it.key();
         }
     }
 
             return it.key();
         }
     }
 

-    return -1;
+    return std::nullopt;

 }
 
 }
 

-bool KItemListView::isAboveSelectionToggle(int index, const QPointF& pos) const
+bool KItemListView::isAboveSelectionToggle(int index, const QPointF &pos) const

 {
     if (!m_enabledSelectionToggles) {
         return false;
     }
 
 {
     if (!m_enabledSelectionToggles) {
         return false;
     }
 

-    const KItemListWidget* widget = m_visibleItems.value(index);
+    const KItemListWidget *widget = m_visibleItems.value(index);

     if (widget) {
         const QRectF selectionToggleRect = widget->selectionToggleRect();
         if (!selectionToggleRect.isEmpty()) {
     if (widget) {
         const QRectF selectionToggleRect = widget->selectionToggleRect();
         if (!selectionToggleRect.isEmpty()) {


@@ -431,9 +437,9 @@ bool KItemListView::isAboveSelectionToggle(int index, const QPointF& pos) const
     return false;
 }
 
     return false;
 }
 

-bool KItemListView::isAboveExpansionToggle(int index, const QPointF& pos) const
+bool KItemListView::isAboveExpansionToggle(int index, const QPointF &pos) const

 {
 {

-    const KItemListWidget* widget = m_visibleItems.value(index);
+    const KItemListWidget *widget = m_visibleItems.value(index);

     if (widget) {
         const QRectF expansionToggleRect = widget->expansionToggleRect();
         if (!expansionToggleRect.isEmpty()) {
     if (widget) {
         const QRectF expansionToggleRect = widget->expansionToggleRect();
         if (!expansionToggleRect.isEmpty()) {


@@ -446,7 +452,7 @@ bool KItemListView::isAboveExpansionToggle(int index, const QPointF& pos) const
 
 bool KItemListView::isAboveText(int index, const QPointF &pos) const
 {
 
 bool KItemListView::isAboveText(int index, const QPointF &pos) const
 {

-    const KItemListWidget* widget = m_visibleItems.value(index);
+    const KItemListWidget *widget = m_visibleItems.value(index);

     if (widget) {
         const QRectF &textRect = widget->textRect();
         if (!textRect.isEmpty()) {
     if (widget) {
         const QRectF &textRect = widget->textRect();
         if (!textRect.isEmpty()) {


@@ -467,7 +473,7 @@ int KItemListView::lastVisibleIndex() const
     return m_layouter->lastVisibleIndex();
 }
 
     return m_layouter->lastVisibleIndex();
 }
 

-void KItemListView::calculateItemSizeHints(QVector<qreal>& logicalHeightHints, qreal& logicalWidthHint) const
+void KItemListView::calculateItemSizeHints(QVector<std::pair<qreal, bool>> &logicalHeightHints, qreal &logicalWidthHint) const

 {
     widgetCreator()->calculateItemSizeHints(logicalHeightHints, logicalWidthHint, this);
 }
 {
     widgetCreator()->calculateItemSizeHints(logicalHeightHints, logicalWidthHint, this);
 }


@@ -486,6 +492,32 @@ bool KItemListView::supportsItemExpanding() const
     return m_supportsItemExpanding;
 }
 
     return m_supportsItemExpanding;
 }
 

+void KItemListView::setHighlightEntireRow(bool highlightEntireRow)
+{
+    if (m_highlightEntireRow != highlightEntireRow) {
+        m_highlightEntireRow = highlightEntireRow;
+        onHighlightEntireRowChanged(highlightEntireRow);
+    }
+}
+
+bool KItemListView::highlightEntireRow() const
+{
+    return m_highlightEntireRow;
+}
+
+void KItemListView::setAlternateBackgrounds(bool alternate)
+{
+    if (m_alternateBackgrounds != alternate) {
+        m_alternateBackgrounds = alternate;
+        updateAlternateBackgrounds();
+    }
+}
+
+bool KItemListView::alternateBackgrounds() const
+{
+    return m_alternateBackgrounds;
+}
+

 QRectF KItemListView::itemRect(int index) const
 {
     return m_layouter->itemRect(index);
 QRectF KItemListView::itemRect(int index) const
 {
     return m_layouter->itemRect(index);


@@ -495,7 +527,7 @@ QRectF KItemListView::itemContextRect(int index) const
 {
     QRectF contextRect;
 
 {
     QRectF contextRect;
 

-    const KItemListWidget* widget = m_visibleItems.value(index);
+    const KItemListWidget *widget = m_visibleItems.value(index);

     if (widget) {
         contextRect = widget->iconRect() | widget->textRect();
         contextRect.translate(itemRect(index).topLeft());
     if (widget) {
         contextRect = widget->iconRect() | widget->textRect();
         contextRect.translate(itemRect(index).topLeft());


@@ -504,7 +536,12 @@ QRectF KItemListView::itemContextRect(int index) const
     return contextRect;
 }
 
     return contextRect;
 }
 

-void KItemListView::scrollToItem(int index)
+bool KItemListView::isElided(int index) const
+{
+    return m_sizeHintResolver->isElided(index);
+}
+
+void KItemListView::scrollToItem(int index, ViewItemPosition viewItemPosition)

 {
     QRectF viewGeometry = geometry();
     if (m_headerWidget->isVisible()) {
 {
     QRectF viewGeometry = geometry();
     if (m_headerWidget->isVisible()) {


@@ -513,30 +550,92 @@ void KItemListView::scrollToItem(int index)
     }
     QRectF currentRect = itemRect(index);
 
     }
     QRectF currentRect = itemRect(index);
 

-    // Fix for Bug 311099 - View the underscore when using Ctrl + PagDown
-    currentRect.adjust(-m_styleOption.horizontalMargin, -m_styleOption.verticalMargin,
-                        m_styleOption.horizontalMargin,  m_styleOption.verticalMargin);
+    if (layoutDirection() == Qt::RightToLeft && scrollOrientation() == Qt::Horizontal) {
+        currentRect.moveLeft(m_layouter->size().width() - currentRect.right());
+    }

 
 

-    if (!viewGeometry.contains(currentRect)) {
-        qreal newOffset = scrollOffset();
-        if (scrollOrientation() == Qt::Vertical) {
-            if (currentRect.top() < viewGeometry.top()) {
-                newOffset += currentRect.top() - viewGeometry.top();
-            } else if (currentRect.bottom() > viewGeometry.bottom()) {
-                newOffset += currentRect.bottom() - viewGeometry.bottom();
+    // Fix for Bug 311099 - View the underscore when using Ctrl + PageDown
+    currentRect.adjust(-m_styleOption.horizontalMargin, -m_styleOption.verticalMargin, m_styleOption.horizontalMargin, m_styleOption.verticalMargin);
+
+    qreal offset = 0;
+    switch (scrollOrientation()) {
+    case Qt::Vertical:
+        if (currentRect.top() < viewGeometry.top() || currentRect.bottom() > viewGeometry.bottom()) {
+            switch (viewItemPosition) {
+            case Beginning:
+                offset = currentRect.top() - viewGeometry.top();
+                break;
+            case Middle:
+                offset = 0.5 * (currentRect.top() + currentRect.bottom() - (viewGeometry.top() + viewGeometry.bottom()));
+                break;
+            case End:
+                offset = currentRect.bottom() - viewGeometry.bottom();
+                break;
+            case Nearest:
+                if (currentRect.top() < viewGeometry.top()) {
+                    offset = currentRect.top() - viewGeometry.top();
+                }
+                if (currentRect.bottom() > viewGeometry.bottom() + offset) {
+                    offset += currentRect.bottom() - viewGeometry.bottom() - offset;
+                }
+                break;
+            default:
+                Q_UNREACHABLE();

             }
             }

-        } else {
-            if (currentRect.left() < viewGeometry.left()) {
-                newOffset += currentRect.left() - viewGeometry.left();
-            } else if (currentRect.right() > viewGeometry.right()) {
-                newOffset += currentRect.right() - viewGeometry.right();
+        }
+        break;
+    case Qt::Horizontal:
+        if (currentRect.left() < viewGeometry.left() || currentRect.right() > viewGeometry.right()) {
+            switch (viewItemPosition) {
+            case Beginning:
+                if (layoutDirection() == Qt::RightToLeft) {
+                    offset = currentRect.right() - viewGeometry.right();
+                } else {
+                    offset = currentRect.left() - viewGeometry.left();
+                }
+                break;
+            case Middle:
+                offset = 0.5 * (currentRect.left() + currentRect.right() - (viewGeometry.left() + viewGeometry.right()));
+                break;
+            case End:
+                if (layoutDirection() == Qt::RightToLeft) {
+                    offset = currentRect.left() - viewGeometry.left();
+                } else {
+                    offset = currentRect.right() - viewGeometry.right();
+                }
+                break;
+            case Nearest:
+                if (layoutDirection() == Qt::RightToLeft) {
+                    if (currentRect.left() < viewGeometry.left()) {
+                        offset = currentRect.left() - viewGeometry.left();
+                    }
+                    if (currentRect.right() > viewGeometry.right() + offset) {
+                        offset += currentRect.right() - viewGeometry.right() - offset;
+                    }
+                } else {
+                    if (currentRect.right() > viewGeometry.right()) {
+                        offset = currentRect.right() - viewGeometry.right();
+                    }
+                    if (currentRect.left() < viewGeometry.left() + offset) {
+                        offset += currentRect.left() - viewGeometry.left() - offset;
+                    }
+                }
+                break;
+            default:
+                Q_UNREACHABLE();

             }
         }
             }
         }

+        break;
+    default:
+        Q_UNREACHABLE();
+    }

 
 

-        if (newOffset != scrollOffset()) {
-            emit scrollTo(newOffset);
-        }
+    if (!qFuzzyIsNull(offset)) {
+        Q_EMIT scrollTo(scrollOffset() + offset);
+        return;

     }
     }

+
+    Q_EMIT scrollingStopped();

 }
 
 void KItemListView::beginTransaction()
 }
 
 void KItemListView::beginTransaction()


@@ -571,8 +670,7 @@ void KItemListView::setHeaderVisible(bool visible)
 {
     if (visible && !m_headerWidget->isVisible()) {
         QStyleOptionHeader option;
 {
     if (visible && !m_headerWidget->isVisible()) {
         QStyleOptionHeader option;

-        const QSize headerSize = style()->sizeFromContents(QStyle::CT_HeaderSection,
-                                                           &option, QSize());
+        const QSize headerSize = style()->sizeFromContents(QStyle::CT_HeaderSection, &option, QSize());

 
         m_headerWidget->setPos(0, 0);
         m_headerWidget->resize(size().width(), headerSize.height());
 
         m_headerWidget->setPos(0, 0);
         m_headerWidget->resize(size().width(), headerSize.height());


@@ -580,26 +678,24 @@ void KItemListView::setHeaderVisible(bool visible)
         m_headerWidget->setColumns(m_visibleRoles);
         m_headerWidget->setZValue(1);
 
         m_headerWidget->setColumns(m_visibleRoles);
         m_headerWidget->setZValue(1);
 

-        connect(m_headerWidget, &KItemListHeaderWidget::columnWidthChanged,
-                this, &KItemListView::slotHeaderColumnWidthChanged);
-        connect(m_headerWidget, &KItemListHeaderWidget::columnMoved,
-                this, &KItemListView::slotHeaderColumnMoved);
-        connect(m_headerWidget, &KItemListHeaderWidget::sortOrderChanged,
-                this, &KItemListView::sortOrderChanged);
-        connect(m_headerWidget, &KItemListHeaderWidget::sortRoleChanged,
-                this, &KItemListView::sortRoleChanged);
+        connect(m_headerWidget, &KItemListHeaderWidget::columnWidthChanged, this, &KItemListView::slotHeaderColumnWidthChanged);
+        connect(m_headerWidget, &KItemListHeaderWidget::sidePaddingChanged, this, &KItemListView::slotSidePaddingChanged);
+        connect(m_headerWidget, &KItemListHeaderWidget::columnMoved, this, &KItemListView::slotHeaderColumnMoved);
+        connect(m_headerWidget, &KItemListHeaderWidget::sortOrderChanged, this, &KItemListView::sortOrderChanged);
+        connect(m_headerWidget, &KItemListHeaderWidget::sortRoleChanged, this, &KItemListView::sortRoleChanged);
+        connect(m_headerWidget, &KItemListHeaderWidget::columnHovered, this, &KItemListView::columnHovered);
+        connect(m_headerWidget, &KItemListHeaderWidget::columnUnHovered, this, &KItemListView::columnUnHovered);

 
         m_layouter->setHeaderHeight(headerSize.height());
         m_headerWidget->setVisible(true);
     } else if (!visible && m_headerWidget->isVisible()) {
 
         m_layouter->setHeaderHeight(headerSize.height());
         m_headerWidget->setVisible(true);
     } else if (!visible && m_headerWidget->isVisible()) {

-        disconnect(m_headerWidget, &KItemListHeaderWidget::columnWidthChanged,
-                   this, &KItemListView::slotHeaderColumnWidthChanged);
-        disconnect(m_headerWidget, &KItemListHeaderWidget::columnMoved,
-                   this, &KItemListView::slotHeaderColumnMoved);
-        disconnect(m_headerWidget, &KItemListHeaderWidget::sortOrderChanged,
-                   this, &KItemListView::sortOrderChanged);
-        disconnect(m_headerWidget, &KItemListHeaderWidget::sortRoleChanged,
-                   this, &KItemListView::sortRoleChanged);
+        disconnect(m_headerWidget, &KItemListHeaderWidget::columnWidthChanged, this, &KItemListView::slotHeaderColumnWidthChanged);
+        disconnect(m_headerWidget, &KItemListHeaderWidget::sidePaddingChanged, this, &KItemListView::slotSidePaddingChanged);
+        disconnect(m_headerWidget, &KItemListHeaderWidget::columnMoved, this, &KItemListView::slotHeaderColumnMoved);
+        disconnect(m_headerWidget, &KItemListHeaderWidget::sortOrderChanged, this, &KItemListView::sortOrderChanged);
+        disconnect(m_headerWidget, &KItemListHeaderWidget::sortRoleChanged, this, &KItemListView::sortRoleChanged);
+        disconnect(m_headerWidget, &KItemListHeaderWidget::columnHovered, this, &KItemListView::columnHovered);
+        disconnect(m_headerWidget, &KItemListHeaderWidget::columnUnHovered, this, &KItemListView::columnUnHovered);

 
         m_layouter->setHeaderHeight(0);
         m_headerWidget->setVisible(false);
 
         m_layouter->setHeaderHeight(0);
         m_headerWidget->setVisible(false);


@@ -611,18 +707,18 @@ bool KItemListView::isHeaderVisible() const
     return m_headerWidget->isVisible();
 }
 
     return m_headerWidget->isVisible();
 }
 

-KItemListHeader* KItemListView::header() const
+KItemListHeader *KItemListView::header() const

 {
     return m_header;
 }
 
 {
     return m_header;
 }
 

-QPixmap KItemListView::createDragPixmap(const KItemSet& indexes) const
+QPixmap KItemListView::createDragPixmap(const KItemSet &indexes) const

 {
     QPixmap pixmap;
 
     if (indexes.count() == 1) {
 {
     QPixmap pixmap;
 
     if (indexes.count() == 1) {

-        KItemListWidget* item = m_visibleItems.value(indexes.first());
-        QGraphicsView* graphicsView = scene()->views()[0];
+        KItemListWidget *item = m_visibleItems.value(indexes.first());
+        QGraphicsView *graphicsView = scene()->views()[0];

         if (item && graphicsView) {
             pixmap = item->createDragPixmap(nullptr, graphicsView);
         }
         if (item && graphicsView) {
             pixmap = item->createDragPixmap(nullptr, graphicsView);
         }


@@ -635,9 +731,9 @@ QPixmap KItemListView::createDragPixmap(const KItemSet& indexes) const
     return pixmap;
 }
 
     return pixmap;
 }
 

-void KItemListView::editRole(int index, const QByteArray& role)
+void KItemListView::editRole(int index, const QByteArray &role)

 {
 {

-    KStandardItemListWidget* widget = qobject_cast<KStandardItemListWidget *>(m_visibleItems.value(index));
+    KStandardItemListWidget *widget = qobject_cast<KStandardItemListWidget *>(m_visibleItems.value(index));

     if (!widget || m_editingRole) {
         return;
     }
     if (!widget || m_editingRole) {
         return;
     }


@@ -645,22 +741,42 @@ void KItemListView::editRole(int index, const QByteArray& role)
     m_editingRole = true;
     widget->setEditedRole(role);
 
     m_editingRole = true;
     widget->setEditedRole(role);
 

-    connect(widget, &KItemListWidget::roleEditingCanceled,
-            this, &KItemListView::slotRoleEditingCanceled);
-    connect(widget, &KItemListWidget::roleEditingFinished,
-            this, &KItemListView::slotRoleEditingFinished);
+    connect(widget, &KItemListWidget::roleEditingCanceled, this, &KItemListView::slotRoleEditingCanceled);
+    connect(widget, &KItemListWidget::roleEditingFinished, this, &KItemListView::slotRoleEditingFinished);

 
 

-    connect(this, &KItemListView::scrollOffsetChanged,
-            widget, &KStandardItemListWidget::finishRoleEditing);
+    connect(this, &KItemListView::scrollOffsetChanged, widget, &KStandardItemListWidget::finishRoleEditing);

 }
 
 }
 

-void KItemListView::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
+void KItemListView::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)

 {
     QGraphicsWidget::paint(painter, option, widget);
 
 {
     QGraphicsWidget::paint(painter, option, widget);
 

+    for (auto animation : std::as_const(m_rubberBandAnimations)) {
+        QRectF rubberBandRect = animation->property(RubberPropertyName).toRectF();
+
+        const QPointF topLeft = rubberBandRect.topLeft();
+        if (scrollOrientation() == Qt::Vertical) {
+            rubberBandRect.moveTo(topLeft.x(), topLeft.y() - scrollOffset());
+        } else {
+            rubberBandRect.moveTo(topLeft.x() - scrollOffset(), topLeft.y());
+        }
+
+        QStyleOptionRubberBand opt;
+        initStyleOption(&opt);
+        opt.shape = QRubberBand::Rectangle;
+        opt.opaque = false;
+        opt.rect = rubberBandRect.toRect();
+
+        painter->save();
+
+        painter->setOpacity(animation->currentValue().toReal());
+        style()->drawControl(QStyle::CE_RubberBand, &opt, painter);
+
+        painter->restore();
+    }
+

     if (m_rubberBand->isActive()) {
     if (m_rubberBand->isActive()) {

-        QRectF rubberBandRect = QRectF(m_rubberBand->startPosition(),
-                                       m_rubberBand->endPosition()).normalized();
+        QRectF rubberBandRect = QRectF(m_rubberBand->startPosition(), m_rubberBand->endPosition()).normalized();

 
         const QPointF topLeft = rubberBandRect.topLeft();
         if (scrollOrientation() == Qt::Vertical) {
 
         const QPointF topLeft = rubberBandRect.topLeft();
         if (scrollOrientation() == Qt::Vertical) {


@@ -670,7 +786,19 @@ void KItemListView::paint(QPainter* painter, const QStyleOptionGraphicsItem* opt
         }
 
         QStyleOptionRubberBand opt;
         }
 
         QStyleOptionRubberBand opt;

-        opt.initFrom(widget);
+        initStyleOption(&opt);
+        opt.shape = QRubberBand::Rectangle;
+        opt.opaque = false;
+        opt.rect = rubberBandRect.toRect();
+        style()->drawControl(QStyle::CE_RubberBand, &opt, painter);
+    }
+
+    if (m_tapAndHoldIndicator->isActive()) {
+        const QPointF indicatorSize = m_tapAndHoldIndicator->endPosition();
+        const QRectF rubberBandRect =
+            QRectF(m_tapAndHoldIndicator->startPosition() - indicatorSize, (m_tapAndHoldIndicator->startPosition()) + indicatorSize).normalized();
+        QStyleOptionRubberBand opt;
+        initStyleOption(&opt);

         opt.shape = QRubberBand::Rectangle;
         opt.opaque = false;
         opt.rect = rubberBandRect.toRect();
         opt.shape = QRubberBand::Rectangle;
         opt.opaque = false;
         opt.rect = rubberBandRect.toRect();


@@ -680,7 +808,7 @@ void KItemListView::paint(QPainter* painter, const QStyleOptionGraphicsItem* opt
     if (!m_dropIndicator.isEmpty()) {
         const QRectF r = m_dropIndicator.toRect();
 
     if (!m_dropIndicator.isEmpty()) {
         const QRectF r = m_dropIndicator.toRect();
 

-        QColor color = palette().brush(QPalette::Normal, QPalette::Highlight).color();
+        QColor color = palette().brush(QPalette::Normal, QPalette::Text).color();

         painter->setPen(color);
 
         // TODO: The following implementation works only for a vertical scroll-orientation
         painter->setPen(color);
 
         // TODO: The following implementation works only for a vertical scroll-orientation


@@ -704,7 +832,7 @@ QVariant KItemListView::itemChange(GraphicsItemChange change, const QVariant &va
     return QGraphicsItem::itemChange(change, value);
 }
 
     return QGraphicsItem::itemChange(change, value);
 }
 

-void KItemListView::setItemSize(const QSizeF& size)
+void KItemListView::setItemSize(const QSizeF &size)

 {
     const QSizeF previousSize = m_itemSize;
     if (size == previousSize) {
 {
     const QSizeF previousSize = m_itemSize;
     if (size == previousSize) {


@@ -714,13 +842,9 @@ void KItemListView::setItemSize(const QSizeF& size)
     // Skip animations when the number of rows or columns
     // are changed in the grid layout. Although the animation
     // engine can handle this usecase, it looks obtrusive.
     // Skip animations when the number of rows or columns
     // are changed in the grid layout. Although the animation
     // engine can handle this usecase, it looks obtrusive.

-    const bool animate = !changesItemGridLayout(m_layouter->size(),
-                                                size,
-                                                m_layouter->itemMargin());
+    const bool animate = !changesItemGridLayout(m_layouter->size(), size, m_layouter->itemMargin());

 
 

-    const bool alternateBackgroundsChanged = (m_visibleRoles.count() > 1) &&
-                                             (( m_itemSize.isEmpty() && !size.isEmpty()) ||
-                                              (!m_itemSize.isEmpty() && size.isEmpty()));
+    const bool alternateBackgroundsChanged = m_alternateBackgrounds && ((m_itemSize.isEmpty() && !size.isEmpty()) || (!m_itemSize.isEmpty() && size.isEmpty()));

 
     m_itemSize = size;
 
 
     m_itemSize = size;
 


@@ -750,7 +874,7 @@ void KItemListView::setItemSize(const QSizeF& size)
     onItemSizeChanged(size, previousSize);
 }
 
     onItemSizeChanged(size, previousSize);
 }
 

-void KItemListView::setStyleOption(const KItemListStyleOption& option)
+void KItemListView::setStyleOption(const KItemListStyleOption &option)

 {
     if (m_styleOption == option) {
         return;
 {
     if (m_styleOption == option) {
         return;


@@ -765,9 +889,7 @@ void KItemListView::setStyleOption(const KItemListStyleOption& option)
         // Skip animations when the number of rows or columns
         // are changed in the grid layout. Although the animation
         // engine can handle this usecase, it looks obtrusive.
         // Skip animations when the number of rows or columns
         // are changed in the grid layout. Although the animation
         // engine can handle this usecase, it looks obtrusive.

-        animate = !changesItemGridLayout(m_layouter->size(),
-                                         m_layouter->itemSize(),
-                                         margin);
+        animate = !changesItemGridLayout(m_layouter->size(), m_layouter->itemSize(), margin);

         m_layouter->setItemMargin(margin);
     }
 
         m_layouter->setItemMargin(margin);
     }
 


@@ -775,14 +897,13 @@ void KItemListView::setStyleOption(const KItemListStyleOption& option)
         updateGroupHeaderHeight();
     }
 
         updateGroupHeaderHeight();
     }
 

-    if (animate &&
-        (previousOption.maxTextLines != option.maxTextLines || previousOption.maxTextWidth != option.maxTextWidth)) {
+    if (animate && (previousOption.maxTextLines != option.maxTextLines || previousOption.maxTextWidth != option.maxTextWidth)) {

         // Animating a change of the maximum text size just results in expensive
         // temporary eliding and clipping operations and does not look good visually.
         animate = false;
     }
 
         // Animating a change of the maximum text size just results in expensive
         // temporary eliding and clipping operations and does not look good visually.
         animate = false;
     }
 

-    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    QHashIterator<int, KItemListWidget *> it(m_visibleItems);

     while (it.hasNext()) {
         it.next();
         it.value()->setStyleOption(option);
     while (it.hasNext()) {
         it.next();
         it.value()->setStyleOption(option);


@@ -811,19 +932,18 @@ void KItemListView::setScrollOrientation(Qt::Orientation orientation)
     m_sizeHintResolver->clearCache();
 
     if (m_grouped) {
     m_sizeHintResolver->clearCache();
 
     if (m_grouped) {

-        QMutableHashIterator<KItemListWidget*, KItemListGroupHeader*> it (m_visibleGroups);
+        QMutableHashIterator<KItemListWidget *, KItemListGroupHeader *> it(m_visibleGroups);

         while (it.hasNext()) {
             it.next();
             it.value()->setScrollOrientation(orientation);
         }
         updateGroupHeaderHeight();
         while (it.hasNext()) {
             it.next();
             it.value()->setScrollOrientation(orientation);
         }
         updateGroupHeaderHeight();

-

     }
 
     doLayout(NoAnimation);
 
     onScrollOrientationChanged(orientation, previousOrientation);
     }
 
     doLayout(NoAnimation);
 
     onScrollOrientationChanged(orientation, previousOrientation);

-    emit scrollOrientationChanged(orientation, previousOrientation);
+    Q_EMIT scrollOrientationChanged(orientation, previousOrientation);

 }
 
 Qt::Orientation KItemListView::scrollOrientation() const
 }
 
 Qt::Orientation KItemListView::scrollOrientation() const


@@ -831,72 +951,77 @@ Qt::Orientation KItemListView::scrollOrientation() const
     return m_layouter->scrollOrientation();
 }
 
     return m_layouter->scrollOrientation();
 }
 

-KItemListWidgetCreatorBase* KItemListView::defaultWidgetCreator() const
+KItemListWidgetCreatorBase *KItemListView::defaultWidgetCreator() const

 {
     return nullptr;
 }
 
 {
     return nullptr;
 }
 

-KItemListGroupHeaderCreatorBase* KItemListView::defaultGroupHeaderCreator() const
+KItemListGroupHeaderCreatorBase *KItemListView::defaultGroupHeaderCreator() const

 {
     return nullptr;
 }
 
 {
     return nullptr;
 }
 

-void KItemListView::initializeItemListWidget(KItemListWidget* item)
+void KItemListView::initializeItemListWidget(KItemListWidget *item)

 {
 {

-    Q_UNUSED(item);
+    Q_UNUSED(item)

 }
 
 }
 

-bool KItemListView::itemSizeHintUpdateRequired(const QSet<QByteArray>& changedRoles) const
+bool KItemListView::itemSizeHintUpdateRequired(const QSet<QByteArray> &changedRoles) const

 {
 {

-    Q_UNUSED(changedRoles);
+    Q_UNUSED(changedRoles)

     return true;
 }
 
     return true;
 }
 

-void KItemListView::onControllerChanged(KItemListController* current, KItemListController* previous)
+void KItemListView::onControllerChanged(KItemListController *current, KItemListController *previous)

 {
 {

-    Q_UNUSED(current);
-    Q_UNUSED(previous);
+    Q_UNUSED(current)
+    Q_UNUSED(previous)

 }
 
 }
 

-void KItemListView::onModelChanged(KItemModelBase* current, KItemModelBase* previous)
+void KItemListView::onModelChanged(KItemModelBase *current, KItemModelBase *previous)

 {
 {

-    Q_UNUSED(current);
-    Q_UNUSED(previous);
+    Q_UNUSED(current)
+    Q_UNUSED(previous)

 }
 
 void KItemListView::onScrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous)
 {
 }
 
 void KItemListView::onScrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous)
 {

-    Q_UNUSED(current);
-    Q_UNUSED(previous);
+    Q_UNUSED(current)
+    Q_UNUSED(previous)

 }
 
 }
 

-void KItemListView::onItemSizeChanged(const QSizeF& current, const QSizeF& previous)
+void KItemListView::onItemSizeChanged(const QSizeF &current, const QSizeF &previous)

 {
 {

-    Q_UNUSED(current);
-    Q_UNUSED(previous);
+    Q_UNUSED(current)
+    Q_UNUSED(previous)

 }
 
 void KItemListView::onScrollOffsetChanged(qreal current, qreal previous)
 {
 }
 
 void KItemListView::onScrollOffsetChanged(qreal current, qreal previous)
 {

-    Q_UNUSED(current);
-    Q_UNUSED(previous);
+    Q_UNUSED(current)
+    Q_UNUSED(previous)
+}
+
+void KItemListView::onVisibleRolesChanged(const QList<QByteArray> &current, const QList<QByteArray> &previous)
+{
+    Q_UNUSED(current)
+    Q_UNUSED(previous)

 }
 
 }
 

-void KItemListView::onVisibleRolesChanged(const QList<QByteArray>& current, const QList<QByteArray>& previous)
+void KItemListView::onStyleOptionChanged(const KItemListStyleOption &current, const KItemListStyleOption &previous)

 {
 {

-    Q_UNUSED(current);
-    Q_UNUSED(previous);
+    Q_UNUSED(current)
+    Q_UNUSED(previous)

 }
 
 }
 

-void KItemListView::onStyleOptionChanged(const KItemListStyleOption& current, const KItemListStyleOption& previous)
+void KItemListView::onHighlightEntireRowChanged(bool highlightEntireRow)

 {
 {

-    Q_UNUSED(current);
-    Q_UNUSED(previous);
+    Q_UNUSED(highlightEntireRow)

 }
 
 void KItemListView::onSupportsItemExpandingChanged(bool supportsExpanding)
 {
 }
 
 void KItemListView::onSupportsItemExpandingChanged(bool supportsExpanding)
 {

-    Q_UNUSED(supportsExpanding);
+    Q_UNUSED(supportsExpanding)

 }
 
 void KItemListView::onTransactionBegin()
 }
 
 void KItemListView::onTransactionBegin()


@@ -907,7 +1032,7 @@ void KItemListView::onTransactionEnd()
 {
 }
 
 {
 }
 

-bool KItemListView::event(QEvent* event)
+bool KItemListView::event(QEvent *event)

 {
     switch (event->type()) {
     case QEvent::PaletteChange:
 {
     switch (event->type()) {
     case QEvent::PaletteChange:


@@ -918,6 +1043,18 @@ bool KItemListView::event(QEvent* event)
         updateFont();
         break;
 
         updateFont();
         break;
 

+    case QEvent::FocusIn:
+        focusInEvent(static_cast<QFocusEvent *>(event));
+        event->accept();
+        return true;
+        break;
+
+    case QEvent::FocusOut:
+        focusOutEvent(static_cast<QFocusEvent *>(event));
+        event->accept();
+        return true;
+        break;
+

     default:
         // Forward all other events to the controller and handle them there
         if (!m_editingRole && m_controller && m_controller->processEvent(event, transform())) {
     default:
         // Forward all other events to the controller and handle them there
         if (!m_editingRole && m_controller && m_controller->processEvent(event, transform())) {


@@ -929,13 +1066,13 @@ bool KItemListView::event(QEvent* event)
     return QGraphicsWidget::event(event);
 }
 
     return QGraphicsWidget::event(event);
 }
 

-void KItemListView::mousePressEvent(QGraphicsSceneMouseEvent* event)
+void KItemListView::mousePressEvent(QGraphicsSceneMouseEvent *event)

 {
     m_mousePos = transform().map(event->pos());
     event->accept();
 }
 
 {
     m_mousePos = transform().map(event->pos());
     event->accept();
 }
 

-void KItemListView::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
+void KItemListView::mouseMoveEvent(QGraphicsSceneMouseEvent *event)

 {
     QGraphicsWidget::mouseMoveEvent(event);
 
 {
     QGraphicsWidget::mouseMoveEvent(event);
 


@@ -945,13 +1082,13 @@ void KItemListView::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
     }
 }
 
     }
 }
 

-void KItemListView::dragEnterEvent(QGraphicsSceneDragDropEvent* event)
+void KItemListView::dragEnterEvent(QGraphicsSceneDragDropEvent *event)

 {
     event->setAccepted(true);
     setAutoScroll(true);
 }
 
 {
     event->setAccepted(true);
     setAutoScroll(true);
 }
 

-void KItemListView::dragMoveEvent(QGraphicsSceneDragDropEvent* event)
+void KItemListView::dragMoveEvent(QGraphicsSceneDragDropEvent *event)

 {
     QGraphicsWidget::dragMoveEvent(event);
 
 {
     QGraphicsWidget::dragMoveEvent(event);
 


@@ -961,19 +1098,19 @@ void KItemListView::dragMoveEvent(QGraphicsSceneDragDropEvent* event)
     }
 }
 
     }
 }
 

-void KItemListView::dragLeaveEvent(QGraphicsSceneDragDropEvent* event)
+void KItemListView::dragLeaveEvent(QGraphicsSceneDragDropEvent *event)

 {
     QGraphicsWidget::dragLeaveEvent(event);
     setAutoScroll(false);
 }
 
 {
     QGraphicsWidget::dragLeaveEvent(event);
     setAutoScroll(false);
 }
 

-void KItemListView::dropEvent(QGraphicsSceneDragDropEvent* event)
+void KItemListView::dropEvent(QGraphicsSceneDragDropEvent *event)

 {
     QGraphicsWidget::dropEvent(event);
     setAutoScroll(false);
 }
 
 {
     QGraphicsWidget::dropEvent(event);
     setAutoScroll(false);
 }
 

-QList<KItemListWidget*> KItemListView::visibleItemListWidgets() const
+QList<KItemListWidget *> KItemListView::visibleItemListWidgets() const

 {
     return m_visibleItems.values();
 }
 {
     return m_visibleItems.values();
 }


@@ -991,15 +1128,12 @@ void KItemListView::updateFont()
 
 void KItemListView::updatePalette()
 {
 
 void KItemListView::updatePalette()
 {

-    if (scene() && !scene()->views().isEmpty()) {
-        KItemListStyleOption option = styleOption();
-        option.palette = scene()->views().first()->palette();
-
-        setStyleOption(option);
-    }
+    KItemListStyleOption option = styleOption();
+    option.palette = palette();
+    setStyleOption(option);

 }
 
 }
 

-void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
+void KItemListView::slotItemsInserted(const KItemRangeList &itemRanges)

 {
     if (m_itemSize.isEmpty()) {
         updatePreferredColumnWidths(itemRanges);
 {
     if (m_itemSize.isEmpty()) {
         updatePreferredColumnWidths(itemRanges);


@@ -1015,7 +1149,7 @@ void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
     m_sizeHintResolver->itemsInserted(itemRanges);
 
     int previouslyInsertedCount = 0;
     m_sizeHintResolver->itemsInserted(itemRanges);
 
     int previouslyInsertedCount = 0;

-    foreach (const KItemRange& range, itemRanges) {
+    for (const KItemRange &range : itemRanges) {

         // range.index is related to the model before anything has been inserted.
         // As in each loop the current item-range gets inserted the index must
         // be increased by the already previously inserted items.
         // range.index is related to the model before anything has been inserted.
         // As in each loop the current item-range gets inserted the index must
         // be increased by the already previously inserted items.


@@ -1029,7 +1163,7 @@ void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
 
         // Determine which visible items must be moved
         QList<int> itemsToMove;
 
         // Determine which visible items must be moved
         QList<int> itemsToMove;

-        QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+        QHashIterator<int, KItemListWidget *> it(m_visibleItems);

         while (it.hasNext()) {
             it.next();
             const int visibleItemIndex = it.key();
         while (it.hasNext()) {
             it.next();
             const int visibleItemIndex = it.key();


@@ -1041,9 +1175,9 @@ void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
         // Update the indexes of all KItemListWidget instances that are located
         // after the inserted items. It is important to adjust the indexes in the order
         // from the highest index to the lowest index to prevent overlaps when setting the new index.
         // Update the indexes of all KItemListWidget instances that are located
         // after the inserted items. It is important to adjust the indexes in the order
         // from the highest index to the lowest index to prevent overlaps when setting the new index.

-        qSort(itemsToMove);
+        std::sort(itemsToMove.begin(), itemsToMove.end());

         for (int i = itemsToMove.count() - 1; i >= 0; --i) {
         for (int i = itemsToMove.count() - 1; i >= 0; --i) {

-            KItemListWidget* widget = m_visibleItems.value(itemsToMove[i]);
+            KItemListWidget *widget = m_visibleItems.value(itemsToMove[i]);

             Q_ASSERT(widget);
             const int newIndex = widget->index() + count;
             if (hasMultipleRanges) {
             Q_ASSERT(widget);
             const int newIndex = widget->index() + count;
             if (hasMultipleRanges) {


@@ -1059,8 +1193,8 @@ void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
             // the size of the layouter will be decreased before calling doLayout(): This prevents
             // an unnecessary temporary animation due to the geometry change of the inserted scrollbar.
             const bool verticalScrollOrientation = (scrollOrientation() == Qt::Vertical);
             // the size of the layouter will be decreased before calling doLayout(): This prevents
             // an unnecessary temporary animation due to the geometry change of the inserted scrollbar.
             const bool verticalScrollOrientation = (scrollOrientation() == Qt::Vertical);

-            const bool decreaseLayouterSize = ( verticalScrollOrientation && maximumScrollOffset() > size().height()) ||
-                                              (!verticalScrollOrientation && maximumScrollOffset() > size().width());
+            const bool decreaseLayouterSize = (verticalScrollOrientation && maximumScrollOffset() > size().height())
+                || (!verticalScrollOrientation && maximumScrollOffset() > size().width());

             if (decreaseLayouterSize) {
                 const int scrollBarExtent = style()->pixelMetric(QStyle::PM_ScrollBarExtent);
 
             if (decreaseLayouterSize) {
                 const int scrollBarExtent = style()->pixelMetric(QStyle::PM_ScrollBarExtent);
 


@@ -1108,7 +1242,7 @@ void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
     }
 }
 
     }
 }
 

-void KItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
+void KItemListView::slotItemsRemoved(const KItemRangeList &itemRanges)

 {
     if (m_itemSize.isEmpty()) {
         // Don't pass the item-range: The preferred column-widths of
 {
     if (m_itemSize.isEmpty()) {
         // Don't pass the item-range: The preferred column-widths of


@@ -1126,7 +1260,7 @@ void KItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
     m_sizeHintResolver->itemsRemoved(itemRanges);
 
     for (int i = itemRanges.count() - 1; i >= 0; --i) {
     m_sizeHintResolver->itemsRemoved(itemRanges);
 
     for (int i = itemRanges.count() - 1; i >= 0; --i) {

-        const KItemRange& range = itemRanges[i];
+        const KItemRange &range = itemRanges[i];

         const int index = range.index;
         const int count = range.count;
         if (index < 0 || count <= 0) {
         const int index = range.index;
         const int count = range.count;
         if (index < 0 || count <= 0) {


@@ -1141,7 +1275,10 @@ void KItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
         QVector<int> itemsToMove;
 
         // Remove all KItemListWidget instances that got deleted
         QVector<int> itemsToMove;
 
         // Remove all KItemListWidget instances that got deleted

-        foreach (KItemListWidget* widget, m_visibleItems) {
+        // Iterate over a const copy because the container is mutated within the loop
+        // directly and in `recycleWidget()` (https://bugs.kde.org/show_bug.cgi?id=428374)
+        const auto visibleItems = m_visibleItems;
+        for (KItemListWidget *widget : visibleItems) {

             const int i = widget->index();
             if (i < firstRemovedIndex) {
                 continue;
             const int i = widget->index();
             if (i < firstRemovedIndex) {
                 continue;


@@ -1177,8 +1314,8 @@ void KItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
         // after the deleted items. It is important to update them in ascending
         // order to prevent overlaps when setting the new index.
         std::sort(itemsToMove.begin(), itemsToMove.end());
         // after the deleted items. It is important to update them in ascending
         // order to prevent overlaps when setting the new index.
         std::sort(itemsToMove.begin(), itemsToMove.end());

-        foreach (int i, itemsToMove) {
-            KItemListWidget* widget = m_visibleItems.value(i);
+        for (int i : std::as_const(itemsToMove)) {
+            KItemListWidget *widget = m_visibleItems.value(i);

             Q_ASSERT(widget);
             const int newIndex = i - count;
             if (hasMultipleRanges) {
             Q_ASSERT(widget);
             const int newIndex = i - count;
             if (hasMultipleRanges) {


@@ -1223,7 +1360,7 @@ void KItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
     }
 }
 
     }
 }
 

-void KItemListView::slotItemsMoved(const KItemRange& itemRange, const QList<int>& movedToIndexes)
+void KItemListView::slotItemsMoved(const KItemRange &itemRange, const QList<int> &movedToIndexes)

 {
     m_sizeHintResolver->itemsMoved(itemRange, movedToIndexes);
     m_layouter->markAsDirty();
 {
     m_sizeHintResolver->itemsMoved(itemRange, movedToIndexes);
     m_layouter->markAsDirty();


@@ -1236,7 +1373,7 @@ void KItemListView::slotItemsMoved(const KItemRange& itemRange, const QList<int>
     const int lastVisibleMovedIndex = qMin(lastVisibleIndex(), itemRange.index + itemRange.count - 1);
 
     for (int index = firstVisibleMovedIndex; index <= lastVisibleMovedIndex; ++index) {
     const int lastVisibleMovedIndex = qMin(lastVisibleIndex(), itemRange.index + itemRange.count - 1);
 
     for (int index = firstVisibleMovedIndex; index <= lastVisibleMovedIndex; ++index) {

-        KItemListWidget* widget = m_visibleItems.value(index);
+        KItemListWidget *widget = m_visibleItems.value(index);

         if (widget) {
             updateWidgetProperties(widget, index);
             initializeItemListWidget(widget);
         if (widget) {
             updateWidgetProperties(widget, index);
             initializeItemListWidget(widget);


@@ -1247,31 +1384,26 @@ void KItemListView::slotItemsMoved(const KItemRange& itemRange, const QList<int>
     updateSiblingsInformation();
 }
 
     updateSiblingsInformation();
 }
 

-void KItemListView::slotItemsChanged(const KItemRangeList& itemRanges,
-                                     const QSet<QByteArray>& roles)
+void KItemListView::slotItemsChanged(const KItemRangeList &itemRanges, const QSet<QByteArray> &roles)

 {
     const bool updateSizeHints = itemSizeHintUpdateRequired(roles);
     if (updateSizeHints && m_itemSize.isEmpty()) {
         updatePreferredColumnWidths(itemRanges);
     }
 
 {
     const bool updateSizeHints = itemSizeHintUpdateRequired(roles);
     if (updateSizeHints && m_itemSize.isEmpty()) {
         updatePreferredColumnWidths(itemRanges);
     }
 

-    foreach (const KItemRange& itemRange, itemRanges) {
+    for (const KItemRange &itemRange : itemRanges) {

         const int index = itemRange.index;
         const int count = itemRange.count;
 
         if (updateSizeHints) {
             m_sizeHintResolver->itemsChanged(index, count, roles);
             m_layouter->markAsDirty();
         const int index = itemRange.index;
         const int count = itemRange.count;
 
         if (updateSizeHints) {
             m_sizeHintResolver->itemsChanged(index, count, roles);
             m_layouter->markAsDirty();

-
-            if (!m_layoutTimer->isActive()) {
-                m_layoutTimer->start();
-            }

         }
 
         // Apply the changed roles to the visible item-widgets
         const int lastIndex = index + count - 1;
         for (int i = index; i <= lastIndex; ++i) {
         }
 
         // Apply the changed roles to the visible item-widgets
         const int lastIndex = index + count - 1;
         for (int i = index; i <= lastIndex; ++i) {

-            KItemListWidget* widget = m_visibleItems.value(i);
+            KItemListWidget *widget = m_visibleItems.value(i);

             if (widget) {
                 widget->setData(m_model->data(i), roles);
             }
             if (widget) {
                 widget->setData(m_model->data(i), roles);
             }


@@ -1289,6 +1421,8 @@ void KItemListView::slotItemsChanged(const KItemRangeList& itemRanges,
         ev.setLastRow(itemRange.index + itemRange.count);
         QAccessible::updateAccessibility(&ev);
     }
         ev.setLastRow(itemRange.index + itemRange.count);
         QAccessible::updateAccessibility(&ev);
     }

+
+    doLayout(NoAnimation);

 }
 
 void KItemListView::slotGroupsChanged()
 }
 
 void KItemListView::slotGroupsChanged()


@@ -1309,7 +1443,7 @@ void KItemListView::slotGroupedSortingChanged(bool current)
         // Clear all visible headers. Note that the QHashIterator takes a copy of
         // m_visibleGroups. Therefore, it remains valid even if items are removed
         // from m_visibleGroups in recycleGroupHeaderForWidget().
         // Clear all visible headers. Note that the QHashIterator takes a copy of
         // m_visibleGroups. Therefore, it remains valid even if items are removed
         // from m_visibleGroups in recycleGroupHeaderForWidget().

-        QHashIterator<KItemListWidget*, KItemListGroupHeader*> it(m_visibleGroups);
+        QHashIterator<KItemListWidget *, KItemListGroupHeader *> it(m_visibleGroups);

         while (it.hasNext()) {
             it.next();
             recycleGroupHeaderForWidget(it.key());
         while (it.hasNext()) {
             it.next();
             recycleGroupHeaderForWidget(it.key());


@@ -1329,18 +1463,38 @@ void KItemListView::slotGroupedSortingChanged(bool current)
 
 void KItemListView::slotSortOrderChanged(Qt::SortOrder current, Qt::SortOrder previous)
 {
 
 void KItemListView::slotSortOrderChanged(Qt::SortOrder current, Qt::SortOrder previous)
 {

-    Q_UNUSED(current);
-    Q_UNUSED(previous);
+    Q_UNUSED(current)
+    Q_UNUSED(previous)
+    if (m_grouped) {
+        updateVisibleGroupHeaders();
+        doLayout(NoAnimation);
+    }
+}
+
+void KItemListView::slotSortRoleChanged(const QByteArray &current, const QByteArray &previous)
+{
+    Q_UNUSED(current)
+    Q_UNUSED(previous)

     if (m_grouped) {
         updateVisibleGroupHeaders();
         doLayout(NoAnimation);
     }
 }
 
     if (m_grouped) {
         updateVisibleGroupHeaders();
         doLayout(NoAnimation);
     }
 }
 

-void KItemListView::slotSortRoleChanged(const QByteArray& current, const QByteArray& previous)
+void KItemListView::slotGroupOrderChanged(Qt::SortOrder current, Qt::SortOrder previous)

 {
 {

-    Q_UNUSED(current);
-    Q_UNUSED(previous);
+    Q_UNUSED(current)
+    Q_UNUSED(previous)
+    if (m_grouped) {
+        updateVisibleGroupHeaders();
+        doLayout(NoAnimation);
+    }
+}
+
+void KItemListView::slotGroupRoleChanged(const QByteArray &current, const QByteArray &previous)
+{
+    Q_UNUSED(current)
+    Q_UNUSED(previous)

     if (m_grouped) {
         updateVisibleGroupHeaders();
         doLayout(NoAnimation);
     if (m_grouped) {
         updateVisibleGroupHeaders();
         doLayout(NoAnimation);


@@ -1349,17 +1503,17 @@ void KItemListView::slotSortRoleChanged(const QByteArray& current, const QByteAr
 
 void KItemListView::slotCurrentChanged(int current, int previous)
 {
 
 void KItemListView::slotCurrentChanged(int current, int previous)
 {

-    Q_UNUSED(previous);
+    Q_UNUSED(previous)

 
     // In SingleSelection mode (e.g., in the Places Panel), the current item is
     // always the selected item. It is not necessary to highlight the current item then.
     if (m_controller->selectionBehavior() != KItemListController::SingleSelection) {
 
     // In SingleSelection mode (e.g., in the Places Panel), the current item is
     // always the selected item. It is not necessary to highlight the current item then.
     if (m_controller->selectionBehavior() != KItemListController::SingleSelection) {

-        KItemListWidget* previousWidget = m_visibleItems.value(previous, 0);
+        KItemListWidget *previousWidget = m_visibleItems.value(previous, nullptr);

         if (previousWidget) {
             previousWidget->setCurrent(false);
         }
 
         if (previousWidget) {
             previousWidget->setCurrent(false);
         }
 

-        KItemListWidget* currentWidget = m_visibleItems.value(current, 0);
+        KItemListWidget *currentWidget = m_visibleItems.value(current, nullptr);

         if (currentWidget) {
             currentWidget->setCurrent(true);
         }
         if (currentWidget) {
             currentWidget->setCurrent(true);
         }


@@ -1370,27 +1524,25 @@ void KItemListView::slotCurrentChanged(int current, int previous)
     QAccessible::updateAccessibility(&ev);
 }
 
     QAccessible::updateAccessibility(&ev);
 }
 

-void KItemListView::slotSelectionChanged(const KItemSet& current, const KItemSet& previous)
+void KItemListView::slotSelectionChanged(const KItemSet &current, const KItemSet &previous)

 {
 {

-    Q_UNUSED(previous);
+    Q_UNUSED(previous)

 
 

-    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    QHashIterator<int, KItemListWidget *> it(m_visibleItems);

     while (it.hasNext()) {
         it.next();
         const int index = it.key();
     while (it.hasNext()) {
         it.next();
         const int index = it.key();

-        KItemListWidget* widget = it.value();
+        KItemListWidget *widget = it.value();

         widget->setSelected(current.contains(index));
     }
 }
 
         widget->setSelected(current.contains(index));
     }
 }
 

-void KItemListView::slotAnimationFinished(QGraphicsWidget* widget,
-                                          KItemListViewAnimation::AnimationType type)
+void KItemListView::slotAnimationFinished(QGraphicsWidget *widget, KItemListViewAnimation::AnimationType type)

 {
 {

-    KItemListWidget* itemListWidget = qobject_cast<KItemListWidget*>(widget);
+    KItemListWidget *itemListWidget = qobject_cast<KItemListWidget *>(widget);

     Q_ASSERT(itemListWidget);
 
     Q_ASSERT(itemListWidget);
 

-    switch (type) {
-    case KItemListViewAnimation::DeleteAnimation: {
+    if (type == KItemListViewAnimation::DeleteAnimation) {

         // As we recycle the widget in this case it is important to assure that no
         // other animation has been started. This is a convention in KItemListView and
         // not a requirement defined by KItemListViewAnimation.
         // As we recycle the widget in this case it is important to assure that no
         // other animation has been started. This is a convention in KItemListView and
         // not a requirement defined by KItemListViewAnimation.


@@ -1401,31 +1553,15 @@ void KItemListView::slotAnimationFinished(QGraphicsWidget* widget,
         // been finished.
         recycleGroupHeaderForWidget(itemListWidget);
         widgetCreator()->recycle(itemListWidget);
         // been finished.
         recycleGroupHeaderForWidget(itemListWidget);
         widgetCreator()->recycle(itemListWidget);

-        break;
-    }
-
-    case KItemListViewAnimation::CreateAnimation:
-    case KItemListViewAnimation::MovingAnimation:
-    case KItemListViewAnimation::ResizeAnimation: {
+    } else {

         const int index = itemListWidget->index();
         const int index = itemListWidget->index();

-        const bool invisible = (index < m_layouter->firstVisibleIndex()) ||
-                               (index > m_layouter->lastVisibleIndex());
+        const bool invisible = (index < m_layouter->firstVisibleIndex()) || (index > m_layouter->lastVisibleIndex());

         if (invisible && !m_animation->isStarted(itemListWidget)) {
             recycleWidget(itemListWidget);
         }
         if (invisible && !m_animation->isStarted(itemListWidget)) {
             recycleWidget(itemListWidget);
         }

-        break;
-    }
-
-    default: break;

     }
 }
 
     }
 }
 

-void KItemListView::slotLayoutTimerFinished()
-{
-    m_layouter->setSize(geometry().size());
-    doLayout(Animation);
-}
-

 void KItemListView::slotRubberBandPosChanged()
 {
     update();
 void KItemListView::slotRubberBandPosChanged()
 {
     update();


@@ -1438,6 +1574,29 @@ void KItemListView::slotRubberBandActivationChanged(bool active)
         connect(m_rubberBand, &KItemListRubberBand::endPositionChanged, this, &KItemListView::slotRubberBandPosChanged);
         m_skipAutoScrollForRubberBand = true;
     } else {
         connect(m_rubberBand, &KItemListRubberBand::endPositionChanged, this, &KItemListView::slotRubberBandPosChanged);
         m_skipAutoScrollForRubberBand = true;
     } else {

+        QRectF rubberBandRect = QRectF(m_rubberBand->startPosition(), m_rubberBand->endPosition()).normalized();
+
+        auto animation = new QVariantAnimation(this);
+        animation->setStartValue(1.0);
+        animation->setEndValue(0.0);
+        animation->setDuration(RubberFadeSpeed);
+        animation->setProperty(RubberPropertyName, rubberBandRect);
+
+        QEasingCurve curve;
+        curve.setType(QEasingCurve::BezierSpline);
+        curve.addCubicBezierSegment(QPointF(0.4, 0.0), QPointF(1.0, 1.0), QPointF(1.0, 1.0));
+        animation->setEasingCurve(curve);
+
+        connect(animation, &QVariantAnimation::valueChanged, this, [=](const QVariant &) {
+            update();
+        });
+        connect(animation, &QVariantAnimation::finished, this, [=]() {
+            m_rubberBandAnimations.removeAll(animation);
+            delete animation;
+        });
+        animation->start();
+        m_rubberBandAnimations << animation;
+

         disconnect(m_rubberBand, &KItemListRubberBand::startPositionChanged, this, &KItemListView::slotRubberBandPosChanged);
         disconnect(m_rubberBand, &KItemListRubberBand::endPositionChanged, this, &KItemListView::slotRubberBandPosChanged);
         m_skipAutoScrollForRubberBand = false;
         disconnect(m_rubberBand, &KItemListRubberBand::startPositionChanged, this, &KItemListView::slotRubberBandPosChanged);
         disconnect(m_rubberBand, &KItemListRubberBand::endPositionChanged, this, &KItemListView::slotRubberBandPosChanged);
         m_skipAutoScrollForRubberBand = false;


@@ -1446,22 +1605,28 @@ void KItemListView::slotRubberBandActivationChanged(bool active)
     update();
 }
 
     update();
 }
 

-void KItemListView::slotHeaderColumnWidthChanged(const QByteArray& role,
-                                                 qreal currentWidth,
-                                                 qreal previousWidth)
+void KItemListView::slotHeaderColumnWidthChanged(const QByteArray &role, qreal currentWidth, qreal previousWidth)

 {
 {

-    Q_UNUSED(role);
-    Q_UNUSED(currentWidth);
-    Q_UNUSED(previousWidth);
+    Q_UNUSED(role)
+    Q_UNUSED(currentWidth)
+    Q_UNUSED(previousWidth)

 
     m_headerWidget->setAutomaticColumnResizing(false);
     applyColumnWidthsFromHeader();
     doLayout(NoAnimation);
 }
 
 
     m_headerWidget->setAutomaticColumnResizing(false);
     applyColumnWidthsFromHeader();
     doLayout(NoAnimation);
 }
 

-void KItemListView::slotHeaderColumnMoved(const QByteArray& role,
-                                          int currentIndex,
-                                          int previousIndex)
+void KItemListView::slotSidePaddingChanged(qreal width)
+{
+    Q_UNUSED(width)
+    if (m_headerWidget->automaticColumnResizing()) {
+        applyAutomaticColumnWidths();
+    }
+    applyColumnWidthsFromHeader();
+    doLayout(NoAnimation);
+}
+
+void KItemListView::slotHeaderColumnMoved(const QByteArray &role, int currentIndex, int previousIndex)

 {
     Q_ASSERT(m_visibleRoles[previousIndex] == role);
 
 {
     Q_ASSERT(m_visibleRoles[previousIndex] == role);
 


@@ -1473,7 +1638,7 @@ void KItemListView::slotHeaderColumnMoved(const QByteArray& role,
 
     setVisibleRoles(current);
 
 
     setVisibleRoles(current);
 

-    emit visibleRolesChanged(current, previous);
+    Q_EMIT visibleRolesChanged(current, previous);

 }
 
 void KItemListView::triggerAutoScrolling()
 }
 
 void KItemListView::triggerAutoScrolling()


@@ -1511,9 +1676,8 @@ void KItemListView::triggerAutoScrolling()
         // an autoscrolling.
 
         const qreal minDiff = 4; // Ignore any autoscrolling if the rubberband is very small
         // an autoscrolling.
 
         const qreal minDiff = 4; // Ignore any autoscrolling if the rubberband is very small

-        const qreal diff = (scrollOrientation() == Qt::Vertical)
-                           ? m_rubberBand->endPosition().y() - m_rubberBand->startPosition().y()
-                           : m_rubberBand->endPosition().x() - m_rubberBand->startPosition().x();
+        const qreal diff = (scrollOrientation() == Qt::Vertical) ? m_rubberBand->endPosition().y() - m_rubberBand->startPosition().y()
+                                                                 : m_rubberBand->endPosition().x() - m_rubberBand->startPosition().x();

         if (qAbs(diff) < minDiff || (m_autoScrollIncrement < 0 && diff > 0) || (m_autoScrollIncrement > 0 && diff < 0)) {
             // The rubberband direction is different from the scroll direction (e.g. the rubberband has
             // been moved up although the autoscroll direction might be down)
         if (qAbs(diff) < minDiff || (m_autoScrollIncrement < 0 && diff > 0) || (m_autoScrollIncrement > 0 && diff < 0)) {
             // The rubberband direction is different from the scroll direction (e.g. the rubberband has
             // been moved up although the autoscroll direction might be down)


@@ -1537,35 +1701,35 @@ void KItemListView::triggerAutoScrolling()
 
 void KItemListView::slotGeometryOfGroupHeaderParentChanged()
 {
 
 void KItemListView::slotGeometryOfGroupHeaderParentChanged()
 {

-    KItemListWidget* widget = qobject_cast<KItemListWidget*>(sender());
+    KItemListWidget *widget = qobject_cast<KItemListWidget *>(sender());

     Q_ASSERT(widget);
     Q_ASSERT(widget);

-    KItemListGroupHeader* groupHeader = m_visibleGroups.value(widget);
+    KItemListGroupHeader *groupHeader = m_visibleGroups.value(widget);

     Q_ASSERT(groupHeader);
     updateGroupHeaderLayout(widget);
 }
 
     Q_ASSERT(groupHeader);
     updateGroupHeaderLayout(widget);
 }
 

-void KItemListView::slotRoleEditingCanceled(int index, const QByteArray& role, const QVariant& value)
+void KItemListView::slotRoleEditingCanceled(int index, const QByteArray &role, const QVariant &value)

 {
     disconnectRoleEditingSignals(index);
 
 {
     disconnectRoleEditingSignals(index);
 

-    emit roleEditingCanceled(index, role, value);

     m_editingRole = false;
     m_editingRole = false;

+    Q_EMIT roleEditingCanceled(index, role, value);

 }
 
 }
 

-void KItemListView::slotRoleEditingFinished(int index, const QByteArray& role, const QVariant& value)
+void KItemListView::slotRoleEditingFinished(int index, const QByteArray &role, const QVariant &value)

 {
     disconnectRoleEditingSignals(index);
 
 {
     disconnectRoleEditingSignals(index);
 

-    emit roleEditingFinished(index, role, value);

     m_editingRole = false;
     m_editingRole = false;

+    Q_EMIT roleEditingFinished(index, role, value);

 }
 
 }
 

-void KItemListView::setController(KItemListController* controller)
+void KItemListView::setController(KItemListController *controller)

 {
     if (m_controller != controller) {
 {
     if (m_controller != controller) {

-        KItemListController* previous = m_controller;
+        KItemListController *previous = m_controller;

         if (previous) {
         if (previous) {

-            KItemListSelectionManager* selectionManager = previous->selectionManager();
+            KItemListSelectionManager *selectionManager = previous->selectionManager();

             disconnect(selectionManager, &KItemListSelectionManager::currentChanged, this, &KItemListView::slotCurrentChanged);
             disconnect(selectionManager, &KItemListSelectionManager::selectionChanged, this, &KItemListView::slotSelectionChanged);
         }
             disconnect(selectionManager, &KItemListSelectionManager::currentChanged, this, &KItemListView::slotCurrentChanged);
             disconnect(selectionManager, &KItemListSelectionManager::selectionChanged, this, &KItemListView::slotSelectionChanged);
         }


@@ -1573,7 +1737,7 @@ void KItemListView::setController(KItemListController* controller)
         m_controller = controller;
 
         if (controller) {
         m_controller = controller;
 
         if (controller) {

-            KItemListSelectionManager* selectionManager = controller->selectionManager();
+            KItemListSelectionManager *selectionManager = controller->selectionManager();

             connect(selectionManager, &KItemListSelectionManager::currentChanged, this, &KItemListView::slotCurrentChanged);
             connect(selectionManager, &KItemListSelectionManager::selectionChanged, this, &KItemListView::slotSelectionChanged);
         }
             connect(selectionManager, &KItemListSelectionManager::currentChanged, this, &KItemListView::slotCurrentChanged);
             connect(selectionManager, &KItemListSelectionManager::selectionChanged, this, &KItemListView::slotSelectionChanged);
         }


@@ -1582,31 +1746,25 @@ void KItemListView::setController(KItemListController* controller)
     }
 }
 
     }
 }
 

-void KItemListView::setModel(KItemModelBase* model)
+void KItemListView::setModel(KItemModelBase *model)

 {
     if (m_model == model) {
         return;
     }
 
 {
     if (m_model == model) {
         return;
     }
 

-    KItemModelBase* previous = m_model;
+    KItemModelBase *previous = m_model;

 
     if (m_model) {
 
     if (m_model) {

-        disconnect(m_model, &KItemModelBase::itemsChanged,
-                   this,    &KItemListView::slotItemsChanged);
-        disconnect(m_model, &KItemModelBase::itemsInserted,
-                   this,    &KItemListView::slotItemsInserted);
-        disconnect(m_model, &KItemModelBase::itemsRemoved,
-                   this,    &KItemListView::slotItemsRemoved);
-        disconnect(m_model, &KItemModelBase::itemsMoved,
-                   this,    &KItemListView::slotItemsMoved);
-        disconnect(m_model, &KItemModelBase::groupsChanged,
-                   this,    &KItemListView::slotGroupsChanged);
-        disconnect(m_model, &KItemModelBase::groupedSortingChanged,
-                   this,    &KItemListView::slotGroupedSortingChanged);
-        disconnect(m_model, &KItemModelBase::sortOrderChanged,
-                   this,    &KItemListView::slotSortOrderChanged);
-        disconnect(m_model, &KItemModelBase::sortRoleChanged,
-                   this,    &KItemListView::slotSortRoleChanged);
+        disconnect(m_model, &KItemModelBase::itemsChanged, this, &KItemListView::slotItemsChanged);
+        disconnect(m_model, &KItemModelBase::itemsInserted, this, &KItemListView::slotItemsInserted);
+        disconnect(m_model, &KItemModelBase::itemsRemoved, this, &KItemListView::slotItemsRemoved);
+        disconnect(m_model, &KItemModelBase::itemsMoved, this, &KItemListView::slotItemsMoved);
+        disconnect(m_model, &KItemModelBase::groupsChanged, this, &KItemListView::slotGroupsChanged);
+        disconnect(m_model, &KItemModelBase::groupedSortingChanged, this, &KItemListView::slotGroupedSortingChanged);
+        disconnect(m_model, &KItemModelBase::sortOrderChanged, this, &KItemListView::slotSortOrderChanged);
+        disconnect(m_model, &KItemModelBase::sortRoleChanged, this, &KItemListView::slotSortRoleChanged);
+        disconnect(m_model, &KItemModelBase::groupOrderChanged, this, &KItemListView::slotGroupOrderChanged);
+        disconnect(m_model, &KItemModelBase::groupRoleChanged, this, &KItemListView::slotGroupRoleChanged);

 
         m_sizeHintResolver->itemsRemoved(KItemRangeList() << KItemRange(0, m_model->count()));
     }
 
         m_sizeHintResolver->itemsRemoved(KItemRangeList() << KItemRange(0, m_model->count()));
     }


@@ -1616,22 +1774,14 @@ void KItemListView::setModel(KItemModelBase* model)
     m_grouped = model->groupedSorting();
 
     if (m_model) {
     m_grouped = model->groupedSorting();
 
     if (m_model) {

-        connect(m_model, &KItemModelBase::itemsChanged,
-                this,    &KItemListView::slotItemsChanged);
-        connect(m_model, &KItemModelBase::itemsInserted,
-                this,    &KItemListView::slotItemsInserted);
-        connect(m_model, &KItemModelBase::itemsRemoved,
-                this,    &KItemListView::slotItemsRemoved);
-        connect(m_model, &KItemModelBase::itemsMoved,
-                this,    &KItemListView::slotItemsMoved);
-        connect(m_model, &KItemModelBase::groupsChanged,
-                this,    &KItemListView::slotGroupsChanged);
-        connect(m_model, &KItemModelBase::groupedSortingChanged,
-                this,    &KItemListView::slotGroupedSortingChanged);
-        connect(m_model, &KItemModelBase::sortOrderChanged,
-                this,    &KItemListView::slotSortOrderChanged);
-        connect(m_model, &KItemModelBase::sortRoleChanged,
-                this,    &KItemListView::slotSortRoleChanged);
+        connect(m_model, &KItemModelBase::itemsChanged, this, &KItemListView::slotItemsChanged);
+        connect(m_model, &KItemModelBase::itemsInserted, this, &KItemListView::slotItemsInserted);
+        connect(m_model, &KItemModelBase::itemsRemoved, this, &KItemListView::slotItemsRemoved);
+        connect(m_model, &KItemModelBase::itemsMoved, this, &KItemListView::slotItemsMoved);
+        connect(m_model, &KItemModelBase::groupsChanged, this, &KItemListView::slotGroupsChanged);
+        connect(m_model, &KItemModelBase::groupedSortingChanged, this, &KItemListView::slotGroupedSortingChanged);
+        connect(m_model, &KItemModelBase::sortOrderChanged, this, &KItemListView::slotSortOrderChanged);
+        connect(m_model, &KItemModelBase::sortRoleChanged, this, &KItemListView::slotSortRoleChanged);

 
         const int itemCount = m_model->count();
         if (itemCount > 0) {
 
         const int itemCount = m_model->count();
         if (itemCount > 0) {


@@ -1642,17 +1792,13 @@ void KItemListView::setModel(KItemModelBase* model)
     onModelChanged(model, previous);
 }
 
     onModelChanged(model, previous);
 }
 

-KItemListRubberBand* KItemListView::rubberBand() const
+KItemListRubberBand *KItemListView::rubberBand() const

 {
     return m_rubberBand;
 }
 
 void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int changedCount)
 {
 {
     return m_rubberBand;
 }
 
 void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int changedCount)
 {

-    if (m_layoutTimer->isActive()) {
-        m_layoutTimer->stop();
-    }
-

     if (m_activeTransactions > 0) {
         if (hint == NoAnimation) {
             // As soon as at least one property change should be done without animation,
     if (m_activeTransactions > 0) {
         if (hint == NoAnimation) {
             // As soon as at least one property change should be done without animation,


@@ -1696,13 +1842,11 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
     const bool animate = (hint == Animation);
     for (int i = firstVisibleIndex; i <= lastVisibleIndex; ++i) {
         bool applyNewPos = true;
     const bool animate = (hint == Animation);
     for (int i = firstVisibleIndex; i <= lastVisibleIndex; ++i) {
         bool applyNewPos = true;

-        bool wasHidden = false;

 
         const QRectF itemBounds = m_layouter->itemRect(i);
         const QPointF newPos = itemBounds.topLeft();
 
         const QRectF itemBounds = m_layouter->itemRect(i);
         const QPointF newPos = itemBounds.topLeft();

-        KItemListWidget* widget = m_visibleItems.value(i);
+        KItemListWidget *widget = m_visibleItems.value(i);

         if (!widget) {
         if (!widget) {

-            wasHidden = true;

             if (!reusableItems.isEmpty()) {
                 // Reuse a KItemListWidget instance from an invisible item
                 const int oldIndex = reusableItems.takeLast();
             if (!reusableItems.isEmpty()) {
                 // Reuse a KItemListWidget instance from an invisible item
                 const int oldIndex = reusableItems.takeLast();


@@ -1725,8 +1869,7 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
                     const int previousIndex = i - changedCount;
                     const QRectF itemRect = m_layouter->itemRect(previousIndex);
                     if (itemRect.isEmpty()) {
                     const int previousIndex = i - changedCount;
                     const QRectF itemRect = m_layouter->itemRect(previousIndex);
                     if (itemRect.isEmpty()) {

-                        const QPointF invisibleOldPos = (scrollOrientation() == Qt::Vertical)
-                                                        ? QPointF(0, size().height()) : QPointF(size().width(), 0);
+                        const QPointF invisibleOldPos = (scrollOrientation() == Qt::Vertical) ? QPointF(0, size().height()) : QPointF(size().width(), 0);

                         widget->setPos(invisibleOldPos);
                     } else {
                         widget->setPos(itemRect.topLeft());
                         widget->setPos(invisibleOldPos);
                     } else {
                         widget->setPos(itemRect.topLeft());


@@ -1745,7 +1888,7 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
 
         if (animate) {
             if (m_animation->isStarted(widget, KItemListViewAnimation::MovingAnimation)) {
 
         if (animate) {
             if (m_animation->isStarted(widget, KItemListViewAnimation::MovingAnimation)) {

-                m_animation->start(widget,  KItemListViewAnimation::MovingAnimation, newPos);
+                m_animation->start(widget, KItemListViewAnimation::MovingAnimation, newPos);

                 applyNewPos = false;
             }
 
                 applyNewPos = false;
             }
 


@@ -1769,9 +1912,6 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
                     // prevents a "move animation mess" when inserting several ranges in parallel.
                     applyNewPos = !moveWidget(widget, newPos);
                 }
                     // prevents a "move animation mess" when inserting several ranges in parallel.
                     applyNewPos = !moveWidget(widget, newPos);
                 }

-            } else if (!itemsRemoved && !itemsInserted && !wasHidden) {
-                // The size of the view might have been changed. Animate the moving of the position.
-                applyNewPos = !moveWidget(widget, newPos);

             }
         } else {
             m_animation->stop(widget);
             }
         } else {
             m_animation->stop(widget);


@@ -1784,6 +1924,8 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
         Q_ASSERT(widget->index() == i);
         widget->setVisible(true);
 
         Q_ASSERT(widget->index() == i);
         widget->setVisible(true);
 

+        bool animateIconResizing = animate;
+

         if (widget->size() != itemBounds.size()) {
             // Resize the widget for the item to the changed size.
             if (animate) {
         if (widget->size() != itemBounds.size()) {
             // Resize the widget for the item to the changed size.
             if (animate) {


@@ -1800,6 +1942,17 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
             } else {
                 widget->resize(itemBounds.size());
             }
             } else {
                 widget->resize(itemBounds.size());
             }

+        } else {
+            animateIconResizing = false;
+        }
+
+        const int newIconSize = widget->styleOption().iconSize;
+        if (widget->iconSize() != newIconSize) {
+            if (animateIconResizing) {
+                m_animation->start(widget, KItemListViewAnimation::IconResizeAnimation, newIconSize);
+            } else {
+                widget->setIconSize(newIconSize);
+            }

         }
 
         // Updating the cell-information must be done as last step: The decision whether the
         }
 
         // Updating the cell-information must be done as last step: The decision whether the


@@ -1809,7 +1962,7 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
     }
 
     // Delete invisible KItemListWidget instances that have not been reused
     }
 
     // Delete invisible KItemListWidget instances that have not been reused

-    foreach (int index, reusableItems) {
+    for (int index : std::as_const(reusableItems)) {

         recycleWidget(m_visibleItems.value(index));
     }
 
         recycleWidget(m_visibleItems.value(index));
     }
 


@@ -1820,7 +1973,7 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
 
     if (m_grouped) {
         // Update the layout of all visible group headers
 
     if (m_grouped) {
         // Update the layout of all visible group headers

-        QHashIterator<KItemListWidget*, KItemListGroupHeader*> it(m_visibleGroups);
+        QHashIterator<KItemListWidget *, KItemListGroupHeader *> it(m_visibleGroups);

         while (it.hasNext()) {
             it.next();
             updateGroupHeaderLayout(it.key());
         while (it.hasNext()) {
             it.next();
             updateGroupHeaderLayout(it.key());


@@ -1830,9 +1983,7 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
     emitOffsetChanges();
 }
 
     emitOffsetChanges();
 }
 

-QList<int> KItemListView::recycleInvisibleItems(int firstVisibleIndex,
-                                                int lastVisibleIndex,
-                                                LayoutAnimationHint hint)
+QList<int> KItemListView::recycleInvisibleItems(int firstVisibleIndex, int lastVisibleIndex, LayoutAnimationHint hint)

 {
     // Determine all items that are completely invisible and might be
     // reused for items that just got (at least partly) visible. If the
 {
     // Determine all items that are completely invisible and might be
     // reused for items that just got (at least partly) visible. If the


@@ -1842,11 +1993,11 @@ QList<int> KItemListView::recycleInvisibleItems(int firstVisibleIndex,
 
     QList<int> items;
 
 
     QList<int> items;
 

-    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    QHashIterator<int, KItemListWidget *> it(m_visibleItems);

     while (it.hasNext()) {
         it.next();
 
     while (it.hasNext()) {
         it.next();
 

-        KItemListWidget* widget = it.value();
+        KItemListWidget *widget = it.value();

         const int index = widget->index();
         const bool invisible = (index < firstVisibleIndex) || (index > lastVisibleIndex);
 
         const int index = widget->index();
         const bool invisible = (index < firstVisibleIndex) || (index > lastVisibleIndex);
 


@@ -1871,7 +2022,7 @@ QList<int> KItemListView::recycleInvisibleItems(int firstVisibleIndex,
     return items;
 }
 
     return items;
 }
 

-bool KItemListView::moveWidget(KItemListWidget* widget,const QPointF& newPos)
+bool KItemListView::moveWidget(KItemListWidget *widget, const QPointF &newPos)

 {
     if (widget->pos() == newPos) {
         return false;
 {
     if (widget->pos() == newPos) {
         return false;


@@ -1912,32 +2063,32 @@ void KItemListView::emitOffsetChanges()
 {
     const qreal newScrollOffset = m_layouter->scrollOffset();
     if (m_oldScrollOffset != newScrollOffset) {
 {
     const qreal newScrollOffset = m_layouter->scrollOffset();
     if (m_oldScrollOffset != newScrollOffset) {

-        emit scrollOffsetChanged(newScrollOffset, m_oldScrollOffset);
+        Q_EMIT scrollOffsetChanged(newScrollOffset, m_oldScrollOffset);

         m_oldScrollOffset = newScrollOffset;
     }
 
     const qreal newMaximumScrollOffset = m_layouter->maximumScrollOffset();
     if (m_oldMaximumScrollOffset != newMaximumScrollOffset) {
         m_oldScrollOffset = newScrollOffset;
     }
 
     const qreal newMaximumScrollOffset = m_layouter->maximumScrollOffset();
     if (m_oldMaximumScrollOffset != newMaximumScrollOffset) {

-        emit maximumScrollOffsetChanged(newMaximumScrollOffset, m_oldMaximumScrollOffset);
+        Q_EMIT maximumScrollOffsetChanged(newMaximumScrollOffset, m_oldMaximumScrollOffset);

         m_oldMaximumScrollOffset = newMaximumScrollOffset;
     }
 
     const qreal newItemOffset = m_layouter->itemOffset();
     if (m_oldItemOffset != newItemOffset) {
         m_oldMaximumScrollOffset = newMaximumScrollOffset;
     }
 
     const qreal newItemOffset = m_layouter->itemOffset();
     if (m_oldItemOffset != newItemOffset) {

-        emit itemOffsetChanged(newItemOffset, m_oldItemOffset);
+        Q_EMIT itemOffsetChanged(newItemOffset, m_oldItemOffset);

         m_oldItemOffset = newItemOffset;
     }
 
     const qreal newMaximumItemOffset = m_layouter->maximumItemOffset();
     if (m_oldMaximumItemOffset != newMaximumItemOffset) {
         m_oldItemOffset = newItemOffset;
     }
 
     const qreal newMaximumItemOffset = m_layouter->maximumItemOffset();
     if (m_oldMaximumItemOffset != newMaximumItemOffset) {

-        emit maximumItemOffsetChanged(newMaximumItemOffset, m_oldMaximumItemOffset);
+        Q_EMIT maximumItemOffsetChanged(newMaximumItemOffset, m_oldMaximumItemOffset);

         m_oldMaximumItemOffset = newMaximumItemOffset;
     }
 }
 
         m_oldMaximumItemOffset = newMaximumItemOffset;
     }
 }
 

-KItemListWidget* KItemListView::createWidget(int index)
+KItemListWidget *KItemListView::createWidget(int index)

 {
 {

-    KItemListWidget* widget = widgetCreator()->create(this);
+    KItemListWidget *widget = widgetCreator()->create(this);

     widget->setFlag(QGraphicsItem::ItemStacksBehindParent);
 
     m_visibleItems.insert(index, widget);
     widget->setFlag(QGraphicsItem::ItemStacksBehindParent);
 
     m_visibleItems.insert(index, widget);


@@ -1947,7 +2098,7 @@ KItemListWidget* KItemListView::createWidget(int index)
     return widget;
 }
 
     return widget;
 }
 

-void KItemListView::recycleWidget(KItemListWidget* widget)
+void KItemListView::recycleWidget(KItemListWidget *widget)

 {
     if (m_grouped) {
         recycleGroupHeaderForWidget(widget);
 {
     if (m_grouped) {
         recycleGroupHeaderForWidget(widget);


@@ -1960,7 +2111,7 @@ void KItemListView::recycleWidget(KItemListWidget* widget)
     widgetCreator()->recycle(widget);
 }
 
     widgetCreator()->recycle(widget);
 }
 

-void KItemListView::setWidgetIndex(KItemListWidget* widget, int index)
+void KItemListView::setWidgetIndex(KItemListWidget *widget, int index)

 {
     const int oldIndex = widget->index();
     m_visibleItems.remove(oldIndex);
 {
     const int oldIndex = widget->index();
     m_visibleItems.remove(oldIndex);


@@ -1972,7 +2123,7 @@ void KItemListView::setWidgetIndex(KItemListWidget* widget, int index)
     widget->setIndex(index);
 }
 
     widget->setIndex(index);
 }
 

-void KItemListView::moveWidgetToIndex(KItemListWidget* widget, int index)
+void KItemListView::moveWidgetToIndex(KItemListWidget *widget, int index)

 {
     const int oldIndex = widget->index();
     const Cell oldCell = m_visibleCells.value(oldIndex);
 {
     const int oldIndex = widget->index();
     const Cell oldCell = m_visibleCells.value(oldIndex);


@@ -1981,29 +2132,33 @@ void KItemListView::moveWidgetToIndex(KItemListWidget* widget, int index)
 
     const Cell newCell(m_layouter->itemColumn(index), m_layouter->itemRow(index));
     const bool vertical = (scrollOrientation() == Qt::Vertical);
 
     const Cell newCell(m_layouter->itemColumn(index), m_layouter->itemRow(index));
     const bool vertical = (scrollOrientation() == Qt::Vertical);

-    const bool updateCell = (vertical  && oldCell.row    == newCell.row) ||
-                            (!vertical && oldCell.column == newCell.column);
+    const bool updateCell = (vertical && oldCell.row == newCell.row) || (!vertical && oldCell.column == newCell.column);

     if (updateCell) {
         m_visibleCells.insert(index, newCell);
     }
 }
 
     if (updateCell) {
         m_visibleCells.insert(index, newCell);
     }
 }
 

-void KItemListView::setLayouterSize(const QSizeF& size, SizeType sizeType)
+void KItemListView::setLayouterSize(const QSizeF &size, SizeType sizeType)

 {
     switch (sizeType) {
 {
     switch (sizeType) {

-    case LayouterSize: m_layouter->setSize(size); break;
-    case ItemSize: m_layouter->setItemSize(size); break;
-    default: break;
+    case LayouterSize:
+        m_layouter->setSize(size);
+        break;
+    case ItemSize:
+        m_layouter->setItemSize(size);
+        break;
+    default:
+        break;

     }
 }
 
     }
 }
 

-void KItemListView::updateWidgetProperties(KItemListWidget* widget, int index)
+void KItemListView::updateWidgetProperties(KItemListWidget *widget, int index)

 {
     widget->setVisibleRoles(m_visibleRoles);
     updateWidgetColumnWidths(widget);
     widget->setStyleOption(m_styleOption);
 
 {
     widget->setVisibleRoles(m_visibleRoles);
     updateWidgetColumnWidths(widget);
     widget->setStyleOption(m_styleOption);
 

-    const KItemListSelectionManager* selectionManager = m_controller->selectionManager();
+    const KItemListSelectionManager *selectionManager = m_controller->selectionManager();

 
     // In SingleSelection mode (e.g., in the Places Panel), the current item is
     // always the selected item. It is not necessary to highlight the current item then.
 
     // In SingleSelection mode (e.g., in the Places Panel), the current item is
     // always the selected item. It is not necessary to highlight the current item then.


@@ -2023,7 +2178,7 @@ void KItemListView::updateWidgetProperties(KItemListWidget* widget, int index)
     }
 }
 
     }
 }
 

-void KItemListView::updateGroupHeaderForWidget(KItemListWidget* widget)
+void KItemListView::updateGroupHeaderForWidget(KItemListWidget *widget)

 {
     Q_ASSERT(m_grouped);
 
 {
     Q_ASSERT(m_grouped);
 


@@ -2035,12 +2190,12 @@ void KItemListView::updateGroupHeaderForWidget(KItemListWidget* widget)
         return;
     }
 
         return;
     }
 

-    const QList<QPair<int, QVariant> > groups = model()->groups();
+    const QList<QPair<int, QVariant>> groups = model()->groups();

     if (groups.isEmpty() || !groupHeaderCreator()) {
         return;
     }
 
     if (groups.isEmpty() || !groupHeaderCreator()) {
         return;
     }
 

-    KItemListGroupHeader* groupHeader = m_visibleGroups.value(widget);
+    KItemListGroupHeader *groupHeader = m_visibleGroups.value(widget);

     if (!groupHeader) {
         groupHeader = groupHeaderCreator()->create(this);
         groupHeader->setParentItem(widget);
     if (!groupHeader) {
         groupHeader = groupHeaderCreator()->create(this);
         groupHeader->setParentItem(widget);


@@ -2052,7 +2207,7 @@ void KItemListView::updateGroupHeaderForWidget(KItemListWidget* widget)
     const int groupIndex = groupIndexForItem(index);
     Q_ASSERT(groupIndex >= 0);
     groupHeader->setData(groups.at(groupIndex).second);
     const int groupIndex = groupIndexForItem(index);
     Q_ASSERT(groupIndex >= 0);
     groupHeader->setData(groups.at(groupIndex).second);

-    groupHeader->setRole(model()->sortRole());
+    groupHeader->setRole(model()->groupRole());

     groupHeader->setStyleOption(m_styleOption);
     groupHeader->setScrollOrientation(scrollOrientation());
     groupHeader->setItemIndex(index);
     groupHeader->setStyleOption(m_styleOption);
     groupHeader->setScrollOrientation(scrollOrientation());
     groupHeader->setItemIndex(index);


@@ -2060,9 +2215,9 @@ void KItemListView::updateGroupHeaderForWidget(KItemListWidget* widget)
     groupHeader->show();
 }
 
     groupHeader->show();
 }
 

-void KItemListView::updateGroupHeaderLayout(KItemListWidget* widget)
+void KItemListView::updateGroupHeaderLayout(KItemListWidget *widget)

 {
 {

-    KItemListGroupHeader* groupHeader = m_visibleGroups.value(widget);
+    KItemListGroupHeader *groupHeader = m_visibleGroups.value(widget);

     Q_ASSERT(groupHeader);
 
     const int index = widget->index();
     Q_ASSERT(groupHeader);
 
     const int index = widget->index();


@@ -2085,9 +2240,9 @@ void KItemListView::updateGroupHeaderLayout(KItemListWidget* widget)
     }
 }
 
     }
 }
 

-void KItemListView::recycleGroupHeaderForWidget(KItemListWidget* widget)
+void KItemListView::recycleGroupHeaderForWidget(KItemListWidget *widget)

 {
 {

-    KItemListGroupHeader* header = m_visibleGroups.value(widget);
+    KItemListGroupHeader *header = m_visibleGroups.value(widget);

     if (header) {
         header->setParentItem(nullptr);
         groupHeaderCreator()->recycle(header);
     if (header) {
         header->setParentItem(nullptr);
         groupHeaderCreator()->recycle(header);


@@ -2101,7 +2256,7 @@ void KItemListView::updateVisibleGroupHeaders()
     Q_ASSERT(m_grouped);
     m_layouter->markAsDirty();
 
     Q_ASSERT(m_grouped);
     m_layouter->markAsDirty();
 

-    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    QHashIterator<int, KItemListWidget *> it(m_visibleItems);

     while (it.hasNext()) {
         it.next();
         updateGroupHeaderForWidget(it.value());
     while (it.hasNext()) {
         it.next();
         updateGroupHeaderForWidget(it.value());


@@ -2112,7 +2267,7 @@ int KItemListView::groupIndexForItem(int index) const
 {
     Q_ASSERT(m_grouped);
 
 {
     Q_ASSERT(m_grouped);
 

-    const QList<QPair<int, QVariant> > groups = model()->groups();
+    const QList<QPair<int, QVariant>> groups = model()->groups();

     if (groups.isEmpty()) {
         return -1;
     }
     if (groups.isEmpty()) {
         return -1;
     }


@@ -2140,14 +2295,14 @@ int KItemListView::groupIndexForItem(int index) const
 
 void KItemListView::updateAlternateBackgrounds()
 {
 
 void KItemListView::updateAlternateBackgrounds()
 {

-    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    QHashIterator<int, KItemListWidget *> it(m_visibleItems);

     while (it.hasNext()) {
         it.next();
         updateAlternateBackgroundForWidget(it.value());
     }
 }
 
     while (it.hasNext()) {
         it.next();
         updateAlternateBackgroundForWidget(it.value());
     }
 }
 

-void KItemListView::updateAlternateBackgroundForWidget(KItemListWidget* widget)
+void KItemListView::updateAlternateBackgroundForWidget(KItemListWidget *widget)

 {
     bool enabled = useAlternateBackgrounds();
     if (enabled) {
 {
     bool enabled = useAlternateBackgrounds();
     if (enabled) {


@@ -2156,7 +2311,7 @@ void KItemListView::updateAlternateBackgroundForWidget(KItemListWidget* widget)
         if (m_grouped) {
             const int groupIndex = groupIndexForItem(index);
             if (groupIndex >= 0) {
         if (m_grouped) {
             const int groupIndex = groupIndexForItem(index);
             if (groupIndex >= 0) {

-                const QList<QPair<int, QVariant> > groups = model()->groups();
+                const QList<QPair<int, QVariant>> groups = model()->groups();

                 const int indexOfFirstGroupItem = groups[groupIndex].first;
                 const int relativeIndex = index - indexOfFirstGroupItem;
                 enabled = (relativeIndex & 0x1) > 0;
                 const int indexOfFirstGroupItem = groups[groupIndex].first;
                 const int relativeIndex = index - indexOfFirstGroupItem;
                 enabled = (relativeIndex & 0x1) > 0;


@@ -2168,10 +2323,10 @@ void KItemListView::updateAlternateBackgroundForWidget(KItemListWidget* widget)
 
 bool KItemListView::useAlternateBackgrounds() const
 {
 
 bool KItemListView::useAlternateBackgrounds() const
 {

-    return m_itemSize.isEmpty() && m_visibleRoles.count() > 1;
+    return m_alternateBackgrounds && m_itemSize.isEmpty();

 }
 
 }
 

-QHash<QByteArray, qreal> KItemListView::preferredColumnWidths(const KItemRangeList& itemRanges) const
+QHash<QByteArray, qreal> KItemListView::preferredColumnWidths(const KItemRangeList &itemRanges) const

 {
     QElapsedTimer timer;
     timer.start();
 {
     QElapsedTimer timer;
     timer.start();


@@ -2181,25 +2336,25 @@ QHash<QByteArray, qreal> KItemListView::preferredColumnWidths(const KItemRangeLi
     // Calculate the minimum width for each column that is required
     // to show the headline unclipped.
     const QFontMetricsF fontMetrics(m_headerWidget->font());
     // Calculate the minimum width for each column that is required
     // to show the headline unclipped.
     const QFontMetricsF fontMetrics(m_headerWidget->font());

-    const int gripMargin   = m_headerWidget->style()->pixelMetric(QStyle::PM_HeaderGripMargin);
+    const int gripMargin = m_headerWidget->style()->pixelMetric(QStyle::PM_HeaderGripMargin);

     const int headerMargin = m_headerWidget->style()->pixelMetric(QStyle::PM_HeaderMargin);
     const int headerMargin = m_headerWidget->style()->pixelMetric(QStyle::PM_HeaderMargin);

-    foreach (const QByteArray& visibleRole, visibleRoles()) {
+    for (const QByteArray &visibleRole : std::as_const(m_visibleRoles)) {

         const QString headerText = m_model->roleDescription(visibleRole);
         const QString headerText = m_model->roleDescription(visibleRole);

-        const qreal headerWidth = fontMetrics.width(headerText) + gripMargin + headerMargin * 2;
+        const qreal headerWidth = fontMetrics.horizontalAdvance(headerText) + gripMargin + headerMargin * 2;

         widths.insert(visibleRole, headerWidth);
     }
 
         widths.insert(visibleRole, headerWidth);
     }
 

-    // Calculate the preferred column withs for each item and ignore values
+    // Calculate the preferred column widths for each item and ignore values

     // smaller than the width for showing the headline unclipped.
     // smaller than the width for showing the headline unclipped.

-    const KItemListWidgetCreatorBase* creator = widgetCreator();
+    const KItemListWidgetCreatorBase *creator = widgetCreator();

     int calculatedItemCount = 0;
     bool maxTimeExceeded = false;
     int calculatedItemCount = 0;
     bool maxTimeExceeded = false;

-    foreach (const KItemRange& itemRange, itemRanges) {
+    for (const KItemRange &itemRange : itemRanges) {

         const int startIndex = itemRange.index;
         const int endIndex = startIndex + itemRange.count - 1;
 
         for (int i = startIndex; i <= endIndex; ++i) {
         const int startIndex = itemRange.index;
         const int endIndex = startIndex + itemRange.count - 1;
 
         for (int i = startIndex; i <= endIndex; ++i) {

-            foreach (const QByteArray& visibleRole, visibleRoles()) {
+            for (const QByteArray &visibleRole : std::as_const(m_visibleRoles)) {

                 qreal maxWidth = widths.value(visibleRole, 0);
                 const qreal width = creator->preferredRoleColumnWidth(visibleRole, i, this);
                 maxWidth = qMax(width, maxWidth);
                 qreal maxWidth = widths.value(visibleRole, 0);
                 const qreal width = creator->preferredRoleColumnWidth(visibleRole, i, this);
                 maxWidth = qMax(width, maxWidth);


@@ -2226,38 +2381,38 @@ QHash<QByteArray, qreal> KItemListView::preferredColumnWidths(const KItemRangeLi
 void KItemListView::applyColumnWidthsFromHeader()
 {
     // Apply the new size to the layouter
 void KItemListView::applyColumnWidthsFromHeader()
 {
     // Apply the new size to the layouter

-    const qreal requiredWidth = columnWidthsSum();
-    const QSizeF dynamicItemSize(qMax(size().width(), requiredWidth),
-                                 m_itemSize.height());
+    const qreal requiredWidth = columnWidthsSum() + 2 * m_headerWidget->sidePadding();
+    const QSizeF dynamicItemSize(qMax(size().width(), requiredWidth), m_itemSize.height());

     m_layouter->setItemSize(dynamicItemSize);
 
     // Update the role sizes for all visible widgets
     m_layouter->setItemSize(dynamicItemSize);
 
     // Update the role sizes for all visible widgets

-    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    QHashIterator<int, KItemListWidget *> it(m_visibleItems);

     while (it.hasNext()) {
         it.next();
         updateWidgetColumnWidths(it.value());
     }
 }
 
     while (it.hasNext()) {
         it.next();
         updateWidgetColumnWidths(it.value());
     }
 }
 

-void KItemListView::updateWidgetColumnWidths(KItemListWidget* widget)
+void KItemListView::updateWidgetColumnWidths(KItemListWidget *widget)

 {
 {

-    foreach (const QByteArray& role, m_visibleRoles) {
+    for (const QByteArray &role : std::as_const(m_visibleRoles)) {

         widget->setColumnWidth(role, m_headerWidget->columnWidth(role));
     }
         widget->setColumnWidth(role, m_headerWidget->columnWidth(role));
     }

+    widget->setSidePadding(m_headerWidget->sidePadding());

 }
 
 }
 

-void KItemListView::updatePreferredColumnWidths(const KItemRangeList& itemRanges)
+void KItemListView::updatePreferredColumnWidths(const KItemRangeList &itemRanges)

 {
     Q_ASSERT(m_itemSize.isEmpty());
     const int itemCount = m_model->count();
     int rangesItemCount = 0;
 {
     Q_ASSERT(m_itemSize.isEmpty());
     const int itemCount = m_model->count();
     int rangesItemCount = 0;

-    foreach (const KItemRange& range, itemRanges) {
+    for (const KItemRange &range : itemRanges) {

         rangesItemCount += range.count;
     }
 
     if (itemCount == rangesItemCount) {
         const QHash<QByteArray, qreal> preferredWidths = preferredColumnWidths(itemRanges);
         rangesItemCount += range.count;
     }
 
     if (itemCount == rangesItemCount) {
         const QHash<QByteArray, qreal> preferredWidths = preferredColumnWidths(itemRanges);

-        foreach (const QByteArray& role, m_visibleRoles) {
+        for (const QByteArray &role : std::as_const(m_visibleRoles)) {

             m_headerWidget->setPreferredColumnWidth(role, preferredWidths.value(role));
         }
     } else {
             m_headerWidget->setPreferredColumnWidth(role, preferredWidths.value(role));
         }
     } else {


@@ -2271,7 +2426,7 @@ void KItemListView::updatePreferredColumnWidths(const KItemRangeList& itemRanges
         QHashIterator<QByteArray, qreal> it(updatedWidths);
         while (it.hasNext()) {
             it.next();
         QHashIterator<QByteArray, qreal> it(updatedWidths);
         while (it.hasNext()) {
             it.next();

-            const QByteArray& role = it.key();
+            const QByteArray &role = it.key();

             const qreal updatedWidth = it.value();
             const qreal currentWidth = m_headerWidget->preferredColumnWidth(role);
             if (updatedWidth > currentWidth) {
             const qreal updatedWidth = it.value();
             const qreal currentWidth = m_headerWidget->preferredColumnWidth(role);
             if (updatedWidth > currentWidth) {


@@ -2312,7 +2467,7 @@ void KItemListView::applyAutomaticColumnWidths()
     // size does not use the available view-size the size of the
     // first role will get stretched.
 
     // size does not use the available view-size the size of the
     // first role will get stretched.
 

-    foreach (const QByteArray& role, m_visibleRoles) {
+    for (const QByteArray &role : std::as_const(m_visibleRoles)) {

         const qreal preferredWidth = m_headerWidget->preferredColumnWidth(role);
         m_headerWidget->setColumnWidth(role, preferredWidth);
     }
         const qreal preferredWidth = m_headerWidget->preferredColumnWidth(role);
         m_headerWidget->setColumnWidth(role, preferredWidth);
     }


@@ -2321,7 +2476,9 @@ void KItemListView::applyAutomaticColumnWidths()
     qreal firstColumnWidth = m_headerWidget->columnWidth(firstRole);
     QSizeF dynamicItemSize = m_itemSize;
 
     qreal firstColumnWidth = m_headerWidget->columnWidth(firstRole);
     QSizeF dynamicItemSize = m_itemSize;
 

-    qreal requiredWidth = columnWidthsSum();
+    qreal requiredWidth = columnWidthsSum() + 2 * m_headerWidget->sidePadding(); // Adding the padding a second time so we have the same padding
+    // symmetrically on both sides of the view. This improves UX, looks better and increases the chances of users figuring out that the padding
+    // area can be used for deselecting and dropping files.

     const qreal availableWidth = size().width();
     if (requiredWidth < availableWidth) {
         // Stretch the first column to use the whole remaining width
     const qreal availableWidth = size().width();
     if (requiredWidth < availableWidth) {
         // Stretch the first column to use the whole remaining width


@@ -2349,7 +2506,7 @@ void KItemListView::applyAutomaticColumnWidths()
     m_layouter->setItemSize(dynamicItemSize);
 
     // Update the role sizes for all visible widgets
     m_layouter->setItemSize(dynamicItemSize);
 
     // Update the role sizes for all visible widgets

-    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    QHashIterator<int, KItemListWidget *> it(m_visibleItems);

     while (it.hasNext()) {
         it.next();
         updateWidgetColumnWidths(it.value());
     while (it.hasNext()) {
         it.next();
         updateWidgetColumnWidths(it.value());


@@ -2359,7 +2516,7 @@ void KItemListView::applyAutomaticColumnWidths()
 qreal KItemListView::columnWidthsSum() const
 {
     qreal widthsSum = 0;
 qreal KItemListView::columnWidthsSum() const
 {
     qreal widthsSum = 0;

-    foreach (const QByteArray& role, m_visibleRoles) {
+    for (const QByteArray &role : std::as_const(m_visibleRoles)) {

         widthsSum += m_headerWidget->columnWidth(role);
     }
     return widthsSum;
         widthsSum += m_headerWidget->columnWidth(role);
     }
     return widthsSum;


@@ -2370,9 +2527,7 @@ QRectF KItemListView::headerBoundaries() const
     return m_headerWidget->isVisible() ? m_headerWidget->geometry() : QRectF();
 }
 
     return m_headerWidget->isVisible() ? m_headerWidget->geometry() : QRectF();
 }
 

-bool KItemListView::changesItemGridLayout(const QSizeF& newGridSize,
-                                          const QSizeF& newItemSize,
-                                          const QSizeF& newItemMargin) const
+bool KItemListView::changesItemGridLayout(const QSizeF &newGridSize, const QSizeF &newItemSize, const QSizeF &newItemMargin) const

 {
     if (newItemSize.isEmpty() || newGridSize.isEmpty()) {
         return false;
 {
     if (newItemSize.isEmpty() || newGridSize.isEmpty()) {
         return false;


@@ -2381,26 +2536,18 @@ bool KItemListView::changesItemGridLayout(const QSizeF& newGridSize,
     if (m_layouter->scrollOrientation() == Qt::Vertical) {
         const qreal itemWidth = m_layouter->itemSize().width();
         if (itemWidth > 0) {
     if (m_layouter->scrollOrientation() == Qt::Vertical) {
         const qreal itemWidth = m_layouter->itemSize().width();
         if (itemWidth > 0) {

-            const int newColumnCount = itemsPerSize(newGridSize.width(),
-                                                    newItemSize.width(),
-                                                    newItemMargin.width());
+            const int newColumnCount = itemsPerSize(newGridSize.width(), newItemSize.width(), newItemMargin.width());

             if (m_model->count() > newColumnCount) {
             if (m_model->count() > newColumnCount) {

-                const int oldColumnCount = itemsPerSize(m_layouter->size().width(),
-                                                        itemWidth,
-                                                        m_layouter->itemMargin().width());
+                const int oldColumnCount = itemsPerSize(m_layouter->size().width(), itemWidth, m_layouter->itemMargin().width());

                 return oldColumnCount != newColumnCount;
             }
         }
     } else {
         const qreal itemHeight = m_layouter->itemSize().height();
         if (itemHeight > 0) {
                 return oldColumnCount != newColumnCount;
             }
         }
     } else {
         const qreal itemHeight = m_layouter->itemSize().height();
         if (itemHeight > 0) {

-            const int newRowCount = itemsPerSize(newGridSize.height(),
-                                                 newItemSize.height(),
-                                                 newItemMargin.height());
+            const int newRowCount = itemsPerSize(newGridSize.height(), newItemSize.height(), newItemMargin.height());

             if (m_model->count() > newRowCount) {
             if (m_model->count() > newRowCount) {

-                const int oldRowCount = itemsPerSize(m_layouter->size().height(),
-                                                     itemHeight,
-                                                     m_layouter->itemMargin().height());
+                const int oldRowCount = itemsPerSize(m_layouter->size().height(), itemHeight, m_layouter->itemMargin().height());

                 return oldRowCount != newRowCount;
             }
         }
                 return oldRowCount != newRowCount;
             }
         }


@@ -2421,15 +2568,13 @@ bool KItemListView::animateChangedItemCount(int changedItemCount) const
         return false;
     }
 
         return false;
     }
 

-    const int maximum = (scrollOrientation() == Qt::Vertical)
-                        ? m_layouter->size().width()  / m_layouter->itemSize().width()
-                        : m_layouter->size().height() / m_layouter->itemSize().height();
+    const int maximum = (scrollOrientation() == Qt::Vertical) ? m_layouter->size().width() / m_layouter->itemSize().width()
+                                                              : m_layouter->size().height() / m_layouter->itemSize().height();

     // Only animate if up to 2/3 of a row or column are inserted or removed
     return changedItemCount <= maximum * 2 / 3;
 }
 
     // Only animate if up to 2/3 of a row or column are inserted or removed
     return changedItemCount <= maximum * 2 / 3;
 }
 

-
-bool KItemListView::scrollBarRequired(const QSizeF& size) const
+bool KItemListView::scrollBarRequired(const QSizeF &size) const

 {
     const QSizeF oldSize = m_layouter->size();
 
 {
     const QSizeF oldSize = m_layouter->size();
 


@@ -2437,16 +2582,15 @@ bool KItemListView::scrollBarRequired(const QSizeF& size) const
     const qreal maxOffset = m_layouter->maximumScrollOffset();
     m_layouter->setSize(oldSize);
 
     const qreal maxOffset = m_layouter->maximumScrollOffset();
     m_layouter->setSize(oldSize);
 

-    return m_layouter->scrollOrientation() == Qt::Vertical ? maxOffset > size.height()
-                                                           : maxOffset > size.width();
+    return m_layouter->scrollOrientation() == Qt::Vertical ? maxOffset > size.height() : maxOffset > size.width();

 }
 
 }
 

-int KItemListView::showDropIndicator(const QPointF& pos)
+int KItemListView::showDropIndicator(const QPointF &pos)

 {
 {

-    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    QHashIterator<int, KItemListWidget *> it(m_visibleItems);

     while (it.hasNext()) {
         it.next();
     while (it.hasNext()) {
         it.next();

-        const KItemListWidget* widget = it.value();
+        const KItemListWidget *widget = it.value();

 
         const QPointF mappedPos = widget->mapFromItem(this, pos);
         const QRectF rect = itemRect(widget->index());
 
         const QPointF mappedPos = widget->mapFromItem(this, pos);
         const QRectF rect = itemRect(widget->index());


@@ -2459,7 +2603,7 @@ int KItemListView::showDropIndicator(const QPointF& pos)
                 }
             }
 
                 }
             }
 

-            const bool isAboveItem = (mappedPos.y () < rect.height() / 2);
+            const bool isAboveItem = (mappedPos.y() < rect.height() / 2);

             const qreal y = isAboveItem ? rect.top() : rect.bottom();
 
             const QRectF draggingInsertIndicator(rect.left(), y, rect.width(), 1);
             const qreal y = isAboveItem ? rect.top() : rect.bottom();
 
             const QRectF draggingInsertIndicator(rect.left(), y, rect.width(), 1);


@@ -2499,7 +2643,7 @@ void KItemListView::updateGroupHeaderHeight()
         // from m_styleOption.
         groupHeaderHeight += 2 * m_styleOption.horizontalMargin;
         groupHeaderMargin = m_styleOption.horizontalMargin;
         // from m_styleOption.
         groupHeaderHeight += 2 * m_styleOption.horizontalMargin;
         groupHeaderMargin = m_styleOption.horizontalMargin;

-    } else if (m_itemSize.isEmpty()){
+    } else if (m_itemSize.isEmpty()) {

         groupHeaderHeight += 4 * m_styleOption.padding;
         groupHeaderMargin = m_styleOption.iconSize / 2;
     } else {
         groupHeaderHeight += 4 * m_styleOption.padding;
         groupHeaderMargin = m_styleOption.iconSize / 2;
     } else {


@@ -2520,10 +2664,9 @@ void KItemListView::updateSiblingsInformation(int firstIndex, int lastIndex)
 
     if (firstIndex < 0 || lastIndex < 0) {
         firstIndex = m_layouter->firstVisibleIndex();
 
     if (firstIndex < 0 || lastIndex < 0) {
         firstIndex = m_layouter->firstVisibleIndex();

-        lastIndex  = m_layouter->lastVisibleIndex();
+        lastIndex = m_layouter->lastVisibleIndex();

     } else {
     } else {

-        const bool isRangeVisible = (firstIndex <= m_layouter->lastVisibleIndex() &&
-                                     lastIndex  >= m_layouter->firstVisibleIndex());
+        const bool isRangeVisible = (firstIndex <= m_layouter->lastVisibleIndex() && lastIndex >= m_layouter->firstVisibleIndex());

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


@@ -2539,7 +2682,7 @@ void KItemListView::updateSiblingsInformation(int firstIndex, int lastIndex)
     // contain a siblings information which can be used as base.
     int rootIndex = firstIndex;
 
     // contain a siblings information which can be used as base.
     int rootIndex = firstIndex;
 

-    KItemListWidget* widget = m_visibleItems.value(firstIndex - 1);
+    KItemListWidget *widget = m_visibleItems.value(firstIndex - 1);

     if (!widget) {
         // There is no visible widget before the range, check whether there
         // is one after the range:
     if (!widget) {
         // There is no visible widget before the range, check whether there
         // is one after the range:


@@ -2592,7 +2735,7 @@ void KItemListView::updateSiblingsInformation(int firstIndex, int lastIndex)
         if (i >= firstIndex) {
             // The index represents a visible item. Apply the parent-siblings
             // and update the sibling of the current item.
         if (i >= firstIndex) {
             // The index represents a visible item. Apply the parent-siblings
             // and update the sibling of the current item.

-            KItemListWidget* widget = m_visibleItems.value(i);
+            KItemListWidget *widget = m_visibleItems.value(i);

             if (!widget) {
                 continue;
             }
             if (!widget) {
                 continue;
             }


@@ -2641,7 +2784,7 @@ bool KItemListView::hasSiblingSuccessor(int index) const
 
 void KItemListView::disconnectRoleEditingSignals(int index)
 {
 
 void KItemListView::disconnectRoleEditingSignals(int index)
 {

-    KStandardItemListWidget* widget = qobject_cast<KStandardItemListWidget *>(m_visibleItems.value(index));
+    KStandardItemListWidget *widget = qobject_cast<KStandardItemListWidget *>(m_visibleItems.value(index));

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


@@ -2684,20 +2827,18 @@ int KItemListView::itemsPerSize(qreal size, qreal itemSize, qreal itemMargin)
     return count;
 }
 
     return count;
 }
 

-
-

 KItemListCreatorBase::~KItemListCreatorBase()
 {
     qDeleteAll(m_recycleableWidgets);
     qDeleteAll(m_createdWidgets);
 }
 
 KItemListCreatorBase::~KItemListCreatorBase()
 {
     qDeleteAll(m_recycleableWidgets);
     qDeleteAll(m_createdWidgets);
 }
 

-void KItemListCreatorBase::addCreatedWidget(QGraphicsWidget* widget)
+void KItemListCreatorBase::addCreatedWidget(QGraphicsWidget *widget)

 {
     m_createdWidgets.insert(widget);
 }
 
 {
     m_createdWidgets.insert(widget);
 }
 

-void KItemListCreatorBase::pushRecycleableWidget(QGraphicsWidget* widget)
+void KItemListCreatorBase::pushRecycleableWidget(QGraphicsWidget *widget)

 {
     Q_ASSERT(m_createdWidgets.contains(widget));
     m_createdWidgets.remove(widget);
 {
     Q_ASSERT(m_createdWidgets.contains(widget));
     m_createdWidgets.remove(widget);


@@ -2710,13 +2851,13 @@ void KItemListCreatorBase::pushRecycleableWidget(QGraphicsWidget* widget)
     }
 }
 
     }
 }
 

-QGraphicsWidget* KItemListCreatorBase::popRecycleableWidget()
+QGraphicsWidget *KItemListCreatorBase::popRecycleableWidget()

 {
     if (m_recycleableWidgets.isEmpty()) {
         return nullptr;
     }
 
 {
     if (m_recycleableWidgets.isEmpty()) {
         return nullptr;
     }
 

-    QGraphicsWidget* widget = m_recycleableWidgets.takeLast();
+    QGraphicsWidget *widget = m_recycleableWidgets.takeLast();

     m_createdWidgets.insert(widget);
     return widget;
 }
     m_createdWidgets.insert(widget);
     return widget;
 }


@@ -2725,7 +2866,7 @@ KItemListWidgetCreatorBase::~KItemListWidgetCreatorBase()
 {
 }
 
 {
 }
 

-void KItemListWidgetCreatorBase::recycle(KItemListWidget* widget)
+void KItemListWidgetCreatorBase::recycle(KItemListWidget *widget)

 {
     widget->setParentItem(nullptr);
     widget->setOpacity(1.0);
 {
     widget->setParentItem(nullptr);
     widget->setOpacity(1.0);


@@ -2736,9 +2877,10 @@ KItemListGroupHeaderCreatorBase::~KItemListGroupHeaderCreatorBase()
 {
 }
 
 {
 }
 

-void KItemListGroupHeaderCreatorBase::recycle(KItemListGroupHeader* header)
+void KItemListGroupHeaderCreatorBase::recycle(KItemListGroupHeader *header)

 {
     header->setOpacity(1.0);
     pushRecycleableWidget(header);
 }
 
 {
     header->setOpacity(1.0);
     pushRecycleableWidget(header);
 }
 

+#include "moc_kitemlistview.cpp"