File indexing completed on 2024-12-01 03:41:15

 /*
     This file is part of the KDE project
     SPDX-FileCopyrightText: 2009 Shaun Reich <shaun.reich@kdemail.net>
     SPDX-FileCopyrightText: 2006-2007, 2008 Fredrik Höglund <fredrik@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "kfileitemdelegate.h"
 #include "imagefilter_p.h"
 
 #include <QApplication>
 #include <QCache>
 #include <QImage>
 #include <QListView>
 #include <QLocale>
 #include <QMimeDatabase>
 #include <QModelIndex>
 #include <QPaintEngine>
 #include <QPainter>
 #include <QPainterPath>
 #include <QStyle>
 #include <QTextEdit>
 #include <QTextLayout>
 #include <qmath.h>
 
 #include <KIconEffect>
 #include <KIconLoader>
 #include <KLocalizedString>
 #include <KStatefulBrush>
 #include <KStringHandler>
 #include <kdirmodel.h>
 #include <kfileitem.h>
 
 #include "delegateanimationhandler_p.h"
 
 struct Margin {
     int left, right, top, bottom;
 };
 
 class Q_DECL_HIDDEN KFileItemDelegate::Private
 {
 public:
     enum MarginType { ItemMargin = 0, TextMargin, IconMargin, NMargins };
 
     explicit Private(KFileItemDelegate *parent);
     ~Private()
     {
     }
 
     QSize decorationSizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const;
     QSize displaySizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const;
     QString replaceNewlines(const QString &string) const;
     inline KFileItem fileItem(const QModelIndex &index) const;
     QString elidedText(QTextLayout &layout, const QStyleOptionViewItem &option, const QSize &maxSize) const;
     QSize layoutText(QTextLayout &layout, const QStyleOptionViewItem &option, const QString &text, const QSize &constraints) const;
     QSize layoutText(QTextLayout &layout, const QString &text, int maxWidth) const;
     inline void setLayoutOptions(QTextLayout &layout, const QStyleOptionViewItem &options) const;
     inline bool verticalLayout(const QStyleOptionViewItem &option) const;
     inline QBrush brush(const QVariant &value, const QStyleOptionViewItem &option) const;
     QBrush foregroundBrush(const QStyleOptionViewItem &option, const QModelIndex &index) const;
     inline void setActiveMargins(Qt::Orientation layout);
     void setVerticalMargin(MarginType type, int left, int right, int top, int bottom);
     void setHorizontalMargin(MarginType type, int left, int right, int top, int bottom);
     inline void setVerticalMargin(MarginType type, int hor, int ver);
     inline void setHorizontalMargin(MarginType type, int hor, int ver);
     inline QRect addMargin(const QRect &rect, MarginType type) const;
     inline QRect subtractMargin(const QRect &rect, MarginType type) const;
     inline QSize addMargin(const QSize &size, MarginType type) const;
     inline QSize subtractMargin(const QSize &size, MarginType type) const;
     QString itemSize(const QModelIndex &index, const KFileItem &item) const;
     QString information(const QStyleOptionViewItem &option, const QModelIndex &index, const KFileItem &item) const;
     bool isListView(const QStyleOptionViewItem &option) const;
     QString display(const QModelIndex &index) const;
     QIcon decoration(const QStyleOptionViewItem &option, const QModelIndex &index) const;
     QPoint iconPosition(const QStyleOptionViewItem &option) const;
     QRect labelRectangle(const QStyleOptionViewItem &option, const QModelIndex &index) const;
     void layoutTextItems(const QStyleOptionViewItem &option,
                          const QModelIndex &index,
                          QTextLayout *labelLayout,
                          QTextLayout *infoLayout,
                          QRect *textBoundingRect) const;
     void drawTextItems(QPainter *painter,
                        const QTextLayout &labelLayout,
                        const QColor &labelColor,
                        const QTextLayout &infoLayout,
                        const QColor &infoColor,
                        const QRect &textBoundingRect) const;
     KIO::AnimationState *animationState(const QStyleOptionViewItem &option, const QModelIndex &index, const QAbstractItemView *view) const;
     void restartAnimation(KIO::AnimationState *state);
     QPixmap applyHoverEffect(const QPixmap &icon) const;
     QPixmap transition(const QPixmap &from, const QPixmap &to, qreal amount) const;
     void initStyleOption(QStyleOptionViewItem *option, const QModelIndex &index) const;
     void drawFocusRect(QPainter *painter, const QStyleOptionViewItem &option, const QRect &rect) const;
 
     void gotNewIcon(const QModelIndex &index);
 
     void paintJobTransfers(QPainter *painter, const qreal &jobAnimationAngle, const QPoint &iconPos, const QStyleOptionViewItem &opt);
 
 public:
     KFileItemDelegate::InformationList informationList;
     QColor shadowColor;
     QPointF shadowOffset;
     qreal shadowBlur;
     QSize maximumSize;
     bool showToolTipWhenElided;
     QTextOption::WrapMode wrapMode;
     bool jobTransfersVisible;
     QIcon downArrowIcon;
 
 private:
     KIO::DelegateAnimationHandler *animationHandler;
     Margin verticalMargin[NMargins];
     Margin horizontalMargin[NMargins];
     Margin *activeMargins;
 };
 
 KFileItemDelegate::Private::Private(KFileItemDelegate *parent)
     : shadowColor(Qt::transparent)
     , shadowOffset(1, 1)
     , shadowBlur(2)
     , maximumSize(0, 0)
     , showToolTipWhenElided(true)
     , wrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere)
     , jobTransfersVisible(false)
     , animationHandler(new KIO::DelegateAnimationHandler(parent))
     , activeMargins(nullptr)
 {
 }
 
 void KFileItemDelegate::Private::setActiveMargins(Qt::Orientation layout)
 {
     activeMargins = (layout == Qt::Horizontal ? horizontalMargin : verticalMargin);
 }
 
 void KFileItemDelegate::Private::setVerticalMargin(MarginType type, int left, int top, int right, int bottom)
 {
     verticalMargin[type].left = left;
     verticalMargin[type].right = right;
     verticalMargin[type].top = top;
     verticalMargin[type].bottom = bottom;
 }
 
 void KFileItemDelegate::Private::setHorizontalMargin(MarginType type, int left, int top, int right, int bottom)
 {
     horizontalMargin[type].left = left;
     horizontalMargin[type].right = right;
     horizontalMargin[type].top = top;
     horizontalMargin[type].bottom = bottom;
 }
 
 void KFileItemDelegate::Private::setVerticalMargin(MarginType type, int horizontal, int vertical)
 {
     setVerticalMargin(type, horizontal, vertical, horizontal, vertical);
 }
 
 void KFileItemDelegate::Private::setHorizontalMargin(MarginType type, int horizontal, int vertical)
 {
     setHorizontalMargin(type, horizontal, vertical, horizontal, vertical);
 }
 
 QRect KFileItemDelegate::Private::addMargin(const QRect &rect, MarginType type) const
 {
     Q_ASSERT(activeMargins != nullptr);
     const Margin &m = activeMargins[type];
     return rect.adjusted(-m.left, -m.top, m.right, m.bottom);
 }
 
 QRect KFileItemDelegate::Private::subtractMargin(const QRect &rect, MarginType type) const
 {
     Q_ASSERT(activeMargins != nullptr);
     const Margin &m = activeMargins[type];
     return rect.adjusted(m.left, m.top, -m.right, -m.bottom);
 }
 
 QSize KFileItemDelegate::Private::addMargin(const QSize &size, MarginType type) const
 {
     Q_ASSERT(activeMargins != nullptr);
     const Margin &m = activeMargins[type];
     return QSize(size.width() + m.left + m.right, size.height() + m.top + m.bottom);
 }
 
 QSize KFileItemDelegate::Private::subtractMargin(const QSize &size, MarginType type) const
 {
     Q_ASSERT(activeMargins != nullptr);
     const Margin &m = activeMargins[type];
     return QSize(size.width() - m.left - m.right, size.height() - m.top - m.bottom);
 }
 
 // Returns the size of a file, or the number of items in a directory, as a QString
 QString KFileItemDelegate::Private::itemSize(const QModelIndex &index, const KFileItem &item) const
 {
     // Return a formatted string containing the file size, if the item is a file
     if (item.isFile()) {
         return KIO::convertSize(item.size());
     }
 
     // Return the number of items in the directory
     const QVariant value = index.data(KDirModel::ChildCountRole);
     const int count = value.typeId() == QMetaType::Int ? value.toInt() : KDirModel::ChildCountUnknown;
 
     if (count == KDirModel::ChildCountUnknown) {
         // was: i18nc("Items in a folder", "? items");
         // but this just looks useless in a remote directory listing,
         // better not show anything.
         return QString();
     }
 
     return i18ncp("Items in a folder", "1 item", "%1 items", count);
 }
 
 // Returns the additional information string, if one should be shown, or an empty string otherwise
 QString KFileItemDelegate::Private::information(const QStyleOptionViewItem &option, const QModelIndex &index, const KFileItem &item) const
 {
     QString string;
 
     if (informationList.isEmpty() || item.isNull() || !isListView(option)) {
         return string;
     }
 
     for (KFileItemDelegate::Information info : informationList) {
         if (info == KFileItemDelegate::NoInformation) {
             continue;
         }
 
         if (!string.isEmpty()) {
             string += QChar::LineSeparator;
         }
 
         switch (info) {
         case KFileItemDelegate::Size:
             string += itemSize(index, item);
             break;
 
         case KFileItemDelegate::Permissions:
             string += item.permissionsString();
             break;
 
         case KFileItemDelegate::OctalPermissions:
             string += QLatin1Char('0') + QString::number(item.permissions(), 8);
             break;
 
         case KFileItemDelegate::Owner:
             string += item.user();
             break;
 
         case KFileItemDelegate::OwnerAndGroup:
             string += item.user() + QLatin1Char(':') + item.group();
             break;
 
         case KFileItemDelegate::CreationTime:
             string += item.timeString(KFileItem::CreationTime);
             break;
 
         case KFileItemDelegate::ModificationTime:
             string += item.timeString(KFileItem::ModificationTime);
             break;
 
         case KFileItemDelegate::AccessTime:
             string += item.timeString(KFileItem::AccessTime);
             break;
 
         case KFileItemDelegate::MimeType:
             string += item.isMimeTypeKnown() ? item.mimetype() : i18nc("@info mimetype", "Unknown");
             break;
 
         case KFileItemDelegate::FriendlyMimeType:
             string += item.isMimeTypeKnown() ? item.mimeComment() : i18nc("@info mimetype", "Unknown");
             break;
 
         case KFileItemDelegate::LinkDest:
             string += item.linkDest();
             break;
 
         case KFileItemDelegate::LocalPathOrUrl:
             if (!item.localPath().isEmpty()) {
                 string += item.localPath();
             } else {
                 string += item.url().toDisplayString();
             }
             break;
 
         case KFileItemDelegate::Comment:
             string += item.comment();
             break;
 
         default:
             break;
         } // switch (info)
     } // for (info, list)
 
     return string;
 }
 
 // Returns the KFileItem for the index
 KFileItem KFileItemDelegate::Private::fileItem(const QModelIndex &index) const
 {
     const QVariant value = index.data(KDirModel::FileItemRole);
     return qvariant_cast<KFileItem>(value);
 }
 
 // Replaces any newline characters in the provided string, with QChar::LineSeparator
 QString KFileItemDelegate::Private::replaceNewlines(const QString &text) const
 {
     QString string = text;
     string.replace(QLatin1Char('\n'), QChar::LineSeparator);
     return string;
 }
 
 // Lays the text out in a rectangle no larger than constraints, eliding it as necessary
 QSize KFileItemDelegate::Private::layoutText(QTextLayout &layout, const QStyleOptionViewItem &option, const QString &text, const QSize &constraints) const
 {
     const QSize size = layoutText(layout, text, constraints.width());
 
     if (size.width() > constraints.width() || size.height() > constraints.height()) {
         const QString elided = elidedText(layout, option, constraints);
         return layoutText(layout, elided, constraints.width());
     }
 
     return size;
 }
 
 // Lays the text out in a rectangle no wider than maxWidth
 QSize KFileItemDelegate::Private::layoutText(QTextLayout &layout, const QString &text, int maxWidth) const
 {
     QFontMetrics metrics(layout.font());
     int leading = metrics.leading();
     int height = 0;
     qreal widthUsed = 0;
     QTextLine line;
 
     layout.setText(text);
 
     layout.beginLayout();
     while ((line = layout.createLine()).isValid()) {
         line.setLineWidth(maxWidth);
         height += leading;
         line.setPosition(QPoint(0, height));
         height += int(line.height());
         widthUsed = qMax(widthUsed, line.naturalTextWidth());
     }
     layout.endLayout();
 
     return QSize(qCeil(widthUsed), height);
 }
 
 // Elides the text in the layout, by iterating over each line in the layout, eliding
 // or word breaking the line if it's wider than the max width, and finally adding an
 // ellipses at the end of the last line, if there are more lines than will fit within
 // the vertical size constraints.
 QString KFileItemDelegate::Private::elidedText(QTextLayout &layout, const QStyleOptionViewItem &option, const QSize &size) const
 {
     const QString text = layout.text();
     int maxWidth = size.width();
     int maxHeight = size.height();
     qreal height = 0;
     bool wrapText = (option.features & QStyleOptionViewItem::WrapText);
 
     // If the string contains a single line of text that shouldn't be word wrapped
     if (!wrapText && text.indexOf(QChar::LineSeparator) == -1) {
         return option.fontMetrics.elidedText(text, option.textElideMode, maxWidth);
     }
 
     // Elide each line that has already been laid out in the layout.
     QString elided;
     elided.reserve(text.length());
 
     for (int i = 0; i < layout.lineCount(); i++) {
         QTextLine line = layout.lineAt(i);
         const int start = line.textStart();
         const int length = line.textLength();
 
         height += option.fontMetrics.leading();
         if (height + line.height() + option.fontMetrics.lineSpacing() > maxHeight) {
             // Unfortunately, if the line ends because of a line separator, elidedText() will be too
             // clever and keep adding lines until it finds one that's too wide.
             if (line.naturalTextWidth() < maxWidth && text[start + length - 1] == QChar::LineSeparator) {
                 elided += QStringView(text).mid(start, length - 1);
             } else {
                 elided += option.fontMetrics.elidedText(text.mid(start), option.textElideMode, maxWidth);
             }
             break;
         } else if (line.naturalTextWidth() > maxWidth) {
             elided += option.fontMetrics.elidedText(text.mid(start, length), option.textElideMode, maxWidth);
             if (!elided.endsWith(QChar::LineSeparator)) {
                 elided += QChar::LineSeparator;
             }
         } else {
             elided += QStringView(text).mid(start, length);
         }
 
         height += line.height();
     }
 
     return elided;
 }
 
 void KFileItemDelegate::Private::setLayoutOptions(QTextLayout &layout, const QStyleOptionViewItem &option) const
 {
     QTextOption textoption;
     textoption.setTextDirection(option.direction);
     textoption.setAlignment(QStyle::visualAlignment(option.direction, option.displayAlignment));
     textoption.setWrapMode((option.features & QStyleOptionViewItem::WrapText) ? wrapMode : QTextOption::NoWrap);
 
     layout.setFont(option.font);
     layout.setTextOption(textoption);
 }
 
 QSize KFileItemDelegate::Private::displaySizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     QString label = option.text;
     int maxWidth = 0;
     if (maximumSize.isEmpty()) {
         maxWidth = verticalLayout(option) && (option.features & QStyleOptionViewItem::WrapText) ? option.decorationSize.width() + 10 : 32757;
     } else {
         const Margin &itemMargin = activeMargins[ItemMargin];
         const Margin &textMargin = activeMargins[TextMargin];
         maxWidth = maximumSize.width() - (itemMargin.left + itemMargin.right) - (textMargin.left + textMargin.right);
     }
 
     KFileItem item = fileItem(index);
 
     // To compute the nominal size for the label + info, we'll just append
     // the information string to the label
     const QString info = information(option, index, item);
     if (!info.isEmpty()) {
         label += QChar(QChar::LineSeparator) + info;
     }
 
     QTextLayout layout;
     setLayoutOptions(layout, option);
 
     QSize size = layoutText(layout, label, maxWidth);
     if (!info.isEmpty()) {
         // As soon as additional information is shown, it might be necessary that
         // the label and/or the additional information must get elided. To prevent
         // an expensive eliding in the scope of displaySizeHint, the maximum
         // width is reserved instead.
         size.setWidth(maxWidth);
     }
 
     return addMargin(size, TextMargin);
 }
 
 QSize KFileItemDelegate::Private::decorationSizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     if (index.column() > 0) {
         return QSize(0, 0);
     }
 
     QSize iconSize = option.icon.actualSize(option.decorationSize);
     if (!verticalLayout(option)) {
         iconSize.rwidth() = option.decorationSize.width();
     } else if (iconSize.width() < option.decorationSize.width()) {
         iconSize.rwidth() = qMin(iconSize.width() + 10, option.decorationSize.width());
     }
     if (iconSize.height() < option.decorationSize.height()) {
         iconSize.rheight() = option.decorationSize.height();
     }
 
     return addMargin(iconSize, IconMargin);
 }
 
 bool KFileItemDelegate::Private::verticalLayout(const QStyleOptionViewItem &option) const
 {
     return (option.decorationPosition == QStyleOptionViewItem::Top || option.decorationPosition == QStyleOptionViewItem::Bottom);
 }
 
 // Converts a QVariant of type Brush or Color to a QBrush
 QBrush KFileItemDelegate::Private::brush(const QVariant &value, const QStyleOptionViewItem &option) const
 {
     if (value.userType() == qMetaTypeId<KStatefulBrush>()) {
         return qvariant_cast<KStatefulBrush>(value).brush(option.palette);
     }
     switch (value.typeId()) {
     case QMetaType::QColor:
         return QBrush(qvariant_cast<QColor>(value));
 
     case QMetaType::QBrush:
         return qvariant_cast<QBrush>(value);
 
     default:
         return QBrush(Qt::NoBrush);
     }
 }
 
 QBrush KFileItemDelegate::Private::foregroundBrush(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     QPalette::ColorGroup cg = QPalette::Active;
     if (!(option.state & QStyle::State_Enabled)) {
         cg = QPalette::Disabled;
     } else if (!(option.state & QStyle::State_Active)) {
         cg = QPalette::Inactive;
     }
 
     // Always use the highlight color for selected items
     if (option.state & QStyle::State_Selected) {
         return option.palette.brush(cg, QPalette::HighlightedText);
     }
 
     // If the model provides its own foreground color/brush for this item
     const QVariant value = index.data(Qt::ForegroundRole);
     if (value.isValid()) {
         return brush(value, option);
     }
 
     return option.palette.brush(cg, QPalette::Text);
 }
 
 bool KFileItemDelegate::Private::isListView(const QStyleOptionViewItem &option) const
 {
     if (qobject_cast<const QListView *>(option.widget) || verticalLayout(option)) {
         return true;
     }
 
     return false;
 }
 
 QPixmap KFileItemDelegate::Private::applyHoverEffect(const QPixmap &icon) const
 {
     KIconEffect *effect = KIconLoader::global()->iconEffect();
 
     // Note that in KIconLoader terminology, active = hover.
     // ### We're assuming that the icon group is desktop/filemanager, since this
     //     is KFileItemDelegate.
     if (effect->hasEffect(KIconLoader::Desktop, KIconLoader::ActiveState)) {
         return effect->apply(icon, KIconLoader::Desktop, KIconLoader::ActiveState);
     }
 
     return icon;
 }
 
 void KFileItemDelegate::Private::gotNewIcon(const QModelIndex &index)
 {
     animationHandler->gotNewIcon(index);
 }
 
 void KFileItemDelegate::Private::restartAnimation(KIO::AnimationState *state)
 {
     animationHandler->restartAnimation(state);
 }
 
 KIO::AnimationState *
 KFileItemDelegate::Private::animationState(const QStyleOptionViewItem &option, const QModelIndex &index, const QAbstractItemView *view) const
 {
     if (!option.widget->style()->styleHint(QStyle::SH_Widget_Animate, nullptr, option.widget)) {
         return nullptr;
     }
 
     if (index.column() == KDirModel::Name) {
         return animationHandler->animationState(option, index, view);
     }
 
     return nullptr;
 }
 
 QPixmap KFileItemDelegate::Private::transition(const QPixmap &from, const QPixmap &to, qreal amount) const
 {
     int value = int(0xff * amount);
 
     if (value == 0 || to.isNull()) {
         return from;
     }
 
     if (value == 0xff || from.isNull()) {
         return to;
     }
 
     QColor color;
     color.setAlphaF(amount);
 
 // FIXME: Somehow this doesn't work on Mac OS..
 #if defined(Q_OS_MAC)
     const bool usePixmap = false;
 #else
     const bool usePixmap = from.paintEngine()->hasFeature(QPaintEngine::PorterDuff) && from.paintEngine()->hasFeature(QPaintEngine::BlendModes);
 #endif
 
     // If the native paint engine supports Porter/Duff compositing and CompositionMode_Plus
     if (usePixmap) {
         QPixmap under = from;
         QPixmap over = to;
 
         QPainter p;
         p.begin(&over);
         p.setCompositionMode(QPainter::CompositionMode_DestinationIn);
         p.fillRect(over.rect(), color);
         p.end();
 
         p.begin(&under);
         p.setCompositionMode(QPainter::CompositionMode_DestinationOut);
         p.fillRect(under.rect(), color);
         p.setCompositionMode(QPainter::CompositionMode_Plus);
         p.drawPixmap(0, 0, over);
         p.end();
 
         return under;
     } else {
         // Fall back to using QRasterPaintEngine to do the transition.
         QImage under = from.toImage();
         QImage over = to.toImage();
 
         QPainter p;
         p.begin(&over);
         p.setCompositionMode(QPainter::CompositionMode_DestinationIn);
         p.fillRect(over.rect(), color);
         p.end();
 
         p.begin(&under);
         p.setCompositionMode(QPainter::CompositionMode_DestinationOut);
         p.fillRect(under.rect(), color);
         p.setCompositionMode(QPainter::CompositionMode_Plus);
         p.drawImage(0, 0, over);
         p.end();
 
         return QPixmap::fromImage(under);
     }
 }
 
 void KFileItemDelegate::Private::layoutTextItems(const QStyleOptionViewItem &option,
                                                  const QModelIndex &index,
                                                  QTextLayout *labelLayout,
                                                  QTextLayout *infoLayout,
                                                  QRect *textBoundingRect) const
 {
     KFileItem item = fileItem(index);
     const QString info = information(option, index, item);
     bool showInformation = false;
 
     setLayoutOptions(*labelLayout, option);
 
     const QRect textArea = labelRectangle(option, index);
     QRect textRect = subtractMargin(textArea, Private::TextMargin);
 
     // Sizes and constraints for the different text parts
     QSize maxLabelSize = textRect.size();
     QSize maxInfoSize = textRect.size();
     QSize labelSize;
     QSize infoSize;
 
     // If we have additional info text, and there's space for at least two lines of text,
     // adjust the max label size to make room for at least one line of the info text
     if (!info.isEmpty() && textRect.height() >= option.fontMetrics.lineSpacing() * 2) {
         infoLayout->setFont(labelLayout->font());
         infoLayout->setTextOption(labelLayout->textOption());
 
         maxLabelSize.rheight() -= option.fontMetrics.lineSpacing();
         showInformation = true;
     }
 
     // Lay out the label text, and adjust the max info size based on the label size
     labelSize = layoutText(*labelLayout, option, option.text, maxLabelSize);
     maxInfoSize.rheight() -= labelSize.height();
 
     // Lay out the info text
     if (showInformation) {
         infoSize = layoutText(*infoLayout, option, info, maxInfoSize);
     } else {
         infoSize = QSize(0, 0);
     }
 
     // Compute the bounding rect of the text
     const QSize size(qMax(labelSize.width(), infoSize.width()), labelSize.height() + infoSize.height());
     *textBoundingRect = QStyle::alignedRect(option.direction, option.displayAlignment, size, textRect);
 
     // Compute the positions where we should draw the layouts
     labelLayout->setPosition(QPointF(textRect.x(), textBoundingRect->y()));
     infoLayout->setPosition(QPointF(textRect.x(), textBoundingRect->y() + labelSize.height()));
 }
 
 void KFileItemDelegate::Private::drawTextItems(QPainter *painter,
                                                const QTextLayout &labelLayout,
                                                const QColor &labelColor,
                                                const QTextLayout &infoLayout,
                                                const QColor &infoColor,
                                                const QRect &boundingRect) const
 {
     if (shadowColor.alpha() > 0) {
         QPixmap pixmap(boundingRect.size());
         pixmap.fill(Qt::transparent);
 
         QPainter p(&pixmap);
         p.translate(-boundingRect.topLeft());
         p.setPen(labelColor);
         labelLayout.draw(&p, QPoint());
 
         if (!infoLayout.text().isEmpty()) {
             p.setPen(infoColor);
             infoLayout.draw(&p, QPoint());
         }
         p.end();
 
         int padding = qCeil(shadowBlur);
         int blurFactor = qRound(shadowBlur);
 
         QImage image(boundingRect.size() + QSize(padding * 2, padding * 2), QImage::Format_ARGB32_Premultiplied);
         image.fill(0);
         p.begin(&image);
         p.drawImage(padding, padding, pixmap.toImage());
         p.end();
 
         KIO::ImageFilter::shadowBlur(image, blurFactor, shadowColor);
 
         painter->drawImage(boundingRect.topLeft() - QPoint(padding, padding) + shadowOffset.toPoint(), image);
         painter->drawPixmap(boundingRect.topLeft(), pixmap);
         return;
     }
 
     painter->save();
     painter->setPen(labelColor);
 
     labelLayout.draw(painter, QPoint());
     if (!infoLayout.text().isEmpty()) {
         // TODO - for apps not doing funny things with the color palette,
         // KColorScheme::InactiveText would be a much more correct choice. We
         // should provide an API to specify what color to use for information.
         painter->setPen(infoColor);
         infoLayout.draw(painter, QPoint());
     }
 
     painter->restore();
 }
 
 void KFileItemDelegate::Private::initStyleOption(QStyleOptionViewItem *option, const QModelIndex &index) const
 {
     const KFileItem item = fileItem(index);
     bool updateFontMetrics = false;
 
     // Try to get the font from the model
     QVariant value = index.data(Qt::FontRole);
     if (value.isValid()) {
         option->font = qvariant_cast<QFont>(value).resolve(option->font);
         updateFontMetrics = true;
     }
 
     // Use an italic font for symlinks
     if (!item.isNull() && item.isLink()) {
         option->font.setItalic(true);
         updateFontMetrics = true;
     }
 
     if (updateFontMetrics) {
         option->fontMetrics = QFontMetrics(option->font);
     }
 
     // Try to get the alignment for the item from the model
     value = index.data(Qt::TextAlignmentRole);
     if (value.isValid()) {
         option->displayAlignment = Qt::Alignment(value.toInt());
     }
 
     value = index.data(Qt::BackgroundRole);
     if (value.isValid()) {
         option->backgroundBrush = brush(value, *option);
     }
 
     option->text = display(index);
     if (!option->text.isEmpty()) {
         option->features |= QStyleOptionViewItem::HasDisplay;
     }
 
     option->icon = decoration(*option, index);
     // Note that even null icons are still drawn for alignment
     if (!option->icon.isNull()) {
         option->features |= QStyleOptionViewItem::HasDecoration;
     }
 
     // ### Make sure this value is always true for now
     option->showDecorationSelected = true;
 }
 
 void KFileItemDelegate::Private::paintJobTransfers(QPainter *painter, const qreal &jobAnimationAngle, const QPoint &iconPos, const QStyleOptionViewItem &opt)
 {
     painter->save();
     QSize iconSize = opt.icon.actualSize(opt.decorationSize);
     QPixmap downArrow = downArrowIcon.pixmap(iconSize * 0.30);
     // corner (less x and y than bottom-right corner) that we will center the painter around
     QPoint bottomRightCorner = QPoint(iconPos.x() + iconSize.width() * 0.75, iconPos.y() + iconSize.height() * 0.60);
 
     QPainter pixmapPainter(&downArrow);
     // make the icon transparent and such
     pixmapPainter.setCompositionMode(QPainter::CompositionMode_DestinationIn);
     pixmapPainter.fillRect(downArrow.rect(), QColor(255, 255, 255, 110));
 
     painter->translate(bottomRightCorner);
 
     painter->drawPixmap(-downArrow.size().width() * .50, -downArrow.size().height() * .50, downArrow);
 
     // animate the circles by rotating the painter around the center point..
     painter->rotate(jobAnimationAngle);
     painter->setPen(QColor(20, 20, 20, 80));
     painter->setBrush(QColor(250, 250, 250, 90));
 
     int radius = iconSize.width() * 0.04;
     int spacing = radius * 4.5;
 
     // left
     painter->drawEllipse(QPoint(-spacing, 0), radius, radius);
     // right
     painter->drawEllipse(QPoint(spacing, 0), radius, radius);
     // up
     painter->drawEllipse(QPoint(0, -spacing), radius, radius);
     // down
     painter->drawEllipse(QPoint(0, spacing), radius, radius);
     painter->restore();
 }
 
 // ---------------------------------------------------------------------------
 
 KFileItemDelegate::KFileItemDelegate(QObject *parent)
     : QAbstractItemDelegate(parent)
     , d(new Private(this))
 {
     int focusHMargin = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin);
     int focusVMargin = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameVMargin);
 
     // Margins for horizontal mode (list views, tree views, table views)
     const int textMargin = focusHMargin * 4;
     if (QApplication::isRightToLeft()) {
         d->setHorizontalMargin(Private::TextMargin, textMargin, focusVMargin, focusHMargin, focusVMargin);
     } else {
         d->setHorizontalMargin(Private::TextMargin, focusHMargin, focusVMargin, textMargin, focusVMargin);
     }
 
     d->setHorizontalMargin(Private::IconMargin, focusHMargin, focusVMargin);
     d->setHorizontalMargin(Private::ItemMargin, 0, 0);
 
     // Margins for vertical mode (icon views)
     d->setVerticalMargin(Private::TextMargin, 6, 2);
     d->setVerticalMargin(Private::IconMargin, focusHMargin, focusVMargin);
     d->setVerticalMargin(Private::ItemMargin, 0, 0);
 
     setShowInformation(NoInformation);
 }
 
 KFileItemDelegate::~KFileItemDelegate() = default;
 
 QSize KFileItemDelegate::sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     // If the model wants to provide its own size hint for the item
     const QVariant value = index.data(Qt::SizeHintRole);
     if (value.isValid()) {
         return qvariant_cast<QSize>(value);
     }
 
     QStyleOptionViewItem opt(option);
     d->initStyleOption(&opt, index);
     d->setActiveMargins(d->verticalLayout(opt) ? Qt::Vertical : Qt::Horizontal);
 
     const QSize displaySize = d->displaySizeHint(opt, index);
     const QSize decorationSize = d->decorationSizeHint(opt, index);
 
     QSize size;
 
     if (d->verticalLayout(opt)) {
         size.rwidth() = qMax(displaySize.width(), decorationSize.width());
         size.rheight() = decorationSize.height() + displaySize.height() + 1;
     } else {
         size.rwidth() = decorationSize.width() + displaySize.width() + 1;
         size.rheight() = qMax(decorationSize.height(), displaySize.height());
     }
 
     size = d->addMargin(size, Private::ItemMargin);
     if (!d->maximumSize.isEmpty()) {
         size = size.boundedTo(d->maximumSize);
     }
 
     return size;
 }
 
 QString KFileItemDelegate::Private::display(const QModelIndex &index) const
 {
     const QVariant value = index.data(Qt::DisplayRole);
 
     switch (value.typeId()) {
     case QMetaType::QString: {
         if (index.column() == KDirModel::Size) {
             return itemSize(index, fileItem(index));
         } else {
             const QString text = replaceNewlines(value.toString());
             return KStringHandler::preProcessWrap(text);
         }
     }
 
     case QMetaType::Double:
         return QLocale().toString(value.toDouble(), 'f');
 
     case QMetaType::Int:
     case QMetaType::UInt:
         return QLocale().toString(value.toInt());
 
     default:
         return QString();
     }
 }
 
 void KFileItemDelegate::setShowInformation(const InformationList &list)
 {
     d->informationList = list;
 }
 
 void KFileItemDelegate::setShowInformation(Information value)
 {
     if (value != NoInformation) {
         d->informationList = InformationList() << value;
     } else {
         d->informationList = InformationList();
     }
 }
 
 KFileItemDelegate::InformationList KFileItemDelegate::showInformation() const
 {
     return d->informationList;
 }
 
 void KFileItemDelegate::setShadowColor(const QColor &color)
 {
     d->shadowColor = color;
 }
 
 QColor KFileItemDelegate::shadowColor() const
 {
     return d->shadowColor;
 }
 
 void KFileItemDelegate::setShadowOffset(const QPointF &offset)
 {
     d->shadowOffset = offset;
 }
 
 QPointF KFileItemDelegate::shadowOffset() const
 {
     return d->shadowOffset;
 }
 
 void KFileItemDelegate::setShadowBlur(qreal factor)
 {
     d->shadowBlur = factor;
 }
 
 qreal KFileItemDelegate::shadowBlur() const
 {
     return d->shadowBlur;
 }
 
 void KFileItemDelegate::setMaximumSize(const QSize &size)
 {
     d->maximumSize = size;
 }
 
 QSize KFileItemDelegate::maximumSize() const
 {
     return d->maximumSize;
 }
 
 void KFileItemDelegate::setShowToolTipWhenElided(bool showToolTip)
 {
     d->showToolTipWhenElided = showToolTip;
 }
 
 bool KFileItemDelegate::showToolTipWhenElided() const
 {
     return d->showToolTipWhenElided;
 }
 
 void KFileItemDelegate::setWrapMode(QTextOption::WrapMode wrapMode)
 {
     d->wrapMode = wrapMode;
 }
 
 QTextOption::WrapMode KFileItemDelegate::wrapMode() const
 {
     return d->wrapMode;
 }
 
 QRect KFileItemDelegate::iconRect(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     if (index.column() > 0) {
         return QRect(0, 0, 0, 0);
     }
     QStyleOptionViewItem opt(option);
     d->initStyleOption(&opt, index);
     return QRect(d->iconPosition(opt), opt.icon.actualSize(opt.decorationSize));
 }
 
 void KFileItemDelegate::setJobTransfersVisible(bool jobTransfersVisible)
 {
     d->downArrowIcon = QIcon::fromTheme(QStringLiteral("go-down"));
     d->jobTransfersVisible = jobTransfersVisible;
 }
 
 bool KFileItemDelegate::jobTransfersVisible() const
 {
     return d->jobTransfersVisible;
 }
 
 QIcon KFileItemDelegate::Private::decoration(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     const QVariant value = index.data(Qt::DecorationRole);
     QIcon icon;
 
     switch (value.typeId()) {
     case QMetaType::QIcon:
         icon = qvariant_cast<QIcon>(value);
         break;
 
     case QMetaType::QPixmap:
         icon.addPixmap(qvariant_cast<QPixmap>(value));
         break;
 
     case QMetaType::QColor: {
         QPixmap pixmap(option.decorationSize);
         pixmap.fill(qvariant_cast<QColor>(value));
         icon.addPixmap(pixmap);
         break;
     }
 
     default:
         break;
     }
 
     return icon;
 }
 
 QRect KFileItemDelegate::Private::labelRectangle(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     const QSize decoSize = (index.column() == 0) ? addMargin(option.decorationSize, Private::IconMargin) : QSize(0, 0);
     const QRect itemRect = subtractMargin(option.rect, Private::ItemMargin);
     QRect textArea(QPoint(0, 0), itemRect.size());
 
     switch (option.decorationPosition) {
     case QStyleOptionViewItem::Top:
         textArea.setTop(decoSize.height() + 1);
         break;
 
     case QStyleOptionViewItem::Bottom:
         textArea.setBottom(itemRect.height() - decoSize.height() - 1);
         break;
 
     case QStyleOptionViewItem::Left:
         textArea.setLeft(decoSize.width() + 1);
         break;
 
     case QStyleOptionViewItem::Right:
         textArea.setRight(itemRect.width() - decoSize.width() - 1);
         break;
     }
 
     textArea.translate(itemRect.topLeft());
     return QStyle::visualRect(option.direction, option.rect, textArea);
 }
 
 QPoint KFileItemDelegate::Private::iconPosition(const QStyleOptionViewItem &option) const
 {
     if (option.index.column() > 0) {
         return QPoint(0, 0);
     }
 
     const QRect itemRect = subtractMargin(option.rect, Private::ItemMargin);
     Qt::Alignment alignment;
 
     // Convert decorationPosition to the alignment the decoration will have in option.rect
     switch (option.decorationPosition) {
     case QStyleOptionViewItem::Top:
         alignment = Qt::AlignHCenter | Qt::AlignTop;
         break;
 
     case QStyleOptionViewItem::Bottom:
         alignment = Qt::AlignHCenter | Qt::AlignBottom;
         break;
 
     case QStyleOptionViewItem::Left:
         alignment = Qt::AlignVCenter | Qt::AlignLeft;
         break;
 
     case QStyleOptionViewItem::Right:
         alignment = Qt::AlignVCenter | Qt::AlignRight;
         break;
     }
 
     // Compute the nominal decoration rectangle
     const QSize size = addMargin(option.decorationSize, Private::IconMargin);
     const QRect rect = QStyle::alignedRect(option.direction, alignment, size, itemRect);
 
     // Position the icon in the center of the rectangle
     QRect iconRect = QRect(QPoint(), option.icon.actualSize(option.decorationSize));
     iconRect.moveCenter(rect.center());
 
     return iconRect.topLeft();
 }
 
 void KFileItemDelegate::Private::drawFocusRect(QPainter *painter, const QStyleOptionViewItem &option, const QRect &rect) const
 {
     if (!(option.state & QStyle::State_HasFocus)) {
         return;
     }
 
     QStyleOptionFocusRect opt;
     opt.direction = option.direction;
     opt.fontMetrics = option.fontMetrics;
     opt.palette = option.palette;
     opt.rect = rect;
     opt.state = option.state | QStyle::State_KeyboardFocusChange | QStyle::State_Item;
     opt.backgroundColor = option.palette.color(option.state & QStyle::State_Selected ? QPalette::Highlight : QPalette::Base);
 
     // Apparently some widget styles expect this hint to not be set
     painter->setRenderHint(QPainter::Antialiasing, false);
 
     QStyle *style = option.widget ? option.widget->style() : QApplication::style();
     style->drawPrimitive(QStyle::PE_FrameFocusRect, &opt, painter, option.widget);
 
     painter->setRenderHint(QPainter::Antialiasing);
 }
 
 void KFileItemDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     if (!index.isValid()) {
         return;
     }
 
     QStyleOptionViewItem opt(option);
     d->initStyleOption(&opt, index);
     d->setActiveMargins(d->verticalLayout(opt) ? Qt::Vertical : Qt::Horizontal);
 
     if (!(option.state & QStyle::State_Enabled)) {
         opt.palette.setCurrentColorGroup(QPalette::Disabled);
     }
 
     // Unset the mouse over bit if we're not drawing the first column
     if (index.column() > 0) {
         opt.state &= ~QStyle::State_MouseOver;
     } else {
         opt.viewItemPosition = QStyleOptionViewItem::OnlyOne;
     }
 
     const QAbstractItemView *view = qobject_cast<const QAbstractItemView *>(opt.widget);
 
     // Check if the item is being animated
     // ========================================================================
     KIO::AnimationState *state = d->animationState(opt, index, view);
     KIO::CachedRendering *cache = nullptr;
     qreal progress = ((opt.state & QStyle::State_MouseOver) && index.column() == KDirModel::Name) ? 1.0 : 0.0;
     const QPoint iconPos = d->iconPosition(opt);
     QIcon::Mode iconMode;
 
     if (!(option.state & QStyle::State_Enabled)) {
         iconMode = QIcon::Disabled;
     } else if ((option.state & QStyle::State_Selected) && (option.state & QStyle::State_Active)) {
         iconMode = QIcon::Selected;
     } else {
         iconMode = QIcon::Normal;
     }
 
     QIcon::State iconState = option.state & QStyle::State_Open ? QIcon::On : QIcon::Off;
     QPixmap icon = opt.icon.pixmap(opt.decorationSize, iconMode, iconState);
 
     const KFileItem fileItem = d->fileItem(index);
     if (fileItem.isHidden()) {
         KIconEffect::semiTransparent(icon);
     }
 
     if (state && !state->hasJobAnimation()) {
         cache = state->cachedRendering();
         progress = state->hoverProgress();
         // Clear the mouse over bit temporarily
         opt.state &= ~QStyle::State_MouseOver;
 
         // If we have a cached rendering, draw the item from the cache
         if (cache) {
             if (cache->checkValidity(opt.state) && cache->regular.size() == opt.rect.size()) {
                 QPixmap pixmap = d->transition(cache->regular, cache->hover, progress);
 
                 if (state->cachedRenderingFadeFrom() && state->fadeProgress() != 1.0) {
                     // Apply icon fading animation
                     KIO::CachedRendering *fadeFromCache = state->cachedRenderingFadeFrom();
                     const QPixmap fadeFromPixmap = d->transition(fadeFromCache->regular, fadeFromCache->hover, progress);
 
                     pixmap = d->transition(fadeFromPixmap, pixmap, state->fadeProgress());
                 }
                 painter->drawPixmap(option.rect.topLeft(), pixmap);
                 if (d->jobTransfersVisible && index.column() == 0) {
                     if (index.data(KDirModel::HasJobRole).toBool()) {
                         d->paintJobTransfers(painter, state->jobAnimationAngle(), iconPos, opt);
                     }
                 }
                 return;
             }
 
             if (!cache->checkValidity(opt.state)) {
                 if (opt.widget->style()->styleHint(QStyle::SH_Widget_Animate, nullptr, opt.widget)) {
                     // Fade over from the old icon to the new one
                     // Only start a new fade if the previous one is ready
                     // Else we may start racing when checkValidity() always returns false
                     if (state->fadeProgress() == 1) {
                         state->setCachedRenderingFadeFrom(state->takeCachedRendering());
                     }
                 }
                 d->gotNewIcon(index);
             }
             // If it wasn't valid, delete it
             state->setCachedRendering(nullptr);
         } else {
             // The cache may have been discarded, but the animation handler still needs to know about new icons
             d->gotNewIcon(index);
         }
     }
 
     // Compute the metrics, and lay out the text items
     // ========================================================================
     QColor labelColor = d->foregroundBrush(opt, index).color();
     QColor infoColor = labelColor;
     if (!(option.state & QStyle::State_Selected)) {
         // the code below is taken from Dolphin
         const QColor c2 = option.palette.base().color();
         const int p1 = 70;
         const int p2 = 100 - p1;
         infoColor = QColor((labelColor.red() * p1 + c2.red() * p2) / 100,
                            (labelColor.green() * p1 + c2.green() * p2) / 100,
                            (labelColor.blue() * p1 + c2.blue() * p2) / 100);
 
         if (fileItem.isHidden()) {
             labelColor = infoColor;
         }
     }
 
     // ### Apply the selection effect to the icon when the item is selected and
     //      showDecorationSelected is false.
 
     QTextLayout labelLayout;
     QTextLayout infoLayout;
     QRect textBoundingRect;
 
     d->layoutTextItems(opt, index, &labelLayout, &infoLayout, &textBoundingRect);
 
     QStyle *style = opt.widget ? opt.widget->style() : QApplication::style();
 
     int focusHMargin = style->pixelMetric(QStyle::PM_FocusFrameHMargin);
     int focusVMargin = style->pixelMetric(QStyle::PM_FocusFrameVMargin);
     QRect focusRect = textBoundingRect.adjusted(-focusHMargin, -focusVMargin, +focusHMargin, +focusVMargin);
 
     // Create a new cached rendering of a hovered and an unhovered item.
     // We don't create a new cache for a fully hovered item, since we don't
     // know yet if a hover out animation will be run.
     // ========================================================================
     if (state && (state->hoverProgress() < 1 || state->fadeProgress() < 1)) {
         const qreal dpr = painter->device()->devicePixelRatioF();
 
         cache = new KIO::CachedRendering(opt.state, option.rect.size(), index, dpr);
 
         QPainter p;
         p.begin(&cache->regular);
         p.translate(-option.rect.topLeft());
         p.setRenderHint(QPainter::Antialiasing);
         style->drawPrimitive(QStyle::PE_PanelItemViewItem, &opt, &p, opt.widget);
         p.drawPixmap(iconPos, icon);
         d->drawTextItems(&p, labelLayout, labelColor, infoLayout, infoColor, textBoundingRect);
         d->drawFocusRect(&p, opt, focusRect);
         p.end();
 
         opt.state |= QStyle::State_MouseOver;
         icon = d->applyHoverEffect(icon);
 
         p.begin(&cache->hover);
         p.translate(-option.rect.topLeft());
         p.setRenderHint(QPainter::Antialiasing);
         style->drawPrimitive(QStyle::PE_PanelItemViewItem, &opt, &p, opt.widget);
         p.drawPixmap(iconPos, icon);
         d->drawTextItems(&p, labelLayout, labelColor, infoLayout, infoColor, textBoundingRect);
         d->drawFocusRect(&p, opt, focusRect);
         p.end();
 
         state->setCachedRendering(cache);
 
         QPixmap pixmap = d->transition(cache->regular, cache->hover, progress);
 
         if (state->cachedRenderingFadeFrom() && state->fadeProgress() == 0) {
             // Apply icon fading animation
             KIO::CachedRendering *fadeFromCache = state->cachedRenderingFadeFrom();
             const QPixmap fadeFromPixmap = d->transition(fadeFromCache->regular, fadeFromCache->hover, progress);
 
             pixmap = d->transition(fadeFromPixmap, pixmap, state->fadeProgress());
 
             d->restartAnimation(state);
         }
 
         painter->drawPixmap(option.rect.topLeft(), pixmap);
         painter->setRenderHint(QPainter::Antialiasing);
         if (d->jobTransfersVisible && index.column() == 0) {
             if (index.data(KDirModel::HasJobRole).toBool()) {
                 d->paintJobTransfers(painter, state->jobAnimationAngle(), iconPos, opt);
             }
         }
         return;
     }
 
     // Render the item directly if we're not using a cached rendering
     // ========================================================================
     painter->save();
     painter->setRenderHint(QPainter::Antialiasing);
 
     if (progress > 0 && !(opt.state & QStyle::State_MouseOver)) {
         opt.state |= QStyle::State_MouseOver;
         icon = d->applyHoverEffect(icon);
     }
 
     style->drawPrimitive(QStyle::PE_PanelItemViewItem, &opt, painter, opt.widget);
     painter->drawPixmap(iconPos, icon);
 
     d->drawTextItems(painter, labelLayout, labelColor, infoLayout, infoColor, textBoundingRect);
     d->drawFocusRect(painter, opt, focusRect);
 
     if (d->jobTransfersVisible && index.column() == 0 && state) {
         if (index.data(KDirModel::HasJobRole).toBool()) {
             d->paintJobTransfers(painter, state->jobAnimationAngle(), iconPos, opt);
         }
     }
     painter->restore();
 }
 
 QWidget *KFileItemDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     QStyleOptionViewItem opt(option);
     d->initStyleOption(&opt, index);
 
     QTextEdit *edit = new QTextEdit(parent);
     edit->setAcceptRichText(false);
     edit->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
     edit->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
     edit->setAlignment(opt.displayAlignment);
     edit->setEnabled(false); // Disable the text-edit to mark it as un-initialized
     return edit;
 }
 
 bool KFileItemDelegate::editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option, const QModelIndex &index)
 {
     Q_UNUSED(event)
     Q_UNUSED(model)
     Q_UNUSED(option)
     Q_UNUSED(index)
 
     return false;
 }
 
 void KFileItemDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
 {
     QTextEdit *textedit = qobject_cast<QTextEdit *>(editor);
     Q_ASSERT(textedit != nullptr);
 
     // Do not update existing text that the user may already have edited.
     // The models will call setEditorData(..) whenever the icon has changed,
     // and this makes the editing work correctly despite that.
     if (textedit->isEnabled()) {
         return;
     }
     textedit->setEnabled(true); // Enable the text-edit to mark it as initialized
 
     const QVariant value = index.data(Qt::EditRole);
     const QString text = value.toString();
     textedit->insertPlainText(text);
     textedit->selectAll();
 
     QMimeDatabase db;
     const QString extension = db.suffixForFileName(text);
     if (!extension.isEmpty()) {
         // The filename contains an extension. Assure that only the filename
         // gets selected.
         const int selectionLength = text.length() - extension.length() - 1;
         QTextCursor cursor = textedit->textCursor();
         cursor.movePosition(QTextCursor::StartOfBlock);
         cursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor, selectionLength);
         textedit->setTextCursor(cursor);
     }
 }
 
 void KFileItemDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const
 {
     QTextEdit *textedit = qobject_cast<QTextEdit *>(editor);
     Q_ASSERT(textedit != nullptr);
 
     model->setData(index, textedit->toPlainText(), Qt::EditRole);
 }
 
 void KFileItemDelegate::updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     QStyleOptionViewItem opt(option);
     d->initStyleOption(&opt, index);
     d->setActiveMargins(d->verticalLayout(opt) ? Qt::Vertical : Qt::Horizontal);
 
     QRect r = d->labelRectangle(opt, index);
 
     // Use the full available width for the editor when maximumSize is set
     if (!d->maximumSize.isEmpty()) {
         if (d->verticalLayout(option)) {
             int diff = qMax(r.width(), d->maximumSize.width()) - r.width();
             if (diff > 1) {
                 r.adjust(-(diff / 2), 0, diff / 2, 0);
             }
         } else {
             int diff = qMax(r.width(), d->maximumSize.width() - opt.decorationSize.width()) - r.width();
             if (diff > 0) {
                 if (opt.decorationPosition == QStyleOptionViewItem::Left) {
                     r.adjust(0, 0, diff, 0);
                 } else {
                     r.adjust(-diff, 0, 0, 0);
                 }
             }
         }
     }
 
     QTextEdit *textedit = qobject_cast<QTextEdit *>(editor);
     Q_ASSERT(textedit != nullptr);
     const int frame = textedit->frameWidth();
     r.adjust(-frame, -frame, frame, frame);
 
     editor->setGeometry(r);
 }
 
 bool KFileItemDelegate::helpEvent(QHelpEvent *event, QAbstractItemView *view, const QStyleOptionViewItem &option, const QModelIndex &index)
 {
     Q_UNUSED(event)
     Q_UNUSED(view)
 
     // if the tooltip information the model keeps is different from the display information,
     // show it always
     const QVariant toolTip = index.data(Qt::ToolTipRole);
 
     if (!toolTip.isValid()) {
         return false;
     }
 
     if (index.data() != toolTip) {
         return QAbstractItemDelegate::helpEvent(event, view, option, index);
     }
 
     if (!d->showToolTipWhenElided) {
         return false;
     }
 
     // in the case the tooltip information is the same as the display information,
     // show it only in the case the display information is elided
     QStyleOptionViewItem opt(option);
     d->initStyleOption(&opt, index);
     d->setActiveMargins(d->verticalLayout(opt) ? Qt::Vertical : Qt::Horizontal);
 
     QTextLayout labelLayout;
     QTextLayout infoLayout;
     QRect textBoundingRect;
     d->layoutTextItems(opt, index, &labelLayout, &infoLayout, &textBoundingRect);
     const QString elidedText = d->elidedText(labelLayout, opt, textBoundingRect.size());
 
     if (elidedText != d->display(index)) {
         return QAbstractItemDelegate::helpEvent(event, view, option, index);
     }
 
     return false;
 }
 
 QRegion KFileItemDelegate::shape(const QStyleOptionViewItem &option, const QModelIndex &index)
 {
     QStyleOptionViewItem opt(option);
     d->initStyleOption(&opt, index);
     d->setActiveMargins(d->verticalLayout(opt) ? Qt::Vertical : Qt::Horizontal);
 
     QTextLayout labelLayout;
     QTextLayout infoLayout;
     QRect textBoundingRect;
     d->layoutTextItems(opt, index, &labelLayout, &infoLayout, &textBoundingRect);
 
     const QPoint pos = d->iconPosition(opt);
     QRect iconRect = QRect(pos, opt.icon.actualSize(opt.decorationSize));
 
     // Extend the icon rect so it touches the text rect
     switch (opt.decorationPosition) {
     case QStyleOptionViewItem::Top:
         if (iconRect.width() < textBoundingRect.width()) {
             iconRect.setBottom(textBoundingRect.top());
         } else {
             textBoundingRect.setTop(iconRect.bottom());
         }
         break;
     case QStyleOptionViewItem::Bottom:
         if (iconRect.width() < textBoundingRect.width()) {
             iconRect.setTop(textBoundingRect.bottom());
         } else {
             textBoundingRect.setBottom(iconRect.top());
         }
         break;
     case QStyleOptionViewItem::Left:
         iconRect.setRight(textBoundingRect.left());
         break;
     case QStyleOptionViewItem::Right:
         iconRect.setLeft(textBoundingRect.right());
         break;
     }
 
     QRegion region;
     region += iconRect;
     region += textBoundingRect;
     return region;
 }
 
 bool KFileItemDelegate::eventFilter(QObject *object, QEvent *event)
 {
     QTextEdit *editor = qobject_cast<QTextEdit *>(object);
     if (!editor) {
         return false;
     }
 
     switch (event->type()) {
     case QEvent::KeyPress: {
         QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
         switch (keyEvent->key()) {
         case Qt::Key_Tab:
         case Qt::Key_Backtab:
             Q_EMIT commitData(editor);
             Q_EMIT closeEditor(editor, NoHint);
             return true;
 
         case Qt::Key_Enter:
         case Qt::Key_Return: {
             const QString text = editor->toPlainText();
             if (text.isEmpty() || (text == QLatin1Char('.')) || (text == QLatin1String(".."))) {
                 return true; // So a newline doesn't get inserted
             }
 
             Q_EMIT commitData(editor);
             Q_EMIT closeEditor(editor, SubmitModelCache);
             return true;
         }
 
         case Qt::Key_Escape:
             Q_EMIT closeEditor(editor, RevertModelCache);
             return true;
 
         default:
             return false;
         } // switch (keyEvent->key())
     } // case QEvent::KeyPress
 
     case QEvent::FocusOut: {
         const QWidget *w = QApplication::activePopupWidget();
         if (!w || w->parent() != editor) {
             Q_EMIT commitData(editor);
             Q_EMIT closeEditor(editor, NoHint);
             return true;
         } else {
             return false;
         }
     }
 
     default:
         return false;
     } // switch (event->type())
 }
 
 #include "moc_kfileitemdelegate.cpp"