Full row highlight implementation

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

diff --git a/src/kitemviews/kitemlistview.cpp b/src/kitemviews/kitemlistview.cpp
index ebcf48680388b28512b304b31d2be84afc0d82a7..86583db1ec958a25ed5b3fa7e1ea3febec725f76 100644 (file)
--- a/src/kitemviews/kitemlistview.cpp
+++ b/src/kitemviews/kitemlistview.cpp
@@ -1,47 +1,34 @@
-/***************************************************************************
- *   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"
 

-#include <KDebug>
+#include "dolphindebug.h"
+#include "kitemlistcontainer.h"

 #include "kitemlistcontroller.h"
 #include "kitemlistheader.h"
 #include "kitemlistselectionmanager.h"
 #include "kitemlistcontroller.h"
 #include "kitemlistheader.h"
 #include "kitemlistselectionmanager.h"

-#include "kitemlistwidget.h"
+#include "kitemlistviewaccessible.h"
+#include "kstandarditemlistwidget.h"

 
 #include "private/kitemlistheaderwidget.h"
 #include "private/kitemlistrubberband.h"
 #include "private/kitemlistsizehintresolver.h"
 #include "private/kitemlistviewlayouter.h"
 
 #include "private/kitemlistheaderwidget.h"
 #include "private/kitemlistrubberband.h"
 #include "private/kitemlistsizehintresolver.h"
 #include "private/kitemlistviewlayouter.h"

-#include "private/kitemlistviewanimation.h"

 
 

-#include <QCursor>
+#include <QElapsedTimer>

 #include <QGraphicsSceneMouseEvent>
 #include <QGraphicsView>
 #include <QGraphicsSceneMouseEvent>
 #include <QGraphicsView>

-#include <QPainter>

 #include <QPropertyAnimation>
 #include <QPropertyAnimation>

-#include <QStyle>

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

+#include <QVariantAnimation>
+

 
 namespace {
     // Time in ms until reaching the autoscroll margin triggers
 
 namespace {
     // Time in ms until reaching the autoscroll margin triggers


@@ -50,7 +37,27 @@ namespace {
 
     // Delay in ms for triggering the next autoscroll
     const int RepeatingAutoScrollDelay = 1000 / 60;
 
     // Delay in ms for triggering the next autoscroll
     const int RepeatingAutoScrollDelay = 1000 / 60;

+
+    // Copied from the Kirigami.Units.shortDuration
+    const int RubberFadeSpeed = 150;
+
+    const char* RubberPropertyName = "_kitemviews_rubberBandPosition";
+}
+
+#ifndef QT_NO_ACCESSIBILITY
+QAccessibleInterface* accessibleInterfaceFactory(const QString& key, QObject* object)
+{
+    Q_UNUSED(key)
+
+    if (KItemListContainer* container = qobject_cast<KItemListContainer*>(object)) {
+        return new KItemListContainerAccessible(container);
+    } else if (KItemListView* view = qobject_cast<KItemListView*>(object)) {
+        return new KItemListViewAccessible(view);
+    }
+
+    return nullptr;

 }
 }

+#endif

 
 KItemListView::KItemListView(QGraphicsWidget* parent) :
     QGraphicsWidget(parent),
 
 KItemListView::KItemListView(QGraphicsWidget* parent) :
     QGraphicsWidget(parent),


@@ -61,54 +68,79 @@ KItemListView::KItemListView(QGraphicsWidget* parent) :
     m_activeTransactions(0),
     m_endTransactionAnimationHint(Animation),
     m_itemSize(),
     m_activeTransactions(0),
     m_endTransactionAnimationHint(Animation),
     m_itemSize(),

-    m_controller(0),
-    m_model(0),
+    m_controller(nullptr),
+    m_model(nullptr),

     m_visibleRoles(),
     m_visibleRoles(),

-    m_widgetCreator(0),
-    m_groupHeaderCreator(0),
+    m_widgetCreator(nullptr),
+    m_groupHeaderCreator(nullptr),

     m_styleOption(),
     m_visibleItems(),
     m_visibleGroups(),
     m_visibleCells(),
     m_styleOption(),
     m_visibleItems(),
     m_visibleGroups(),
     m_visibleCells(),

-    m_sizeHintResolver(0),
-    m_layouter(0),
-    m_animation(0),
-    m_layoutTimer(0),
+    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_oldScrollOffset(0),
     m_oldMaximumScrollOffset(0),
     m_oldItemOffset(0),
     m_oldMaximumItemOffset(0),
     m_skipAutoScrollForRubberBand(false),

-    m_rubberBand(0),
+    m_rubberBand(nullptr),
+    m_tapAndHoldIndicator(nullptr),

     m_mousePos(),
     m_autoScrollIncrement(0),
     m_mousePos(),
     m_autoScrollIncrement(0),

-    m_autoScrollTimer(0),
-    m_header(0),
-    m_headerWidget(0)
+    m_autoScrollTimer(nullptr),
+    m_header(nullptr),
+    m_headerWidget(nullptr),
+    m_indicatorAnimation(nullptr),
+    m_dropIndicator()

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

+    setAcceptTouchEvents(true);

 
     m_sizeHintResolver = new KItemListSizeHintResolver(this);
 
 
     m_sizeHintResolver = new KItemListSizeHintResolver(this);
 

-    m_layouter = new KItemListViewLayouter(this);
-    m_layouter->setSizeHintResolver(m_sizeHintResolver);
+    m_layouter = new KItemListViewLayouter(m_sizeHintResolver, this);

 
     m_animation = new KItemListViewAnimation(this);
 
     m_animation = new KItemListViewAnimation(this);

-    connect(m_animation, SIGNAL(finished(QGraphicsWidget*,KItemListViewAnimation::AnimationType)),
-            this, SLOT(slotAnimationFinished(QGraphicsWidget*,KItemListViewAnimation::AnimationType)));
+    connect(m_animation, &KItemListViewAnimation::finished,
+            this, &KItemListView::slotAnimationFinished);

 
     m_layoutTimer = new QTimer(this);
     m_layoutTimer->setInterval(300);
     m_layoutTimer->setSingleShot(true);
 
     m_layoutTimer = new QTimer(this);
     m_layoutTimer->setInterval(300);
     m_layoutTimer->setSingleShot(true);

-    connect(m_layoutTimer, SIGNAL(timeout()), this, SLOT(slotLayoutTimerFinished()));
+    connect(m_layoutTimer, &QTimer::timeout, this, &KItemListView::slotLayoutTimerFinished);

 
     m_rubberBand = new KItemListRubberBand(this);
 
     m_rubberBand = new KItemListRubberBand(this);

-    connect(m_rubberBand, SIGNAL(activationChanged(bool)), this, SLOT(slotRubberBandActivationChanged(bool)));
+    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_header = new KItemListHeader(this);
 
     m_headerWidget = new KItemListHeaderWidget(this);
     m_headerWidget->setVisible(false);
 
     m_header = new KItemListHeader(this);

+
+#ifndef QT_NO_ACCESSIBILITY
+    QAccessible::installFactory(accessibleInterfaceFactory);
+#endif
+

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


@@ -117,13 +149,13 @@ KItemListView::~KItemListView()
     // widgetCreator(). So it is mandatory to delete the group headers
     // first.
     delete m_groupHeaderCreator;
     // widgetCreator(). So it is mandatory to delete the group headers
     // first.
     delete m_groupHeaderCreator;

-    m_groupHeaderCreator = 0;
+    m_groupHeaderCreator = nullptr;

 
     delete m_widgetCreator;
 
     delete m_widgetCreator;

-    m_widgetCreator = 0;
+    m_widgetCreator = nullptr;

 
     delete m_sizeHintResolver;
 
     delete m_sizeHintResolver;

-    m_sizeHintResolver = 0;
+    m_sizeHintResolver = nullptr;

 }
 
 void KItemListView::setScrollOffset(qreal offset)
 }
 
 void KItemListView::setScrollOffset(qreal offset)


@@ -184,6 +216,11 @@ qreal KItemListView::maximumItemOffset() const
     return m_layouter->maximumItemOffset();
 }
 
     return m_layouter->maximumItemOffset();
 }
 

+int KItemListView::maximumVisibleItems() const
+{
+    return m_layouter->maximumVisibleItems();
+}
+

 void KItemListView::setVisibleRoles(const QList<QByteArray>& roles)
 {
     const QList<QByteArray> previousRoles = m_visibleRoles;
 void KItemListView::setVisibleRoles(const QList<QByteArray>& roles)
 {
     const QList<QByteArray> previousRoles = m_visibleRoles;


@@ -199,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 : qAsConst(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);


@@ -237,17 +274,17 @@ void KItemListView::setAutoScroll(bool enabled)
     if (enabled && !m_autoScrollTimer) {
         m_autoScrollTimer = new QTimer(this);
         m_autoScrollTimer->setSingleShot(true);
     if (enabled && !m_autoScrollTimer) {
         m_autoScrollTimer = new QTimer(this);
         m_autoScrollTimer->setSingleShot(true);

-        connect(m_autoScrollTimer, SIGNAL(timeout()), this, SLOT(triggerAutoScrolling()));
+        connect(m_autoScrollTimer, &QTimer::timeout, this, &KItemListView::triggerAutoScrolling);

         m_autoScrollTimer->start(InitialAutoScrollDelay);
     } else if (!enabled && m_autoScrollTimer) {
         delete m_autoScrollTimer;
         m_autoScrollTimer->start(InitialAutoScrollDelay);
     } else if (!enabled && m_autoScrollTimer) {
         delete m_autoScrollTimer;

-        m_autoScrollTimer = 0;
+        m_autoScrollTimer = nullptr;

     }
 }
 
 bool KItemListView::autoScroll() const
 {
     }
 }
 
 bool KItemListView::autoScroll() const
 {

-    return m_autoScrollTimer != 0;
+    return m_autoScrollTimer != nullptr;

 }
 
 void KItemListView::setEnabledSelectionToggles(bool enabled)
 }
 
 void KItemListView::setEnabledSelectionToggles(bool enabled)


@@ -280,9 +317,7 @@ KItemModelBase* KItemListView::model() const
 
 void KItemListView::setWidgetCreator(KItemListWidgetCreatorBase* widgetCreator)
 {
 
 void KItemListView::setWidgetCreator(KItemListWidgetCreatorBase* widgetCreator)
 {

-    if (m_widgetCreator) {
-        delete m_widgetCreator;
-    }
+    delete m_widgetCreator;

     m_widgetCreator = widgetCreator;
 }
 
     m_widgetCreator = widgetCreator;
 }
 


@@ -296,9 +331,7 @@ KItemListWidgetCreatorBase* KItemListView::widgetCreator() const
 
 void KItemListView::setGroupHeaderCreator(KItemListGroupHeaderCreatorBase* groupHeaderCreator)
 {
 
 void KItemListView::setGroupHeaderCreator(KItemListGroupHeaderCreatorBase* groupHeaderCreator)
 {

-    if (m_groupHeaderCreator) {
-        delete m_groupHeaderCreator;
-    }
+    delete m_groupHeaderCreator;

     m_groupHeaderCreator = groupHeaderCreator;
 }
 
     m_groupHeaderCreator = groupHeaderCreator;
 }
 


@@ -339,32 +372,24 @@ void KItemListView::setGeometry(const QRectF& rect)
                                          m_itemSize.height());
             m_layouter->setItemSize(dynamicItemSize);
         }
                                          m_itemSize.height());
             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);
+    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);
+}

 
 

-        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);
-        }
+qreal KItemListView::verticalPageStep() const
+{
+    qreal headerHeight = 0;
+    if (m_headerWidget->isVisible()) {
+        headerHeight = m_headerWidget->size().height();

     }
     }

+    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);
     while (it.hasNext()) {
 {
     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
     while (it.hasNext()) {


@@ -372,12 +397,12 @@ int KItemListView::itemAt(const QPointF& pos) const
 
         const KItemListWidget* widget = it.value();
         const QPointF mappedPos = widget->mapFromItem(this, pos);
 
         const KItemListWidget* widget = it.value();
         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


@@ -410,6 +435,19 @@ bool KItemListView::isAboveExpansionToggle(int index, const QPointF& pos) const
     return false;
 }
 
     return false;
 }
 

+bool KItemListView::isAboveText(int index, const QPointF &pos) const
+{
+    const KItemListWidget* widget = m_visibleItems.value(index);
+    if (widget) {
+        const QRectF &textRect = widget->textRect();
+        if (!textRect.isEmpty()) {
+            const QPointF mappedPos = widget->mapFromItem(this, pos);
+            return textRect.contains(mappedPos);
+        }
+    }
+    return false;
+}
+

 int KItemListView::firstVisibleIndex() const
 {
     return m_layouter->firstVisibleIndex();
 int KItemListView::firstVisibleIndex() const
 {
     return m_layouter->firstVisibleIndex();


@@ -420,9 +458,9 @@ int KItemListView::lastVisibleIndex() const
     return m_layouter->lastVisibleIndex();
 }
 
     return m_layouter->lastVisibleIndex();
 }
 

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

 {
 {

-    return widgetCreator()->itemSizeHint(index, this);
+    widgetCreator()->calculateItemSizeHints(logicalHeightHints, logicalWidthHint, this);

 }
 
 void KItemListView::setSupportsItemExpanding(bool supportsExpanding)
 }
 
 void KItemListView::setSupportsItemExpanding(bool supportsExpanding)


@@ -439,6 +477,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);


@@ -457,6 +521,11 @@ QRectF KItemListView::itemContextRect(int index) const
     return contextRect;
 }
 
     return contextRect;
 }
 

+bool KItemListView::isElided(int index) const
+{
+    return m_sizeHintResolver->isElided(index);
+}
+

 void KItemListView::scrollToItem(int index)
 {
     QRectF viewGeometry = geometry();
 void KItemListView::scrollToItem(int index)
 {
     QRectF viewGeometry = geometry();


@@ -464,7 +533,11 @@ void KItemListView::scrollToItem(int index)
         const qreal headerHeight = m_headerWidget->size().height();
         viewGeometry.adjust(0, headerHeight, 0, 0);
     }
         const qreal headerHeight = m_headerWidget->size().height();
         viewGeometry.adjust(0, headerHeight, 0, 0);
     }

-    const 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 (!viewGeometry.contains(currentRect)) {
         qreal newOffset = scrollOffset();
 
     if (!viewGeometry.contains(currentRect)) {
         qreal newOffset = scrollOffset();


@@ -483,9 +556,12 @@ void KItemListView::scrollToItem(int index)
         }
 
         if (newOffset != scrollOffset()) {
         }
 
         if (newOffset != scrollOffset()) {

-            emit scrollTo(newOffset);
+            Q_EMIT scrollTo(newOffset);
+            return;

         }
     }
         }
     }

+
+    Q_EMIT scrollingStopped();

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


@@ -501,7 +577,7 @@ void KItemListView::endTransaction()
     --m_activeTransactions;
     if (m_activeTransactions < 0) {
         m_activeTransactions = 0;
     --m_activeTransactions;
     if (m_activeTransactions < 0) {
         m_activeTransactions = 0;

-        kWarning() << "Mismatch between beginTransaction()/endTransaction()";
+        qCWarning(DolphinDebug) << "Mismatch between beginTransaction()/endTransaction()";

     }
 
     if (m_activeTransactions == 0) {
     }
 
     if (m_activeTransactions == 0) {


@@ -529,26 +605,30 @@ 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, SIGNAL(columnWidthChanged(QByteArray,qreal,qreal)),
-                this, SLOT(slotHeaderColumnWidthChanged(QByteArray,qreal,qreal)));
-        connect(m_headerWidget, SIGNAL(columnMoved(QByteArray,int,int)),
-                this, SLOT(slotHeaderColumnMoved(QByteArray,int,int)));
-        connect(m_headerWidget, SIGNAL(sortOrderChanged(Qt::SortOrder,Qt::SortOrder)),
-                this, SIGNAL(sortOrderChanged(Qt::SortOrder,Qt::SortOrder)));
-        connect(m_headerWidget, SIGNAL(sortRoleChanged(QByteArray,QByteArray)),
-                this, SIGNAL(sortRoleChanged(QByteArray,QByteArray)));
+        connect(m_headerWidget, &KItemListHeaderWidget::columnWidthChanged,
+                this, &KItemListView::slotHeaderColumnWidthChanged);
+        connect(m_headerWidget, &KItemListHeaderWidget::leadingPaddingChanged,
+                this, &KItemListView::slotLeadingPaddingChanged);
+        connect(m_headerWidget, &KItemListHeaderWidget::columnMoved,
+                this, &KItemListView::slotHeaderColumnMoved);
+        connect(m_headerWidget, &KItemListHeaderWidget::sortOrderChanged,
+                this, &KItemListView::sortOrderChanged);
+        connect(m_headerWidget, &KItemListHeaderWidget::sortRoleChanged,
+                this, &KItemListView::sortRoleChanged);

 
         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, SIGNAL(columnWidthChanged(QByteArray,qreal,qreal)),
-                   this, SLOT(slotHeaderColumnWidthChanged(QByteArray,qreal,qreal)));
-        disconnect(m_headerWidget, SIGNAL(columnMoved(QByteArray,int,int)),
-                   this, SLOT(slotHeaderColumnMoved(QByteArray,int,int)));
-        disconnect(m_headerWidget, SIGNAL(sortOrderChanged(Qt::SortOrder,Qt::SortOrder)),
-                   this, SIGNAL(sortOrderChanged(Qt::SortOrder,Qt::SortOrder)));
-        disconnect(m_headerWidget, SIGNAL(sortRoleChanged(QByteArray,QByteArray)),
-                   this, SIGNAL(sortRoleChanged(QByteArray,QByteArray)));
+        disconnect(m_headerWidget, &KItemListHeaderWidget::columnWidthChanged,
+                   this, &KItemListView::slotHeaderColumnWidthChanged);
+        disconnect(m_headerWidget, &KItemListHeaderWidget::leadingPaddingChanged,
+                this, &KItemListView::slotLeadingPaddingChanged);
+        disconnect(m_headerWidget, &KItemListHeaderWidget::columnMoved,
+                   this, &KItemListView::slotHeaderColumnMoved);
+        disconnect(m_headerWidget, &KItemListHeaderWidget::sortOrderChanged,
+                   this, &KItemListView::sortOrderChanged);
+        disconnect(m_headerWidget, &KItemListHeaderWidget::sortRoleChanged,
+                   this, &KItemListView::sortRoleChanged);

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


@@ -565,15 +645,15 @@ KItemListHeader* KItemListView::header() const
     return m_header;
 }
 
     return m_header;
 }
 

-QPixmap KItemListView::createDragPixmap(const QSet<int>& 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.toList().first());
+        KItemListWidget* item = m_visibleItems.value(indexes.first());

         QGraphicsView* graphicsView = scene()->views()[0];
         if (item && graphicsView) {
         QGraphicsView* graphicsView = scene()->views()[0];
         if (item && graphicsView) {

-            pixmap = item->createDragPixmap(0, graphicsView);
+            pixmap = item->createDragPixmap(nullptr, graphicsView);

         }
     } else {
         // TODO: Not implemented yet. Probably extend the interface
         }
     } else {
         // TODO: Not implemented yet. Probably extend the interface


@@ -586,7 +666,7 @@ QPixmap KItemListView::createDragPixmap(const QSet<int>& indexes) const
 
 void KItemListView::editRole(int index, const QByteArray& role)
 {
 
 void KItemListView::editRole(int index, const QByteArray& role)
 {

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

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


@@ -594,16 +674,43 @@ void KItemListView::editRole(int index, const QByteArray& role)
     m_editingRole = true;
     widget->setEditedRole(role);
 
     m_editingRole = true;
     widget->setEditedRole(role);
 

-    connect(widget, SIGNAL(roleEditingCanceled(int,QByteArray,QVariant)),
-            this, SLOT(slotRoleEditingCanceled(int,QByteArray,QVariant)));
-    connect(widget, SIGNAL(roleEditingFinished(int,QByteArray,QVariant)),
-            this, SLOT(slotRoleEditingFinished(int,QByteArray,QVariant)));
+    connect(widget, &KItemListWidget::roleEditingCanceled,
+            this, &KItemListView::slotRoleEditingCanceled);
+    connect(widget, &KItemListWidget::roleEditingFinished,
+            this, &KItemListView::slotRoleEditingFinished);
+
+    connect(this, &KItemListView::scrollOffsetChanged,
+            widget, &KStandardItemListWidget::finishRoleEditing);

 }
 
 void KItemListView::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
 {
     QGraphicsWidget::paint(painter, option, widget);
 
 }
 
 void KItemListView::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
 {
     QGraphicsWidget::paint(painter, option, widget);
 

+    for (auto animation : qAsConst(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()) {
         QRectF rubberBandRect = QRectF(m_rubberBand->startPosition(),
                                        m_rubberBand->endPosition()).normalized();
     if (m_rubberBand->isActive()) {
         QRectF rubberBandRect = QRectF(m_rubberBand->startPosition(),
                                        m_rubberBand->endPosition()).normalized();


@@ -616,12 +723,50 @@ 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);
     }
         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();
+        style()->drawControl(QStyle::CE_RubberBand, &opt, painter);
+    }
+
+    if (!m_dropIndicator.isEmpty()) {
+        const QRectF r = m_dropIndicator.toRect();
+
+        QColor color = palette().brush(QPalette::Normal, QPalette::Text).color();
+        painter->setPen(color);
+
+        // TODO: The following implementation works only for a vertical scroll-orientation
+        // and assumes a height of the m_draggingInsertIndicator of 1.
+        Q_ASSERT(r.height() == 1);
+        painter->drawLine(r.left() + 1, r.top(), r.right() - 1, r.top());
+
+        color.setAlpha(128);
+        painter->setPen(color);
+        painter->drawRect(r.left(), r.top() - 1, r.width() - 1, 2);
+    }
+}
+
+QVariant KItemListView::itemChange(GraphicsItemChange change, const QVariant &value)
+{
+    if (change == QGraphicsItem::ItemSceneHasChanged && scene()) {
+        if (!scene()->views().isEmpty()) {
+            m_styleOption.palette = scene()->views().at(0)->palette();
+        }
+    }
+    return QGraphicsItem::itemChange(change, value);

 }
 
 void KItemListView::setItemSize(const QSizeF& size)
 }
 
 void KItemListView::setItemSize(const QSizeF& size)


@@ -638,7 +783,7 @@ void KItemListView::setItemSize(const QSizeF& size)
                                                 size,
                                                 m_layouter->itemMargin());
 
                                                 size,
                                                 m_layouter->itemMargin());
 

-    const bool alternateBackgroundsChanged = (m_visibleRoles.count() > 1) &&
+    const bool alternateBackgroundsChanged = m_alternateBackgrounds &&

                                              (( m_itemSize.isEmpty() && !size.isEmpty()) ||
                                               (!m_itemSize.isEmpty() && size.isEmpty()));
 
                                              (( m_itemSize.isEmpty() && !size.isEmpty()) ||
                                               (!m_itemSize.isEmpty() && size.isEmpty()));
 


@@ -672,6 +817,10 @@ void KItemListView::setItemSize(const QSizeF& size)
 
 void KItemListView::setStyleOption(const KItemListStyleOption& option)
 {
 
 void KItemListView::setStyleOption(const KItemListStyleOption& option)
 {

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

     const KItemListStyleOption previousOption = m_styleOption;
     m_styleOption = option;
 
     const KItemListStyleOption previousOption = m_styleOption;
     m_styleOption = option;
 


@@ -691,7 +840,8 @@ void KItemListView::setStyleOption(const KItemListStyleOption& option)
         updateGroupHeaderHeight();
     }
 
         updateGroupHeaderHeight();
     }
 

-    if (animate && previousOption.maxTextSize != option.maxTextSize) {
+    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;


@@ -738,7 +888,7 @@ void KItemListView::setScrollOrientation(Qt::Orientation orientation)
     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


@@ -748,70 +898,75 @@ Qt::Orientation KItemListView::scrollOrientation() const
 
 KItemListWidgetCreatorBase* KItemListView::defaultWidgetCreator() const
 {
 
 KItemListWidgetCreatorBase* KItemListView::defaultWidgetCreator() const
 {

-    return 0;
+    return nullptr;

 }
 
 KItemListGroupHeaderCreatorBase* KItemListView::defaultGroupHeaderCreator() const
 {
 }
 
 KItemListGroupHeaderCreatorBase* KItemListView::defaultGroupHeaderCreator() const
 {

-    return 0;
+    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;
 }
 
 void KItemListView::onControllerChanged(KItemListController* current, KItemListController* previous)
 {
     return true;
 }
 
 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)
 {
 }
 
 void KItemListView::onVisibleRolesChanged(const QList<QByteArray>& current, const QList<QByteArray>& previous)
 {

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

 }
 
 void KItemListView::onStyleOptionChanged(const KItemListStyleOption& current, const KItemListStyleOption& previous)
 {
 }
 
 void KItemListView::onStyleOptionChanged(const KItemListStyleOption& current, const KItemListStyleOption& previous)
 {

-    Q_UNUSED(current);
-    Q_UNUSED(previous);
+    Q_UNUSED(current)
+    Q_UNUSED(previous)
+}
+
+void KItemListView::onHighlightEntireRowChanged(bool highlightEntireRow)
+{
+    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()


@@ -824,11 +979,23 @@ void KItemListView::onTransactionEnd()
 
 bool KItemListView::event(QEvent* event)
 {
 
 bool KItemListView::event(QEvent* event)
 {

-    // Forward all events to the controller and handle them there
-    if (!m_editingRole && m_controller && m_controller->processEvent(event, transform())) {
-        event->accept();
-        return true;
+    switch (event->type()) {
+    case QEvent::PaletteChange:
+        updatePalette();
+        break;
+
+    case QEvent::FontChange:
+        updateFont();
+        break;
+
+    default:
+        // Forward all other events to the controller and handle them there
+        if (!m_editingRole && m_controller && m_controller->processEvent(event, transform())) {
+            event->accept();
+            return true;
+        }

     }
     }

+

     return QGraphicsWidget::event(event);
 }
 
     return QGraphicsWidget::event(event);
 }
 


@@ -854,7 +1021,7 @@ void KItemListView::dragEnterEvent(QGraphicsSceneDragDropEvent* event)
     setAutoScroll(true);
 }
 
     setAutoScroll(true);
 }
 

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

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


@@ -864,7 +1031,7 @@ 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);


@@ -881,6 +1048,27 @@ QList<KItemListWidget*> KItemListView::visibleItemListWidgets() const
     return m_visibleItems.values();
 }
 
     return m_visibleItems.values();
 }
 

+void KItemListView::updateFont()
+{
+    if (scene() && !scene()->views().isEmpty()) {
+        KItemListStyleOption option = styleOption();
+        option.font = scene()->views().first()->font();
+        option.fontMetrics = QFontMetrics(option.font);
+
+        setStyleOption(option);
+    }
+}
+
+void KItemListView::updatePalette()
+{
+    if (scene() && !scene()->views().isEmpty()) {
+        KItemListStyleOption option = styleOption();
+        option.palette = scene()->views().first()->palette();
+
+        setStyleOption(option);
+    }
+}
+

 void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
 {
     if (m_itemSize.isEmpty()) {
 void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
 {
     if (m_itemSize.isEmpty()) {


@@ -894,21 +1082,21 @@ void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
 
     m_layouter->markAsDirty();
 
 
     m_layouter->markAsDirty();
 

+    m_sizeHintResolver->itemsInserted(itemRanges);
+

     int previouslyInsertedCount = 0;
     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.
         const int index = range.index + previouslyInsertedCount;
         const int count = range.count;
         if (index < 0 || count <= 0) {
         // 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.
         const int index = range.index + previouslyInsertedCount;
         const int count = range.count;
         if (index < 0 || count <= 0) {

-            kWarning() << "Invalid item range (index:" << index << ", count:" << count << ")";
+            qCWarning(DolphinDebug) << "Invalid item range (index:" << index << ", count:" << count << ")";

             continue;
         }
         previouslyInsertedCount += count;
 
             continue;
         }
         previouslyInsertedCount += count;
 

-        m_sizeHintResolver->itemsInserted(index, count);
-

         // Determine which visible items must be moved
         QList<int> itemsToMove;
         QHashIterator<int, KItemListWidget*> it(m_visibleItems);
         // Determine which visible items must be moved
         QList<int> itemsToMove;
         QHashIterator<int, KItemListWidget*> it(m_visibleItems);


@@ -923,7 +1111,7 @@ 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) {
             KItemListWidget* widget = m_visibleItems.value(itemsToMove[i]);
             Q_ASSERT(widget);
         for (int i = itemsToMove.count() - 1; i >= 0; --i) {
             KItemListWidget* widget = m_visibleItems.value(itemsToMove[i]);
             Q_ASSERT(widget);


@@ -945,11 +1133,17 @@ void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
                                               (!verticalScrollOrientation && maximumScrollOffset() > size().width());
             if (decreaseLayouterSize) {
                 const int scrollBarExtent = style()->pixelMetric(QStyle::PM_ScrollBarExtent);
                                               (!verticalScrollOrientation && maximumScrollOffset() > size().width());
             if (decreaseLayouterSize) {
                 const int scrollBarExtent = style()->pixelMetric(QStyle::PM_ScrollBarExtent);

+
+                int scrollbarSpacing = 0;
+                if (style()->styleHint(QStyle::SH_ScrollView_FrameOnlyAroundContents)) {
+                    scrollbarSpacing = style()->pixelMetric(QStyle::PM_ScrollView_ScrollBarSpacing);
+                }
+

                 QSizeF layouterSize = m_layouter->size();
                 if (verticalScrollOrientation) {
                 QSizeF layouterSize = m_layouter->size();
                 if (verticalScrollOrientation) {

-                    layouterSize.rwidth() -= scrollBarExtent;
+                    layouterSize.rwidth() -= scrollBarExtent + scrollbarSpacing;

                 } else {
                 } else {

-                    layouterSize.rheight() -= scrollBarExtent;
+                    layouterSize.rheight() -= scrollBarExtent + scrollbarSpacing;

                 }
                 m_layouter->setSize(layouterSize);
             }
                 }
                 m_layouter->setSize(layouterSize);
             }


@@ -966,12 +1160,6 @@ void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
     }
 
     if (hasMultipleRanges) {
     }
 
     if (hasMultipleRanges) {

-#ifndef QT_NO_DEBUG
-        // Important: Don't read any m_layouter-property inside the for-loop in case if
-        // multiple ranges are given! m_layouter accesses m_sizeHintResolver which is
-        // updated in each loop-cycle and has only a consistent state after the loop.
-        Q_ASSERT(m_layouter->isDirty());
-#endif

         m_endTransactionAnimationHint = NoAnimation;
         endTransaction();
 
         m_endTransactionAnimationHint = NoAnimation;
         endTransaction();
 


@@ -1005,31 +1193,33 @@ void KItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
 
     m_layouter->markAsDirty();
 
 
     m_layouter->markAsDirty();
 

-    int removedItemsCount = 0;
-    for (int i = 0; i < itemRanges.count(); ++i) {
-        removedItemsCount += itemRanges[i].count;
-    }
+    m_sizeHintResolver->itemsRemoved(itemRanges);

 
     for (int i = itemRanges.count() - 1; i >= 0; --i) {
         const KItemRange& range = itemRanges[i];
         const int index = range.index;
         const int count = range.count;
         if (index < 0 || count <= 0) {
 
     for (int i = itemRanges.count() - 1; i >= 0; --i) {
         const KItemRange& range = itemRanges[i];
         const int index = range.index;
         const int count = range.count;
         if (index < 0 || count <= 0) {

-            kWarning() << "Invalid item range (index:" << index << ", count:" << count << ")";
+            qCWarning(DolphinDebug) << "Invalid item range (index:" << index << ", count:" << count << ")";

             continue;
         }
 
             continue;
         }
 

-        m_sizeHintResolver->itemsRemoved(index, count);
-

         const int firstRemovedIndex = index;
         const int lastRemovedIndex = index + count - 1;
         const int firstRemovedIndex = index;
         const int lastRemovedIndex = index + count - 1;

-        const int lastIndex = m_model->count() - 1 + removedItemsCount;
-        removedItemsCount -= count;
+
+        // Remember which items have to be moved because they are behind the removed range.
+        QVector<int> itemsToMove;

 
         // Remove all KItemListWidget instances that got deleted
 
         // Remove all KItemListWidget instances that got deleted

-        for (int i = firstRemovedIndex; i <= lastRemovedIndex; ++i) {
-            KItemListWidget* widget = m_visibleItems.value(i);
-            if (!widget) {
+        // 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;
+            } else if (i > lastRemovedIndex) {
+                itemsToMove.append(i);

                 continue;
             }
 
                 continue;
             }
 


@@ -1057,17 +1247,18 @@ void KItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
         }
 
         // Update the indexes of all KItemListWidget instances that are located
         }
 
         // Update the indexes of all KItemListWidget instances that are located

-        // after the deleted items
-        for (int i = lastRemovedIndex + 1; i <= lastIndex; ++i) {
+        // 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());
+        for (int i : qAsConst(itemsToMove)) {

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

-            if (widget) {
-                const int newIndex = i - count;
-                if (hasMultipleRanges) {
-                    setWidgetIndex(widget, newIndex);
-                } else {
-                    // Try to animate the moving of the item
-                    moveWidgetToIndex(widget, newIndex);
-                }
+            Q_ASSERT(widget);
+            const int newIndex = i - count;
+            if (hasMultipleRanges) {
+                setWidgetIndex(widget, newIndex);
+            } else {
+                // Try to animate the moving of the item
+                moveWidgetToIndex(widget, newIndex);

             }
         }
 
             }
         }
 


@@ -1089,12 +1280,6 @@ void KItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
     }
 
     if (hasMultipleRanges) {
     }
 
     if (hasMultipleRanges) {

-#ifndef QT_NO_DEBUG
-        // Important: Don't read any m_layouter-property inside the for-loop in case if
-        // multiple ranges are given! m_layouter accesses m_sizeHintResolver which is
-        // updated in each loop-cycle and has only a consistent state after the loop.
-        Q_ASSERT(m_layouter->isDirty());
-#endif

         m_endTransactionAnimationHint = NoAnimation;
         endTransaction();
         updateSiblingsInformation();
         m_endTransactionAnimationHint = NoAnimation;
         endTransaction();
         updateSiblingsInformation();


@@ -1113,7 +1298,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.index, itemRange.count);
+    m_sizeHintResolver->itemsMoved(itemRange, movedToIndexes);

     m_layouter->markAsDirty();
 
     if (m_controller) {
     m_layouter->markAsDirty();
 
     if (m_controller) {


@@ -1143,7 +1328,7 @@ void KItemListView::slotItemsChanged(const KItemRangeList& itemRanges,
         updatePreferredColumnWidths(itemRanges);
     }
 
         updatePreferredColumnWidths(itemRanges);
     }
 

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

         const int index = itemRange.index;
         const int count = itemRange.count;
 
         const int index = itemRange.index;
         const int count = itemRange.count;
 


@@ -1171,9 +1356,21 @@ void KItemListView::slotItemsChanged(const KItemRangeList& itemRanges,
             updateVisibleGroupHeaders();
             doLayout(NoAnimation);
         }
             updateVisibleGroupHeaders();
             doLayout(NoAnimation);
         }

+
+        QAccessibleTableModelChangeEvent ev(this, QAccessibleTableModelChangeEvent::DataChanged);
+        ev.setFirstRow(itemRange.index);
+        ev.setLastRow(itemRange.index + itemRange.count);
+        QAccessible::updateAccessibility(&ev);

     }
 }
 
     }
 }
 

+void KItemListView::slotGroupsChanged()
+{
+    updateVisibleGroupHeaders();
+    doLayout(NoAnimation);
+    updateSiblingsInformation();
+}
+

 void KItemListView::slotGroupedSortingChanged(bool current)
 {
     m_grouped = current;
 void KItemListView::slotGroupedSortingChanged(bool current)
 {
     m_grouped = current;


@@ -1182,8 +1379,10 @@ void KItemListView::slotGroupedSortingChanged(bool current)
     if (m_grouped) {
         updateGroupHeaderHeight();
     } else {
     if (m_grouped) {
         updateGroupHeaderHeight();
     } else {

-        // Clear all visible headers
-        QMutableHashIterator<KItemListWidget*, KItemListGroupHeader*> it (m_visibleGroups);
+        // 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);

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


@@ -1203,8 +1402,8 @@ 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);
     if (m_grouped) {
         updateVisibleGroupHeaders();
         doLayout(NoAnimation);


@@ -1213,8 +1412,8 @@ void KItemListView::slotSortOrderChanged(Qt::SortOrder current, Qt::SortOrder pr
 
 void KItemListView::slotSortRoleChanged(const QByteArray& current, const QByteArray& previous)
 {
 
 void KItemListView::slotSortRoleChanged(const QByteArray& current, const QByteArray& previous)
 {

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

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


@@ -1223,22 +1422,30 @@ 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)

 
 

-    KItemListWidget* previousWidget = m_visibleItems.value(previous, 0);
-    if (previousWidget) {
-        previousWidget->setCurrent(false);
-    }
+    // 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, nullptr);
+        if (previousWidget) {
+            previousWidget->setCurrent(false);
+        }

 
 

-    KItemListWidget* currentWidget = m_visibleItems.value(current, 0);
-    if (currentWidget) {
-        currentWidget->setCurrent(true);
+        KItemListWidget* currentWidget = m_visibleItems.value(current, nullptr);
+        if (currentWidget) {
+            currentWidget->setCurrent(true);
+        }

     }
     }

+
+    QAccessibleEvent ev(this, QAccessible::Focus);
+    ev.setChild(current);
+    QAccessible::updateAccessibility(&ev);

 }
 
 }
 

-void KItemListView::slotSelectionChanged(const QSet<int>& current, const QSet<int>& previous)
+void KItemListView::slotSelectionChanged(const KItemSet& current, const KItemSet& previous)

 {
 {

-    Q_UNUSED(previous);
+    Q_UNUSED(previous)

 
     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
     while (it.hasNext()) {
 
     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
     while (it.hasNext()) {


@@ -1300,12 +1507,36 @@ void KItemListView::slotRubberBandPosChanged()
 void KItemListView::slotRubberBandActivationChanged(bool active)
 {
     if (active) {
 void KItemListView::slotRubberBandActivationChanged(bool active)
 {
     if (active) {

-        connect(m_rubberBand, SIGNAL(startPositionChanged(QPointF,QPointF)), this, SLOT(slotRubberBandPosChanged()));
-        connect(m_rubberBand, SIGNAL(endPositionChanged(QPointF,QPointF)), this, SLOT(slotRubberBandPosChanged()));
+        connect(m_rubberBand, &KItemListRubberBand::startPositionChanged, this, &KItemListView::slotRubberBandPosChanged);
+        connect(m_rubberBand, &KItemListRubberBand::endPositionChanged, this, &KItemListView::slotRubberBandPosChanged);

         m_skipAutoScrollForRubberBand = true;
     } else {
         m_skipAutoScrollForRubberBand = true;
     } else {

-        disconnect(m_rubberBand, SIGNAL(startPositionChanged(QPointF,QPointF)), this, SLOT(slotRubberBandPosChanged()));
-        disconnect(m_rubberBand, SIGNAL(endPositionChanged(QPointF,QPointF)), this, SLOT(slotRubberBandPosChanged()));
+        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;
     }
 
         m_skipAutoScrollForRubberBand = false;
     }
 


@@ -1316,15 +1547,25 @@ void KItemListView::slotHeaderColumnWidthChanged(const QByteArray& role,
                                                  qreal currentWidth,
                                                  qreal previousWidth)
 {
                                                  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::slotLeadingPaddingChanged(qreal width)
+{
+    Q_UNUSED(width)
+    if (m_headerWidget->automaticColumnResizing()) {
+        applyAutomaticColumnWidths();
+    }
+    applyColumnWidthsFromHeader();
+    doLayout(NoAnimation);
+}
+

 void KItemListView::slotHeaderColumnMoved(const QByteArray& role,
                                           int currentIndex,
                                           int previousIndex)
 void KItemListView::slotHeaderColumnMoved(const QByteArray& role,
                                           int currentIndex,
                                           int previousIndex)


@@ -1339,7 +1580,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()


@@ -1396,9 +1637,9 @@ void KItemListView::triggerAutoScrolling()
     const qreal newScrollOffset = qMin(scrollOffset() + m_autoScrollIncrement, maxVisibleOffset);
     setScrollOffset(newScrollOffset);
 
     const qreal newScrollOffset = qMin(scrollOffset() + m_autoScrollIncrement, maxVisibleOffset);
     setScrollOffset(newScrollOffset);
 

-   // Trigger the autoscroll timer which will periodically call
-   // triggerAutoScrolling()
-   m_autoScrollTimer->start(RepeatingAutoScrollDelay);
+    // Trigger the autoscroll timer which will periodically call
+    // triggerAutoScrolling()
+    m_autoScrollTimer->start(RepeatingAutoScrollDelay);

 }
 
 void KItemListView::slotGeometryOfGroupHeaderParentChanged()
 }
 
 void KItemListView::slotGeometryOfGroupHeaderParentChanged()


@@ -1412,14 +1653,18 @@ void KItemListView::slotGeometryOfGroupHeaderParentChanged()
 
 void KItemListView::slotRoleEditingCanceled(int index, const QByteArray& role, const QVariant& value)
 {
 
 void KItemListView::slotRoleEditingCanceled(int index, const QByteArray& role, const QVariant& value)
 {

-    emit roleEditingCanceled(index, role, value);
+    disconnectRoleEditingSignals(index);
+

     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)
 {

-    emit roleEditingFinished(index, role, value);
+    disconnectRoleEditingSignals(index);
+

     m_editingRole = false;
     m_editingRole = false;

+    Q_EMIT roleEditingFinished(index, role, value);

 }
 
 void KItemListView::setController(KItemListController* controller)
 }
 
 void KItemListView::setController(KItemListController* controller)


@@ -1428,16 +1673,16 @@ void KItemListView::setController(KItemListController* controller)
         KItemListController* previous = m_controller;
         if (previous) {
             KItemListSelectionManager* selectionManager = previous->selectionManager();
         KItemListController* previous = m_controller;
         if (previous) {
             KItemListSelectionManager* selectionManager = previous->selectionManager();

-            disconnect(selectionManager, SIGNAL(currentChanged(int,int)), this, SLOT(slotCurrentChanged(int,int)));
-            disconnect(selectionManager, SIGNAL(selectionChanged(QSet<int>,QSet<int>)), this, SLOT(slotSelectionChanged(QSet<int>,QSet<int>)));
+            disconnect(selectionManager, &KItemListSelectionManager::currentChanged, this, &KItemListView::slotCurrentChanged);
+            disconnect(selectionManager, &KItemListSelectionManager::selectionChanged, this, &KItemListView::slotSelectionChanged);

         }
 
         m_controller = controller;
 
         if (controller) {
             KItemListSelectionManager* selectionManager = controller->selectionManager();
         }
 
         m_controller = controller;
 
         if (controller) {
             KItemListSelectionManager* selectionManager = controller->selectionManager();

-            connect(selectionManager, SIGNAL(currentChanged(int,int)), this, SLOT(slotCurrentChanged(int,int)));
-            connect(selectionManager, SIGNAL(selectionChanged(QSet<int>,QSet<int>)), this, SLOT(slotSelectionChanged(QSet<int>,QSet<int>)));
+            connect(selectionManager, &KItemListSelectionManager::currentChanged, this, &KItemListView::slotCurrentChanged);
+            connect(selectionManager, &KItemListSelectionManager::selectionChanged, this, &KItemListView::slotSelectionChanged);

         }
 
         onControllerChanged(controller, previous);
         }
 
         onControllerChanged(controller, previous);


@@ -1453,47 +1698,50 @@ void KItemListView::setModel(KItemModelBase* model)
     KItemModelBase* previous = m_model;
 
     if (m_model) {
     KItemModelBase* previous = m_model;
 
     if (m_model) {

-        disconnect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
-                   this,    SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
-        disconnect(m_model, SIGNAL(itemsInserted(KItemRangeList)),
-                   this,    SLOT(slotItemsInserted(KItemRangeList)));
-        disconnect(m_model, SIGNAL(itemsRemoved(KItemRangeList)),
-                   this,    SLOT(slotItemsRemoved(KItemRangeList)));
-        disconnect(m_model, SIGNAL(itemsMoved(KItemRange,QList<int>)),
-                   this,    SLOT(slotItemsMoved(KItemRange,QList<int>)));
-        disconnect(m_model, SIGNAL(groupedSortingChanged(bool)),
-                   this,    SLOT(slotGroupedSortingChanged(bool)));
-        disconnect(m_model, SIGNAL(sortOrderChanged(Qt::SortOrder,Qt::SortOrder)),
-                   this,    SLOT(slotSortOrderChanged(Qt::SortOrder,Qt::SortOrder)));
-        disconnect(m_model, SIGNAL(sortRoleChanged(QByteArray,QByteArray)),
-                   this,    SLOT(slotSortRoleChanged(QByteArray,QByteArray)));
+        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);
+
+        m_sizeHintResolver->itemsRemoved(KItemRangeList() << KItemRange(0, m_model->count()));

     }
 
     }
 

-    m_sizeHintResolver->clearCache();
-

     m_model = model;
     m_layouter->setModel(model);
     m_grouped = model->groupedSorting();
 
     if (m_model) {
     m_model = model;
     m_layouter->setModel(model);
     m_grouped = model->groupedSorting();
 
     if (m_model) {

-        connect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
-                this,    SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
-        connect(m_model, SIGNAL(itemsInserted(KItemRangeList)),
-                this,    SLOT(slotItemsInserted(KItemRangeList)));
-        connect(m_model, SIGNAL(itemsRemoved(KItemRangeList)),
-                this,    SLOT(slotItemsRemoved(KItemRangeList)));
-        connect(m_model, SIGNAL(itemsMoved(KItemRange,QList<int>)),
-                this,    SLOT(slotItemsMoved(KItemRange,QList<int>)));
-        connect(m_model, SIGNAL(groupedSortingChanged(bool)),
-                this,    SLOT(slotGroupedSortingChanged(bool)));
-        connect(m_model, SIGNAL(sortOrderChanged(Qt::SortOrder,Qt::SortOrder)),
-                this,    SLOT(slotSortOrderChanged(Qt::SortOrder,Qt::SortOrder)));
-        connect(m_model, SIGNAL(sortRoleChanged(QByteArray,QByteArray)),
-                this,    SLOT(slotSortRoleChanged(QByteArray,QByteArray)));
+        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) {

-            m_sizeHintResolver->itemsInserted(0, itemCount);

             slotItemsInserted(KItemRangeList() << KItemRange(0, itemCount));
         }
     }
             slotItemsInserted(KItemRangeList() << KItemRange(0, itemCount));
         }
     }


@@ -1555,13 +1803,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();
         KItemListWidget* widget = m_visibleItems.value(i);
         if (!widget) {
 
         const QRectF itemBounds = m_layouter->itemRect(i);
         const QPointF newPos = itemBounds.topLeft();
         KItemListWidget* widget = m_visibleItems.value(i);
         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();


@@ -1576,18 +1822,22 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
             widget->resize(itemBounds.size());
 
             if (animate && changedCount < 0) {
             widget->resize(itemBounds.size());
 
             if (animate && changedCount < 0) {

-                // Items have been deleted, move the created item to the
-                // imaginary old position. They will get animated to the new position
-                // later.
-                const QRectF itemRect = m_layouter->itemRect(i - changedCount);
-                if (itemRect.isEmpty()) {
-                    const QPointF invisibleOldPos = (scrollOrientation() == Qt::Vertical)
-                                                    ? QPointF(0, size().height()) : QPointF(size().width(), 0);
-                    widget->setPos(invisibleOldPos);
-                } else {
-                    widget->setPos(itemRect.topLeft());
+                // Items have been deleted.
+                if (i >= changedIndex) {
+                    // The item is located behind the removed range. Move the
+                    // created item to the imaginary old position outside the
+                    // view. It will get animated to the new position later.
+                    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);
+                        widget->setPos(invisibleOldPos);
+                    } else {
+                        widget->setPos(itemRect.topLeft());
+                    }
+                    applyNewPos = false;

                 }
                 }

-                applyNewPos = false;

             }
 
             if (supportsExpanding && changedCount == 0) {
             }
 
             if (supportsExpanding && changedCount == 0) {


@@ -1599,9 +1849,14 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
         }
 
         if (animate) {
         }
 
         if (animate) {

+            if (m_animation->isStarted(widget, KItemListViewAnimation::MovingAnimation)) {
+                m_animation->start(widget,  KItemListViewAnimation::MovingAnimation, newPos);
+                applyNewPos = false;
+            }
+

             const bool itemsRemoved = (changedCount < 0);
             const bool itemsInserted = (changedCount > 0);
             const bool itemsRemoved = (changedCount < 0);
             const bool itemsInserted = (changedCount > 0);

-            if (itemsRemoved && (i >= changedIndex + changedCount + 1)) {
+            if (itemsRemoved && (i >= changedIndex)) {

                 // The item is located after the removed items. Animate the moving of the position.
                 applyNewPos = !moveWidget(widget, newPos);
             } else if (itemsInserted && i >= changedIndex) {
                 // The item is located after the removed items. Animate the moving of the position.
                 applyNewPos = !moveWidget(widget, newPos);
             } else if (itemsInserted && i >= changedIndex) {


@@ -1619,9 +1874,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);


@@ -1659,7 +1911,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 : qAsConst(reusableItems)) {

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


@@ -1731,7 +1983,7 @@ bool KItemListView::moveWidget(KItemListWidget* widget,const QPointF& newPos)
 
     if (m_itemSize.isEmpty()) {
         // The items are not aligned in a grid but either as columns or rows.
 
     if (m_itemSize.isEmpty()) {
         // The items are not aligned in a grid but either as columns or rows.

-        startMovingAnim = !supportsItemExpanding();
+        startMovingAnim = true;

     } else {
         // When having a grid the moving-animation should only be started, if it is done within
         // one row in the vertical scroll-orientation or one column in the horizontal scroll-orientation.
     } else {
         // When having a grid the moving-animation should only be started, if it is done within
         // one row in the vertical scroll-orientation or one column in the horizontal scroll-orientation.


@@ -1762,25 +2014,25 @@ 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;
     }
 }


@@ -1854,7 +2106,12 @@ void KItemListView::updateWidgetProperties(KItemListWidget* widget, int index)
     widget->setStyleOption(m_styleOption);
 
     const KItemListSelectionManager* selectionManager = m_controller->selectionManager();
     widget->setStyleOption(m_styleOption);
 
     const KItemListSelectionManager* selectionManager = m_controller->selectionManager();

-    widget->setCurrent(index == selectionManager->currentItem());
+
+    // 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) {
+        widget->setCurrent(index == selectionManager->currentItem());
+    }

     widget->setSelected(selectionManager->isSelected(index));
     widget->setHovered(false);
     widget->setEnabledSelectionToggle(enabledSelectionToggles());
     widget->setSelected(selectionManager->isSelected(index));
     widget->setHovered(false);
     widget->setEnabledSelectionToggle(enabledSelectionToggles());


@@ -1890,7 +2147,7 @@ void KItemListView::updateGroupHeaderForWidget(KItemListWidget* widget)
         groupHeader = groupHeaderCreator()->create(this);
         groupHeader->setParentItem(widget);
         m_visibleGroups.insert(widget, groupHeader);
         groupHeader = groupHeaderCreator()->create(this);
         groupHeader->setParentItem(widget);
         m_visibleGroups.insert(widget, groupHeader);

-        connect(widget, SIGNAL(geometryChanged()), this, SLOT(slotGeometryOfGroupHeaderParentChanged()));
+        connect(widget, &KItemListWidget::geometryChanged, this, &KItemListView::slotGeometryOfGroupHeaderParentChanged);

     }
     Q_ASSERT(groupHeader->parentItem() == widget);
 
     }
     Q_ASSERT(groupHeader->parentItem() == widget);
 


@@ -1934,10 +2191,10 @@ void KItemListView::recycleGroupHeaderForWidget(KItemListWidget* widget)
 {
     KItemListGroupHeader* header = m_visibleGroups.value(widget);
     if (header) {
 {
     KItemListGroupHeader* header = m_visibleGroups.value(widget);
     if (header) {

-        header->setParentItem(0);
+        header->setParentItem(nullptr);

         groupHeaderCreator()->recycle(header);
         m_visibleGroups.remove(widget);
         groupHeaderCreator()->recycle(header);
         m_visibleGroups.remove(widget);

-        disconnect(widget, SIGNAL(geometryChanged()), this, SLOT(slotGeometryOfGroupHeaderParentChanged()));
+        disconnect(widget, &KItemListWidget::geometryChanged, this, &KItemListView::slotGeometryOfGroupHeaderParentChanged);

     }
 }
 
     }
 }
 


@@ -2013,7 +2270,7 @@ 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


@@ -2028,23 +2285,23 @@ QHash<QByteArray, qreal> KItemListView::preferredColumnWidths(const KItemRangeLi
     const QFontMetricsF fontMetrics(m_headerWidget->font());
     const int gripMargin   = m_headerWidget->style()->pixelMetric(QStyle::PM_HeaderGripMargin);
     const int headerMargin = m_headerWidget->style()->pixelMetric(QStyle::PM_HeaderMargin);
     const QFontMetricsF fontMetrics(m_headerWidget->font());
     const int gripMargin   = m_headerWidget->style()->pixelMetric(QStyle::PM_HeaderGripMargin);
     const int headerMargin = m_headerWidget->style()->pixelMetric(QStyle::PM_HeaderMargin);

-    foreach (const QByteArray& visibleRole, visibleRoles()) {
+    for (const QByteArray& visibleRole : qAsConst(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.
     const KItemListWidgetCreatorBase* creator = widgetCreator();
     int calculatedItemCount = 0;
     bool maxTimeExceeded = false;
     // smaller than the width for showing the headline unclipped.
     const KItemListWidgetCreatorBase* creator = widgetCreator();
     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 : qAsConst(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);


@@ -2071,7 +2328,7 @@ 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 qreal requiredWidth = columnWidthsSum() + m_headerWidget->leadingPadding();

     const QSizeF dynamicItemSize(qMax(size().width(), requiredWidth),
                                  m_itemSize.height());
     m_layouter->setItemSize(dynamicItemSize);
     const QSizeF dynamicItemSize(qMax(size().width(), requiredWidth),
                                  m_itemSize.height());
     m_layouter->setItemSize(dynamicItemSize);


@@ -2086,9 +2343,10 @@ void KItemListView::applyColumnWidthsFromHeader()
 
 void KItemListView::updateWidgetColumnWidths(KItemListWidget* widget)
 {
 
 void KItemListView::updateWidgetColumnWidths(KItemListWidget* widget)
 {

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

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

+    widget->setLeadingPadding(m_headerWidget->leadingPadding());

 }
 
 void KItemListView::updatePreferredColumnWidths(const KItemRangeList& itemRanges)
 }
 
 void KItemListView::updatePreferredColumnWidths(const KItemRangeList& itemRanges)


@@ -2096,13 +2354,13 @@ 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 : qAsConst(m_visibleRoles)) {

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


@@ -2157,7 +2415,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 : qAsConst(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);
     }


@@ -2166,7 +2424,7 @@ 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() + m_headerWidget->leadingPadding();

     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


@@ -2204,7 +2462,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 : qAsConst(m_visibleRoles)) {

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


@@ -2286,6 +2544,53 @@ bool KItemListView::scrollBarRequired(const QSizeF& size) const
                                                            : maxOffset > size.width();
 }
 
                                                            : maxOffset > size.width();
 }
 

+int KItemListView::showDropIndicator(const QPointF& pos)
+{
+    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    while (it.hasNext()) {
+        it.next();
+        const KItemListWidget* widget = it.value();
+
+        const QPointF mappedPos = widget->mapFromItem(this, pos);
+        const QRectF rect = itemRect(widget->index());
+        if (mappedPos.y() >= 0 && mappedPos.y() <= rect.height()) {
+            if (m_model->supportsDropping(widget->index())) {
+                // Keep 30% of the rectangle as the gap instead of always having a fixed gap
+                const int gap = qMax(qreal(4.0), qreal(0.3) * rect.height());
+                if (mappedPos.y() >= gap && mappedPos.y() <= rect.height() - gap) {
+                    return -1;
+                }
+            }
+
+            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);
+            if (m_dropIndicator != draggingInsertIndicator) {
+                m_dropIndicator = draggingInsertIndicator;
+                update();
+            }
+
+            int index = widget->index();
+            if (!isAboveItem) {
+                ++index;
+            }
+            return index;
+        }
+    }
+
+    const QRectF firstItemRect = itemRect(firstVisibleIndex());
+    return (pos.y() <= firstItemRect.top()) ? 0 : -1;
+}
+
+void KItemListView::hideDropIndicator()
+{
+    if (!m_dropIndicator.isNull()) {
+        m_dropIndicator = QRectF();
+        update();
+    }
+}
+

 void KItemListView::updateGroupHeaderHeight()
 {
     qreal groupHeaderHeight = m_styleOption.fontMetrics.height();
 void KItemListView::updateGroupHeaderHeight()
 {
     qreal groupHeaderHeight = m_styleOption.fontMetrics.height();


@@ -2348,7 +2653,7 @@ void KItemListView::updateSiblingsInformation(int firstIndex, int lastIndex)
             const int parents = m_model->expandedParentsCount(lastIndex + 1);
             for (int i = lastIndex; i >= firstIndex; --i) {
                 if (m_model->expandedParentsCount(i) != parents) {
             const int parents = m_model->expandedParentsCount(lastIndex + 1);
             for (int i = lastIndex; i >= firstIndex; --i) {
                 if (m_model->expandedParentsCount(i) != parents) {

-                    widget = 0;
+                    widget = nullptr;

                     break;
                 }
             }
                     break;
                 }
             }


@@ -2437,6 +2742,18 @@ bool KItemListView::hasSiblingSuccessor(int index) const
     return hasSuccessor;
 }
 
     return hasSuccessor;
 }
 

+void KItemListView::disconnectRoleEditingSignals(int index)
+{
+    KStandardItemListWidget* widget = qobject_cast<KStandardItemListWidget *>(m_visibleItems.value(index));
+    if (!widget) {
+        return;
+    }
+
+    disconnect(widget, &KItemListWidget::roleEditingCanceled, this, nullptr);
+    disconnect(widget, &KItemListWidget::roleEditingFinished, this, nullptr);
+    disconnect(this, &KItemListView::scrollOffsetChanged, widget, nullptr);
+}
+

 int KItemListView::calculateAutoScrollingIncrement(int pos, int range, int oldInc)
 {
     int inc = 0;
 int KItemListView::calculateAutoScrollingIncrement(int pos, int range, int oldInc)
 {
     int inc = 0;


@@ -2499,7 +2816,7 @@ void KItemListCreatorBase::pushRecycleableWidget(QGraphicsWidget* widget)
 QGraphicsWidget* KItemListCreatorBase::popRecycleableWidget()
 {
     if (m_recycleableWidgets.isEmpty()) {
 QGraphicsWidget* KItemListCreatorBase::popRecycleableWidget()
 {
     if (m_recycleableWidgets.isEmpty()) {

-        return 0;
+        return nullptr;

     }
 
     QGraphicsWidget* widget = m_recycleableWidgets.takeLast();
     }
 
     QGraphicsWidget* widget = m_recycleableWidgets.takeLast();


@@ -2513,7 +2830,7 @@ KItemListWidgetCreatorBase::~KItemListWidgetCreatorBase()
 
 void KItemListWidgetCreatorBase::recycle(KItemListWidget* widget)
 {
 
 void KItemListWidgetCreatorBase::recycle(KItemListWidget* widget)
 {

-    widget->setParentItem(0);
+    widget->setParentItem(nullptr);

     widget->setOpacity(1.0);
     pushRecycleableWidget(widget);
 }
     widget->setOpacity(1.0);
     pushRecycleableWidget(widget);
 }


@@ -2528,4 +2845,3 @@ void KItemListGroupHeaderCreatorBase::recycle(KItemListGroupHeader* header)
     pushRecycleableWidget(header);
 }
 
     pushRecycleableWidget(header);
 }
 

-#include "kitemlistview.moc"