Port from KIconLoader::drawOverlays to KIconUtils::addOverlays

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

diff --git a/src/kitemviews/kfileitemlistview.cpp b/src/kitemviews/kfileitemlistview.cpp
index 27ef7fdb5019c633bc1a5eb4fa54299d35025d2f..d763fe287924325b3a92e62c1e74c109cdd06cd7 100644 (file)
--- a/src/kitemviews/kfileitemlistview.cpp
+++ b/src/kitemviews/kfileitemlistview.cpp
@@ -1,122 +1,101 @@
-/***************************************************************************
- *   Copyright (C) 2011 by Peter Penz <peter.penz19@gmail.com>             *
- *                                                                         *
- *   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>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */

 
 #include "kfileitemlistview.h"
 
 
 #include "kfileitemlistview.h"
 

-#include "kfileitemlistgroupheader.h"
-#include "kfileitemmodelrolesupdater.h"

 #include "kfileitemlistwidget.h"
 #include "kfileitemmodel.h"
 #include "kfileitemlistwidget.h"
 #include "kfileitemmodel.h"

-#include "kpixmapmodifier_p.h"
-#include <KLocale>
-#include <KStringHandler>
+#include "kfileitemmodelrolesupdater.h"
+#include "private/kitemviewsutils.h"
+#include "private/kpixmapmodifier.h"

 
 

-#include <KDebug>
-#include <KIcon>
+#include <KIconLoader>

 
 

+#include <QGraphicsScene>
+#include <QGraphicsView>
+#include <QIcon>
+#include <QMimeDatabase>

 #include <QPainter>
 #include <QPainter>

-#include <QTextLine>

 #include <QTimer>
 
 // #define KFILEITEMLISTVIEW_DEBUG
 
 #include <QTimer>
 
 // #define KFILEITEMLISTVIEW_DEBUG
 

-namespace {
-    const int ShortInterval = 50;
-    const int LongInterval = 300;
+namespace
+{
+// If the visible index range changes, KFileItemModelRolesUpdater is not
+// informed immediately, but with a short delay. This ensures that scrolling
+// always feels smooth and is not interrupted by icon loading (which can be
+// quite expensive if a disk access is required to determine the final icon).
+const int ShortInterval = 50;
+
+// If the icon size changes, a longer delay is used. This prevents that
+// the expensive re-generation of all previews is triggered repeatedly when
+// changing the zoom level.
+const int LongInterval = 300;

 }
 
 }
 

-KFileItemListView::KFileItemListView(QGraphicsWidget* parent) :
-    KItemListView(parent),
-    m_itemLayout(IconsLayout),
-    m_modelRolesUpdater(0),
-    m_updateVisibleIndexRangeTimer(0),
-    m_updateIconSizeTimer(0),
-    m_minimumRolesWidths()
+KFileItemListView::KFileItemListView(QGraphicsWidget *parent)
+    : KStandardItemListView(parent)
+    , m_modelRolesUpdater(nullptr)
+    , m_updateVisibleIndexRangeTimer(nullptr)
+    , m_updateIconSizeTimer(nullptr)

 {
     setAcceptDrops(true);
 
     setScrollOrientation(Qt::Vertical);
 {
     setAcceptDrops(true);
 
     setScrollOrientation(Qt::Vertical);

-    setWidgetCreator(new KItemListWidgetCreator<KFileItemListWidget>());
-    setGroupHeaderCreator(new KItemListGroupHeaderCreator<KFileItemListGroupHeader>());

 
     m_updateVisibleIndexRangeTimer = new QTimer(this);
     m_updateVisibleIndexRangeTimer->setSingleShot(true);
     m_updateVisibleIndexRangeTimer->setInterval(ShortInterval);
 
     m_updateVisibleIndexRangeTimer = new QTimer(this);
     m_updateVisibleIndexRangeTimer->setSingleShot(true);
     m_updateVisibleIndexRangeTimer->setInterval(ShortInterval);

-    connect(m_updateVisibleIndexRangeTimer, SIGNAL(timeout()), this, SLOT(updateVisibleIndexRange()));
+    connect(m_updateVisibleIndexRangeTimer, &QTimer::timeout, this, &KFileItemListView::updateVisibleIndexRange);

 
     m_updateIconSizeTimer = new QTimer(this);
     m_updateIconSizeTimer->setSingleShot(true);
 
     m_updateIconSizeTimer = new QTimer(this);
     m_updateIconSizeTimer->setSingleShot(true);

-    m_updateIconSizeTimer->setInterval(ShortInterval);
-    connect(m_updateIconSizeTimer, SIGNAL(timeout()), this, SLOT(updateIconSize()));
-
-    setVisibleRoles(QList<QByteArray>() << "name");
+    m_updateIconSizeTimer->setInterval(LongInterval);
+    connect(m_updateIconSizeTimer, &QTimer::timeout, this, &KFileItemListView::updateIconSize);

 
 

-    updateMinimumRolesWidths();
+    setVisibleRoles({"text"});

 }
 
 KFileItemListView::~KFileItemListView()
 {
 }
 
 KFileItemListView::~KFileItemListView()
 {

-    // The group headers are children of the widgets created by
-    // widgetCreator(). So it is mandatory to delete the group headers
-    // first.
-    delete groupHeaderCreator();
-    delete widgetCreator();
-
-    delete m_modelRolesUpdater;
-    m_modelRolesUpdater = 0;

 }
 
 void KFileItemListView::setPreviewsShown(bool show)
 {
 }
 
 void KFileItemListView::setPreviewsShown(bool show)
 {

-    if (m_modelRolesUpdater) {
-        m_modelRolesUpdater->setPreviewShown(show);
+    if (!m_modelRolesUpdater) {
+        return;
+    }
+
+    if (m_modelRolesUpdater->previewsShown() != show) {
+        beginTransaction();
+        m_modelRolesUpdater->setPreviewsShown(show);
+        onPreviewsShownChanged(show);
+        endTransaction();

     }
 }
 
 bool KFileItemListView::previewsShown() const
 {
     }
 }
 
 bool KFileItemListView::previewsShown() const
 {

-    return m_modelRolesUpdater->isPreviewShown();
+    return m_modelRolesUpdater ? m_modelRolesUpdater->previewsShown() : false;

 }
 
 }
 

