[KStandardItemListWidget] Pass icon state to overlay painter

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

diff --git a/src/kitemviews/kstandarditemlistwidget.cpp b/src/kitemviews/kstandarditemlistwidget.cpp
index e0375480e02d401d15d096cec2a94b117215965d..f56f68ac54007b826d458ab53e603a5c688c4e91 100644 (file)
--- a/src/kitemviews/kstandarditemlistwidget.cpp
+++ b/src/kitemviews/kstandarditemlistwidget.cpp
@@ -21,28 +21,21 @@
 
 #include "kfileitemlistview.h"
 #include "kfileitemmodel.h"
 
 #include "kfileitemlistview.h"
 #include "kfileitemmodel.h"

+#include "private/kfileitemclipboard.h"
+#include "private/kitemlistroleeditor.h"
+#include "private/kpixmapmodifier.h"

 
 

-#include <KIcon>

 #include <KIconEffect>
 #include <KIconLoader>
 #include <KIconEffect>
 #include <KIconLoader>

-#include <KLocale>
-#include <kratingpainter.h>
+#include <KRatingPainter>

 #include <KStringHandler>
 #include <KStringHandler>

-#include <KDebug>
-
-#include "private/kfileitemclipboard.h"
-#include "private/kitemlistroleeditor.h"
-#include "private/kpixmapmodifier.h"

 
 

-#include <QFontMetricsF>

 #include <QGraphicsScene>
 #include <QGraphicsSceneResizeEvent>
 #include <QGraphicsView>
 #include <QGraphicsScene>
 #include <QGraphicsSceneResizeEvent>
 #include <QGraphicsView>

-#include <QPainter>
-#include <QStyleOption>
-#include <QTextLayout>
-#include <QTextLine>
+#include <QGuiApplication>

 #include <QPixmapCache>
 #include <QPixmapCache>

+#include <QStyleOption>

 
 // #define KSTANDARDITEMLISTWIDGET_DEBUG
 
 
 // #define KSTANDARDITEMLISTWIDGET_DEBUG
 


