Elide file names in the middle again

[dolphin.git] / src / kitemviews / kitemlistview.cpp
diff --git a/src/kitemviews/kitemlistview.cpp b/src/kitemviews/kitemlistview.cpp

index 7f497210cdd5eb5abc8603319c950f3f374ad9ef..369415f1ba73c4552f93397af205d03379e1f2ec 100644 (file)
--- a/src/kitemviews/kitemlistview.cpp
+++ b/src/kitemviews/kitemlistview.cpp
@@ -1,130 +1,143 @@
-/***************************************************************************
- *   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>
+#ifndef QT_NO_ACCESSIBILITY
+#include "accessibility/kitemlistcontaineraccessible.h"
+#include "accessibility/kitemlistdelegateaccessible.h"
+#include "accessibility/kitemlistviewaccessible.h"
+#endif
+#include "dolphindebug.h"
  #include "kitemlistcontainer.h"
  #include "kitemlistcontroller.h"
  #include "kitemlistheader.h"
  #include "kitemlistselectionmanager.h"
  #include "kitemlistcontainer.h"
  #include "kitemlistcontroller.h"
  #include "kitemlistheader.h"
  #include "kitemlistselectionmanager.h"
-#include "kitemlistwidget.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 <optional>
+
+#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>
  
  
-#include <algorithm>
+namespace
+{
+// Time in ms until reaching the autoscroll margin triggers
+// an initial autoscrolling
+const int InitialAutoScrollDelay = 700;
  
  
-#include "kitemlistviewaccessible.h"
+// Delay in ms for triggering the next autoscroll
+const int RepeatingAutoScrollDelay = 1000 / 60;
  
  
-namespace {
-    // Time in ms until reaching the autoscroll margin triggers
-    // an initial autoscrolling
-    const int InitialAutoScrollDelay = 700;
+// Copied from the Kirigami.Units.shortDuration
+const int RubberFadeSpeed = 150;
  
  
-    // Delay in ms for triggering the next autoscroll
-    const int RepeatingAutoScrollDelay = 1000 / 60;
+const char *RubberPropertyName = "_kitemviews_rubberBandPosition";
  }
  
  #ifndef QT_NO_ACCESSIBILITY
  }
  
  #ifndef QT_NO_ACCESSIBILITY
-QAccessibleInterface* accessibleInterfaceFactory(const QString &key, QObject *object)
+QAccessibleInterface *accessibleInterfaceFactory(const QString &key, QObject *object)
  {
      Q_UNUSED(key)
  
  {
      Q_UNUSED(key)
  
-    if (KItemListContainer* container = qobject_cast<KItemListContainer*>(object)) {
+    if (KItemListContainer *container = qobject_cast<KItemListContainer *>(object)) {
+        if (auto controller = container->controller(); controller) {
+            if (KItemListView *view = controller->view(); view && view->accessibleParent()) {
+                return view->accessibleParent();
+            }
+        }
          return new KItemListContainerAccessible(container);
          return new KItemListContainerAccessible(container);
-    } else if (KItemListView* view = qobject_cast<KItemListView*>(object)) {
-        return new KItemListViewAccessible(view);
+    } else if (KItemListView *view = qobject_cast<KItemListView *>(object)) {
+        return new KItemListViewAccessible(view, view->accessibleParent());
      }
  
      }
  
-    return 0;
+    return nullptr;
  }
  #endif
  
  }
  #endif
  
-KItemListView::KItemListView(QGraphicsWidget* parent) :
-    QGraphicsWidget(parent),
-    m_enabledSelectionToggles(false),
-    m_grouped(false),
-    m_supportsItemExpanding(false),
-    m_editingRole(false),
-    m_activeTransactions(0),
-    m_endTransactionAnimationHint(Animation),
-    m_itemSize(),
-    m_controller(0),
-    m_model(0),
-    m_visibleRoles(),
-    m_widgetCreator(0),
-    m_groupHeaderCreator(0),
-    m_styleOption(),
-    m_visibleItems(),
-    m_visibleGroups(),
-    m_visibleCells(),
-    m_sizeHintResolver(0),
-    m_layouter(0),
-    m_animation(0),
-    m_layoutTimer(0),
-    m_oldScrollOffset(0),
-    m_oldMaximumScrollOffset(0),
-    m_oldItemOffset(0),
-    m_oldMaximumItemOffset(0),
-    m_skipAutoScrollForRubberBand(false),
-    m_rubberBand(0),
-    m_mousePos(),
-    m_autoScrollIncrement(0),
-    m_autoScrollTimer(0),
-    m_header(0),
-    m_headerWidget(0),
-    m_dropIndicator()
+KItemListView::KItemListView(QGraphicsWidget *parent)
+    : QGraphicsWidget(parent)
+    , m_enabledSelectionToggles(false)
+    , m_grouped(false)
+    , m_highlightEntireRow(false)
+    , m_alternateBackgrounds(false)
+    , m_supportsItemExpanding(false)
+    , m_editingRole(false)
+    , m_activeTransactions(0)
+    , m_endTransactionAnimationHint(Animation)
+    , m_itemSize()
+    , m_controller(nullptr)
+    , m_model(nullptr)
+    , m_visibleRoles()
+    , m_widgetCreator(nullptr)
+    , m_groupHeaderCreator(nullptr)
+    , m_styleOption()
+    , m_visibleItems()
+    , m_visibleGroups()
+    , m_visibleCells()
+    , m_scrollBarExtent(0)
+    , m_layouter(nullptr)
+    , m_animation(nullptr)
+    , m_oldScrollOffset(0)
+    , m_oldMaximumScrollOffset(0)
+    , m_oldItemOffset(0)
+    , m_oldMaximumItemOffset(0)
+    , m_skipAutoScrollForRubberBand(false)
+    , m_rubberBand(nullptr)
+    , m_tapAndHoldIndicator(nullptr)
+    , m_mousePos()
+    , m_autoScrollIncrement(0)
+    , m_autoScrollTimer(nullptr)
+    , m_header(nullptr)
+    , m_headerWidget(nullptr)
+    , m_indicatorAnimation(nullptr)
+    , m_dropIndicator()
+    , m_sizeHintResolver(nullptr)
  {
      setAcceptHoverEvents(true);
  {
      setAcceptHoverEvents(true);
+    setAcceptTouchEvents(true);
  
      m_sizeHintResolver = new KItemListSizeHintResolver(this);
  
  
      m_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)));
-
-    m_layoutTimer = new QTimer(this);
-    m_layoutTimer->setInterval(300);
-    m_layoutTimer->setSingleShot(true);
-    connect(m_layoutTimer, SIGNAL(timeout()), this, SLOT(slotLayoutTimerFinished()));
+    connect(m_animation, &KItemListViewAnimation::finished, this, &KItemListView::slotAnimationFinished);
  
      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_headerWidget = new KItemListHeaderWidget(this);
      m_headerWidget->setVisible(false);
@@ -134,7 +147,6 @@ KItemListView::KItemListView(QGraphicsWidget* parent) :
  #ifndef QT_NO_ACCESSIBILITY
      QAccessible::installFactory(accessibleInterfaceFactory);
  #endif
  #ifndef QT_NO_ACCESSIBILITY
      QAccessible::installFactory(accessibleInterfaceFactory);
  #endif
-
  }
  
  KItemListView::~KItemListView()
  }
  
  KItemListView::~KItemListView()
@@ -143,13 +155,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)
@@ -215,7 +227,7 @@ int KItemListView::maximumVisibleItems() const
      return m_layouter->maximumVisibleItems();
  }
  
      return m_layouter->maximumVisibleItems();
  }
  
-void KItemListView::setVisibleRoles(const QList<QByteArray>& roles)
+void KItemListView::setVisibleRoles(const QList<QByteArray> &roles)
  {
      const QList<QByteArray> previousRoles = m_visibleRoles;
      m_visibleRoles = roles;
  {
      const QList<QByteArray> previousRoles = m_visibleRoles;
      m_visibleRoles = roles;
@@ -230,7 +242,7 @@ void KItemListView::setVisibleRoles(const QList<QByteArray>& roles)
          if (!m_headerWidget->automaticColumnResizing()) {
              // The column-width of new roles are still 0. Apply the preferred
              // column-width as default with.
          if (!m_headerWidget->automaticColumnResizing()) {
              // The column-width of new roles are still 0. Apply the preferred
              // column-width as default with.
-            foreach (const QByteArray& role, m_visibleRoles) {
+            for (const QByteArray &role : std::as_const(m_visibleRoles)) {
                  if (m_headerWidget->columnWidth(role) == 0) {
                      const qreal width = m_headerWidget->preferredColumnWidth(role);
                      m_headerWidget->setColumnWidth(role, width);
                  if (m_headerWidget->columnWidth(role) == 0) {
                      const qreal width = m_headerWidget->preferredColumnWidth(role);
                      m_headerWidget->setColumnWidth(role, width);
@@ -241,14 +253,13 @@ void KItemListView::setVisibleRoles(const QList<QByteArray>& roles)
          }
      }
  
          }
      }
  
-    const bool alternateBackgroundsChanged = m_itemSize.isEmpty() &&
-                                             ((roles.count() > 1 && previousRoles.count() <= 1) ||
-                                              (roles.count() <= 1 && previousRoles.count() > 1));
+    const bool alternateBackgroundsChanged =
+        m_itemSize.isEmpty() && ((roles.count() > 1 && previousRoles.count() <= 1) || (roles.count() <= 1 && previousRoles.count() > 1));
  
  
-    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    QHashIterator<int, KItemListWidget *> it(m_visibleItems);
      while (it.hasNext()) {
          it.next();
      while (it.hasNext()) {
          it.next();
-        KItemListWidget* widget = it.value();
+        KItemListWidget *widget = it.value();
          widget->setVisibleRoles(roles);
          if (alternateBackgroundsChanged) {
              updateAlternateBackgroundForWidget(widget);
          widget->setVisibleRoles(roles);
          if (alternateBackgroundsChanged) {
              updateAlternateBackgroundForWidget(widget);
@@ -268,17 +279,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)
@@ -286,7 +297,7 @@ void KItemListView::setEnabledSelectionToggles(bool enabled)
      if (m_enabledSelectionToggles != enabled) {
          m_enabledSelectionToggles = enabled;
  
      if (m_enabledSelectionToggles != enabled) {
          m_enabledSelectionToggles = enabled;
  
-        QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+        QHashIterator<int, KItemListWidget *> it(m_visibleItems);
          while (it.hasNext()) {
              it.next();
              it.value()->setEnabledSelectionToggle(enabled);
          while (it.hasNext()) {
              it.next();
              it.value()->setEnabledSelectionToggle(enabled);
@@ -299,25 +310,23 @@ bool KItemListView::enabledSelectionToggles() const
      return m_enabledSelectionToggles;
  }
  
      return m_enabledSelectionToggles;
  }
  
-KItemListController* KItemListView::controller() const
+KItemListController *KItemListView::controller() const
  {
      return m_controller;
  }
  
  {
      return m_controller;
  }
  
-KItemModelBase* KItemListView::model() const
+KItemModelBase *KItemListView::model() const
  {
      return m_model;
  }
  
  {
      return m_model;
  }
  
-void KItemListView::setWidgetCreator(KItemListWidgetCreatorBase* widgetCreator)
+void KItemListView::setWidgetCreator(KItemListWidgetCreatorBase *widgetCreator)
  {
  {
-    if (m_widgetCreator) {
-        delete m_widgetCreator;
-    }
+    delete m_widgetCreator;
      m_widgetCreator = widgetCreator;
  }
  
      m_widgetCreator = widgetCreator;
  }
  
-KItemListWidgetCreatorBase* KItemListView::widgetCreator() const
+KItemListWidgetCreatorBase *KItemListView::widgetCreator() const
  {
      if (!m_widgetCreator) {
          m_widgetCreator = defaultWidgetCreator();
  {
      if (!m_widgetCreator) {
          m_widgetCreator = defaultWidgetCreator();
@@ -325,15 +334,13 @@ KItemListWidgetCreatorBase* KItemListView::widgetCreator() const
      return m_widgetCreator;
  }
  
      return m_widgetCreator;
  }
  
-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;
  }
  
-KItemListGroupHeaderCreatorBase* KItemListView::groupHeaderCreator() const
+KItemListGroupHeaderCreatorBase *KItemListView::groupHeaderCreator() const
  {
      if (!m_groupHeaderCreator) {
          m_groupHeaderCreator = defaultGroupHeaderCreator();
  {
      if (!m_groupHeaderCreator) {
          m_groupHeaderCreator = defaultGroupHeaderCreator();
@@ -341,17 +348,30 @@ KItemListGroupHeaderCreatorBase* KItemListView::groupHeaderCreator() const
      return m_groupHeaderCreator;
  }
  
      return m_groupHeaderCreator;
  }
  
+#ifndef QT_NO_ACCESSIBILITY
+void KItemListView::setAccessibleParentsObject(KItemListContainer *accessibleParentsObject)
+{
+    Q_ASSERT(!m_accessibleParent);
+    m_accessibleParent = new KItemListContainerAccessible(accessibleParentsObject);
+}
+KItemListContainerAccessible *KItemListView::accessibleParent()
+{
+    Q_CHECK_PTR(m_accessibleParent); // We always want the accessibility tree/hierarchy to be complete.
+    return m_accessibleParent;
+}
+#endif
+
  QSizeF KItemListView::itemSize() const
  {
      return m_itemSize;
  }
  
  QSizeF KItemListView::itemSize() const
  {
      return m_itemSize;
  }
  
-const KItemListStyleOption& KItemListView::styleOption() const
+const KItemListStyleOption &KItemListView::styleOption() const
  {
      return m_styleOption;
  }
  
  {
      return m_styleOption;
  }
  
-void KItemListView::setGeometry(const QRectF& rect)
+void KItemListView::setGeometry(const QRectF &rect)
  {
      QGraphicsWidget::setGeometry(rect);
  
  {
      QGraphicsWidget::setGeometry(rect);
  
@@ -365,34 +385,16 @@ void KItemListView::setGeometry(const QRectF& rect)
          if (m_headerWidget->automaticColumnResizing()) {
              applyAutomaticColumnWidths();
          } else {
          if (m_headerWidget->automaticColumnResizing()) {
              applyAutomaticColumnWidths();
          } else {
-            const qreal requiredWidth = columnWidthsSum();
-            const QSizeF dynamicItemSize(qMax(newSize.width(), requiredWidth),
-                                         m_itemSize.height());
+            const qreal requiredWidth = m_headerWidget->leftPadding() + columnWidthsSum() + m_headerWidget->rightPadding();
+            const QSizeF dynamicItemSize(qMax(newSize.width(), requiredWidth), m_itemSize.height());
              m_layouter->setItemSize(dynamicItemSize);
          }
              m_layouter->setItemSize(dynamicItemSize);
          }
-
-        // Triggering a synchronous layout is fine from a performance point of view,
-        // as with dynamic item sizes no moving animation must be done.
-        m_layouter->setSize(newSize);
-        doLayout(NoAnimation);
-    } else {
-        const bool animate = !changesItemGridLayout(newSize,
-                                                    m_layouter->itemSize(),
-                                                    m_layouter->itemMargin());
-        m_layouter->setSize(newSize);
-
-        if (animate) {
-            // Trigger an asynchronous relayout with m_layoutTimer to prevent
-            // performance bottlenecks. If the timer is exceeded, an animated layout
-            // will be triggered.
-            if (!m_layoutTimer->isActive()) {
-                m_layoutTimer->start();
-            }
-        } else {
-            m_layoutTimer->stop();
-            doLayout(NoAnimation);
-        }
      }
      }
+
+    m_layouter->setSize(newSize);
+    // We don't animate the moving of the items here because
+    // it would look like the items are slow to find their position.
+    doLayout(NoAnimation);
  }
  
  qreal KItemListView::verticalPageStep() const
  }
  
  qreal KItemListView::verticalPageStep() const
@@ -404,29 +406,33 @@ qreal KItemListView::verticalPageStep() const
      return size().height() - headerHeight;
  }
  
      return size().height() - headerHeight;
  }
  
-int KItemListView::itemAt(const QPointF& pos) const
+std::optional<int> KItemListView::itemAt(const QPointF &pos) const
  {
  {
-    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    if (headerBoundaries().contains(pos)) {
+        return std::nullopt;
+    }
+
+    QHashIterator<int, KItemListWidget *> it(m_visibleItems);
      while (it.hasNext()) {
          it.next();
  
      while (it.hasNext()) {
          it.next();
  
-        const KItemListWidget* widget = it.value();
+        const KItemListWidget *widget = it.value();
          const QPointF mappedPos = widget->mapFromItem(this, pos);
          const QPointF mappedPos = widget->mapFromItem(this, pos);
-        if (widget->contains(mappedPos)) {
+        if (widget->contains(mappedPos) || widget->selectionRect().contains(mappedPos)) {
              return it.key();
          }
      }
  
              return it.key();
          }
      }
  
-    return -1;
+    return std::nullopt;
  }
  
  }
  
-bool KItemListView::isAboveSelectionToggle(int index, const QPointF& pos) const
+bool KItemListView::isAboveSelectionToggle(int index, const QPointF &pos) const
  {
      if (!m_enabledSelectionToggles) {
          return false;
      }
  
  {
      if (!m_enabledSelectionToggles) {
          return false;
      }
  
-    const KItemListWidget* widget = m_visibleItems.value(index);
+    const KItemListWidget *widget = m_visibleItems.value(index);
      if (widget) {
          const QRectF selectionToggleRect = widget->selectionToggleRect();
          if (!selectionToggleRect.isEmpty()) {
      if (widget) {
          const QRectF selectionToggleRect = widget->selectionToggleRect();
          if (!selectionToggleRect.isEmpty()) {
@@ -437,9 +443,9 @@ bool KItemListView::isAboveSelectionToggle(int index, const QPointF& pos) const
      return false;
  }
  
      return false;
  }
  
-bool KItemListView::isAboveExpansionToggle(int index, const QPointF& pos) const
+bool KItemListView::isAboveExpansionToggle(int index, const QPointF &pos) const
  {
  {
-    const KItemListWidget* widget = m_visibleItems.value(index);
+    const KItemListWidget *widget = m_visibleItems.value(index);
      if (widget) {
          const QRectF expansionToggleRect = widget->expansionToggleRect();
          if (!expansionToggleRect.isEmpty()) {
      if (widget) {
          const QRectF expansionToggleRect = widget->expansionToggleRect();
          if (!expansionToggleRect.isEmpty()) {
@@ -450,6 +456,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();
@@ -460,9 +479,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)
@@ -479,6 +498,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);
@@ -488,7 +533,7 @@ QRectF KItemListView::itemContextRect(int index) const
  {
      QRectF contextRect;
  
  {
      QRectF contextRect;
  
-    const KItemListWidget* widget = m_visibleItems.value(index);
+    const KItemListWidget *widget = m_visibleItems.value(index);
      if (widget) {
          contextRect = widget->iconRect() | widget->textRect();
          contextRect.translate(itemRect(index).topLeft());
      if (widget) {
          contextRect = widget->iconRect() | widget->textRect();
          contextRect.translate(itemRect(index).topLeft());
@@ -497,7 +542,12 @@ QRectF KItemListView::itemContextRect(int index) const
      return contextRect;
  }
  
      return contextRect;
  }
  
-void KItemListView::scrollToItem(int index)
+bool KItemListView::isElided(int index) const
+{
+    return m_sizeHintResolver->isElided(index);
+}
+
+void KItemListView::scrollToItem(int index, ViewItemPosition viewItemPosition)
  {
      QRectF viewGeometry = geometry();
      if (m_headerWidget->isVisible()) {
  {
      QRectF viewGeometry = geometry();
      if (m_headerWidget->isVisible()) {
@@ -506,30 +556,92 @@ void KItemListView::scrollToItem(int index)
      }
      QRectF currentRect = itemRect(index);
  
      }
      QRectF currentRect = itemRect(index);
  
-    // Fix for Bug 311099 - View the underscore when using Ctrl + PagDown
-    currentRect.adjust(-m_styleOption.horizontalMargin, -m_styleOption.verticalMargin,
-                        m_styleOption.horizontalMargin,  m_styleOption.verticalMargin);
+    if (layoutDirection() == Qt::RightToLeft && scrollOrientation() == Qt::Horizontal) {
+        currentRect.moveLeft(m_layouter->size().width() - currentRect.right());
+    }
  
  
-    if (!viewGeometry.contains(currentRect)) {
-        qreal newOffset = scrollOffset();
-        if (scrollOrientation() == Qt::Vertical) {
-            if (currentRect.top() < viewGeometry.top()) {
-                newOffset += currentRect.top() - viewGeometry.top();
-            } else if (currentRect.bottom() > viewGeometry.bottom()) {
-                newOffset += currentRect.bottom() - viewGeometry.bottom();
+    // Fix for Bug 311099 - View the underscore when using Ctrl + PageDown
+    currentRect.adjust(-m_styleOption.horizontalMargin, -m_styleOption.verticalMargin, m_styleOption.horizontalMargin, m_styleOption.verticalMargin);
+
+    qreal offset = 0;
+    switch (scrollOrientation()) {
+    case Qt::Vertical:
+        if (currentRect.top() < viewGeometry.top() || currentRect.bottom() > viewGeometry.bottom()) {
+            switch (viewItemPosition) {
+            case Beginning:
+                offset = currentRect.top() - viewGeometry.top();
+                break;
+            case Middle:
+                offset = 0.5 * (currentRect.top() + currentRect.bottom() - (viewGeometry.top() + viewGeometry.bottom()));
+                break;
+            case End:
+                offset = currentRect.bottom() - viewGeometry.bottom();
+                break;
+            case Nearest:
+                if (currentRect.top() < viewGeometry.top()) {
+                    offset = currentRect.top() - viewGeometry.top();
+                }
+                if (currentRect.bottom() > viewGeometry.bottom() + offset) {
+                    offset += currentRect.bottom() - viewGeometry.bottom() - offset;
+                }
+                break;
+            default:
+                Q_UNREACHABLE();
              }
              }
-        } else {
-            if (currentRect.left() < viewGeometry.left()) {
-                newOffset += currentRect.left() - viewGeometry.left();
-            } else if (currentRect.right() > viewGeometry.right()) {
-                newOffset += currentRect.right() - viewGeometry.right();
+        }
+        break;
+    case Qt::Horizontal:
+        if (currentRect.left() < viewGeometry.left() || currentRect.right() > viewGeometry.right()) {
+            switch (viewItemPosition) {
+            case Beginning:
+                if (layoutDirection() == Qt::RightToLeft) {
+                    offset = currentRect.right() - viewGeometry.right();
+                } else {
+                    offset = currentRect.left() - viewGeometry.left();
+                }
+                break;
+            case Middle:
+                offset = 0.5 * (currentRect.left() + currentRect.right() - (viewGeometry.left() + viewGeometry.right()));
+                break;
+            case End:
+                if (layoutDirection() == Qt::RightToLeft) {
+                    offset = currentRect.left() - viewGeometry.left();
+                } else {
+                    offset = currentRect.right() - viewGeometry.right();
+                }
+                break;
+            case Nearest:
+                if (layoutDirection() == Qt::RightToLeft) {
+                    if (currentRect.left() < viewGeometry.left()) {
+                        offset = currentRect.left() - viewGeometry.left();
+                    }
+                    if (currentRect.right() > viewGeometry.right() + offset) {
+                        offset += currentRect.right() - viewGeometry.right() - offset;
+                    }
+                } else {
+                    if (currentRect.right() > viewGeometry.right()) {
+                        offset = currentRect.right() - viewGeometry.right();
+                    }
+                    if (currentRect.left() < viewGeometry.left() + offset) {
+                        offset += currentRect.left() - viewGeometry.left() - offset;
+                    }
+                }
+                break;
+            default:
+                Q_UNREACHABLE();
              }
          }
              }
          }
+        break;
+    default:
+        Q_UNREACHABLE();
+    }
  
  
-        if (newOffset != scrollOffset()) {
-            emit scrollTo(newOffset);
-        }
+    if (!qFuzzyIsNull(offset)) {
+        Q_EMIT scrollTo(scrollOffset() + offset);
+        return;
      }
      }
+
+    Q_EMIT scrollingStopped();
  }
  
  void KItemListView::beginTransaction()
  }
  
  void KItemListView::beginTransaction()
@@ -545,7 +657,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) {
@@ -564,8 +676,7 @@ void KItemListView::setHeaderVisible(bool visible)
  {
      if (visible && !m_headerWidget->isVisible()) {
          QStyleOptionHeader option;
  {
      if (visible && !m_headerWidget->isVisible()) {
          QStyleOptionHeader option;
-        const QSize headerSize = style()->sizeFromContents(QStyle::CT_HeaderSection,
-                                                           &option, QSize());
+        const QSize headerSize = style()->sizeFromContents(QStyle::CT_HeaderSection, &option, QSize());
  
          m_headerWidget->setPos(0, 0);
          m_headerWidget->resize(size().width(), headerSize.height());
  
          m_headerWidget->setPos(0, 0);
          m_headerWidget->resize(size().width(), headerSize.height());
@@ -573,26 +684,24 @@ void KItemListView::setHeaderVisible(bool visible)
          m_headerWidget->setColumns(m_visibleRoles);
          m_headerWidget->setZValue(1);
  
          m_headerWidget->setColumns(m_visibleRoles);
          m_headerWidget->setZValue(1);
  
-        connect(m_headerWidget, 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::sidePaddingChanged, this, &KItemListView::slotSidePaddingChanged);
+        connect(m_headerWidget, &KItemListHeaderWidget::columnMoved, this, &KItemListView::slotHeaderColumnMoved);
+        connect(m_headerWidget, &KItemListHeaderWidget::sortOrderChanged, this, &KItemListView::sortOrderChanged);
+        connect(m_headerWidget, &KItemListHeaderWidget::sortRoleChanged, this, &KItemListView::sortRoleChanged);
+        connect(m_headerWidget, &KItemListHeaderWidget::columnHovered, this, &KItemListView::columnHovered);
+        connect(m_headerWidget, &KItemListHeaderWidget::columnUnHovered, this, &KItemListView::columnUnHovered);
  
          m_layouter->setHeaderHeight(headerSize.height());
          m_headerWidget->setVisible(true);
      } else if (!visible && m_headerWidget->isVisible()) {
  
          m_layouter->setHeaderHeight(headerSize.height());
          m_headerWidget->setVisible(true);
      } else if (!visible && m_headerWidget->isVisible()) {
-        disconnect(m_headerWidget, 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::sidePaddingChanged, this, &KItemListView::slotSidePaddingChanged);
+        disconnect(m_headerWidget, &KItemListHeaderWidget::columnMoved, this, &KItemListView::slotHeaderColumnMoved);
+        disconnect(m_headerWidget, &KItemListHeaderWidget::sortOrderChanged, this, &KItemListView::sortOrderChanged);
+        disconnect(m_headerWidget, &KItemListHeaderWidget::sortRoleChanged, this, &KItemListView::sortRoleChanged);
+        disconnect(m_headerWidget, &KItemListHeaderWidget::columnHovered, this, &KItemListView::columnHovered);
+        disconnect(m_headerWidget, &KItemListHeaderWidget::columnUnHovered, this, &KItemListView::columnUnHovered);
  
          m_layouter->setHeaderHeight(0);
          m_headerWidget->setVisible(false);
  
          m_layouter->setHeaderHeight(0);
          m_headerWidget->setVisible(false);
@@ -604,20 +713,20 @@ bool KItemListView::isHeaderVisible() const
      return m_headerWidget->isVisible();
  }
  
      return m_headerWidget->isVisible();
  }
  
-KItemListHeader* KItemListView::header() const
+KItemListHeader *KItemListView::header() const
  {
      return m_header;
  }
  
  {
      return m_header;
  }
  
-QPixmap KItemListView::createDragPixmap(const KItemSet& indexes) const
+QPixmap KItemListView::createDragPixmap(const KItemSet &indexes) const
  {
      QPixmap pixmap;
  
      if (indexes.count() == 1) {
  {
      QPixmap pixmap;
  
      if (indexes.count() == 1) {
-        KItemListWidget* item = m_visibleItems.value(indexes.first());
-        QGraphicsView* graphicsView = scene()->views()[0];
+        KItemListWidget *item = m_visibleItems.value(indexes.first());
+        QGraphicsView *graphicsView = scene()->views()[0];
          if (item && graphicsView) {
          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
@@ -628,29 +737,53 @@ QPixmap KItemListView::createDragPixmap(const KItemSet& indexes) const
      return pixmap;
  }
  
      return pixmap;
  }
  
-void KItemListView::editRole(int index, const QByteArray& role)
+void KItemListView::editRole(int index, const QByteArray &role)
  {
  {
-    KItemListWidget* widget = m_visibleItems.value(index);
+    KStandardItemListWidget *widget = qobject_cast<KStandardItemListWidget *>(m_visibleItems.value(index));
      if (!widget || m_editingRole) {
          return;
      }
  
      m_editingRole = true;
      if (!widget || m_editingRole) {
          return;
      }
  
      m_editingRole = true;
+    m_controller->selectionManager()->setCurrentItem(index);
      widget->setEditedRole(role);
  
      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)
+void KItemListView::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
  {
      QGraphicsWidget::paint(painter, option, widget);
  
  {
      QGraphicsWidget::paint(painter, option, widget);
  
+    for (auto animation : std::as_const(m_rubberBandAnimations)) {
+        QRectF rubberBandRect = animation->property(RubberPropertyName).toRectF();
+
+        const QPointF topLeft = rubberBandRect.topLeft();
+        if (scrollOrientation() == Qt::Vertical) {
+            rubberBandRect.moveTo(topLeft.x(), topLeft.y() - scrollOffset());
+        } else {
+            rubberBandRect.moveTo(topLeft.x() - scrollOffset(), topLeft.y());
+        }
+
+        QStyleOptionRubberBand opt;
+        initStyleOption(&opt);
+        opt.shape = QRubberBand::Rectangle;
+        opt.opaque = false;
+        opt.rect = rubberBandRect.toRect();
+
+        painter->save();
+
+        painter->setOpacity(animation->currentValue().toReal());
+        style()->drawControl(QStyle::CE_RubberBand, &opt, painter);
+
+        painter->restore();
+    }
+
      if (m_rubberBand->isActive()) {
      if (m_rubberBand->isActive()) {
-        QRectF rubberBandRect = QRectF(m_rubberBand->startPosition(),
-                                       m_rubberBand->endPosition()).normalized();
+        QRectF rubberBandRect = QRectF(m_rubberBand->startPosition(), m_rubberBand->endPosition()).normalized();
  
          const QPointF topLeft = rubberBandRect.topLeft();
          if (scrollOrientation() == Qt::Vertical) {
  
          const QPointF topLeft = rubberBandRect.topLeft();
          if (scrollOrientation() == Qt::Vertical) {
@@ -660,7 +793,19 @@ void KItemListView::paint(QPainter* painter, const QStyleOptionGraphicsItem* opt
          }
  
          QStyleOptionRubberBand opt;
          }
  
          QStyleOptionRubberBand opt;
-        opt.initFrom(widget);
+        initStyleOption(&opt);
+        opt.shape = QRubberBand::Rectangle;
+        opt.opaque = false;
+        opt.rect = rubberBandRect.toRect();
+        style()->drawControl(QStyle::CE_RubberBand, &opt, painter);
+    }
+
+    if (m_tapAndHoldIndicator->isActive()) {
+        const QPointF indicatorSize = m_tapAndHoldIndicator->endPosition();
+        const QRectF rubberBandRect =
+            QRectF(m_tapAndHoldIndicator->startPosition() - indicatorSize, (m_tapAndHoldIndicator->startPosition()) + indicatorSize).normalized();
+        QStyleOptionRubberBand opt;
+        initStyleOption(&opt);
          opt.shape = QRubberBand::Rectangle;
          opt.opaque = false;
          opt.rect = rubberBandRect.toRect();
          opt.shape = QRubberBand::Rectangle;
          opt.opaque = false;
          opt.rect = rubberBandRect.toRect();
@@ -670,7 +815,7 @@ void KItemListView::paint(QPainter* painter, const QStyleOptionGraphicsItem* opt
      if (!m_dropIndicator.isEmpty()) {
          const QRectF r = m_dropIndicator.toRect();
  
      if (!m_dropIndicator.isEmpty()) {
          const QRectF r = m_dropIndicator.toRect();
  
-        QColor color = palette().brush(QPalette::Normal, QPalette::Highlight).color();
+        QColor color = palette().brush(QPalette::Normal, QPalette::Text).color();
          painter->setPen(color);
  
          // TODO: The following implementation works only for a vertical scroll-orientation
          painter->setPen(color);
  
          // TODO: The following implementation works only for a vertical scroll-orientation
@@ -694,7 +839,7 @@ QVariant KItemListView::itemChange(GraphicsItemChange change, const QVariant &va
      return QGraphicsItem::itemChange(change, value);
  }
  
      return QGraphicsItem::itemChange(change, value);
  }
  
-void KItemListView::setItemSize(const QSizeF& size)
+void KItemListView::setItemSize(const QSizeF &size)
  {
      const QSizeF previousSize = m_itemSize;
      if (size == previousSize) {
  {
      const QSizeF previousSize = m_itemSize;
      if (size == previousSize) {
@@ -704,13 +849,9 @@ void KItemListView::setItemSize(const QSizeF& size)
      // Skip animations when the number of rows or columns
      // are changed in the grid layout. Although the animation
      // engine can handle this usecase, it looks obtrusive.
      // Skip animations when the number of rows or columns
      // are changed in the grid layout. Although the animation
      // engine can handle this usecase, it looks obtrusive.
-    const bool animate = !changesItemGridLayout(m_layouter->size(),
-                                                size,
-                                                m_layouter->itemMargin());
+    const bool animate = !changesItemGridLayout(m_layouter->size(), size, m_layouter->itemMargin());
  
  
-    const bool alternateBackgroundsChanged = (m_visibleRoles.count() > 1) &&
-                                             (( m_itemSize.isEmpty() && !size.isEmpty()) ||
-                                              (!m_itemSize.isEmpty() && size.isEmpty()));
+    const bool alternateBackgroundsChanged = m_alternateBackgrounds && ((m_itemSize.isEmpty() && !size.isEmpty()) || (!m_itemSize.isEmpty() && size.isEmpty()));
  
      m_itemSize = size;
  
  
      m_itemSize = size;
  
@@ -740,8 +881,12 @@ void KItemListView::setItemSize(const QSizeF& size)
      onItemSizeChanged(size, previousSize);
  }
  
      onItemSizeChanged(size, previousSize);
  }
  
-void KItemListView::setStyleOption(const KItemListStyleOption& option)
+void KItemListView::setStyleOption(const KItemListStyleOption &option)
  {
  {
+    if (m_styleOption == option) {
+        return;
+    }
+
      const KItemListStyleOption previousOption = m_styleOption;
      m_styleOption = option;
  
      const KItemListStyleOption previousOption = m_styleOption;
      m_styleOption = option;
  
@@ -751,9 +896,7 @@ void KItemListView::setStyleOption(const KItemListStyleOption& option)
          // Skip animations when the number of rows or columns
          // are changed in the grid layout. Although the animation
          // engine can handle this usecase, it looks obtrusive.
          // Skip animations when the number of rows or columns
          // are changed in the grid layout. Although the animation
          // engine can handle this usecase, it looks obtrusive.
-        animate = !changesItemGridLayout(m_layouter->size(),
-                                         m_layouter->itemSize(),
-                                         margin);
+        animate = !changesItemGridLayout(m_layouter->size(), m_layouter->itemSize(), margin);
          m_layouter->setItemMargin(margin);
      }
  
          m_layouter->setItemMargin(margin);
      }
  
@@ -761,13 +904,13 @@ 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;
      }
  
-    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    QHashIterator<int, KItemListWidget *> it(m_visibleItems);
      while (it.hasNext()) {
          it.next();
          it.value()->setStyleOption(option);
      while (it.hasNext()) {
          it.next();
          it.value()->setStyleOption(option);
@@ -796,19 +939,18 @@ void KItemListView::setScrollOrientation(Qt::Orientation orientation)
      m_sizeHintResolver->clearCache();
  
      if (m_grouped) {
      m_sizeHintResolver->clearCache();
  
      if (m_grouped) {
-        QMutableHashIterator<KItemListWidget*, KItemListGroupHeader*> it (m_visibleGroups);
+        QMutableHashIterator<KItemListWidget *, KItemListGroupHeader *> it(m_visibleGroups);
          while (it.hasNext()) {
              it.next();
              it.value()->setScrollOrientation(orientation);
          }
          updateGroupHeaderHeight();
          while (it.hasNext()) {
              it.next();
              it.value()->setScrollOrientation(orientation);
          }
          updateGroupHeaderHeight();
-
      }
  
      doLayout(NoAnimation);
  
      onScrollOrientationChanged(orientation, previousOrientation);
      }
  
      doLayout(NoAnimation);
  
      onScrollOrientationChanged(orientation, previousOrientation);
-    emit scrollOrientationChanged(orientation, previousOrientation);
+    Q_EMIT scrollOrientationChanged(orientation, previousOrientation);
  }
  
  Qt::Orientation KItemListView::scrollOrientation() const
  }
  
  Qt::Orientation KItemListView::scrollOrientation() const
@@ -816,72 +958,77 @@ Qt::Orientation KItemListView::scrollOrientation() const
      return m_layouter->scrollOrientation();
  }
  
      return m_layouter->scrollOrientation();
  }
  
-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;
  }
  
      return true;
  }
  
-void KItemListView::onControllerChanged(KItemListController* current, KItemListController* previous)
+void KItemListView::onControllerChanged(KItemListController *current, KItemListController *previous)
  {
  {
-    Q_UNUSED(current);
-    Q_UNUSED(previous);
+    Q_UNUSED(current)
+    Q_UNUSED(previous)
  }
  
  }
  
-void KItemListView::onModelChanged(KItemModelBase* current, KItemModelBase* previous)
+void KItemListView::onModelChanged(KItemModelBase *current, KItemModelBase *previous)
  {
  {
-    Q_UNUSED(current);
-    Q_UNUSED(previous);
+    Q_UNUSED(current)
+    Q_UNUSED(previous)
  }
  
  void KItemListView::onScrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous)
  {
  }
  
  void KItemListView::onScrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous)
  {
-    Q_UNUSED(current);
-    Q_UNUSED(previous);
+    Q_UNUSED(current)
+    Q_UNUSED(previous)
  }
  
  }
  
-void KItemListView::onItemSizeChanged(const QSizeF& current, const QSizeF& previous)
+void KItemListView::onItemSizeChanged(const QSizeF &current, const QSizeF &previous)
  {
  {
-    Q_UNUSED(current);
-    Q_UNUSED(previous);
+    Q_UNUSED(current)
+    Q_UNUSED(previous)
  }
  
  void KItemListView::onScrollOffsetChanged(qreal current, qreal previous)
  {
  }
  
  void KItemListView::onScrollOffsetChanged(qreal current, qreal previous)
  {
-    Q_UNUSED(current);
-    Q_UNUSED(previous);
+    Q_UNUSED(current)
+    Q_UNUSED(previous)
  }
  
  }
  
-void KItemListView::onVisibleRolesChanged(const QList<QByteArray>& current, const QList<QByteArray>& previous)
+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()
@@ -892,23 +1039,47 @@ 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())) {
+    switch (event->type()) {
+    case QEvent::PaletteChange:
+        updatePalette();
+        break;
+
+    case QEvent::FontChange:
+        updateFont();
+        break;
+
+    case QEvent::FocusIn:
+        focusInEvent(static_cast<QFocusEvent *>(event));
          event->accept();
          return true;
          event->accept();
          return true;
+        break;
+
+    case QEvent::FocusOut:
+        focusOutEvent(static_cast<QFocusEvent *>(event));
+        event->accept();
+        return true;
+        break;
+
+    default:
+        // Forward all other events to the controller and handle them there
+        if (!m_editingRole && m_controller && m_controller->processEvent(event, transform())) {
+            event->accept();
+            return true;
+        }
      }
      }
+
      return QGraphicsWidget::event(event);
  }
  
      return QGraphicsWidget::event(event);
  }
  
-void KItemListView::mousePressEvent(QGraphicsSceneMouseEvent* event)
+void KItemListView::mousePressEvent(QGraphicsSceneMouseEvent *event)
  {
      m_mousePos = transform().map(event->pos());
      event->accept();
  }
  
  {
      m_mousePos = transform().map(event->pos());
      event->accept();
  }
  
-void KItemListView::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
+void KItemListView::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
  {
      QGraphicsWidget::mouseMoveEvent(event);
  
  {
      QGraphicsWidget::mouseMoveEvent(event);
  
@@ -918,7 +1089,7 @@ void KItemListView::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
      }
  }
  
      }
  }
  
-void KItemListView::dragEnterEvent(QGraphicsSceneDragDropEvent* event)
+void KItemListView::dragEnterEvent(QGraphicsSceneDragDropEvent *event)
  {
      event->setAccepted(true);
      setAutoScroll(true);
  {
      event->setAccepted(true);
      setAutoScroll(true);
@@ -940,18 +1111,36 @@ void KItemListView::dragLeaveEvent(QGraphicsSceneDragDropEvent *event)
      setAutoScroll(false);
  }
  
      setAutoScroll(false);
  }
  
-void KItemListView::dropEvent(QGraphicsSceneDragDropEvent* event)
+void KItemListView::dropEvent(QGraphicsSceneDragDropEvent *event)
  {
      QGraphicsWidget::dropEvent(event);
      setAutoScroll(false);
  }
  
  {
      QGraphicsWidget::dropEvent(event);
      setAutoScroll(false);
  }
  
-QList<KItemListWidget*> KItemListView::visibleItemListWidgets() const
+QList<KItemListWidget *> KItemListView::visibleItemListWidgets() const
  {
      return m_visibleItems.values();
  }
  
  {
      return m_visibleItems.values();
  }
  
-void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
+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()
+{
+    KItemListStyleOption option = styleOption();
+    option.palette = palette();
+    setStyleOption(option);
+}
+
+void KItemListView::slotItemsInserted(const KItemRangeList &itemRanges)
  {
      if (m_itemSize.isEmpty()) {
          updatePreferredColumnWidths(itemRanges);
  {
      if (m_itemSize.isEmpty()) {
          updatePreferredColumnWidths(itemRanges);
@@ -967,21 +1156,21 @@ void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
      m_sizeHintResolver->itemsInserted(itemRanges);
  
      int previouslyInsertedCount = 0;
      m_sizeHintResolver->itemsInserted(itemRanges);
  
      int previouslyInsertedCount = 0;
-    foreach (const KItemRange& range, itemRanges) {
+    for (const KItemRange &range : itemRanges) {
          // range.index is related to the model before anything has been inserted.
          // As in each loop the current item-range gets inserted the index must
          // be increased by the already previously inserted items.
          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;
  
          // Determine which visible items must be moved
          QList<int> itemsToMove;
              continue;
          }
          previouslyInsertedCount += count;
  
          // Determine which visible items must be moved
          QList<int> itemsToMove;
-        QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+        QHashIterator<int, KItemListWidget *> it(m_visibleItems);
          while (it.hasNext()) {
              it.next();
              const int visibleItemIndex = it.key();
          while (it.hasNext()) {
              it.next();
              const int visibleItemIndex = it.key();
@@ -993,9 +1182,9 @@ void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
          // Update the indexes of all KItemListWidget instances that are located
          // after the inserted items. It is important to adjust the indexes in the order
          // from the highest index to the lowest index to prevent overlaps when setting the new index.
          // Update the indexes of all KItemListWidget instances that are located
          // after the inserted items. It is important to adjust the indexes in the order
          // from the highest index to the lowest index to prevent overlaps when setting the new index.
-        qSort(itemsToMove);
+        std::sort(itemsToMove.begin(), itemsToMove.end());
          for (int i = itemsToMove.count() - 1; i >= 0; --i) {
          for (int i = itemsToMove.count() - 1; i >= 0; --i) {
-            KItemListWidget* widget = m_visibleItems.value(itemsToMove[i]);
+            KItemListWidget *widget = m_visibleItems.value(itemsToMove[i]);
              Q_ASSERT(widget);
              const int newIndex = widget->index() + count;
              if (hasMultipleRanges) {
              Q_ASSERT(widget);
              const int newIndex = widget->index() + count;
              if (hasMultipleRanges) {
@@ -1011,15 +1200,21 @@ void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
              // the size of the layouter will be decreased before calling doLayout(): This prevents
              // an unnecessary temporary animation due to the geometry change of the inserted scrollbar.
              const bool verticalScrollOrientation = (scrollOrientation() == Qt::Vertical);
              // the size of the layouter will be decreased before calling doLayout(): This prevents
              // an unnecessary temporary animation due to the geometry change of the inserted scrollbar.
              const bool verticalScrollOrientation = (scrollOrientation() == Qt::Vertical);
-            const bool decreaseLayouterSize = ( verticalScrollOrientation && maximumScrollOffset() > size().height()) ||
-                                              (!verticalScrollOrientation && maximumScrollOffset() > size().width());
+            const bool decreaseLayouterSize = (verticalScrollOrientation && maximumScrollOffset() > size().height())
+                || (!verticalScrollOrientation && maximumScrollOffset() > size().width());
              if (decreaseLayouterSize) {
                  const int scrollBarExtent = style()->pixelMetric(QStyle::PM_ScrollBarExtent);
              if (decreaseLayouterSize) {
                  const int scrollBarExtent = style()->pixelMetric(QStyle::PM_ScrollBarExtent);
+
+                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);
              }
@@ -1054,7 +1249,7 @@ void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
      }
  }
  
      }
  }
  
-void KItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
+void KItemListView::slotItemsRemoved(const KItemRangeList &itemRanges)
  {
      if (m_itemSize.isEmpty()) {
          // Don't pass the item-range: The preferred column-widths of
  {
      if (m_itemSize.isEmpty()) {
          // Don't pass the item-range: The preferred column-widths of
@@ -1072,22 +1267,25 @@ void KItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
      m_sizeHintResolver->itemsRemoved(itemRanges);
  
      for (int i = itemRanges.count() - 1; i >= 0; --i) {
      m_sizeHintResolver->itemsRemoved(itemRanges);
  
      for (int i = itemRanges.count() - 1; i >= 0; --i) {
-        const KItemRange& range = itemRanges[i];
+        const KItemRange &range = itemRanges[i];
          const int index = range.index;
          const int count = range.count;
          if (index < 0 || count <= 0) {
          const int index = range.index;
          const int count = range.count;
          if (index < 0 || count <= 0) {
-            kWarning() << "Invalid item range (index:" << index << ", count:" << count << ")";
+            qCWarning(DolphinDebug) << "Invalid item range (index:" << index << ", count:" << count << ")";
              continue;
          }
  
          const int firstRemovedIndex = index;
          const int lastRemovedIndex = index + count - 1;
  
              continue;
          }
  
          const int firstRemovedIndex = index;
          const int lastRemovedIndex = index + count - 1;
  
-        // Remeber which items have to be moved because they are behind the removed range.
+        // Remember which items have to be moved because they are behind the removed range.
          QVector<int> itemsToMove;
  
          // Remove all KItemListWidget instances that got deleted
          QVector<int> itemsToMove;
  
          // Remove all KItemListWidget instances that got deleted
-        foreach (KItemListWidget* widget, m_visibleItems) {
+        // Iterate over a const copy because the container is mutated within the loop
+        // directly and in `recycleWidget()` (https://bugs.kde.org/show_bug.cgi?id=428374)
+        const auto visibleItems = m_visibleItems;
+        for (KItemListWidget *widget : visibleItems) {
              const int i = widget->index();
              if (i < firstRemovedIndex) {
                  continue;
              const int i = widget->index();
              if (i < firstRemovedIndex) {
                  continue;
@@ -1123,8 +1321,8 @@ void KItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
          // after the deleted items. It is important to update them in ascending
          // order to prevent overlaps when setting the new index.
          std::sort(itemsToMove.begin(), itemsToMove.end());
          // after the deleted items. It is important to update them in ascending
          // order to prevent overlaps when setting the new index.
          std::sort(itemsToMove.begin(), itemsToMove.end());
-        foreach (int i, itemsToMove) {
-            KItemListWidget* widget = m_visibleItems.value(i);
+        for (int i : std::as_const(itemsToMove)) {
+            KItemListWidget *widget = m_visibleItems.value(i);
              Q_ASSERT(widget);
              const int newIndex = i - count;
              if (hasMultipleRanges) {
              Q_ASSERT(widget);
              const int newIndex = i - count;
              if (hasMultipleRanges) {
@@ -1169,7 +1367,7 @@ void KItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
      }
  }
  
      }
  }
  
-void KItemListView::slotItemsMoved(const KItemRange& itemRange, const QList<int>& movedToIndexes)
+void KItemListView::slotItemsMoved(const KItemRange &itemRange, const QList<int> &movedToIndexes)
  {
      m_sizeHintResolver->itemsMoved(itemRange, movedToIndexes);
      m_layouter->markAsDirty();
  {
      m_sizeHintResolver->itemsMoved(itemRange, movedToIndexes);
      m_layouter->markAsDirty();
@@ -1181,9 +1379,20 @@ void KItemListView::slotItemsMoved(const KItemRange& itemRange, const QList<int>
      const int firstVisibleMovedIndex = qMax(firstVisibleIndex(), itemRange.index);
      const int lastVisibleMovedIndex = qMin(lastVisibleIndex(), itemRange.index + itemRange.count - 1);
  
      const int firstVisibleMovedIndex = qMax(firstVisibleIndex(), itemRange.index);
      const int lastVisibleMovedIndex = qMin(lastVisibleIndex(), itemRange.index + itemRange.count - 1);
  
+    /// Represents an item that was moved while being edited.
+    struct MovedEditedItem {
+        int movedToIndex;
+        QByteArray editedRole;
+    };
+    std::optional<MovedEditedItem> movedEditedItem;
      for (int index = firstVisibleMovedIndex; index <= lastVisibleMovedIndex; ++index) {
      for (int index = firstVisibleMovedIndex; index <= lastVisibleMovedIndex; ++index) {
-        KItemListWidget* widget = m_visibleItems.value(index);
+        KItemListWidget *widget = m_visibleItems.value(index);
          if (widget) {
          if (widget) {
+            if (m_editingRole && !widget->editedRole().isEmpty()) {
+                movedEditedItem = {movedToIndexes[index - itemRange.index], widget->editedRole()};
+                disconnectRoleEditingSignals(index);
+                m_editingRole = false;
+            }
              updateWidgetProperties(widget, index);
              initializeItemListWidget(widget);
          }
              updateWidgetProperties(widget, index);
              initializeItemListWidget(widget);
          }
@@ -1191,33 +1400,32 @@ void KItemListView::slotItemsMoved(const KItemRange& itemRange, const QList<int>
  
      doLayout(NoAnimation);
      updateSiblingsInformation();
  
      doLayout(NoAnimation);
      updateSiblingsInformation();
+
+    if (movedEditedItem) {
+        editRole(movedEditedItem->movedToIndex, movedEditedItem->editedRole);
+    }
  }
  
  }
  
-void KItemListView::slotItemsChanged(const KItemRangeList& itemRanges,
-                                     const QSet<QByteArray>& roles)
+void KItemListView::slotItemsChanged(const KItemRangeList &itemRanges, const QSet<QByteArray> &roles)
  {
      const bool updateSizeHints = itemSizeHintUpdateRequired(roles);
      if (updateSizeHints && m_itemSize.isEmpty()) {
          updatePreferredColumnWidths(itemRanges);
      }
  
  {
      const bool updateSizeHints = itemSizeHintUpdateRequired(roles);
      if (updateSizeHints && m_itemSize.isEmpty()) {
          updatePreferredColumnWidths(itemRanges);
      }
  
-    foreach (const KItemRange& itemRange, itemRanges) {
+    for (const KItemRange &itemRange : itemRanges) {
          const int index = itemRange.index;
          const int count = itemRange.count;
  
          if (updateSizeHints) {
              m_sizeHintResolver->itemsChanged(index, count, roles);
              m_layouter->markAsDirty();
          const int index = itemRange.index;
          const int count = itemRange.count;
  
          if (updateSizeHints) {
              m_sizeHintResolver->itemsChanged(index, count, roles);
              m_layouter->markAsDirty();
-
-            if (!m_layoutTimer->isActive()) {
-                m_layoutTimer->start();
-            }
          }
  
          // Apply the changed roles to the visible item-widgets
          const int lastIndex = index + count - 1;
          for (int i = index; i <= lastIndex; ++i) {
          }
  
          // Apply the changed roles to the visible item-widgets
          const int lastIndex = index + count - 1;
          for (int i = index; i <= lastIndex; ++i) {
-            KItemListWidget* widget = m_visibleItems.value(i);
+            KItemListWidget *widget = m_visibleItems.value(i);
              if (widget) {
                  widget->setData(m_model->data(i), roles);
              }
              if (widget) {
                  widget->setData(m_model->data(i), roles);
              }
@@ -1230,7 +1438,7 @@ void KItemListView::slotItemsChanged(const KItemRangeList& itemRanges,
              doLayout(NoAnimation);
          }
      }
              doLayout(NoAnimation);
          }
      }
-    QAccessible::updateAccessibility(this, 0, QAccessible::TableModelChanged);
+    doLayout(NoAnimation);
  }
  
  void KItemListView::slotGroupsChanged()
  }
  
  void KItemListView::slotGroupsChanged()
@@ -1251,7 +1459,7 @@ void KItemListView::slotGroupedSortingChanged(bool current)
          // Clear all visible headers. Note that the QHashIterator takes a copy of
          // m_visibleGroups. Therefore, it remains valid even if items are removed
          // from m_visibleGroups in recycleGroupHeaderForWidget().
          // Clear all visible headers. Note that the QHashIterator takes a copy of
          // m_visibleGroups. Therefore, it remains valid even if items are removed
          // from m_visibleGroups in recycleGroupHeaderForWidget().
-        QHashIterator<KItemListWidget*, KItemListGroupHeader*> it(m_visibleGroups);
+        QHashIterator<KItemListWidget *, KItemListGroupHeader *> it(m_visibleGroups);
          while (it.hasNext()) {
              it.next();
              recycleGroupHeaderForWidget(it.key());
          while (it.hasNext()) {
              it.next();
              recycleGroupHeaderForWidget(it.key());
@@ -1271,18 +1479,18 @@ 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);
      }
  }
  
-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);
@@ -1291,41 +1499,60 @@ 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);
+    // 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* previousWidget = m_visibleItems.value(previous, 0);
-    if (previousWidget) {
-        previousWidget->setCurrent(false);
+        KItemListWidget *currentWidget = m_visibleItems.value(current, nullptr);
+        if (currentWidget) {
+            currentWidget->setCurrent(true);
+        }
      }
      }
-
-    KItemListWidget* currentWidget = m_visibleItems.value(current, 0);
-    if (currentWidget) {
-        currentWidget->setCurrent(true);
+#ifndef QT_NO_ACCESSIBILITY
+    if (current != previous && QAccessible::isActive()) {
+        static_cast<KItemListViewAccessible *>(QAccessible::queryAccessibleInterface(this))->announceCurrentItem();
      }
      }
-    QAccessible::updateAccessibility(this, current+1, QAccessible::Focus);
+#endif
  }
  
  }
  
-void KItemListView::slotSelectionChanged(const KItemSet& current, const KItemSet& previous)
+void KItemListView::slotSelectionChanged(const KItemSet &current, const KItemSet &previous)
  {
  {
-    Q_UNUSED(previous);
-
-    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    QHashIterator<int, KItemListWidget *> it(m_visibleItems);
      while (it.hasNext()) {
          it.next();
          const int index = it.key();
      while (it.hasNext()) {
          it.next();
          const int index = it.key();
-        KItemListWidget* widget = it.value();
-        widget->setSelected(current.contains(index));
+        KItemListWidget *widget = it.value();
+        const bool isSelected(current.contains(index));
+        widget->setSelected(isSelected);
+
+#ifndef QT_NO_ACCESSIBILITY
+        if (!QAccessible::isActive()) {
+            continue;
+        }
+        // Let the screen reader announce "selected" or "not selected" for the active item.
+        const bool wasSelected(previous.contains(index));
+        if (isSelected != wasSelected) {
+            QAccessibleEvent accessibleSelectionChangedEvent(this, QAccessible::SelectionAdd);
+            accessibleSelectionChangedEvent.setChild(index);
+            QAccessible::updateAccessibility(&accessibleSelectionChangedEvent);
+        }
      }
      }
+#else
+    }
+    Q_UNUSED(previous)
+#endif
  }
  
  }
  
-void KItemListView::slotAnimationFinished(QGraphicsWidget* widget,
-                                          KItemListViewAnimation::AnimationType type)
+void KItemListView::slotAnimationFinished(QGraphicsWidget *widget, KItemListViewAnimation::AnimationType type)
  {
  {
-    KItemListWidget* itemListWidget = qobject_cast<KItemListWidget*>(widget);
+    KItemListWidget *itemListWidget = qobject_cast<KItemListWidget *>(widget);
      Q_ASSERT(itemListWidget);
  
      Q_ASSERT(itemListWidget);
  
-    switch (type) {
-    case KItemListViewAnimation::DeleteAnimation: {
+    if (type == KItemListViewAnimation::DeleteAnimation) {
          // As we recycle the widget in this case it is important to assure that no
          // other animation has been started. This is a convention in KItemListView and
          // not a requirement defined by KItemListViewAnimation.
          // As we recycle the widget in this case it is important to assure that no
          // other animation has been started. This is a convention in KItemListView and
          // not a requirement defined by KItemListViewAnimation.
@@ -1336,29 +1563,13 @@ void KItemListView::slotAnimationFinished(QGraphicsWidget* widget,
          // been finished.
          recycleGroupHeaderForWidget(itemListWidget);
          widgetCreator()->recycle(itemListWidget);
          // been finished.
          recycleGroupHeaderForWidget(itemListWidget);
          widgetCreator()->recycle(itemListWidget);
-        break;
-    }
-
-    case KItemListViewAnimation::CreateAnimation:
-    case KItemListViewAnimation::MovingAnimation:
-    case KItemListViewAnimation::ResizeAnimation: {
+    } else {
          const int index = itemListWidget->index();
          const int index = itemListWidget->index();
-        const bool invisible = (index < m_layouter->firstVisibleIndex()) ||
-                               (index > m_layouter->lastVisibleIndex());
+        const bool invisible = (index < m_layouter->firstVisibleIndex()) || (index > m_layouter->lastVisibleIndex());
          if (invisible && !m_animation->isStarted(itemListWidget)) {
              recycleWidget(itemListWidget);
          }
          if (invisible && !m_animation->isStarted(itemListWidget)) {
              recycleWidget(itemListWidget);
          }
-        break;
      }
      }
-
-    default: break;
-    }
-}
-
-void KItemListView::slotLayoutTimerFinished()
-{
-    m_layouter->setSize(geometry().size());
-    doLayout(Animation);
  }
  
  void KItemListView::slotRubberBandPosChanged()
  }
  
  void KItemListView::slotRubberBandPosChanged()
@@ -1369,34 +1580,63 @@ 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, [=, this](const QVariant &) {
+            update();
+        });
+        connect(animation, &QVariantAnimation::finished, this, [=, 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;
      }
  
      update();
  }
  
          m_skipAutoScrollForRubberBand = false;
      }
  
      update();
  }
  
-void KItemListView::slotHeaderColumnWidthChanged(const QByteArray& role,
-                                                 qreal currentWidth,
-                                                 qreal previousWidth)
+void KItemListView::slotHeaderColumnWidthChanged(const QByteArray &role, qreal currentWidth, qreal previousWidth)
  {
  {
-    Q_UNUSED(role);
-    Q_UNUSED(currentWidth);
-    Q_UNUSED(previousWidth);
+    Q_UNUSED(role)
+    Q_UNUSED(currentWidth)
+    Q_UNUSED(previousWidth)
  
      m_headerWidget->setAutomaticColumnResizing(false);
      applyColumnWidthsFromHeader();
      doLayout(NoAnimation);
  }
  
  
      m_headerWidget->setAutomaticColumnResizing(false);
      applyColumnWidthsFromHeader();
      doLayout(NoAnimation);
  }
  
-void KItemListView::slotHeaderColumnMoved(const QByteArray& role,
-                                          int currentIndex,
-                                          int previousIndex)
+void KItemListView::slotSidePaddingChanged(qreal width)
+{
+    Q_UNUSED(width)
+    if (m_headerWidget->automaticColumnResizing()) {
+        applyAutomaticColumnWidths();
+    }
+    applyColumnWidthsFromHeader();
+    doLayout(NoAnimation);
+}
+
+void KItemListView::slotHeaderColumnMoved(const QByteArray &role, int currentIndex, int previousIndex)
  {
      Q_ASSERT(m_visibleRoles[previousIndex] == role);
  
  {
      Q_ASSERT(m_visibleRoles[previousIndex] == role);
  
@@ -1408,7 +1648,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()
@@ -1446,9 +1686,8 @@ void KItemListView::triggerAutoScrolling()
          // an autoscrolling.
  
          const qreal minDiff = 4; // Ignore any autoscrolling if the rubberband is very small
          // an autoscrolling.
  
          const qreal minDiff = 4; // Ignore any autoscrolling if the rubberband is very small
-        const qreal diff = (scrollOrientation() == Qt::Vertical)
-                           ? m_rubberBand->endPosition().y() - m_rubberBand->startPosition().y()
-                           : m_rubberBand->endPosition().x() - m_rubberBand->startPosition().x();
+        const qreal diff = (scrollOrientation() == Qt::Vertical) ? m_rubberBand->endPosition().y() - m_rubberBand->startPosition().y()
+                                                                 : m_rubberBand->endPosition().x() - m_rubberBand->startPosition().x();
          if (qAbs(diff) < minDiff || (m_autoScrollIncrement < 0 && diff > 0) || (m_autoScrollIncrement > 0 && diff < 0)) {
              // The rubberband direction is different from the scroll direction (e.g. the rubberband has
              // been moved up although the autoscroll direction might be down)
          if (qAbs(diff) < minDiff || (m_autoScrollIncrement < 0 && diff > 0) || (m_autoScrollIncrement > 0 && diff < 0)) {
              // The rubberband direction is different from the scroll direction (e.g. the rubberband has
              // been moved up although the autoscroll direction might be down)
@@ -1472,76 +1711,68 @@ void KItemListView::triggerAutoScrolling()
  
  void KItemListView::slotGeometryOfGroupHeaderParentChanged()
  {
  
  void KItemListView::slotGeometryOfGroupHeaderParentChanged()
  {
-    KItemListWidget* widget = qobject_cast<KItemListWidget*>(sender());
+    KItemListWidget *widget = qobject_cast<KItemListWidget *>(sender());
      Q_ASSERT(widget);
      Q_ASSERT(widget);
-    KItemListGroupHeader* groupHeader = m_visibleGroups.value(widget);
+    KItemListGroupHeader *groupHeader = m_visibleGroups.value(widget);
      Q_ASSERT(groupHeader);
      updateGroupHeaderLayout(widget);
  }
  
      Q_ASSERT(groupHeader);
      updateGroupHeaderLayout(widget);
  }
  
-void KItemListView::slotRoleEditingCanceled(int index, const QByteArray& role, const QVariant& value)
+void KItemListView::slotRoleEditingCanceled(int index, const QByteArray &role, const QVariant &value)
  {
      disconnectRoleEditingSignals(index);
  
  {
      disconnectRoleEditingSignals(index);
  
-    emit roleEditingCanceled(index, role, value);
      m_editingRole = false;
      m_editingRole = false;
+    Q_EMIT roleEditingCanceled(index, role, value);
  }
  
  }
  
-void KItemListView::slotRoleEditingFinished(int index, const QByteArray& role, const QVariant& value)
+void KItemListView::slotRoleEditingFinished(int index, const QByteArray &role, const QVariant &value)
  {
      disconnectRoleEditingSignals(index);
  
  {
      disconnectRoleEditingSignals(index);
  
-    emit roleEditingFinished(index, role, value);
      m_editingRole = false;
      m_editingRole = false;
+    Q_EMIT roleEditingFinished(index, role, value);
  }
  
  }
  
-void KItemListView::setController(KItemListController* controller)
+void KItemListView::setController(KItemListController *controller)
  {
      if (m_controller != controller) {
  {
      if (m_controller != controller) {
-        KItemListController* previous = m_controller;
+        KItemListController *previous = m_controller;
          if (previous) {
          if (previous) {
-            KItemListSelectionManager* selectionManager = previous->selectionManager();
-            disconnect(selectionManager, SIGNAL(currentChanged(int,int)), this, SLOT(slotCurrentChanged(int,int)));
-            disconnect(selectionManager, SIGNAL(selectionChanged(KItemSet,KItemSet)), this, SLOT(slotSelectionChanged(KItemSet,KItemSet)));
+            KItemListSelectionManager *selectionManager = previous->selectionManager();
+            disconnect(selectionManager, &KItemListSelectionManager::currentChanged, this, &KItemListView::slotCurrentChanged);
+            disconnect(selectionManager, &KItemListSelectionManager::selectionChanged, this, &KItemListView::slotSelectionChanged);
          }
  
          m_controller = controller;
  
          if (controller) {
          }
  
          m_controller = controller;
  
          if (controller) {
-            KItemListSelectionManager* selectionManager = controller->selectionManager();
-            connect(selectionManager, SIGNAL(currentChanged(int,int)), this, SLOT(slotCurrentChanged(int,int)));
-            connect(selectionManager, SIGNAL(selectionChanged(KItemSet,KItemSet)), this, SLOT(slotSelectionChanged(KItemSet,KItemSet)));
+            KItemListSelectionManager *selectionManager = controller->selectionManager();
+            connect(selectionManager, &KItemListSelectionManager::currentChanged, this, &KItemListView::slotCurrentChanged);
+            connect(selectionManager, &KItemListSelectionManager::selectionChanged, this, &KItemListView::slotSelectionChanged);
          }
  
          onControllerChanged(controller, previous);
      }
  }
  
          }
  
          onControllerChanged(controller, previous);
      }
  }
  
-void KItemListView::setModel(KItemModelBase* model)
+void KItemListView::setModel(KItemModelBase *model)
  {
      if (m_model == model) {
          return;
      }
  
  {
      if (m_model == model) {
          return;
      }
  
-    KItemModelBase* previous = m_model;
+    KItemModelBase *previous = m_model;
  
      if (m_model) {
  
      if (m_model) {
-        disconnect(m_model, 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(groupsChanged()),
-                   this,    SLOT(slotGroupsChanged()));
-        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->itemsRemoved(KItemRangeList() << KItemRange(0, m_model->count()));
      }
@@ -1551,22 +1782,14 @@ void KItemListView::setModel(KItemModelBase* model)
      m_grouped = model->groupedSorting();
  
      if (m_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(groupsChanged()),
-                this,    SLOT(slotGroupsChanged()));
-        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) {
@@ -1577,17 +1800,13 @@ void KItemListView::setModel(KItemModelBase* model)
      onModelChanged(model, previous);
  }
  
      onModelChanged(model, previous);
  }
  
-KItemListRubberBand* KItemListView::rubberBand() const
+KItemListRubberBand *KItemListView::rubberBand() const
  {
      return m_rubberBand;
  }
  
  void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int changedCount)
  {
  {
      return m_rubberBand;
  }
  
  void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int changedCount)
  {
-    if (m_layoutTimer->isActive()) {
-        m_layoutTimer->stop();
-    }
-
      if (m_activeTransactions > 0) {
          if (hint == NoAnimation) {
              // As soon as at least one property change should be done without animation,
      if (m_activeTransactions > 0) {
          if (hint == NoAnimation) {
              // As soon as at least one property change should be done without animation,
@@ -1631,13 +1850,11 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
      const bool animate = (hint == Animation);
      for (int i = firstVisibleIndex; i <= lastVisibleIndex; ++i) {
          bool applyNewPos = true;
      const bool animate = (hint == Animation);
      for (int i = firstVisibleIndex; i <= lastVisibleIndex; ++i) {
          bool applyNewPos = true;
-        bool wasHidden = false;
  
          const QRectF itemBounds = m_layouter->itemRect(i);
          const QPointF newPos = itemBounds.topLeft();
  
          const QRectF itemBounds = m_layouter->itemRect(i);
          const QPointF newPos = itemBounds.topLeft();
-        KItemListWidget* widget = m_visibleItems.value(i);
+        KItemListWidget *widget = m_visibleItems.value(i);
          if (!widget) {
          if (!widget) {
-            wasHidden = true;
              if (!reusableItems.isEmpty()) {
                  // Reuse a KItemListWidget instance from an invisible item
                  const int oldIndex = reusableItems.takeLast();
              if (!reusableItems.isEmpty()) {
                  // Reuse a KItemListWidget instance from an invisible item
                  const int oldIndex = reusableItems.takeLast();
@@ -1660,8 +1877,7 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
                      const int previousIndex = i - changedCount;
                      const QRectF itemRect = m_layouter->itemRect(previousIndex);
                      if (itemRect.isEmpty()) {
                      const int previousIndex = i - changedCount;
                      const QRectF itemRect = m_layouter->itemRect(previousIndex);
                      if (itemRect.isEmpty()) {
-                        const QPointF invisibleOldPos = (scrollOrientation() == Qt::Vertical)
-                                                        ? QPointF(0, size().height()) : QPointF(size().width(), 0);
+                        const QPointF invisibleOldPos = (scrollOrientation() == Qt::Vertical) ? QPointF(0, size().height()) : QPointF(size().width(), 0);
                          widget->setPos(invisibleOldPos);
                      } else {
                          widget->setPos(itemRect.topLeft());
                          widget->setPos(invisibleOldPos);
                      } else {
                          widget->setPos(itemRect.topLeft());
@@ -1680,7 +1896,7 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
  
          if (animate) {
              if (m_animation->isStarted(widget, KItemListViewAnimation::MovingAnimation)) {
  
          if (animate) {
              if (m_animation->isStarted(widget, KItemListViewAnimation::MovingAnimation)) {
-                m_animation->start(widget,  KItemListViewAnimation::MovingAnimation, newPos);
+                m_animation->start(widget, KItemListViewAnimation::MovingAnimation, newPos);
                  applyNewPos = false;
              }
  
                  applyNewPos = false;
              }
  
@@ -1704,9 +1920,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);
@@ -1719,6 +1932,8 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
          Q_ASSERT(widget->index() == i);
          widget->setVisible(true);
  
          Q_ASSERT(widget->index() == i);
          widget->setVisible(true);
  
+        bool animateIconResizing = animate;
+
          if (widget->size() != itemBounds.size()) {
              // Resize the widget for the item to the changed size.
              if (animate) {
          if (widget->size() != itemBounds.size()) {
              // Resize the widget for the item to the changed size.
              if (animate) {
@@ -1735,6 +1950,17 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
              } else {
                  widget->resize(itemBounds.size());
              }
              } else {
                  widget->resize(itemBounds.size());
              }
+        } else {
+            animateIconResizing = false;
+        }
+
+        const int newIconSize = widget->styleOption().iconSize;
+        if (widget->iconSize() != newIconSize) {
+            if (animateIconResizing) {
+                m_animation->start(widget, KItemListViewAnimation::IconResizeAnimation, newIconSize);
+            } else {
+                widget->setIconSize(newIconSize);
+            }
          }
  
          // Updating the cell-information must be done as last step: The decision whether the
          }
  
          // Updating the cell-information must be done as last step: The decision whether the
@@ -1744,7 +1970,7 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
      }
  
      // Delete invisible KItemListWidget instances that have not been reused
      }
  
      // Delete invisible KItemListWidget instances that have not been reused
-    foreach (int index, reusableItems) {
+    for (int index : std::as_const(reusableItems)) {
          recycleWidget(m_visibleItems.value(index));
      }
  
          recycleWidget(m_visibleItems.value(index));
      }
  
@@ -1755,7 +1981,7 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
  
      if (m_grouped) {
          // Update the layout of all visible group headers
  
      if (m_grouped) {
          // Update the layout of all visible group headers
-        QHashIterator<KItemListWidget*, KItemListGroupHeader*> it(m_visibleGroups);
+        QHashIterator<KItemListWidget *, KItemListGroupHeader *> it(m_visibleGroups);
          while (it.hasNext()) {
              it.next();
              updateGroupHeaderLayout(it.key());
          while (it.hasNext()) {
              it.next();
              updateGroupHeaderLayout(it.key());
@@ -1765,9 +1991,7 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha
      emitOffsetChanges();
  }
  
      emitOffsetChanges();
  }
  
-QList<int> KItemListView::recycleInvisibleItems(int firstVisibleIndex,
-                                                int lastVisibleIndex,
-                                                LayoutAnimationHint hint)
+QList<int> KItemListView::recycleInvisibleItems(int firstVisibleIndex, int lastVisibleIndex, LayoutAnimationHint hint)
  {
      // Determine all items that are completely invisible and might be
      // reused for items that just got (at least partly) visible. If the
  {
      // Determine all items that are completely invisible and might be
      // reused for items that just got (at least partly) visible. If the
@@ -1777,11 +2001,11 @@ QList<int> KItemListView::recycleInvisibleItems(int firstVisibleIndex,
  
      QList<int> items;
  
  
      QList<int> items;
  
-    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    QHashIterator<int, KItemListWidget *> it(m_visibleItems);
      while (it.hasNext()) {
          it.next();
  
      while (it.hasNext()) {
          it.next();
  
-        KItemListWidget* widget = it.value();
+        KItemListWidget *widget = it.value();
          const int index = widget->index();
          const bool invisible = (index < firstVisibleIndex) || (index > lastVisibleIndex);
  
          const int index = widget->index();
          const bool invisible = (index < firstVisibleIndex) || (index > lastVisibleIndex);
  
@@ -1806,7 +2030,7 @@ QList<int> KItemListView::recycleInvisibleItems(int firstVisibleIndex,
      return items;
  }
  
      return items;
  }
  
-bool KItemListView::moveWidget(KItemListWidget* widget,const QPointF& newPos)
+bool KItemListView::moveWidget(KItemListWidget *widget, const QPointF &newPos)
  {
      if (widget->pos() == newPos) {
          return false;
  {
      if (widget->pos() == newPos) {
          return false;
@@ -1847,32 +2071,32 @@ void KItemListView::emitOffsetChanges()
  {
      const qreal newScrollOffset = m_layouter->scrollOffset();
      if (m_oldScrollOffset != newScrollOffset) {
  {
      const qreal newScrollOffset = m_layouter->scrollOffset();
      if (m_oldScrollOffset != newScrollOffset) {
-        emit scrollOffsetChanged(newScrollOffset, m_oldScrollOffset);
+        Q_EMIT scrollOffsetChanged(newScrollOffset, m_oldScrollOffset);
          m_oldScrollOffset = newScrollOffset;
      }
  
      const qreal newMaximumScrollOffset = m_layouter->maximumScrollOffset();
      if (m_oldMaximumScrollOffset != newMaximumScrollOffset) {
          m_oldScrollOffset = newScrollOffset;
      }
  
      const qreal newMaximumScrollOffset = m_layouter->maximumScrollOffset();
      if (m_oldMaximumScrollOffset != newMaximumScrollOffset) {
-        emit maximumScrollOffsetChanged(newMaximumScrollOffset, m_oldMaximumScrollOffset);
+        Q_EMIT maximumScrollOffsetChanged(newMaximumScrollOffset, m_oldMaximumScrollOffset);
          m_oldMaximumScrollOffset = newMaximumScrollOffset;
      }
  
      const qreal newItemOffset = m_layouter->itemOffset();
      if (m_oldItemOffset != newItemOffset) {
          m_oldMaximumScrollOffset = newMaximumScrollOffset;
      }
  
      const qreal newItemOffset = m_layouter->itemOffset();
      if (m_oldItemOffset != newItemOffset) {
-        emit itemOffsetChanged(newItemOffset, m_oldItemOffset);
+        Q_EMIT itemOffsetChanged(newItemOffset, m_oldItemOffset);
          m_oldItemOffset = newItemOffset;
      }
  
      const qreal newMaximumItemOffset = m_layouter->maximumItemOffset();
      if (m_oldMaximumItemOffset != newMaximumItemOffset) {
          m_oldItemOffset = newItemOffset;
      }
  
      const qreal newMaximumItemOffset = m_layouter->maximumItemOffset();
      if (m_oldMaximumItemOffset != newMaximumItemOffset) {
-        emit maximumItemOffsetChanged(newMaximumItemOffset, m_oldMaximumItemOffset);
+        Q_EMIT maximumItemOffsetChanged(newMaximumItemOffset, m_oldMaximumItemOffset);
          m_oldMaximumItemOffset = newMaximumItemOffset;
      }
  }
  
          m_oldMaximumItemOffset = newMaximumItemOffset;
      }
  }
  
-KItemListWidget* KItemListView::createWidget(int index)
+KItemListWidget *KItemListView::createWidget(int index)
  {
  {
-    KItemListWidget* widget = widgetCreator()->create(this);
+    KItemListWidget *widget = widgetCreator()->create(this);
      widget->setFlag(QGraphicsItem::ItemStacksBehindParent);
  
      m_visibleItems.insert(index, widget);
      widget->setFlag(QGraphicsItem::ItemStacksBehindParent);
  
      m_visibleItems.insert(index, widget);
@@ -1882,7 +2106,7 @@ KItemListWidget* KItemListView::createWidget(int index)
      return widget;
  }
  
      return widget;
  }
  
-void KItemListView::recycleWidget(KItemListWidget* widget)
+void KItemListView::recycleWidget(KItemListWidget *widget)
  {
      if (m_grouped) {
          recycleGroupHeaderForWidget(widget);
  {
      if (m_grouped) {
          recycleGroupHeaderForWidget(widget);
@@ -1895,7 +2119,7 @@ void KItemListView::recycleWidget(KItemListWidget* widget)
      widgetCreator()->recycle(widget);
  }
  
      widgetCreator()->recycle(widget);
  }
  
-void KItemListView::setWidgetIndex(KItemListWidget* widget, int index)
+void KItemListView::setWidgetIndex(KItemListWidget *widget, int index)
  {
      const int oldIndex = widget->index();
      m_visibleItems.remove(oldIndex);
  {
      const int oldIndex = widget->index();
      m_visibleItems.remove(oldIndex);
@@ -1907,7 +2131,7 @@ void KItemListView::setWidgetIndex(KItemListWidget* widget, int index)
      widget->setIndex(index);
  }
  
      widget->setIndex(index);
  }
  
-void KItemListView::moveWidgetToIndex(KItemListWidget* widget, int index)
+void KItemListView::moveWidgetToIndex(KItemListWidget *widget, int index)
  {
      const int oldIndex = widget->index();
      const Cell oldCell = m_visibleCells.value(oldIndex);
  {
      const int oldIndex = widget->index();
      const Cell oldCell = m_visibleCells.value(oldIndex);
@@ -1916,30 +2140,39 @@ void KItemListView::moveWidgetToIndex(KItemListWidget* widget, int index)
  
      const Cell newCell(m_layouter->itemColumn(index), m_layouter->itemRow(index));
      const bool vertical = (scrollOrientation() == Qt::Vertical);
  
      const Cell newCell(m_layouter->itemColumn(index), m_layouter->itemRow(index));
      const bool vertical = (scrollOrientation() == Qt::Vertical);
-    const bool updateCell = (vertical  && oldCell.row    == newCell.row) ||
-                            (!vertical && oldCell.column == newCell.column);
+    const bool updateCell = (vertical && oldCell.row == newCell.row) || (!vertical && oldCell.column == newCell.column);
      if (updateCell) {
          m_visibleCells.insert(index, newCell);
      }
  }
  
      if (updateCell) {
          m_visibleCells.insert(index, newCell);
      }
  }
  
-void KItemListView::setLayouterSize(const QSizeF& size, SizeType sizeType)
+void KItemListView::setLayouterSize(const QSizeF &size, SizeType sizeType)
  {
      switch (sizeType) {
  {
      switch (sizeType) {
-    case LayouterSize: m_layouter->setSize(size); break;
-    case ItemSize: m_layouter->setItemSize(size); break;
-    default: break;
+    case LayouterSize:
+        m_layouter->setSize(size);
+        break;
+    case ItemSize:
+        m_layouter->setItemSize(size);
+        break;
+    default:
+        break;
      }
  }
  
      }
  }
  
-void KItemListView::updateWidgetProperties(KItemListWidget* widget, int index)
+void KItemListView::updateWidgetProperties(KItemListWidget *widget, int index)
  {
      widget->setVisibleRoles(m_visibleRoles);
      updateWidgetColumnWidths(widget);
      widget->setStyleOption(m_styleOption);
  
  {
      widget->setVisibleRoles(m_visibleRoles);
      updateWidgetColumnWidths(widget);
      widget->setStyleOption(m_styleOption);
  
-    const KItemListSelectionManager* selectionManager = m_controller->selectionManager();
-    widget->setCurrent(index == selectionManager->currentItem());
+    const KItemListSelectionManager *selectionManager = m_controller->selectionManager();
+
+    // In SingleSelection mode (e.g., in the Places Panel), the current item is
+    // always the selected item. It is not necessary to highlight the current item then.
+    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());
@@ -1953,7 +2186,7 @@ void KItemListView::updateWidgetProperties(KItemListWidget* widget, int index)
      }
  }
  
      }
  }
  
-void KItemListView::updateGroupHeaderForWidget(KItemListWidget* widget)
+void KItemListView::updateGroupHeaderForWidget(KItemListWidget *widget)
  {
      Q_ASSERT(m_grouped);
  
  {
      Q_ASSERT(m_grouped);
  
@@ -1965,17 +2198,17 @@ void KItemListView::updateGroupHeaderForWidget(KItemListWidget* widget)
          return;
      }
  
          return;
      }
  
-    const QList<QPair<int, QVariant> > groups = model()->groups();
+    const QList<QPair<int, QVariant>> groups = model()->groups();
      if (groups.isEmpty() || !groupHeaderCreator()) {
          return;
      }
  
      if (groups.isEmpty() || !groupHeaderCreator()) {
          return;
      }
  
-    KItemListGroupHeader* groupHeader = m_visibleGroups.value(widget);
+    KItemListGroupHeader *groupHeader = m_visibleGroups.value(widget);
      if (!groupHeader) {
          groupHeader = groupHeaderCreator()->create(this);
          groupHeader->setParentItem(widget);
          m_visibleGroups.insert(widget, groupHeader);
      if (!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);
  
@@ -1990,9 +2223,9 @@ void KItemListView::updateGroupHeaderForWidget(KItemListWidget* widget)
      groupHeader->show();
  }
  
      groupHeader->show();
  }
  
-void KItemListView::updateGroupHeaderLayout(KItemListWidget* widget)
+void KItemListView::updateGroupHeaderLayout(KItemListWidget *widget)
  {
  {
-    KItemListGroupHeader* groupHeader = m_visibleGroups.value(widget);
+    KItemListGroupHeader *groupHeader = m_visibleGroups.value(widget);
      Q_ASSERT(groupHeader);
  
      const int index = widget->index();
      Q_ASSERT(groupHeader);
  
      const int index = widget->index();
@@ -2015,14 +2248,14 @@ void KItemListView::updateGroupHeaderLayout(KItemListWidget* widget)
      }
  }
  
      }
  }
  
-void KItemListView::recycleGroupHeaderForWidget(KItemListWidget* widget)
+void KItemListView::recycleGroupHeaderForWidget(KItemListWidget *widget)
  {
  {
-    KItemListGroupHeader* header = m_visibleGroups.value(widget);
+    KItemListGroupHeader *header = m_visibleGroups.value(widget);
      if (header) {
      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);
      }
  }
  
      }
  }
  
@@ -2031,7 +2264,7 @@ void KItemListView::updateVisibleGroupHeaders()
      Q_ASSERT(m_grouped);
      m_layouter->markAsDirty();
  
      Q_ASSERT(m_grouped);
      m_layouter->markAsDirty();
  
-    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    QHashIterator<int, KItemListWidget *> it(m_visibleItems);
      while (it.hasNext()) {
          it.next();
          updateGroupHeaderForWidget(it.value());
      while (it.hasNext()) {
          it.next();
          updateGroupHeaderForWidget(it.value());
@@ -2042,7 +2275,7 @@ int KItemListView::groupIndexForItem(int index) const
  {
      Q_ASSERT(m_grouped);
  
  {
      Q_ASSERT(m_grouped);
  
-    const QList<QPair<int, QVariant> > groups = model()->groups();
+    const QList<QPair<int, QVariant>> groups = model()->groups();
      if (groups.isEmpty()) {
          return -1;
      }
      if (groups.isEmpty()) {
          return -1;
      }
@@ -2070,14 +2303,14 @@ int KItemListView::groupIndexForItem(int index) const
  
  void KItemListView::updateAlternateBackgrounds()
  {
  
  void KItemListView::updateAlternateBackgrounds()
  {
-    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    QHashIterator<int, KItemListWidget *> it(m_visibleItems);
      while (it.hasNext()) {
          it.next();
          updateAlternateBackgroundForWidget(it.value());
      }
  }
  
      while (it.hasNext()) {
          it.next();
          updateAlternateBackgroundForWidget(it.value());
      }
  }
  
-void KItemListView::updateAlternateBackgroundForWidget(KItemListWidget* widget)
+void KItemListView::updateAlternateBackgroundForWidget(KItemListWidget *widget)
  {
      bool enabled = useAlternateBackgrounds();
      if (enabled) {
  {
      bool enabled = useAlternateBackgrounds();
      if (enabled) {
@@ -2086,7 +2319,7 @@ void KItemListView::updateAlternateBackgroundForWidget(KItemListWidget* widget)
          if (m_grouped) {
              const int groupIndex = groupIndexForItem(index);
              if (groupIndex >= 0) {
          if (m_grouped) {
              const int groupIndex = groupIndexForItem(index);
              if (groupIndex >= 0) {
-                const QList<QPair<int, QVariant> > groups = model()->groups();
+                const QList<QPair<int, QVariant>> groups = model()->groups();
                  const int indexOfFirstGroupItem = groups[groupIndex].first;
                  const int relativeIndex = index - indexOfFirstGroupItem;
                  enabled = (relativeIndex & 0x1) > 0;
                  const int indexOfFirstGroupItem = groups[groupIndex].first;
                  const int relativeIndex = index - indexOfFirstGroupItem;
                  enabled = (relativeIndex & 0x1) > 0;
@@ -2098,10 +2331,10 @@ void KItemListView::updateAlternateBackgroundForWidget(KItemListWidget* widget)
  
  bool KItemListView::useAlternateBackgrounds() const
  {
  
  bool KItemListView::useAlternateBackgrounds() const
  {
-    return m_itemSize.isEmpty() && m_visibleRoles.count() > 1;
+    return m_alternateBackgrounds && m_itemSize.isEmpty();
  }
  
  }
  
-QHash<QByteArray, qreal> KItemListView::preferredColumnWidths(const KItemRangeList& itemRanges) const
+QHash<QByteArray, qreal> KItemListView::preferredColumnWidths(const KItemRangeList &itemRanges) const
  {
      QElapsedTimer timer;
      timer.start();
  {
      QElapsedTimer timer;
      timer.start();
@@ -2111,25 +2344,25 @@ QHash<QByteArray, qreal> KItemListView::preferredColumnWidths(const KItemRangeLi
      // Calculate the minimum width for each column that is required
      // to show the headline unclipped.
      const QFontMetricsF fontMetrics(m_headerWidget->font());
      // Calculate the minimum width for each column that is required
      // to show the headline unclipped.
      const QFontMetricsF fontMetrics(m_headerWidget->font());
-    const int gripMargin   = m_headerWidget->style()->pixelMetric(QStyle::PM_HeaderGripMargin);
+    const int gripMargin = m_headerWidget->style()->pixelMetric(QStyle::PM_HeaderGripMargin);
      const int headerMargin = m_headerWidget->style()->pixelMetric(QStyle::PM_HeaderMargin);
      const int headerMargin = m_headerWidget->style()->pixelMetric(QStyle::PM_HeaderMargin);
-    foreach (const QByteArray& visibleRole, visibleRoles()) {
+    for (const QByteArray &visibleRole : std::as_const(m_visibleRoles)) {
          const QString headerText = m_model->roleDescription(visibleRole);
          const QString headerText = m_model->roleDescription(visibleRole);
-        const qreal headerWidth = fontMetrics.width(headerText) + gripMargin + headerMargin * 2;
+        const qreal headerWidth = fontMetrics.horizontalAdvance(headerText) + gripMargin + headerMargin * 2;
          widths.insert(visibleRole, headerWidth);
      }
  
          widths.insert(visibleRole, headerWidth);
      }
  
-    // Calculate the preferred column withs for each item and ignore values
+    // Calculate the preferred column widths for each item and ignore values
      // smaller than the width for showing the headline unclipped.
      // smaller than the width for showing the headline unclipped.
-    const KItemListWidgetCreatorBase* creator = widgetCreator();
+    const KItemListWidgetCreatorBase *creator = widgetCreator();
      int calculatedItemCount = 0;
      bool maxTimeExceeded = false;
      int calculatedItemCount = 0;
      bool maxTimeExceeded = false;
-    foreach (const KItemRange& itemRange, itemRanges) {
+    for (const KItemRange &itemRange : itemRanges) {
          const int startIndex = itemRange.index;
          const int endIndex = startIndex + itemRange.count - 1;
  
          for (int i = startIndex; i <= endIndex; ++i) {
          const int startIndex = itemRange.index;
          const int endIndex = startIndex + itemRange.count - 1;
  
          for (int i = startIndex; i <= endIndex; ++i) {
-            foreach (const QByteArray& visibleRole, visibleRoles()) {
+            for (const QByteArray &visibleRole : std::as_const(m_visibleRoles)) {
                  qreal maxWidth = widths.value(visibleRole, 0);
                  const qreal width = creator->preferredRoleColumnWidth(visibleRole, i, this);
                  maxWidth = qMax(width, maxWidth);
                  qreal maxWidth = widths.value(visibleRole, 0);
                  const qreal width = creator->preferredRoleColumnWidth(visibleRole, i, this);
                  maxWidth = qMax(width, maxWidth);
@@ -2156,38 +2389,38 @@ QHash<QByteArray, qreal> KItemListView::preferredColumnWidths(const KItemRangeLi
  void KItemListView::applyColumnWidthsFromHeader()
  {
      // Apply the new size to the layouter
  void KItemListView::applyColumnWidthsFromHeader()
  {
      // Apply the new size to the layouter
-    const qreal requiredWidth = columnWidthsSum();
-    const QSizeF dynamicItemSize(qMax(size().width(), requiredWidth),
-                                 m_itemSize.height());
+    const qreal requiredWidth = m_headerWidget->leftPadding() + columnWidthsSum() + m_headerWidget->rightPadding();
+    const QSizeF dynamicItemSize(qMax(size().width(), requiredWidth), m_itemSize.height());
      m_layouter->setItemSize(dynamicItemSize);
  
      // Update the role sizes for all visible widgets
      m_layouter->setItemSize(dynamicItemSize);
  
      // Update the role sizes for all visible widgets
-    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    QHashIterator<int, KItemListWidget *> it(m_visibleItems);
      while (it.hasNext()) {
          it.next();
          updateWidgetColumnWidths(it.value());
      }
  }
  
      while (it.hasNext()) {
          it.next();
          updateWidgetColumnWidths(it.value());
      }
  }
  
-void KItemListView::updateWidgetColumnWidths(KItemListWidget* widget)
+void KItemListView::updateWidgetColumnWidths(KItemListWidget *widget)
  {
  {
-    foreach (const QByteArray& role, m_visibleRoles) {
+    for (const QByteArray &role : std::as_const(m_visibleRoles)) {
          widget->setColumnWidth(role, m_headerWidget->columnWidth(role));
      }
          widget->setColumnWidth(role, m_headerWidget->columnWidth(role));
      }
+    widget->setSidePadding(m_headerWidget->leftPadding(), m_headerWidget->rightPadding());
  }
  
  }
  
-void KItemListView::updatePreferredColumnWidths(const KItemRangeList& itemRanges)
+void KItemListView::updatePreferredColumnWidths(const KItemRangeList &itemRanges)
  {
      Q_ASSERT(m_itemSize.isEmpty());
      const int itemCount = m_model->count();
      int rangesItemCount = 0;
  {
      Q_ASSERT(m_itemSize.isEmpty());
      const int itemCount = m_model->count();
      int rangesItemCount = 0;
-    foreach (const KItemRange& range, itemRanges) {
+    for (const KItemRange &range : itemRanges) {
          rangesItemCount += range.count;
      }
  
      if (itemCount == rangesItemCount) {
          const QHash<QByteArray, qreal> preferredWidths = preferredColumnWidths(itemRanges);
          rangesItemCount += range.count;
      }
  
      if (itemCount == rangesItemCount) {
          const QHash<QByteArray, qreal> preferredWidths = preferredColumnWidths(itemRanges);
-        foreach (const QByteArray& role, m_visibleRoles) {
+        for (const QByteArray &role : std::as_const(m_visibleRoles)) {
              m_headerWidget->setPreferredColumnWidth(role, preferredWidths.value(role));
          }
      } else {
              m_headerWidget->setPreferredColumnWidth(role, preferredWidths.value(role));
          }
      } else {
@@ -2201,7 +2434,7 @@ void KItemListView::updatePreferredColumnWidths(const KItemRangeList& itemRanges
          QHashIterator<QByteArray, qreal> it(updatedWidths);
          while (it.hasNext()) {
              it.next();
          QHashIterator<QByteArray, qreal> it(updatedWidths);
          while (it.hasNext()) {
              it.next();
-            const QByteArray& role = it.key();
+            const QByteArray &role = it.key();
              const qreal updatedWidth = it.value();
              const qreal currentWidth = m_headerWidget->preferredColumnWidth(role);
              if (updatedWidth > currentWidth) {
              const qreal updatedWidth = it.value();
              const qreal currentWidth = m_headerWidget->preferredColumnWidth(role);
              if (updatedWidth > currentWidth) {
@@ -2242,7 +2475,7 @@ void KItemListView::applyAutomaticColumnWidths()
      // size does not use the available view-size the size of the
      // first role will get stretched.
  
      // size does not use the available view-size the size of the
      // first role will get stretched.
  
-    foreach (const QByteArray& role, m_visibleRoles) {
+    for (const QByteArray &role : std::as_const(m_visibleRoles)) {
          const qreal preferredWidth = m_headerWidget->preferredColumnWidth(role);
          m_headerWidget->setColumnWidth(role, preferredWidth);
      }
          const qreal preferredWidth = m_headerWidget->preferredColumnWidth(role);
          m_headerWidget->setColumnWidth(role, preferredWidth);
      }
@@ -2251,7 +2484,9 @@ void KItemListView::applyAutomaticColumnWidths()
      qreal firstColumnWidth = m_headerWidget->columnWidth(firstRole);
      QSizeF dynamicItemSize = m_itemSize;
  
      qreal firstColumnWidth = m_headerWidget->columnWidth(firstRole);
      QSizeF dynamicItemSize = m_itemSize;
  
-    qreal requiredWidth = columnWidthsSum();
+    qreal requiredWidth = m_headerWidget->leftPadding() + columnWidthsSum() + m_headerWidget->rightPadding();
+    // By default we want the same padding symmetrically on both sides of the view. This improves UX, looks better and increases the chances of users figuring
+    // out that the padding area can be used for deselecting and dropping files.
      const qreal availableWidth = size().width();
      if (requiredWidth < availableWidth) {
          // Stretch the first column to use the whole remaining width
      const qreal availableWidth = size().width();
      if (requiredWidth < availableWidth) {
          // Stretch the first column to use the whole remaining width
@@ -2279,7 +2514,7 @@ void KItemListView::applyAutomaticColumnWidths()
      m_layouter->setItemSize(dynamicItemSize);
  
      // Update the role sizes for all visible widgets
      m_layouter->setItemSize(dynamicItemSize);
  
      // Update the role sizes for all visible widgets
-    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    QHashIterator<int, KItemListWidget *> it(m_visibleItems);
      while (it.hasNext()) {
          it.next();
          updateWidgetColumnWidths(it.value());
      while (it.hasNext()) {
          it.next();
          updateWidgetColumnWidths(it.value());
@@ -2289,7 +2524,7 @@ void KItemListView::applyAutomaticColumnWidths()
  qreal KItemListView::columnWidthsSum() const
  {
      qreal widthsSum = 0;
  qreal KItemListView::columnWidthsSum() const
  {
      qreal widthsSum = 0;
-    foreach (const QByteArray& role, m_visibleRoles) {
+    for (const QByteArray &role : std::as_const(m_visibleRoles)) {
          widthsSum += m_headerWidget->columnWidth(role);
      }
      return widthsSum;
          widthsSum += m_headerWidget->columnWidth(role);
      }
      return widthsSum;
@@ -2300,9 +2535,7 @@ QRectF KItemListView::headerBoundaries() const
      return m_headerWidget->isVisible() ? m_headerWidget->geometry() : QRectF();
  }
  
      return m_headerWidget->isVisible() ? m_headerWidget->geometry() : QRectF();
  }
  
-bool KItemListView::changesItemGridLayout(const QSizeF& newGridSize,
-                                          const QSizeF& newItemSize,
-                                          const QSizeF& newItemMargin) const
+bool KItemListView::changesItemGridLayout(const QSizeF &newGridSize, const QSizeF &newItemSize, const QSizeF &newItemMargin) const
  {
      if (newItemSize.isEmpty() || newGridSize.isEmpty()) {
          return false;
  {
      if (newItemSize.isEmpty() || newGridSize.isEmpty()) {
          return false;
@@ -2311,26 +2544,18 @@ bool KItemListView::changesItemGridLayout(const QSizeF& newGridSize,
      if (m_layouter->scrollOrientation() == Qt::Vertical) {
          const qreal itemWidth = m_layouter->itemSize().width();
          if (itemWidth > 0) {
      if (m_layouter->scrollOrientation() == Qt::Vertical) {
          const qreal itemWidth = m_layouter->itemSize().width();
          if (itemWidth > 0) {
-            const int newColumnCount = itemsPerSize(newGridSize.width(),
-                                                    newItemSize.width(),
-                                                    newItemMargin.width());
+            const int newColumnCount = itemsPerSize(newGridSize.width(), newItemSize.width(), newItemMargin.width());
              if (m_model->count() > newColumnCount) {
              if (m_model->count() > newColumnCount) {
-                const int oldColumnCount = itemsPerSize(m_layouter->size().width(),
-                                                        itemWidth,
-                                                        m_layouter->itemMargin().width());
+                const int oldColumnCount = itemsPerSize(m_layouter->size().width(), itemWidth, m_layouter->itemMargin().width());
                  return oldColumnCount != newColumnCount;
              }
          }
      } else {
          const qreal itemHeight = m_layouter->itemSize().height();
          if (itemHeight > 0) {
                  return oldColumnCount != newColumnCount;
              }
          }
      } else {
          const qreal itemHeight = m_layouter->itemSize().height();
          if (itemHeight > 0) {
-            const int newRowCount = itemsPerSize(newGridSize.height(),
-                                                 newItemSize.height(),
-                                                 newItemMargin.height());
+            const int newRowCount = itemsPerSize(newGridSize.height(), newItemSize.height(), newItemMargin.height());
              if (m_model->count() > newRowCount) {
              if (m_model->count() > newRowCount) {
-                const int oldRowCount = itemsPerSize(m_layouter->size().height(),
-                                                     itemHeight,
-                                                     m_layouter->itemMargin().height());
+                const int oldRowCount = itemsPerSize(m_layouter->size().height(), itemHeight, m_layouter->itemMargin().height());
                  return oldRowCount != newRowCount;
              }
          }
                  return oldRowCount != newRowCount;
              }
          }
@@ -2351,15 +2576,13 @@ bool KItemListView::animateChangedItemCount(int changedItemCount) const
          return false;
      }
  
          return false;
      }
  
-    const int maximum = (scrollOrientation() == Qt::Vertical)
-                        ? m_layouter->size().width()  / m_layouter->itemSize().width()
-                        : m_layouter->size().height() / m_layouter->itemSize().height();
+    const int maximum = (scrollOrientation() == Qt::Vertical) ? m_layouter->size().width() / m_layouter->itemSize().width()
+                                                              : m_layouter->size().height() / m_layouter->itemSize().height();
      // Only animate if up to 2/3 of a row or column are inserted or removed
      return changedItemCount <= maximum * 2 / 3;
  }
  
      // Only animate if up to 2/3 of a row or column are inserted or removed
      return changedItemCount <= maximum * 2 / 3;
  }
  
-
-bool KItemListView::scrollBarRequired(const QSizeF& size) const
+bool KItemListView::scrollBarRequired(const QSizeF &size) const
  {
      const QSizeF oldSize = m_layouter->size();
  
  {
      const QSizeF oldSize = m_layouter->size();
  
@@ -2367,29 +2590,28 @@ bool KItemListView::scrollBarRequired(const QSizeF& size) const
      const qreal maxOffset = m_layouter->maximumScrollOffset();
      m_layouter->setSize(oldSize);
  
      const qreal maxOffset = m_layouter->maximumScrollOffset();
      m_layouter->setSize(oldSize);
  
-    return m_layouter->scrollOrientation() == Qt::Vertical ? maxOffset > size.height()
-                                                           : maxOffset > size.width();
+    return m_layouter->scrollOrientation() == Qt::Vertical ? maxOffset > size.height() : maxOffset > size.width();
  }
  
  }
  
-int KItemListView::showDropIndicator(const QPointF& pos)
+int KItemListView::showDropIndicator(const QPointF &pos)
  {
  {
-    QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+    QHashIterator<int, KItemListWidget *> it(m_visibleItems);
      while (it.hasNext()) {
          it.next();
      while (it.hasNext()) {
          it.next();
-        const KItemListWidget* widget = it.value();
+        const KItemListWidget *widget = it.value();
  
          const QPointF mappedPos = widget->mapFromItem(this, pos);
          const QRectF rect = itemRect(widget->index());
          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 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(4.0, 0.3 * rect.height());
+                const int gap = qMax(qreal(4.0), qreal(0.3) * rect.height());
                  if (mappedPos.y() >= gap && mappedPos.y() <= rect.height() - gap) {
                      return -1;
                  }
              }
  
                  if (mappedPos.y() >= gap && mappedPos.y() <= rect.height() - gap) {
                      return -1;
                  }
              }
  
-            const bool isAboveItem = (mappedPos.y () < rect.height() / 2);
+            const bool isAboveItem = (mappedPos.y() < rect.height() / 2);
              const qreal y = isAboveItem ? rect.top() : rect.bottom();
  
              const QRectF draggingInsertIndicator(rect.left(), y, rect.width(), 1);
              const qreal y = isAboveItem ? rect.top() : rect.bottom();
  
              const QRectF draggingInsertIndicator(rect.left(), y, rect.width(), 1);
@@ -2429,7 +2651,7 @@ void KItemListView::updateGroupHeaderHeight()
          // from m_styleOption.
          groupHeaderHeight += 2 * m_styleOption.horizontalMargin;
          groupHeaderMargin = m_styleOption.horizontalMargin;
          // from m_styleOption.
          groupHeaderHeight += 2 * m_styleOption.horizontalMargin;
          groupHeaderMargin = m_styleOption.horizontalMargin;
-    } else if (m_itemSize.isEmpty()){
+    } else if (m_itemSize.isEmpty()) {
          groupHeaderHeight += 4 * m_styleOption.padding;
          groupHeaderMargin = m_styleOption.iconSize / 2;
      } else {
          groupHeaderHeight += 4 * m_styleOption.padding;
          groupHeaderMargin = m_styleOption.iconSize / 2;
      } else {
@@ -2450,10 +2672,9 @@ void KItemListView::updateSiblingsInformation(int firstIndex, int lastIndex)
  
      if (firstIndex < 0 || lastIndex < 0) {
          firstIndex = m_layouter->firstVisibleIndex();
  
      if (firstIndex < 0 || lastIndex < 0) {
          firstIndex = m_layouter->firstVisibleIndex();
-        lastIndex  = m_layouter->lastVisibleIndex();
+        lastIndex = m_layouter->lastVisibleIndex();
      } else {
      } else {
-        const bool isRangeVisible = (firstIndex <= m_layouter->lastVisibleIndex() &&
-                                     lastIndex  >= m_layouter->firstVisibleIndex());
+        const bool isRangeVisible = (firstIndex <= m_layouter->lastVisibleIndex() && lastIndex >= m_layouter->firstVisibleIndex());
          if (!isRangeVisible) {
              return;
          }
          if (!isRangeVisible) {
              return;
          }
@@ -2469,7 +2690,7 @@ void KItemListView::updateSiblingsInformation(int firstIndex, int lastIndex)
      // contain a siblings information which can be used as base.
      int rootIndex = firstIndex;
  
      // contain a siblings information which can be used as base.
      int rootIndex = firstIndex;
  
-    KItemListWidget* widget = m_visibleItems.value(firstIndex - 1);
+    KItemListWidget *widget = m_visibleItems.value(firstIndex - 1);
      if (!widget) {
          // There is no visible widget before the range, check whether there
          // is one after the range:
      if (!widget) {
          // There is no visible widget before the range, check whether there
          // is one after the range:
@@ -2480,7 +2701,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;
                  }
              }
@@ -2522,7 +2743,7 @@ void KItemListView::updateSiblingsInformation(int firstIndex, int lastIndex)
          if (i >= firstIndex) {
              // The index represents a visible item. Apply the parent-siblings
              // and update the sibling of the current item.
          if (i >= firstIndex) {
              // The index represents a visible item. Apply the parent-siblings
              // and update the sibling of the current item.
-            KItemListWidget* widget = m_visibleItems.value(i);
+            KItemListWidget *widget = m_visibleItems.value(i);
              if (!widget) {
                  continue;
              }
              if (!widget) {
                  continue;
              }
@@ -2571,13 +2792,14 @@ bool KItemListView::hasSiblingSuccessor(int index) const
  
  void KItemListView::disconnectRoleEditingSignals(int index)
  {
  
  void KItemListView::disconnectRoleEditingSignals(int index)
  {
-    KItemListWidget* widget = m_visibleItems.value(index);
+    KStandardItemListWidget *widget = qobject_cast<KStandardItemListWidget *>(m_visibleItems.value(index));
      if (!widget) {
          return;
      }
  
      if (!widget) {
          return;
      }
  
-    widget->disconnect(SIGNAL(roleEditingCanceled(int,QByteArray,QVariant)), this);
-    widget->disconnect(SIGNAL(roleEditingFinished(int,QByteArray,QVariant)), this);
+    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 KItemListView::calculateAutoScrollingIncrement(int pos, int range, int oldInc)
@@ -2613,20 +2835,18 @@ int KItemListView::itemsPerSize(qreal size, qreal itemSize, qreal itemMargin)
      return count;
  }
  
      return count;
  }
  
-
-
  KItemListCreatorBase::~KItemListCreatorBase()
  {
      qDeleteAll(m_recycleableWidgets);
      qDeleteAll(m_createdWidgets);
  }
  
  KItemListCreatorBase::~KItemListCreatorBase()
  {
      qDeleteAll(m_recycleableWidgets);
      qDeleteAll(m_createdWidgets);
  }
  
-void KItemListCreatorBase::addCreatedWidget(QGraphicsWidget* widget)
+void KItemListCreatorBase::addCreatedWidget(QGraphicsWidget *widget)
  {
      m_createdWidgets.insert(widget);
  }
  
  {
      m_createdWidgets.insert(widget);
  }
  
-void KItemListCreatorBase::pushRecycleableWidget(QGraphicsWidget* widget)
+void KItemListCreatorBase::pushRecycleableWidget(QGraphicsWidget *widget)
  {
      Q_ASSERT(m_createdWidgets.contains(widget));
      m_createdWidgets.remove(widget);
  {
      Q_ASSERT(m_createdWidgets.contains(widget));
      m_createdWidgets.remove(widget);
@@ -2639,13 +2859,13 @@ void KItemListCreatorBase::pushRecycleableWidget(QGraphicsWidget* widget)
      }
  }
  
      }
  }
  
-QGraphicsWidget* KItemListCreatorBase::popRecycleableWidget()
+QGraphicsWidget *KItemListCreatorBase::popRecycleableWidget()
  {
      if (m_recycleableWidgets.isEmpty()) {
  {
      if (m_recycleableWidgets.isEmpty()) {
-        return 0;
+        return nullptr;
      }
  
      }
  
-    QGraphicsWidget* widget = m_recycleableWidgets.takeLast();
+    QGraphicsWidget *widget = m_recycleableWidgets.takeLast();
      m_createdWidgets.insert(widget);
      return widget;
  }
      m_createdWidgets.insert(widget);
      return widget;
  }
@@ -2654,9 +2874,9 @@ 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);
  }
@@ -2665,10 +2885,10 @@ KItemListGroupHeaderCreatorBase::~KItemListGroupHeaderCreatorBase()
  {
  }
  
  {
  }
  
-void KItemListGroupHeaderCreatorBase::recycle(KItemListGroupHeader* header)
+void KItemListGroupHeaderCreatorBase::recycle(KItemListGroupHeader *header)
  {
      header->setOpacity(1.0);
      pushRecycleableWidget(header);
  }
  
  {
      header->setOpacity(1.0);
      pushRecycleableWidget(header);
  }
  
-#include "kitemlistview.moc"
+#include "moc_kitemlistview.cpp"