-void KFileItemListView::setItemLayout(Layout layout)
+void KFileItemListView::setEnlargeSmallPreviews(bool enlarge)

 {
 {

-    if (m_itemLayout != layout) {
-        const bool updateRoles = (m_itemLayout == DetailsLayout || layout == DetailsLayout);
-        m_itemLayout = layout;
-        if (updateRoles) {
-            // The details-layout requires some invisible roles that
-            // must be added to the model if the new layout is "details".
-            // If the old layout was "details" the roles will get removed.
-            applyRolesToModel();
-        }
-        updateLayoutOfVisibleItems();
-
-        setSupportsItemExpanding(m_itemLayout == DetailsLayout);
+    if (m_modelRolesUpdater) {
+        m_modelRolesUpdater->setEnlargeSmallPreviews(enlarge);

     }
 }
 
     }
 }
 

-KFileItemListView::Layout KFileItemListView::itemLayout() const
+bool KFileItemListView::enlargeSmallPreviews() const

 {
 {

-    return m_itemLayout;
+    return m_modelRolesUpdater ? m_modelRolesUpdater->enlargeSmallPreviews() : false;

 }
 
 }
 

-void KFileItemListView::setEnabledPlugins(const QStringList& list)
+void KFileItemListView::setEnabledPlugins(const QStringList &list)

 {
     if (m_modelRolesUpdater) {
         m_modelRolesUpdater->setEnabledPlugins(list);
 {
     if (m_modelRolesUpdater) {
         m_modelRolesUpdater->setEnabledPlugins(list);


@@ -128,122 +107,19 @@ QStringList KFileItemListView::enabledPlugins() const
     return m_modelRolesUpdater ? m_modelRolesUpdater->enabledPlugins() : QStringList();
 }
 
     return m_modelRolesUpdater ? m_modelRolesUpdater->enabledPlugins() : QStringList();
 }
 

-QSizeF KFileItemListView::itemSizeHint(int index) const
+void KFileItemListView::setLocalFileSizePreviewLimit(const qlonglong size)

 {
 {

-    const QHash<QByteArray, QVariant> values = model()->data(index);
-    const KItemListStyleOption& option = styleOption();
-    const int additionalRolesCount = qMax(visibleRoles().count() - 1, 0);
-
-    switch (m_itemLayout) {
-    case IconsLayout: {
-        const QString text = KStringHandler::preProcessWrap(values["name"].toString());
-
-        const qreal maxWidth = itemSize().width() - 2 * option.padding;
-        int textLinesCount = 0;
-        QTextLine line;
-
-        // Calculate the number of lines required for wrapping the name
-        QTextOption textOption(Qt::AlignHCenter);
-        textOption.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
-
-        QTextLayout layout(text, option.font);
-        layout.setTextOption(textOption);
-        layout.beginLayout();
-        while ((line = layout.createLine()).isValid()) {
-            line.setLineWidth(maxWidth);
-            line.naturalTextWidth();
-            ++textLinesCount;
-        }
-        layout.endLayout();
-
-        // Add one line for each additional information
-        textLinesCount += additionalRolesCount;
-
-        const qreal height = textLinesCount * option.fontMetrics.height() +
-                             option.iconSize +
-                             option.padding * 3;
-        return QSizeF(itemSize().width(), height);
-    }
-
-    case CompactLayout: {
-        // For each row exactly one role is shown. Calculate the maximum required width that is necessary
-        // to show all roles without horizontal clipping.
-        qreal maximumRequiredWidth = 0.0;
-
-        foreach (const QByteArray& role, visibleRoles()) {
-            const QString text = KFileItemListWidget::roleText(role, values);
-            const qreal requiredWidth = option.fontMetrics.width(text);
-            maximumRequiredWidth = qMax(maximumRequiredWidth, requiredWidth);
-        }
-
-        const qreal width = option.padding * 4 + option.iconSize + maximumRequiredWidth;
-        const qreal height = option.padding * 2 + qMax(option.iconSize, (1 + additionalRolesCount) * option.fontMetrics.height());
-        return QSizeF(width, height);
-    }
-
-    case DetailsLayout: {
-        // The width will be determined dynamically by KFileItemListView::visibleRoleSizes()
-        const qreal height = option.padding * 2 + qMax(option.iconSize, option.fontMetrics.height());
-        return QSizeF(-1, height);
-    }
-
-    default:
-        Q_ASSERT(false);
-        break;
+    if (m_modelRolesUpdater) {
+        m_modelRolesUpdater->setLocalFileSizePreviewLimit(size);

     }
     }

-
-    return QSize();

 }
 
 }
 

-QHash<QByteArray, QSizeF> KFileItemListView::visibleRolesSizes(const KItemRangeList& itemRanges) const
+qlonglong KFileItemListView::localFileSizePreviewLimit() const

 {
 {

-    QElapsedTimer timer;
-    timer.start();
-
-    QHash<QByteArray, QSizeF> sizes;
-
-    int calculatedItemCount = 0;
-    bool maxTimeExceeded = false;
-    foreach (const KItemRange& itemRange, itemRanges) {
-        const int startIndex = itemRange.index;
-        const int endIndex = startIndex + itemRange.count - 1;
-
-        for (int i = startIndex; i <= endIndex; ++i) {
-            foreach (const QByteArray& visibleRole, visibleRoles()) {
-                QSizeF maxSize = sizes.value(visibleRole, QSizeF(0, 0));
-                const QSizeF itemSize = visibleRoleSizeHint(i, visibleRole);
-                maxSize = maxSize.expandedTo(itemSize);
-                sizes.insert(visibleRole, maxSize);
-            }
-
-            if (calculatedItemCount > 100 && timer.elapsed() > 200) {
-                // When having several thousands of items calculating the sizes can get
-                // very expensive. We accept a possibly too small role-size in favour
-                // of having no blocking user interface.
-                #ifdef KFILEITEMLISTVIEW_DEBUG
-                    kDebug() << "Timer exceeded, stopped after" << calculatedItemCount << "items";
-                #endif
-                maxTimeExceeded = true;
-                break;
-            }
-            ++calculatedItemCount;
-        }
-        if (maxTimeExceeded) {
-            break;
-        }
-    }
-
-#ifdef KFILEITEMLISTVIEW_DEBUG
-    int rangesItemCount = 0;
-    foreach (const KItemRange& itemRange, itemRanges) {
-        rangesItemCount += itemRange.count;
-    }
-    kDebug() << "[TIME] Calculated dynamic item size for " << rangesItemCount << "items:" << timer.elapsed();
-#endif
-    return sizes;
+    return m_modelRolesUpdater ? m_modelRolesUpdater->localFileSizePreviewLimit() : 0;

 }
 
 }
 

-QPixmap KFileItemListView::createDragPixmap(const QSet<int>& indexes) const
+QPixmap KFileItemListView::createDragPixmap(const KItemSet &indexes) const

 {
     if (!model()) {
         return QPixmap();
 {
     if (!model()) {
         return QPixmap();


@@ -251,6 +127,9 @@ QPixmap KFileItemListView::createDragPixmap(const QSet<int>& indexes) const
 
     const int itemCount = indexes.count();
     Q_ASSERT(itemCount > 0);
 
     const int itemCount = indexes.count();
     Q_ASSERT(itemCount > 0);

+    if (itemCount == 1) {
+        return KItemListView::createDragPixmap(indexes);
+    }

 
     // If more than one item is dragged, align the items inside a
     // rectangular grid. The maximum grid size is limited to 5 x 5 items.
 
     // If more than one item is dragged, align the items inside a
     // rectangular grid. The maximum grid size is limited to 5 x 5 items.


@@ -279,23 +158,31 @@ QPixmap KFileItemListView::createDragPixmap(const QSet<int>& indexes) const
         yCount = xCount;
     }
 
         yCount = xCount;
     }
 

+    const qreal dpr = KItemViewsUtils::devicePixelRatio(this);

     // Draw the selected items into the grid cells.
     // Draw the selected items into the grid cells.

-    QPixmap dragPixmap(xCount * size + xCount, yCount * size + yCount);
+    QPixmap dragPixmap(QSize(xCount * size + xCount, yCount * size + yCount) * dpr);
+    dragPixmap.setDevicePixelRatio(dpr);

     dragPixmap.fill(Qt::transparent);
 
     QPainter painter(&dragPixmap);
     int x = 0;
     int y = 0;
     dragPixmap.fill(Qt::transparent);
 
     QPainter painter(&dragPixmap);
     int x = 0;
     int y = 0;

-    QSetIterator<int> it(indexes);
-    while (it.hasNext()) {
-        const int index = it.next();

 
 

+    for (int index : indexes) {

         QPixmap pixmap = model()->data(index).value("iconPixmap").value<QPixmap>();
         if (pixmap.isNull()) {
         QPixmap pixmap = model()->data(index).value("iconPixmap").value<QPixmap>();
         if (pixmap.isNull()) {

-            KIcon icon(model()->data(index).value("iconName").toString());
-            pixmap = icon.pixmap(size, size);
+            QIcon icon = QIcon::fromTheme(model()->data(index).value("iconName").toString());
+            if (icon.isNull()) {
+                icon = QIcon::fromTheme(QStringLiteral("unknown"));
+            }
+            if (!icon.isNull()) {
+                pixmap = icon.pixmap(size, size);
+            } else {
+                pixmap = QPixmap(size, size);
+                pixmap.fill(Qt::transparent);
+            }

         } else {
         } else {

-            KPixmapModifier::scale(pixmap, QSize(size, size));
+            KPixmapModifier::scale(pixmap, QSize(size, size) * dpr);

         }
 
         painter.drawPixmap(x, y, pixmap);
         }
 
         painter.drawPixmap(x, y, pixmap);


@@ -314,117 +201,171 @@ QPixmap KFileItemListView::createDragPixmap(const QSet<int>& indexes) const
     return dragPixmap;
 }
 
     return dragPixmap;
 }
 

-void KFileItemListView::initializeItemListWidget(KItemListWidget* item)
+void KFileItemListView::setHoverSequenceState(const QUrl &itemUrl, int seqIdx)

 {
 {

-    KFileItemListWidget* fileItemListWidget = static_cast<KFileItemListWidget*>(item);
+    if (m_modelRolesUpdater) {
+        m_modelRolesUpdater->setHoverSequenceState(itemUrl, seqIdx);
+    }
+}

 
 

-    switch (m_itemLayout) {
-    case IconsLayout:   fileItemListWidget->setLayout(KFileItemListWidget::IconsLayout); break;
-    case CompactLayout: fileItemListWidget->setLayout(KFileItemListWidget::CompactLayout); break;
-    case DetailsLayout: fileItemListWidget->setLayout(KFileItemListWidget::DetailsLayout); break;
-    default:            Q_ASSERT(false); break;
+KItemListWidgetCreatorBase *KFileItemListView::defaultWidgetCreator() const
+{
+    return new KItemListWidgetCreator<KFileItemListWidget>();
+}
+
+void KFileItemListView::initializeItemListWidget(KItemListWidget *item)
+{
+    KStandardItemListView::initializeItemListWidget(item);
+
+    // Make sure that the item has an icon.
+    QHash<QByteArray, QVariant> data = item->data();
+    if (!data.contains("iconName") && data["iconPixmap"].value<QPixmap>().isNull()) {
+        Q_ASSERT(qobject_cast<KFileItemModel *>(model()));
+        KFileItemModel *fileItemModel = static_cast<KFileItemModel *>(model());
+
+        const KFileItem fileItem = fileItemModel->fileItem(item->index());
+        QString iconName = fileItem.iconName();
+        if (!QIcon::hasThemeIcon(iconName)) {
+            QMimeDatabase mimeDb;
+            iconName = mimeDb.mimeTypeForName(fileItem.mimetype()).genericIconName();
+        }
+        data.insert("iconName", iconName);
+        item->setData(data, {"iconName"});

     }
 }
 
     }
 }
 

-bool KFileItemListView::itemSizeHintUpdateRequired(const QSet<QByteArray>& changedRoles) const
+void KFileItemListView::onPreviewsShownChanged(bool shown)

 {
 {

-    // Even if the icons have a different size they are always aligned within
-    // the area defined by KItemStyleOption.iconSize and hence result in no
-    // change of the item-size.
-    const bool containsIconName = changedRoles.contains("iconName");
-    const bool containsIconPixmap = changedRoles.contains("iconPixmap");
-    const int count = changedRoles.count();
+    Q_UNUSED(shown)
+}

 
 

-    const bool iconChanged = (containsIconName && containsIconPixmap && count == 2) ||
-                             (containsIconName && count == 1) ||
-                             (containsIconPixmap && count == 1);
-    return !iconChanged;
+void KFileItemListView::onItemLayoutChanged(ItemLayout current, ItemLayout previous)
+{
+    KStandardItemListView::onItemLayoutChanged(current, previous);
+    triggerVisibleIndexRangeUpdate();

 }
 
 }
 

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

 {
 {

-    Q_UNUSED(previous);
-    Q_ASSERT(qobject_cast<KFileItemModel*>(current));
+    Q_ASSERT(qobject_cast<KFileItemModel *>(current));
+    KStandardItemListView::onModelChanged(current, previous);

 
     delete m_modelRolesUpdater;
 
     delete m_modelRolesUpdater;

-    m_modelRolesUpdater = new KFileItemModelRolesUpdater(static_cast<KFileItemModel*>(current), this);
-    m_modelRolesUpdater->setIconSize(availableIconSize());
+    m_modelRolesUpdater = nullptr;

 
 

-    applyRolesToModel();
+    if (current) {
+        m_modelRolesUpdater = new KFileItemModelRolesUpdater(static_cast<KFileItemModel *>(current), this);
+        m_modelRolesUpdater->setIconSize(availableIconSize());
+        m_modelRolesUpdater->setDevicePixelRatio(KItemViewsUtils::devicePixelRatio(this));
+
+        applyRolesToModel();
+    }

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

-    Q_UNUSED(current);
-    Q_UNUSED(previous);
-    updateLayoutOfVisibleItems();
+    KStandardItemListView::onScrollOrientationChanged(current, previous);
+    triggerVisibleIndexRangeUpdate();

 }
 
 }
 

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

 {
 {

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

     triggerVisibleIndexRangeUpdate();
 }
 
 void KFileItemListView::onScrollOffsetChanged(qreal current, qreal previous)
 {
     triggerVisibleIndexRangeUpdate();
 }
 
 void KFileItemListView::onScrollOffsetChanged(qreal current, qreal previous)
 {

-    Q_UNUSED(current);
-    Q_UNUSED(previous);
+    KStandardItemListView::onScrollOffsetChanged(current, previous);

     triggerVisibleIndexRangeUpdate();
 }
 
     triggerVisibleIndexRangeUpdate();
 }
 

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

 {
 {

-    Q_UNUSED(current);
-    Q_UNUSED(previous);
+    KStandardItemListView::onVisibleRolesChanged(current, previous);

     applyRolesToModel();
 }
 
     applyRolesToModel();
 }
 

-void KFileItemListView::onStyleOptionChanged(const KItemListStyleOption& current, const KItemListStyleOption& previous)
+void KFileItemListView::onStyleOptionChanged(const KItemListStyleOption &current, const KItemListStyleOption &previous)

 {
 {

-    Q_UNUSED(current);
-    Q_UNUSED(previous);
+    KStandardItemListView::onStyleOptionChanged(current, previous);

     triggerIconSizeUpdate();
 }
 
     triggerIconSizeUpdate();
 }
 

+void KFileItemListView::onSupportsItemExpandingChanged(bool supportsExpanding)
+{
+    applyRolesToModel();
+    KStandardItemListView::onSupportsItemExpandingChanged(supportsExpanding);
+    triggerVisibleIndexRangeUpdate();
+}
+

 void KFileItemListView::onTransactionBegin()
 {
 void KFileItemListView::onTransactionBegin()
 {

-    m_modelRolesUpdater->setPaused(true);
+    if (m_modelRolesUpdater) {
+        m_modelRolesUpdater->setPaused(true);
+    }

 }
 
 void KFileItemListView::onTransactionEnd()
 {
 }
 
 void KFileItemListView::onTransactionEnd()
 {

+    if (!m_modelRolesUpdater) {
+        return;
+    }
+

     // Only unpause the model-roles-updater if no timer is active. If one
     // timer is still active the model-roles-updater will be unpaused later as
     // soon as the timer has been exceeded.
     // Only unpause the model-roles-updater if no timer is active. If one
     // timer is still active the model-roles-updater will be unpaused later as
     // soon as the timer has been exceeded.

-    const bool timerActive = m_updateVisibleIndexRangeTimer->isActive() ||
-                             m_updateIconSizeTimer->isActive();
+    const bool timerActive = m_updateVisibleIndexRangeTimer->isActive() || m_updateIconSizeTimer->isActive();

     if (!timerActive) {
         m_modelRolesUpdater->setPaused(false);
     }
 }
 
     if (!timerActive) {
         m_modelRolesUpdater->setPaused(false);
     }
 }
 

-void KFileItemListView::resizeEvent(QGraphicsSceneResizeEvent* event)
+void KFileItemListView::resizeEvent(QGraphicsSceneResizeEvent *event)

 {
 {

-    KItemListView::resizeEvent(event);
+    KStandardItemListView::resizeEvent(event);

     triggerVisibleIndexRangeUpdate();
 }
 
     triggerVisibleIndexRangeUpdate();
 }
 

-void KFileItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
+void KFileItemListView::focusInEvent(QFocusEvent *event)
+{
+    Q_UNUSED(event)
+    updateSelectedWidgets();
+}
+
+void KFileItemListView::focusOutEvent(QFocusEvent *event)
+{
+    Q_UNUSED(event)
+    updateSelectedWidgets();
+}
+
+void KFileItemListView::updateSelectedWidgets()

 {
 {

-    KItemListView::slotItemsRemoved(itemRanges);
-    updateTimersInterval();
+    const auto visibleWidgets = visibleItemListWidgets();
+    for (KItemListWidget *widget : visibleWidgets) {
+        if (widget->isSelected()) {
+            auto w = qobject_cast<KFileItemListWidget *>(widget);
+            if (w) {
+                w->forceUpdate();
+            }
+        }
+    }

 }
 
 }
 

-void KFileItemListView::slotSortRoleChanged(const QByteArray& current, const QByteArray& previous)
+void KFileItemListView::slotItemsRemoved(const KItemRangeList &itemRanges)
+{
+    KStandardItemListView::slotItemsRemoved(itemRanges);
+}
+
+void KFileItemListView::slotSortRoleChanged(const QByteArray &current, const QByteArray &previous)

 {
     const QByteArray sortRole = model()->sortRole();
     if (!visibleRoles().contains(sortRole)) {
         applyRolesToModel();
     }
 
 {
     const QByteArray sortRole = model()->sortRole();
     if (!visibleRoles().contains(sortRole)) {
         applyRolesToModel();
     }
 

-    KItemListView::slotSortRoleChanged(current, previous);
+    KStandardItemListView::slotSortRoleChanged(current, previous);

 }
 
 void KFileItemListView::triggerVisibleIndexRangeUpdate()
 }
 
 void KFileItemListView::triggerVisibleIndexRangeUpdate()


@@ -433,7 +374,12 @@ void KFileItemListView::triggerVisibleIndexRangeUpdate()
         return;
     }
     m_modelRolesUpdater->setPaused(true);
         return;
     }
     m_modelRolesUpdater->setPaused(true);

-    m_updateVisibleIndexRangeTimer->start();
+
+    // If the icon size has been changed recently, wait until
+    // m_updateIconSizeTimer expires.
+    if (!m_updateIconSizeTimer->isActive()) {
+        m_updateVisibleIndexRangeTimer->start();
+    }

 }
 
 void KFileItemListView::updateVisibleIndexRange()
 }
 
 void KFileItemListView::updateVisibleIndexRange()