@@ -58,15 +51,15 @@ KStandardItemListWidgetInformant::~KStandardItemListWidgetInformant()
 void KStandardItemListWidgetInformant::calculateItemSizeHints(QVector<qreal>& logicalHeightHints, qreal& logicalWidthHint, const KItemListView* view) const
 {
     switch (static_cast<const KStandardItemListView*>(view)->itemLayout()) {
 void KStandardItemListWidgetInformant::calculateItemSizeHints(QVector<qreal>& logicalHeightHints, qreal& logicalWidthHint, const KItemListView* view) const
 {
     switch (static_cast<const KStandardItemListView*>(view)->itemLayout()) {

-    case KStandardItemListWidget::IconsLayout:
+    case KStandardItemListView::IconsLayout:

         calculateIconsLayoutItemSizeHints(logicalHeightHints, logicalWidthHint, view);
         break;
 
         calculateIconsLayoutItemSizeHints(logicalHeightHints, logicalWidthHint, view);
         break;
 

-    case KStandardItemListWidget::CompactLayout:
+    case KStandardItemListView::CompactLayout:

         calculateCompactLayoutItemSizeHints(logicalHeightHints, logicalWidthHint, view);
         break;
 
         calculateCompactLayoutItemSizeHints(logicalHeightHints, logicalWidthHint, view);
         break;
 

-    case KStandardItemListWidget::DetailsLayout:
+    case KStandardItemListView::DetailsLayout:

         calculateDetailsLayoutItemSizeHints(logicalHeightHints, logicalWidthHint, view);
         break;
 
         calculateDetailsLayoutItemSizeHints(logicalHeightHints, logicalWidthHint, view);
         break;
 


@@ -120,6 +113,8 @@ QString KStandardItemListWidgetInformant::itemText(int index, const KItemListVie
 
 bool KStandardItemListWidgetInformant::itemIsLink(int index, const KItemListView* view) const
 {
 
 bool KStandardItemListWidgetInformant::itemIsLink(int index, const KItemListView* view) const
 {

+    Q_UNUSED(index);
+    Q_UNUSED(view);

     return false;
 }
 
     return false;
 }
 


@@ -273,8 +268,8 @@ KStandardItemListWidget::KStandardItemListWidget(KItemListWidgetInformant* infor
     m_additionalInfoTextColor(),
     m_overlay(),
     m_rating(),
     m_additionalInfoTextColor(),
     m_overlay(),
     m_rating(),

-    m_roleEditor(0),
-    m_oldRoleEditor(0)
+    m_roleEditor(nullptr),
+    m_oldRoleEditor(nullptr)

 {
 }
 
 {
 }
 


@@ -343,6 +338,7 @@ void KStandardItemListWidget::paint(QPainter* painter, const QStyleOptionGraphic
              */
             // Paint pixmap1 so that pixmap1 = m_pixmap * (1.0 - hoverOpacity())
             QPixmap pixmap1(m_pixmap.size());
              */
             // Paint pixmap1 so that pixmap1 = m_pixmap * (1.0 - hoverOpacity())
             QPixmap pixmap1(m_pixmap.size());

+            pixmap1.setDevicePixelRatio(m_pixmap.devicePixelRatio());

             pixmap1.fill(Qt::transparent);
             {
                 QPainter p(&pixmap1);
             pixmap1.fill(Qt::transparent);
             {
                 QPainter p(&pixmap1);


@@ -352,6 +348,7 @@ void KStandardItemListWidget::paint(QPainter* painter, const QStyleOptionGraphic
 
             // Paint pixmap2 so that pixmap2 = m_hoverPixmap * hoverOpacity()
             QPixmap pixmap2(pixmap1.size());
 
             // Paint pixmap2 so that pixmap2 = m_hoverPixmap * hoverOpacity()
             QPixmap pixmap2(pixmap1.size());

+            pixmap2.setDevicePixelRatio(pixmap1.devicePixelRatio());

             pixmap2.fill(Qt::transparent);
             {
                 QPainter p(&pixmap2);
             pixmap2.fill(Qt::transparent);
             {
                 QPainter p(&pixmap2);


@@ -494,6 +491,29 @@ QRectF KStandardItemListWidget::textFocusRect() const
     return m_textRect;
 }
 
     return m_textRect;
 }
 

+QRectF KStandardItemListWidget::selectionRect() const
+{
+    const_cast<KStandardItemListWidget*>(this)->triggerCacheRefreshing();
+
+    switch (m_layout) {
+    case IconsLayout:
+        return m_textRect;
+
+    case CompactLayout:
+    case DetailsLayout: {
+        const int padding = styleOption().padding;
+        QRectF adjustedIconRect = iconRect().adjusted(-padding, -padding, padding, padding);
+        return adjustedIconRect | m_textRect;
+    }
+
+    default:
+        Q_ASSERT(false);
+        break;
+    }
+
+    return m_textRect;
+}
+

 QRectF KStandardItemListWidget::expansionToggleRect() const
 {
     const_cast<KStandardItemListWidget*>(this)->triggerCacheRefreshing();
 QRectF KStandardItemListWidget::expansionToggleRect() const
 {
     const_cast<KStandardItemListWidget*>(this)->triggerCacheRefreshing();


@@ -659,7 +679,7 @@ void KStandardItemListWidget::dataChanged(const QHash<QByteArray, QVariant>& cur
     // The URL might have changed (i.e., if the sort order of the items has
     // been changed). Therefore, the "is cut" state must be updated.
     KFileItemClipboard* clipboard = KFileItemClipboard::instance();
     // The URL might have changed (i.e., if the sort order of the items has
     // been changed). Therefore, the "is cut" state must be updated.
     KFileItemClipboard* clipboard = KFileItemClipboard::instance();

-    const KUrl itemUrl = data().value("url").value<KUrl>();
+    const QUrl itemUrl = data().value("url").toUrl();

     m_isCut = clipboard->isCut(itemUrl);
 
     // The icon-state might depend from other roles and hence is
     m_isCut = clipboard->isCut(itemUrl);
 
     // The icon-state might depend from other roles and hence is


@@ -735,17 +755,17 @@ void KStandardItemListWidget::editedRoleChanged(const QByteArray& current, const
         if (m_roleEditor) {
             emit roleEditingCanceled(index(), current, data().value(current));
 
         if (m_roleEditor) {
             emit roleEditingCanceled(index(), current, data().value(current));
 

-            disconnect(m_roleEditor, SIGNAL(roleEditingCanceled(QByteArray,QVariant)),
-                       this, SLOT(slotRoleEditingCanceled(QByteArray,QVariant)));
-            disconnect(m_roleEditor, SIGNAL(roleEditingFinished(QByteArray,QVariant)),
-                       this, SLOT(slotRoleEditingFinished(QByteArray,QVariant)));
+            disconnect(m_roleEditor, &KItemListRoleEditor::roleEditingCanceled,
+                       this, &KStandardItemListWidget::slotRoleEditingCanceled);
+            disconnect(m_roleEditor, &KItemListRoleEditor::roleEditingFinished,
+                       this, &KStandardItemListWidget::slotRoleEditingFinished);

 
             if (m_oldRoleEditor) {
                 m_oldRoleEditor->deleteLater();
             }
             m_oldRoleEditor = m_roleEditor;
             m_roleEditor->hide();
 
             if (m_oldRoleEditor) {
                 m_oldRoleEditor->deleteLater();
             }
             m_oldRoleEditor = m_roleEditor;
             m_roleEditor->hide();

-            m_roleEditor = 0;
+            m_roleEditor = nullptr;

         }
         return;
     }
         }
         return;
     }


@@ -773,10 +793,10 @@ void KStandardItemListWidget::editedRoleChanged(const QByteArray& current, const
         m_roleEditor->setTextCursor(cursor);
     }
 
         m_roleEditor->setTextCursor(cursor);
     }
 

-    connect(m_roleEditor, SIGNAL(roleEditingCanceled(QByteArray,QVariant)),
-            this, SLOT(slotRoleEditingCanceled(QByteArray,QVariant)));
-    connect(m_roleEditor, SIGNAL(roleEditingFinished(QByteArray,QVariant)),
-            this, SLOT(slotRoleEditingFinished(QByteArray,QVariant)));
+    connect(m_roleEditor, &KItemListRoleEditor::roleEditingCanceled,
+            this, &KStandardItemListWidget::slotRoleEditingCanceled);
+    connect(m_roleEditor, &KItemListRoleEditor::roleEditingFinished,
+            this, &KStandardItemListWidget::slotRoleEditingFinished);

 
     // Adjust the geometry of the editor
     QRectF rect = roleEditingRect(current);
 
     // Adjust the geometry of the editor
     QRectF rect = roleEditingRect(current);


@@ -810,24 +830,41 @@ void KStandardItemListWidget::showEvent(QShowEvent* event)
     // Listen to changes of the clipboard to mark the item as cut/uncut
     KFileItemClipboard* clipboard = KFileItemClipboard::instance();
 
     // Listen to changes of the clipboard to mark the item as cut/uncut
     KFileItemClipboard* clipboard = KFileItemClipboard::instance();
 

-    const KUrl itemUrl = data().value("url").value<KUrl>();
+    const QUrl itemUrl = data().value("url").toUrl();

     m_isCut = clipboard->isCut(itemUrl);
 
     m_isCut = clipboard->isCut(itemUrl);
 

-    connect(clipboard, SIGNAL(cutItemsChanged()),
-            this, SLOT(slotCutItemsChanged()));
+    connect(clipboard, &KFileItemClipboard::cutItemsChanged,
+            this, &KStandardItemListWidget::slotCutItemsChanged);

 }
 
 void KStandardItemListWidget::hideEvent(QHideEvent* event)
 {
 }
 
 void KStandardItemListWidget::hideEvent(QHideEvent* event)
 {

-    disconnect(KFileItemClipboard::instance(), SIGNAL(cutItemsChanged()),
-               this, SLOT(slotCutItemsChanged()));
+    disconnect(KFileItemClipboard::instance(), &KFileItemClipboard::cutItemsChanged,
+               this, &KStandardItemListWidget::slotCutItemsChanged);

 
     KItemListWidget::hideEvent(event);
 }
 
 
     KItemListWidget::hideEvent(event);
 }
 

+bool KStandardItemListWidget::event(QEvent *event)
+{
+    if (event->type() == QEvent::WindowDeactivate || event->type() == QEvent::WindowActivate
+            || event->type() == QEvent::PaletteChange) {
+        m_dirtyContent = true;
+    }
+
+    return KItemListWidget::event(event);
+}
+
+void KStandardItemListWidget::finishRoleEditing()
+{
+    if (!editedRole().isEmpty() && m_roleEditor) {
+        slotRoleEditingFinished(editedRole(), KIO::encodeFileName(m_roleEditor->toPlainText()));
+    }
+}
+

 void KStandardItemListWidget::slotCutItemsChanged()
 {
 void KStandardItemListWidget::slotCutItemsChanged()
 {

-    const KUrl itemUrl = data().value("url").value<KUrl>();
+    const QUrl itemUrl = data().value("url").toUrl();

     const bool isCut = KFileItemClipboard::instance()->isCut(itemUrl);
     if (m_isCut != isCut) {
         m_isCut = isCut;
     const bool isCut = KFileItemClipboard::instance()->isCut(itemUrl);
     if (m_isCut != isCut) {
         m_isCut = isCut;


@@ -926,14 +963,15 @@ void KStandardItemListWidget::updatePixmapCache()
             if (iconName.isEmpty()) {
                 // The icon-name has not been not resolved by KFileItemModelRolesUpdater,
                 // use a generic icon as fallback
             if (iconName.isEmpty()) {
                 // The icon-name has not been not resolved by KFileItemModelRolesUpdater,
                 // use a generic icon as fallback

-                iconName = QLatin1String("unknown");
+                iconName = QStringLiteral("unknown");

             }
             const QStringList overlays = values["iconOverlays"].toStringList();
             }
             const QStringList overlays = values["iconOverlays"].toStringList();

-            m_pixmap = pixmapForIcon(iconName, overlays, maxIconHeight);
-        } else if (m_pixmap.width() != maxIconWidth || m_pixmap.height() != maxIconHeight) {
+            m_pixmap = pixmapForIcon(iconName, overlays, maxIconHeight, m_layout != IconsLayout && isActiveWindow() && isSelected() ? QIcon::Selected : QIcon::Normal);
+
+        } else if (m_pixmap.width() / m_pixmap.devicePixelRatio() != maxIconWidth || m_pixmap.height() / m_pixmap.devicePixelRatio() != maxIconHeight) {

             // A custom pixmap has been applied. Assure that the pixmap
             // is scaled to the maximum available size.
             // A custom pixmap has been applied. Assure that the pixmap
             // is scaled to the maximum available size.

-            KPixmapModifier::scale(m_pixmap, QSize(maxIconWidth, maxIconHeight));
+            KPixmapModifier::scale(m_pixmap, QSize(maxIconWidth, maxIconHeight) * qApp->devicePixelRatio());

         }
 
         if (m_isCut) {
         }
 
         if (m_isCut) {


@@ -945,7 +983,7 @@ void KStandardItemListWidget::updatePixmapCache()
             KIconEffect::semiTransparent(m_pixmap);
         }
 
             KIconEffect::semiTransparent(m_pixmap);
         }
 

-        if (isSelected()) {
+        if (m_layout == IconsLayout && isSelected()) {

             const QColor color = palette().brush(QPalette::Normal, QPalette::Highlight).color();
             QImage image = m_pixmap.toImage();
             KIconEffect::colorize(image, color, 0.8f);
             const QColor color = palette().brush(QPalette::Normal, QPalette::Highlight).color();
             QImage image = m_pixmap.toImage();
             KIconEffect::colorize(image, color, 0.8f);


@@ -955,7 +993,7 @@ void KStandardItemListWidget::updatePixmapCache()
 
     if (!m_overlay.isNull()) {
         QPainter painter(&m_pixmap);
 
     if (!m_overlay.isNull()) {
         QPainter painter(&m_pixmap);

-        painter.drawPixmap(0, m_pixmap.height() - m_overlay.height(), m_overlay);
+        painter.drawPixmap(0, (m_pixmap.height() - m_overlay.height()) / m_pixmap.devicePixelRatio(), m_overlay);

     }
 
     int scaledIconSize = 0;
     }
 
     int scaledIconSize = 0;


@@ -973,19 +1011,26 @@ void KStandardItemListWidget::updatePixmapCache()
     const int maxScaledIconHeight = scaledIconSize;
 
     m_scaledPixmapSize = m_pixmap.size();
     const int maxScaledIconHeight = scaledIconSize;
 
     m_scaledPixmapSize = m_pixmap.size();

-    m_scaledPixmapSize.scale(maxScaledIconWidth, maxScaledIconHeight, Qt::KeepAspectRatio);
+    m_scaledPixmapSize.scale(maxScaledIconWidth * qApp->devicePixelRatio(), maxScaledIconHeight * qApp->devicePixelRatio(), Qt::KeepAspectRatio);
+    m_scaledPixmapSize = m_scaledPixmapSize / qApp->devicePixelRatio();

 
     if (iconOnTop) {
         // Center horizontally and align on bottom within the icon-area
 
     if (iconOnTop) {
         // Center horizontally and align on bottom within the icon-area

-        m_pixmapPos.setX((widgetSize.width() - m_scaledPixmapSize.width()) / 2);
+        m_pixmapPos.setX((widgetSize.width() - m_scaledPixmapSize.width()) / 2.0);

         m_pixmapPos.setY(padding + scaledIconSize - m_scaledPixmapSize.height());
     } else {
         // Center horizontally and vertically within the icon-area
         const TextInfo* textInfo = m_textInfo.value("text");
         m_pixmapPos.setY(padding + scaledIconSize - m_scaledPixmapSize.height());
     } else {
         // Center horizontally and vertically within the icon-area
         const TextInfo* textInfo = m_textInfo.value("text");

-        m_pixmapPos.setX(textInfo->pos.x() - 2 * padding
-                         - (scaledIconSize + m_scaledPixmapSize.width()) / 2);
-        m_pixmapPos.setY(padding
-                         + (scaledIconSize - m_scaledPixmapSize.height()) / 2);
+        m_pixmapPos.setX(textInfo->pos.x() - 2.0 * padding
+                      - (scaledIconSize + m_scaledPixmapSize.width()) / 2.0);
+
+        // Derive icon's vertical center from the center of the text frame, including
+        // any necessary adjustment if the font's midline is offset from the frame center
+        const qreal midlineShift = m_customizedFontMetrics.height() / 2.0
+                    - m_customizedFontMetrics.descent()
+                    - m_customizedFontMetrics.capHeight() / 2.0;
+        m_pixmapPos.setY(m_textRect.center().y() + midlineShift - m_scaledPixmapSize.height() / 2.0);
+

     }
 
     m_iconRect = QRectF(m_pixmapPos, QSizeF(m_scaledPixmapSize));
     }
 
     m_iconRect = QRectF(m_pixmapPos, QSizeF(m_scaledPixmapSize));


@@ -1054,11 +1099,13 @@ void KStandardItemListWidget::updateTextsCache()
         if (ratingSize.width() > availableWidth) {
             ratingSize.rwidth() = availableWidth;
         }
         if (ratingSize.width() > availableWidth) {
             ratingSize.rwidth() = availableWidth;
         }

-        m_rating = QPixmap(ratingSize.toSize());
+        const qreal dpr = qApp->devicePixelRatio();
+        m_rating = QPixmap(ratingSize.toSize() * dpr);
+        m_rating.setDevicePixelRatio(dpr);

         m_rating.fill(Qt::transparent);
 
         QPainter painter(&m_rating);
         m_rating.fill(Qt::transparent);
 
         QPainter painter(&m_rating);

-        const QRect rect(0, 0, m_rating.width(), m_rating.height());
+        const QRect rect(QPoint(0, 0), ratingSize.toSize());

         const int rating = data().value("rating").toInt();
         KRatingPainter::paintRating(&painter, rect, Qt::AlignJustify | Qt::AlignVCenter, rating);
     } else if (!m_rating.isNull()) {
         const int rating = data().value("rating").toInt();
         KRatingPainter::paintRating(&painter, rect, Qt::AlignJustify | Qt::AlignVCenter, rating);
     } else if (!m_rating.isNull()) {


@@ -1113,14 +1160,24 @@ void KStandardItemListWidget::updateIconsLayoutTextCache()
             const int textLength = line.textStart() + line.textLength();
             if (textLength < nameText.length()) {
                 // Elide the last line of the text
             const int textLength = line.textStart() + line.textLength();
             if (textLength < nameText.length()) {
                 // Elide the last line of the text

-                QString lastTextLine = nameText.mid(line.textStart());
-                lastTextLine = m_customizedFontMetrics.elidedText(lastTextLine,
-                                                                  Qt::ElideRight,
-                                                                  maxWidth);
-                const QString elidedText = nameText.left(line.textStart()) + lastTextLine;
-                nameTextInfo->staticText.setText(elidedText);
-
-                const qreal lastLineWidth = m_customizedFontMetrics.boundingRect(lastTextLine).width();
+                qreal elidingWidth = maxWidth;
+                qreal lastLineWidth;
+                do {
+                    QString lastTextLine = nameText.mid(line.textStart());
+                    lastTextLine = m_customizedFontMetrics.elidedText(lastTextLine,
+                                                                      Qt::ElideRight,
+                                                                      elidingWidth);
+                    const QString elidedText = nameText.left(line.textStart()) + lastTextLine;
+                    nameTextInfo->staticText.setText(elidedText);
+
+                    lastLineWidth = m_customizedFontMetrics.boundingRect(lastTextLine).width();
+
+                    // We do the text eliding in a loop with decreasing width (1 px / iteration)
+                    // to avoid problems related to different width calculation code paths
+                    // within Qt. (see bug 337104)
+                    elidingWidth -= 1.0;
+                } while (lastLineWidth > maxWidth);
+

                 nameWidth = qMax(nameWidth, lastLineWidth);
             }
             break;
                 nameWidth = qMax(nameWidth, lastLineWidth);
             }
             break;


@@ -1319,9 +1376,10 @@ void KStandardItemListWidget::updateAdditionalInfoTextColor()
 
 void KStandardItemListWidget::drawPixmap(QPainter* painter, const QPixmap& pixmap)
 {
 
 void KStandardItemListWidget::drawPixmap(QPainter* painter, const QPixmap& pixmap)
 {

-    if (m_scaledPixmapSize != pixmap.size()) {
+    if (m_scaledPixmapSize != pixmap.size() / pixmap.devicePixelRatio()) {

         QPixmap scaledPixmap = pixmap;
         QPixmap scaledPixmap = pixmap;

-        KPixmapModifier::scale(scaledPixmap, m_scaledPixmapSize);
+        KPixmapModifier::scale(scaledPixmap, m_scaledPixmapSize * qApp->devicePixelRatio());
+        scaledPixmap.setDevicePixelRatio(qApp->devicePixelRatio());

         painter->drawPixmap(m_pixmapPos, scaledPixmap);
 
 #ifdef KSTANDARDITEMLISTWIDGET_DEBUG
         painter->drawPixmap(m_pixmapPos, scaledPixmap);
 
 #ifdef KSTANDARDITEMLISTWIDGET_DEBUG


@@ -1353,7 +1411,7 @@ void KStandardItemListWidget::drawSiblingsInformation(QPainter* painter)
             if (m_isExpandable) {
                 option.state |= QStyle::State_Children;
             }
             if (m_isExpandable) {
                 option.state |= QStyle::State_Children;
             }

-            if (data()["isExpanded"].toBool()) {
+            if (data().value("isExpanded").toBool()) {

                 option.state |= QStyle::State_Open;
             }
             isItemSibling = false;
                 option.state |= QStyle::State_Open;
             }
             isItemSibling = false;


@@ -1382,10 +1440,10 @@ QRectF KStandardItemListWidget::roleEditingRect(const QByteArray& role) const
 
 void KStandardItemListWidget::closeRoleEditor()
 {
 
 void KStandardItemListWidget::closeRoleEditor()
 {

-    disconnect(m_roleEditor, SIGNAL(roleEditingCanceled(QByteArray,QVariant)),
-               this, SLOT(slotRoleEditingCanceled(QByteArray,QVariant)));
-    disconnect(m_roleEditor, SIGNAL(roleEditingFinished(QByteArray,QVariant)),
-               this, SLOT(slotRoleEditingFinished(QByteArray,QVariant)));
+    disconnect(m_roleEditor, &KItemListRoleEditor::roleEditingCanceled,
+               this, &KStandardItemListWidget::slotRoleEditingCanceled);
+    disconnect(m_roleEditor, &KItemListRoleEditor::roleEditingFinished,
+               this, &KStandardItemListWidget::slotRoleEditingFinished);

 
     if (m_roleEditor->hasFocus()) {
         // If the editing was not ended by a FocusOut event, we have
 
     if (m_roleEditor->hasFocus()) {
         // If the editing was not ended by a FocusOut event, we have


@@ -1398,37 +1456,39 @@ void KStandardItemListWidget::closeRoleEditor()
     }
     m_oldRoleEditor = m_roleEditor;
     m_roleEditor->hide();
     }
     m_oldRoleEditor = m_roleEditor;
     m_roleEditor->hide();

-    m_roleEditor = 0;
-}
+    m_roleEditor = nullptr;
+}
+
+QPixmap KStandardItemListWidget::pixmapForIcon(const QString& name, const QStringList& overlays, int size, QIcon::Mode mode)
+{
+    static const QIcon fallbackIcon = QIcon::fromTheme(QStringLiteral("unknown"));
+
+    int requestedSize = size;
+    if (size <= KIconLoader::SizeSmall) {
+        requestedSize = KIconLoader::SizeSmall;
+    } else if (size <= KIconLoader::SizeSmallMedium) {
+        requestedSize = KIconLoader::SizeSmallMedium;
+    } else if (size <= KIconLoader::SizeMedium) {
+        requestedSize = KIconLoader::SizeMedium;
+    } else if (size <= KIconLoader::SizeLarge) {
+        requestedSize = KIconLoader::SizeLarge;
+    } else if (size <= KIconLoader::SizeHuge) {
+        requestedSize = KIconLoader::SizeHuge;
+    } else if (size <= KIconLoader::SizeEnormous) {
+        requestedSize = KIconLoader::SizeEnormous;
+    } else if (size <= KIconLoader::SizeEnormous * 2) {
+        requestedSize = KIconLoader::SizeEnormous * 2;
+    }
+    size *= qApp->devicePixelRatio();
+    requestedSize *= qApp->devicePixelRatio();

 
 

-QPixmap KStandardItemListWidget::pixmapForIcon(const QString& name, const QStringList& overlays, int size)
-{
-    const QString key = "KStandardItemListWidget:" % name % ":" % overlays.join(":") % ":" % QString::number(size);
+    const QString key = "KStandardItemListWidget:" % name % ":" % overlays.join(QStringLiteral(":")) % ":" % QString::number(size) % ":" % QString::number(mode);

     QPixmap pixmap;
 
     if (!QPixmapCache::find(key, pixmap)) {
     QPixmap pixmap;
 
     if (!QPixmapCache::find(key, pixmap)) {

-        const KIcon icon(name);
-
-        int requestedSize;
-        if (size <= KIconLoader::SizeSmall) {
-            requestedSize = KIconLoader::SizeSmall;
-        } else if (size <= KIconLoader::SizeSmallMedium) {
-            requestedSize = KIconLoader::SizeSmallMedium;
-        } else if (size <= KIconLoader::SizeMedium) {
-            requestedSize = KIconLoader::SizeMedium;
-        } else if (size <= KIconLoader::SizeLarge) {
-            requestedSize = KIconLoader::SizeLarge;
-        } else if (size <= KIconLoader::SizeHuge) {
-            requestedSize = KIconLoader::SizeHuge;
-        } else if (size <= KIconLoader::SizeEnormous) {
-            requestedSize = KIconLoader::SizeEnormous;
-        } else if (size <= KIconLoader::SizeEnormous * 2) {
-            requestedSize = KIconLoader::SizeEnormous * 2;
-        } else {
-            requestedSize = size;
-        }
+        const QIcon icon = QIcon::fromTheme(name, fallbackIcon);

 
 

-        pixmap = icon.pixmap(requestedSize, requestedSize);
+        pixmap = icon.pixmap(requestedSize / qApp->devicePixelRatio(), requestedSize / qApp->devicePixelRatio(), mode);

         if (requestedSize != size) {
             KPixmapModifier::scale(pixmap, QSize(size, size));
         }
         if (requestedSize != size) {
             KPixmapModifier::scale(pixmap, QSize(size, size));
         }


@@ -1440,15 +1500,32 @@ QPixmap KStandardItemListWidget::pixmapForIcon(const QString& name, const QStrin
         // setup time.
         foreach (const QString& overlay, overlays) {
             if (!overlay.isEmpty()) {
         // setup time.
         foreach (const QString& overlay, overlays) {
             if (!overlay.isEmpty()) {

+                int state = KIconLoader::DefaultState;
+
+                switch (mode) {
+                case QIcon::Normal:
+                    break;
+                case QIcon::Active:
+                    state = KIconLoader::ActiveState;
+                    break;
+                case QIcon::Disabled:
+                    state = KIconLoader::DisabledState;
+                    break;
+                case QIcon::Selected:
+                    state = KIconLoader::SelectedState;
+                    break;
+                }
+

                 // There is at least one overlay, draw all overlays above m_pixmap
                 // and cancel the check
                 // There is at least one overlay, draw all overlays above m_pixmap
                 // and cancel the check

-                KIconLoader::global()->drawOverlays(overlays, pixmap, KIconLoader::Desktop);
+                KIconLoader::global()->drawOverlays(overlays, pixmap, KIconLoader::Desktop, state);

                 break;
             }
         }
 
         QPixmapCache::insert(key, pixmap);
     }
                 break;
             }
         }
 
         QPixmapCache::insert(key, pixmap);
     }

+    pixmap.setDevicePixelRatio(qApp->devicePixelRatio());

 
     return pixmap;
 }
 
     return pixmap;
 }


@@ -1464,4 +1541,3 @@ qreal KStandardItemListWidget::columnPadding(const KItemListStyleOption& option)
     return option.padding * 6;
 }
 
     return option.padding * 6;
 }
 

-#include "kstandarditemlistwidget.moc"