@@ -444,18 +390,9 @@ void KFileItemListView::updateVisibleIndexRange()
 
     const int index = firstVisibleIndex();
     const int count = lastVisibleIndex() - index + 1;
 
     const int index = firstVisibleIndex();
     const int count = lastVisibleIndex() - index + 1;

+    m_modelRolesUpdater->setMaximumVisibleItems(maximumVisibleItems());

     m_modelRolesUpdater->setVisibleIndexRange(index, count);
     m_modelRolesUpdater->setVisibleIndexRange(index, count);

-
-    if (m_updateIconSizeTimer->isActive()) {
-        // If the icon-size update is pending do an immediate update
-        // of the icon-size before unpausing m_modelRolesUpdater. This prevents
-        // an unnecessary expensive recreation of all previews afterwards.
-        m_updateIconSizeTimer->stop();
-        m_modelRolesUpdater->setIconSize(availableIconSize());
-    }
-

     m_modelRolesUpdater->setPaused(isTransactionActive());
     m_modelRolesUpdater->setPaused(isTransactionActive());

-    updateTimersInterval();

 }
 
 void KFileItemListView::triggerIconSizeUpdate()
 }
 
 void KFileItemListView::triggerIconSizeUpdate()


@@ -465,6 +402,11 @@ void KFileItemListView::triggerIconSizeUpdate()
     }
     m_modelRolesUpdater->setPaused(true);
     m_updateIconSizeTimer->start();
     }
     m_modelRolesUpdater->setPaused(true);
     m_updateIconSizeTimer->start();

+
+    // The visible index range will be updated when m_updateIconSizeTimer expires.
+    // Stop m_updateVisibleIndexRangeTimer to prevent an expensive re-generation
+    // of all previews (note that the user might change the icon size again soon).
+    m_updateVisibleIndexRangeTimer->stop();

 }
 
 void KFileItemListView::updateIconSize()
 }
 
 void KFileItemListView::updateIconSize()


@@ -474,83 +416,15 @@ void KFileItemListView::updateIconSize()
     }
 
     m_modelRolesUpdater->setIconSize(availableIconSize());
     }
 
     m_modelRolesUpdater->setIconSize(availableIconSize());

+    m_modelRolesUpdater->setDevicePixelRatio(KItemViewsUtils::devicePixelRatio(this));

 
 

-    if (m_updateVisibleIndexRangeTimer->isActive()) {
-        // If the visibility-index-range update is pending do an immediate update
-        // of the range before unpausing m_modelRolesUpdater. This prevents
-        // an unnecessary expensive recreation of all previews afterwards.
-        m_updateVisibleIndexRangeTimer->stop();
-        const int index = firstVisibleIndex();
-        const int count = lastVisibleIndex() - index + 1;
-        m_modelRolesUpdater->setVisibleIndexRange(index, count);
-    }
+    // Update the visible index range (which has most likely changed after the
+    // icon size change) before unpausing m_modelRolesUpdater.
+    const int index = firstVisibleIndex();
+    const int count = lastVisibleIndex() - index + 1;
+    m_modelRolesUpdater->setVisibleIndexRange(index, count);

 
     m_modelRolesUpdater->setPaused(isTransactionActive());
 
     m_modelRolesUpdater->setPaused(isTransactionActive());

-    updateTimersInterval();
-}
-
-QSizeF KFileItemListView::visibleRoleSizeHint(int index, const QByteArray& role) const
-{
-    const KItemListStyleOption& option = styleOption();
-
-    qreal width = m_minimumRolesWidths.value(role, 0);
-    const qreal height = option.padding * 2 + option.fontMetrics.height();
-
-    const QHash<QByteArray, QVariant> values = model()->data(index);
-    const QString text = KFileItemListWidget::roleText(role, values);
-    if (!text.isEmpty()) {
-        const qreal columnPadding = option.padding * 3;
-        width = qMax(width, qreal(2 * columnPadding + option.fontMetrics.width(text)));
-    }
-
-    if (role == "name") {
-        // Increase the width by the expansion-toggle and the current expansion level
-        const int expandedParentsCount = values.value("expandedParentsCount", 0).toInt();
-        width += option.padding + expandedParentsCount * itemSize().height() + KIconLoader::SizeSmall;
-
-        // Increase the width by the required space for the icon
-        width += option.padding * 2 + option.iconSize;
-    }
-
-    return QSizeF(width, height);
-}
-
-void KFileItemListView::updateLayoutOfVisibleItems()
-{
-    if (!model()) {
-        return;
-    }
-
-    foreach (KItemListWidget* widget, visibleItemListWidgets()) {
-        initializeItemListWidget(widget);
-    }
-    triggerVisibleIndexRangeUpdate();
-}
-
-void KFileItemListView::updateTimersInterval()
-{
-    if (!model()) {
-        return;
-    }
-
-    // The ShortInterval is used for cases like switching the directory: If the
-    // model is empty and filled later the creation of the previews should be done
-    // as soon as possible. The LongInterval is used when the model already contains
-    // items and assures that operations like zooming don't result in too many temporary
-    // recreations of the previews.
-
-    const int interval = (model()->count() <= 0) ? ShortInterval : LongInterval;
-    m_updateVisibleIndexRangeTimer->setInterval(interval);
-    m_updateIconSizeTimer->setInterval(interval);
-}
-
-void KFileItemListView::updateMinimumRolesWidths()
-{
-    m_minimumRolesWidths.clear();
-
-    const KItemListStyleOption& option = styleOption();
-    const QString sizeText = QLatin1String("888888") + i18nc("@item:intable", "items");
-    m_minimumRolesWidths.insert("size", option.fontMetrics.width(sizeText));

 }
 
 void KFileItemListView::applyRolesToModel()
 }
 
 void KFileItemListView::applyRolesToModel()


@@ -559,17 +433,20 @@ void KFileItemListView::applyRolesToModel()
         return;
     }
 
         return;
     }
 

-    Q_ASSERT(qobject_cast<KFileItemModel*>(model()));
-    KFileItemModel* fileItemModel = static_cast<KFileItemModel*>(model());
+    Q_ASSERT(qobject_cast<KFileItemModel *>(model()));
+    KFileItemModel *fileItemModel = static_cast<KFileItemModel *>(model());

 
     // KFileItemModel does not distinct between "visible" and "invisible" roles.
     // Add all roles that are mandatory for having a working KFileItemListView:
 
     // KFileItemModel does not distinct between "visible" and "invisible" roles.
     // Add all roles that are mandatory for having a working KFileItemListView:

-    QSet<QByteArray> roles = visibleRoles().toSet();
+    const auto visibleRoles = this->visibleRoles();
+    auto roles = QSet<QByteArray>(visibleRoles.constBegin(), visibleRoles.constEnd());

     roles.insert("iconPixmap");
     roles.insert("iconName");
     roles.insert("iconPixmap");
     roles.insert("iconName");

-    roles.insert("name");
+    roles.insert("text");

     roles.insert("isDir");
     roles.insert("isDir");

-    if (m_itemLayout == DetailsLayout) {
+    roles.insert("isLink");
+    roles.insert("isHidden");
+    if (supportsItemExpanding()) {

         roles.insert("isExpanded");
         roles.insert("isExpandable");
         roles.insert("expandedParentsCount");
         roles.insert("isExpanded");
         roles.insert("isExpandable");
         roles.insert("expandedParentsCount");


@@ -584,9 +461,9 @@ void KFileItemListView::applyRolesToModel()
 
 QSize KFileItemListView::availableIconSize() const
 {
 
 QSize KFileItemListView::availableIconSize() const
 {

-    const KItemListStyleOption& option = styleOption();
+    const KItemListStyleOption &option = styleOption();

     const int iconSize = option.iconSize;
     const int iconSize = option.iconSize;

-    if (m_itemLayout == IconsLayout) {
+    if (itemLayout() == IconsLayout) {

         const int maxIconWidth = itemSize().width() - 2 * option.padding;
         return QSize(maxIconWidth, iconSize);
     }
         const int maxIconWidth = itemSize().width() - 2 * option.padding;
         return QSize(maxIconWidth, iconSize);
     }


@@ -594,4 +471,4 @@ QSize KFileItemListView::availableIconSize() const
     return QSize(iconSize, iconSize);
 }
 
     return QSize(iconSize, iconSize);
 }
 

-#include "kfileitemlistview.moc"
+#include "moc_kfileitemlistview.cpp"