File indexing completed on 2024-05-12 04:19:50

 // vim: set tabstop=4 shiftwidth=4 expandtab:
 /*
 Gwenview: an image viewer
 Copyright 2008 Aurélien Gâteau <agateau@kde.org>
 
 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, Cambridge, MA 02110-1301, USA.
 
 */
 // Self
 #include "previewitemdelegate.h"
 #include <config-gwenview.h>
 
 // Qt
 #include <QApplication>
 #include <QDateTime>
 #include <QEvent>
 #include <QHBoxLayout>
 #include <QHash>
 #include <QHoverEvent>
 #include <QPainter>
 #include <QPainterPath>
 #include <QParallelAnimationGroup>
 #include <QPointer>
 #include <QPropertyAnimation>
 #include <QSequentialAnimationGroup>
 #include <QToolButton>
 #include <QUrl>
 
 // KF
 #include <KDirModel>
 #include <KIconLoader>
 #include <KLocalizedString>
 
 #ifndef GWENVIEW_SEMANTICINFO_BACKEND_NONE
 #include <KRatingPainter>
 #endif
 
 // Local
 #include "archiveutils.h"
 #include "gwenview_lib_debug.h"
 #include "itemeditor.h"
 #include "paintutils.h"
 #include "thumbnailview.h"
 #include "timeutils.h"
 #include "tooltipwidget.h"
 #ifndef GWENVIEW_SEMANTICINFO_BACKEND_NONE
 #include "../semanticinfo/semanticinfodirmodel.h"
 #endif
 
 // Define this to be able to fine tune the rendering of the selection
 // background through a config file
 // #define FINETUNE_SELECTION_BACKGROUND
 #ifdef FINETUNE_SELECTION_BACKGROUND
 #include <QDir>
 #include <QSettings>
 #endif
 
 // #define DEBUG_DRAW_BORDER
 // #define DEBUG_DRAW_CURRENT
 
 namespace Gwenview
 {
 /**
  * Space between the item outer rect and the content, and between the
  * thumbnail and the caption
  */
 const int ITEM_MARGIN_DELEGATE = 5;
 
 /** How darker is the border line around selection */
 const int SELECTION_BORDER_DARKNESS = 140;
 const int FOCUS_BORDER_DARKNESS = 200;
 
 /** Radius of the selection rounded corners, in pixels */
 const int SELECTION_RADIUS = 5;
 
 /** Space between the item outer rect and the context bar */
 const int CONTEXTBAR_MARGIN = 1;
 
 /** How dark is the shadow, 0 is invisible, 255 is as dark as possible */
 const int SHADOW_STRENGTH_DELEGATE = 128;
 
 /** How many pixels around the thumbnail are shadowed */
 const int SHADOW_SIZE_DELEGATE = 4;
 
 static KFileItem fileItemForIndexThumbnailView(const QModelIndex &index)
 {
     Q_ASSERT(index.isValid());
     QVariant data = index.data(KDirModel::FileItemRole);
     return qvariant_cast<KFileItem>(data);
 }
 
 static QUrl urlForIndexThumbnailView(const QModelIndex &index)
 {
     KFileItem item = fileItemForIndexThumbnailView(index);
     return item.url();
 }
 
 struct PreviewItemDelegatePrivate {
     /**
      * Maps full text to elided text.
      */
     mutable QHash<QString, QString> mElidedTextCache;
 
     // Key is height * 1000 + width
     using ShadowCache = QHash<int, QPixmap>;
     mutable ShadowCache mShadowCache;
 
     PreviewItemDelegate *q;
     QPointer<ThumbnailView> mView;
     QWidget *mContextBar;
     QToolButton *mSaveButton;
     QPixmap mSaveButtonPixmap;
 
     QToolButton *mToggleSelectionButton;
     QToolButton *mFullScreenButton;
     QToolButton *mRotateLeftButton;
     QToolButton *mRotateRightButton;
 #ifndef GWENVIEW_SEMANTICINFO_BACKEND_NONE
     KRatingPainter mRatingPainter;
 #endif
 
     QPersistentModelIndex mIndexUnderCursor;
     QSize mThumbnailSize;
     PreviewItemDelegate::ThumbnailDetails mDetails;
     PreviewItemDelegate::ContextBarActions mContextBarActions;
     Qt::TextElideMode mTextElideMode;
 
     QPointer<ToolTipWidget> mToolTip;
     QScopedPointer<QAbstractAnimation> mToolTipAnimation;
 
     void initSaveButtonPixmap()
     {
         if (!mSaveButtonPixmap.isNull()) {
             return;
         }
         // Necessary otherwise we won't see the save button itself
         mSaveButton->adjustSize();
 
         mSaveButtonPixmap = QPixmap(mSaveButton->sizeHint());
         mSaveButtonPixmap.fill(Qt::transparent);
         mSaveButton->render(&mSaveButtonPixmap, QPoint(), QRegion(), QWidget::DrawChildren);
     }
 
     void showContextBar(const QRect &rect, const QPixmap &thumbnailPix)
     {
         if (mContextBarActions == PreviewItemDelegate::NoAction) {
             return;
         }
         mContextBar->adjustSize();
         // Center bar, except if only showing SelectionAction.
         const int posX = mContextBarActions == PreviewItemDelegate::SelectionAction ? 0 : (rect.width() - mContextBar->width()) / 2;
         const int thumbnailPixHeight = qRound(thumbnailPix.height() / thumbnailPix.devicePixelRatio());
         const int posY = qMax(CONTEXTBAR_MARGIN, mThumbnailSize.height() - thumbnailPixHeight - mContextBar->height());
         mContextBar->move(rect.topLeft() + QPoint(posX, posY));
         mContextBar->show();
     }
 
     void initToolTip()
     {
         mToolTip = new ToolTipWidget(mView->viewport());
         mToolTip->setOpacity(0);
         mToolTip->show();
     }
 
     bool hoverEventFilter(QHoverEvent *event)
     {
         QModelIndex index = mView->indexAt(event->pos());
         if (index != mIndexUnderCursor) {
             updateHoverUi(index);
         } else {
             // Same index, nothing to do, but repaint anyway in case we are
             // over the rating row
             mView->update(mIndexUnderCursor);
         }
         return false;
     }
 
     void updateHoverUi(const QModelIndex &index)
     {
         QModelIndex oldIndex = mIndexUnderCursor;
         mIndexUnderCursor = index;
         mView->update(oldIndex);
 
         if (QApplication::style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick, nullptr, mView)) {
             mView->setCursor(mIndexUnderCursor.isValid() ? Qt::PointingHandCursor : Qt::ArrowCursor);
         }
 
         if (mIndexUnderCursor.isValid()) {
             updateToggleSelectionButton();
             updateImageButtons();
 
             const QRect rect = mView->visualRect(mIndexUnderCursor);
             const QPixmap thumbnailPix = mView->thumbnailForIndex(index);
             showContextBar(rect, thumbnailPix);
             if (mView->isModified(mIndexUnderCursor)) {
                 showSaveButton(rect);
             } else {
                 mSaveButton->hide();
             }
 
             showToolTip(index);
             mView->update(mIndexUnderCursor);
 
         } else {
             mContextBar->hide();
             mSaveButton->hide();
             hideToolTip();
         }
     }
 
     QRect ratingRectFromIndexRect(const QRect &rect) const
     {
         return QRect(rect.left(), rect.bottom() - ratingRowHeight() - ITEM_MARGIN_DELEGATE, rect.width(), ratingRowHeight());
     }
 
 #ifndef GWENVIEW_SEMANTICINFO_BACKEND_NONE
     int ratingFromCursorPosition(const QRect &ratingRect) const
     {
         const QPoint pos = mView->viewport()->mapFromGlobal(QCursor::pos());
         return mRatingPainter.ratingFromPosition(ratingRect, pos);
     }
 #endif
 
     bool mouseButtonEventFilter(QEvent::Type type)
     {
 #ifndef GWENVIEW_SEMANTICINFO_BACKEND_NONE
         const QRect rect = ratingRectFromIndexRect(mView->visualRect(mIndexUnderCursor));
         const int rating = ratingFromCursorPosition(rect);
         if (rating == -1) {
             return false;
         }
         if (type == QEvent::MouseButtonRelease) {
             q->setDocumentRatingRequested(urlForIndexThumbnailView(mIndexUnderCursor), rating);
         }
         return true;
 #else
         return false;
 #endif
     }
 
     QPoint saveButtonPosition(const QRect &itemRect) const
     {
         QSize buttonSize = mSaveButton->sizeHint();
         int posX = itemRect.right() - buttonSize.width();
         int posY = itemRect.top() + mThumbnailSize.height() + 2 * ITEM_MARGIN_DELEGATE - buttonSize.height();
 
         return QPoint(posX, posY);
     }
 
     void showSaveButton(const QRect &itemRect) const
     {
         mSaveButton->move(saveButtonPosition(itemRect));
         mSaveButton->show();
     }
 
     void drawBackground(QPainter *painter, const QRect &rect, const QColor &bgColor, const QColor &borderColor) const
     {
         int bgH, bgS, bgV;
         int borderH, borderS, borderV, borderMargin;
 #ifdef FINETUNE_SELECTION_BACKGROUND
         QSettings settings(QDir::homePath() + "/colors.ini", QSettings::IniFormat);
         bgH = settings.value("bg/h").toInt();
         bgS = settings.value("bg/s").toInt();
         bgV = settings.value("bg/v").toInt();
         borderH = settings.value("border/h").toInt();
         borderS = settings.value("border/s").toInt();
         borderV = settings.value("border/v").toInt();
         borderMargin = settings.value("border/margin").toInt();
 #else
         bgH = 0;
         bgS = -20;
         bgV = 43;
         borderH = 0;
         borderS = -100;
         borderV = 60;
         borderMargin = 1;
 #endif
         painter->setRenderHint(QPainter::Antialiasing);
 
         QRectF rectF = QRectF(rect).adjusted(0.5, 0.5, -0.5, -0.5);
 
         QPainterPath path = PaintUtils::roundedRectangle(rectF, SELECTION_RADIUS);
 
         QLinearGradient gradient(rectF.topLeft(), rectF.bottomLeft());
         gradient.setColorAt(0, PaintUtils::adjustedHsv(bgColor, bgH, bgS, bgV));
         gradient.setColorAt(1, bgColor);
         painter->fillPath(path, gradient);
 
         painter->setPen(borderColor);
         painter->drawPath(path);
 
         painter->setPen(PaintUtils::adjustedHsv(borderColor, borderH, borderS, borderV));
         rectF = rectF.adjusted(borderMargin, borderMargin, -borderMargin, -borderMargin);
         path = PaintUtils::roundedRectangle(rectF, SELECTION_RADIUS);
         painter->drawPath(path);
     }
 
     void drawShadow(QPainter *painter, const QRect &rect) const
     {
         const QPoint shadowOffset(-SHADOW_SIZE_DELEGATE, -SHADOW_SIZE_DELEGATE + 1);
 
         const auto dpr = painter->device()->devicePixelRatioF();
         int key = qRound((rect.height() * 1000 + rect.width()) * dpr);
 
         ShadowCache::Iterator it = mShadowCache.find(key);
         if (it == mShadowCache.end()) {
             QSize size = QSize(rect.width() + 2 * SHADOW_SIZE_DELEGATE, rect.height() + 2 * SHADOW_SIZE_DELEGATE);
             QColor color(0, 0, 0, SHADOW_STRENGTH_DELEGATE);
             QPixmap shadow = PaintUtils::generateFuzzyRect(size * dpr, color, qRound(SHADOW_SIZE_DELEGATE * dpr));
             shadow.setDevicePixelRatio(dpr);
             it = mShadowCache.insert(key, shadow);
         }
         painter->drawPixmap(rect.topLeft() + shadowOffset, it.value());
     }
 
     void drawText(QPainter *painter, const QRect &rect, const QColor &fgColor, const QString &fullText) const
     {
         QFontMetrics fm = mView->fontMetrics();
 
         // Elide text
         QString text;
         QHash<QString, QString>::const_iterator it = mElidedTextCache.constFind(fullText);
         if (it == mElidedTextCache.constEnd()) {
             text = fm.elidedText(fullText, mTextElideMode, rect.width());
             mElidedTextCache[fullText] = text;
         } else {
             text = it.value();
         }
 
         // Compute x pos
         int posX;
         if (text.length() == fullText.length()) {
             // Not elided, center text
             posX = (rect.width() - fm.boundingRect(text).width()) / 2;
         } else {
             // Elided, left align
             posX = 0;
         }
 
         // Draw text
         painter->setPen(fgColor);
         painter->drawText(rect.left() + posX, rect.top() + fm.ascent(), text);
     }
 
     void drawRating(QPainter *painter, const QRect &rect, const QVariant &value)
     {
 #ifndef GWENVIEW_SEMANTICINFO_BACKEND_NONE
         const int rating = value.toInt();
         const QRect ratingRect = ratingRectFromIndexRect(rect);
         const int hoverRating = ratingFromCursorPosition(ratingRect);
         mRatingPainter.paint(painter, ratingRect, rating, hoverRating);
 #endif
     }
 
     bool isTextElided(const QString &text) const
     {
         QHash<QString, QString>::const_iterator it = mElidedTextCache.constFind(text);
         if (it == mElidedTextCache.constEnd()) {
             return false;
         }
         return it.value().length() < text.length();
     }
 
     /**
      * Show a tooltip only if the item has been elided.
      * This function places the tooltip over the item text.
      */
     void showToolTip(const QModelIndex &index)
     {
         if (mDetails == 0 || mDetails == PreviewItemDelegate::RatingDetail) {
             // No text to display
             return;
         }
 
         // Gather tip text
         QStringList textList;
         bool elided = false;
         if (mDetails & PreviewItemDelegate::FileNameDetail) {
             const QString text = index.data().toString();
             elided |= isTextElided(text);
             textList << text;
         }
 
         // FIXME: Duplicated from drawText
         const KFileItem fileItem = fileItemForIndexThumbnailView(index);
         const bool isDirOrArchive = ArchiveUtils::fileItemIsDirOrArchive(fileItem);
         if (mDetails & PreviewItemDelegate::DateDetail) {
             if (!ArchiveUtils::fileItemIsDirOrArchive(fileItem)) {
                 const QDateTime dt = TimeUtils::dateTimeForFileItem(fileItem);
                 const QString text = QLocale().toString(dt, QLocale::ShortFormat);
                 elided |= isTextElided(text);
                 textList << text;
             }
         }
 
         if (!isDirOrArchive && (mDetails & PreviewItemDelegate::ImageSizeDetail)) {
             QSize fullSize;
             QPixmap thumbnailPix = mView->thumbnailForIndex(index, &fullSize);
             if (fullSize.isValid()) {
                 const QString text = i18nc("@item:intable %1 is image width, %2 is image height", "%1x%2", fullSize.width(), fullSize.height());
                 elided |= isTextElided(text);
                 textList << text;
             }
         }
 
         if (!isDirOrArchive && (mDetails & PreviewItemDelegate::FileSizeDetail)) {
             const KIO::filesize_t size = fileItem.size();
             if (size > 0) {
                 const QString text = KIO::convertSize(size);
                 elided |= isTextElided(text);
                 textList << text;
             }
         }
 
         if (!elided) {
             hideToolTip();
             return;
         }
 
         bool newTipLabel = !mToolTip;
         if (!mToolTip) {
             initToolTip();
         }
         mToolTip->setText(textList.join(QLatin1Char('\n')));
         QSize tipSize = mToolTip->sizeHint();
 
         // Compute tip position
         QRect rect = mView->visualRect(index);
         const int textY = ITEM_MARGIN_DELEGATE + mThumbnailSize.height() + ITEM_MARGIN_DELEGATE;
         const int spacing = 1;
         QRect geometry(QPoint(rect.topLeft() + QPoint((rect.width() - tipSize.width()) / 2, textY + spacing)), tipSize);
         if (geometry.left() < 0) {
             geometry.moveLeft(0);
         } else if (geometry.right() > mView->viewport()->width()) {
             geometry.moveRight(mView->viewport()->width());
         }
 
         // Show tip
         auto anim = new QParallelAnimationGroup();
         auto fadeIn = new QPropertyAnimation(mToolTip, "opacity");
         fadeIn->setStartValue(mToolTip->opacity());
         fadeIn->setEndValue(1.);
         anim->addAnimation(fadeIn);
 
         if (newTipLabel) {
             mToolTip->setGeometry(geometry);
         } else {
             auto move = new QPropertyAnimation(mToolTip, "geometry");
             move->setStartValue(mToolTip->geometry());
             move->setEndValue(geometry);
             anim->addAnimation(move);
         }
 
         mToolTipAnimation.reset(anim);
         mToolTipAnimation->start();
     }
 
     void hideToolTip()
     {
         if (!mToolTip) {
             return;
         }
         auto anim = new QSequentialAnimationGroup();
         if (mToolTipAnimation->state() == QPropertyAnimation::Stopped) {
             anim->addPause(500);
         }
         auto fadeOut = new QPropertyAnimation(mToolTip, "opacity");
         fadeOut->setStartValue(mToolTip->opacity());
         fadeOut->setEndValue(0.);
         anim->addAnimation(fadeOut);
         mToolTipAnimation.reset(anim);
         mToolTipAnimation->start();
         QObject::connect(anim, &QSequentialAnimationGroup::finished, mToolTip.data(), &ToolTipWidget::deleteLater);
     }
 
     int itemWidth() const
     {
         return mThumbnailSize.width() + 2 * ITEM_MARGIN_DELEGATE;
     }
 
     int ratingRowHeight() const
     {
 #ifndef GWENVIEW_SEMANTICINFO_BACKEND_NONE
         return qMax(mView->fontMetrics().ascent(), int(KIconLoader::SizeSmall));
 #else
         return 0;
 #endif
     }
 
     int itemHeight() const
     {
         const int lineHeight = mView->fontMetrics().height();
         int textHeight = 0;
         if (mDetails & PreviewItemDelegate::FileNameDetail) {
             textHeight += lineHeight;
         }
         if (mDetails & PreviewItemDelegate::DateDetail) {
             textHeight += lineHeight;
         }
         if (mDetails & PreviewItemDelegate::ImageSizeDetail) {
             textHeight += lineHeight;
         }
         if (mDetails & PreviewItemDelegate::FileSizeDetail) {
             textHeight += lineHeight;
         }
         if (mDetails & PreviewItemDelegate::RatingDetail) {
             textHeight += ratingRowHeight();
         }
         if (textHeight == 0) {
             // Keep at least one row of text, so that we can show folder names
             textHeight = lineHeight;
         }
         return mThumbnailSize.height() + textHeight + 3 * ITEM_MARGIN_DELEGATE;
     }
 
     void selectIndexUnderCursorIfNoMultiSelection()
     {
         if (mView->selectionModel()->selectedIndexes().size() <= 1) {
             mView->setCurrentIndex(mIndexUnderCursor);
         }
     }
 
     void updateToggleSelectionButton()
     {
         mToggleSelectionButton->setIcon(
             QIcon::fromTheme(mView->selectionModel()->isSelected(mIndexUnderCursor) ? QStringLiteral("list-remove") : QStringLiteral("list-add")));
     }
 
     void updateImageButtons()
     {
         const KFileItem item = fileItemForIndexThumbnailView(mIndexUnderCursor);
         const bool isImage = !ArchiveUtils::fileItemIsDirOrArchive(item);
         mFullScreenButton->setEnabled(isImage);
         mRotateLeftButton->setEnabled(isImage);
         mRotateRightButton->setEnabled(isImage);
     }
 
     void updateContextBar()
     {
         if (mContextBarActions == PreviewItemDelegate::NoAction) {
             mContextBar->hide();
             return;
         }
         const int width = itemWidth();
         const int buttonWidth = mRotateRightButton->sizeHint().width();
         mFullScreenButton->setVisible(mContextBarActions & PreviewItemDelegate::FullScreenAction);
         bool rotate = mContextBarActions & PreviewItemDelegate::RotateAction;
         mRotateLeftButton->setVisible(rotate && width >= 3 * buttonWidth);
         mRotateRightButton->setVisible(rotate && width >= 4 * buttonWidth);
         mContextBar->adjustSize();
     }
 
     void updateViewGridSize()
     {
         mView->setGridSize(QSize(itemWidth() + 8, itemHeight() + 8));
     }
 };
 
 PreviewItemDelegate::PreviewItemDelegate(ThumbnailView *view)
     : QItemDelegate(view)
     , d(new PreviewItemDelegatePrivate)
 {
     d->q = this;
     d->mView = view;
     view->viewport()->installEventFilter(this);
 
     // Set this attribute so that the viewport receives QEvent::HoverMove and
     // QEvent::HoverLeave events. We use these events in the event filter
     // installed on the viewport.
     // Some styles set this attribute themselves (Oxygen and Skulpture do) but
     // others do not (Plastique, Cleanlooks...)
     view->viewport()->setAttribute(Qt::WA_Hover);
 
     d->mThumbnailSize = view->thumbnailSize();
     d->mDetails = FileNameDetail;
     d->mContextBarActions = SelectionAction | FullScreenAction | RotateAction;
     d->mTextElideMode = Qt::ElideRight;
 
     connect(view, &ThumbnailView::rowsRemovedSignal, this, &PreviewItemDelegate::slotRowsChanged);
     connect(view, &ThumbnailView::rowsInsertedSignal, this, &PreviewItemDelegate::slotRowsChanged);
     connect(view, &ThumbnailView::selectionChangedSignal, [this]() {
         d->updateToggleSelectionButton();
     });
 
 #ifndef GWENVIEW_SEMANTICINFO_BACKEND_NONE
     d->mRatingPainter.setAlignment(Qt::AlignHCenter | Qt::AlignBottom);
     d->mRatingPainter.setLayoutDirection(view->layoutDirection());
     d->mRatingPainter.setMaxRating(10);
 #endif
 
     connect(view, &ThumbnailView::thumbnailSizeChanged, this, &PreviewItemDelegate::setThumbnailSize);
 
     // Button frame
     d->mContextBar = new QWidget(d->mView->viewport());
     d->mContextBar->hide();
 
     d->mToggleSelectionButton = new QToolButton;
     d->mToggleSelectionButton->setIcon(QIcon::fromTheme(QStringLiteral("list-add")));
     connect(d->mToggleSelectionButton, &QToolButton::clicked, this, &PreviewItemDelegate::slotToggleSelectionClicked);
 
     d->mFullScreenButton = new QToolButton;
     d->mFullScreenButton->setIcon(QIcon::fromTheme(QStringLiteral("view-fullscreen")));
     connect(d->mFullScreenButton, &QToolButton::clicked, this, &PreviewItemDelegate::slotFullScreenClicked);
 
     d->mRotateLeftButton = new QToolButton;
     d->mRotateLeftButton->setIcon(QIcon::fromTheme(QStringLiteral("object-rotate-left")));
     connect(d->mRotateLeftButton, &QToolButton::clicked, this, &PreviewItemDelegate::slotRotateLeftClicked);
 
     d->mRotateRightButton = new QToolButton;
     d->mRotateRightButton->setIcon(QIcon::fromTheme(QStringLiteral("object-rotate-right")));
     connect(d->mRotateRightButton, &QToolButton::clicked, this, &PreviewItemDelegate::slotRotateRightClicked);
 
     auto layout = new QHBoxLayout(d->mContextBar);
     layout->setContentsMargins(2, 2, 2, 2);
     layout->setSpacing(2);
     layout->addWidget(d->mToggleSelectionButton);
     layout->addWidget(d->mFullScreenButton);
     layout->addWidget(d->mRotateLeftButton);
     layout->addWidget(d->mRotateRightButton);
 
     // Save button
     d->mSaveButton = new QToolButton(d->mView->viewport());
     d->mSaveButton->setIcon(QIcon::fromTheme(QStringLiteral("document-save")));
     d->mSaveButton->hide();
     connect(d->mSaveButton, &QToolButton::clicked, this, &PreviewItemDelegate::slotSaveClicked);
 }
 
 PreviewItemDelegate::~PreviewItemDelegate()
 {
     delete d;
 }
 
 QSize PreviewItemDelegate::sizeHint(const QStyleOptionViewItem & /*option*/, const QModelIndex & /*index*/) const
 {
     return d->mView->gridSize();
 }
 
 bool PreviewItemDelegate::eventFilter(QObject *object, QEvent *event)
 {
     if (event->type() == QEvent::Destroy || event->type() == QEvent::ChildRemoved || !d->mView) {
         return QItemDelegate::eventFilter(object, event);
     }
 
     if (object == d->mView->viewport()) {
         switch (event->type()) {
         case QEvent::ToolTip:
             return true;
 
         case QEvent::HoverMove:
         case QEvent::HoverLeave:
             return d->hoverEventFilter(static_cast<QHoverEvent *>(event));
 
         case QEvent::MouseButtonPress:
         case QEvent::MouseButtonRelease:
             return d->mouseButtonEventFilter(event->type());
 
         default:
             return false;
         }
     } else {
         // Necessary for the item editor to work correctly (especially closing
         // the editor with the Escape key)
         return QItemDelegate::eventFilter(object, event);
     }
 }
 
 void PreviewItemDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     int thumbnailHeight = d->mThumbnailSize.height();
     QSize fullSize;
     QPixmap thumbnailPix = d->mView->thumbnailForIndex(index, &fullSize);
     QSize thumbnailSize = thumbnailPix.size() / thumbnailPix.devicePixelRatio();
     const KFileItem fileItem = fileItemForIndexThumbnailView(index);
     const bool opaque = !thumbnailPix.hasAlphaChannel();
     const bool isDirOrArchive = ArchiveUtils::fileItemIsDirOrArchive(fileItem);
     QRect rect = option.rect;
     const bool selected = option.state & QStyle::State_Selected;
     const bool underMouse = option.state & QStyle::State_MouseOver;
     const bool hasFocus = option.state & QStyle::State_HasFocus;
 
     const QWidget *viewport = d->mView->viewport();
 
 #ifdef DEBUG_DRAW_BORDER
     painter->setPen(Qt::red);
     painter->setBrush(Qt::NoBrush);
     painter->drawRect(rect);
 #endif
 
     // Select color group
     QPalette::ColorGroup cg;
 
     if ((option.state & QStyle::State_Enabled) && (option.state & QStyle::State_Active)) {
         cg = QPalette::Normal;
     } else if ((option.state & QStyle::State_Enabled)) {
         cg = QPalette::Inactive;
     } else {
         cg = QPalette::Disabled;
     }
 
     // Select colors
     QColor bgColor, borderColor, fgColor;
 
     fgColor = viewport->palette().color(viewport->foregroundRole());
 
     if (selected || underMouse) {
         bgColor = option.palette.color(cg, QPalette::Highlight);
 
         if (hasFocus) {
             borderColor = bgColor.darker(FOCUS_BORDER_DARKNESS);
         } else {
             borderColor = bgColor.darker(SELECTION_BORDER_DARKNESS);
         }
     } else {
         bgColor = viewport->palette().color(viewport->backgroundRole());
         if (hasFocus) {
             borderColor = fgColor;
         } else {
             borderColor = bgColor.lighter(200);
         }
     }
 
     // Compute thumbnailRect
     QRect thumbnailRect = QRect(rect.left() + (rect.width() - thumbnailSize.width()) / 2,
                                 rect.top() + (thumbnailHeight - thumbnailSize.height()) + ITEM_MARGIN_DELEGATE,
                                 thumbnailSize.width(),
                                 thumbnailSize.height());
 
     // Draw background
     const QRect backgroundRect = thumbnailRect.adjusted(-ITEM_MARGIN_DELEGATE, -ITEM_MARGIN_DELEGATE, ITEM_MARGIN_DELEGATE, ITEM_MARGIN_DELEGATE);
     if (selected) {
         d->drawBackground(painter, backgroundRect, bgColor, borderColor);
     } else if (underMouse) {
         painter->setOpacity(0.2);
         d->drawBackground(painter, backgroundRect, bgColor, borderColor);
         painter->setOpacity(1.);
     } else if (opaque) {
         d->drawShadow(painter, thumbnailRect);
     }
 
     // Draw thumbnail
     if (opaque) {
         painter->setPen(borderColor);
         painter->setRenderHint(QPainter::Antialiasing, false);
         QRect borderRect = thumbnailRect.adjusted(-1, -1, 0, 0);
         painter->drawRect(borderRect);
     } else if (hasFocus && !selected) {
         painter->setPen(option.palette.color(cg, QPalette::Highlight));
         painter->setRenderHint(QPainter::Antialiasing, false);
         QLine underLine = QLine(thumbnailRect.bottomLeft(), thumbnailRect.bottomRight());
         underLine.translate(0, 3);
         painter->drawLine(underLine);
     }
     painter->drawPixmap(thumbnailRect.left(), thumbnailRect.top(), thumbnailPix);
 
     // Draw modified indicator
     bool isModified = d->mView->isModified(index);
     if (isModified) {
         // Draws a pixmap of the save button frame, as an indicator that
         // the image has been modified
         QPoint framePosition = d->saveButtonPosition(rect);
         d->initSaveButtonPixmap();
         painter->drawPixmap(framePosition, d->mSaveButtonPixmap);
     }
 
     // Draw busy indicator
     if (d->mView->isBusy(index)) {
         QPixmap pix = d->mView->busySequenceCurrentPixmap();
         painter->drawPixmap(thumbnailRect.left() + (thumbnailRect.width() - pix.width()) / 2,
                             thumbnailRect.top() + (thumbnailRect.height() - pix.height()) / 2,
                             pix);
     }
 
     if (index == d->mIndexUnderCursor) {
         // Show bar again: if the thumbnail has changed, we may need to update
         // its position. Don't do it if we are over rotate buttons, though: it
         // would not be nice to move the button now, the user may want to
         // rotate the image one more time.
         // The button will get moved when the mouse leaves.
         if (!d->mRotateLeftButton->underMouse() && !d->mRotateRightButton->underMouse()) {
             d->showContextBar(rect, thumbnailPix);
         }
         if (isModified) {
             // If we just rotated the image with the buttons from the
             // button frame, we need to show the save button frame right now.
             d->showSaveButton(rect);
         } else {
             d->mSaveButton->hide();
         }
     }
 
     QRect textRect(rect.left() + ITEM_MARGIN_DELEGATE,
                    rect.top() + 2 * ITEM_MARGIN_DELEGATE + thumbnailHeight,
                    rect.width() - 2 * ITEM_MARGIN_DELEGATE,
                    d->mView->fontMetrics().height());
     if (isDirOrArchive || (d->mDetails & PreviewItemDelegate::FileNameDetail)) {
         d->drawText(painter, textRect, fgColor, index.data().toString());
         textRect.moveTop(textRect.bottom());
     }
 
     if (!isDirOrArchive && (d->mDetails & PreviewItemDelegate::DateDetail)) {
         const QDateTime dt = TimeUtils::dateTimeForFileItem(fileItem);
         d->drawText(painter, textRect, fgColor, QLocale().toString(dt, QLocale::ShortFormat));
         textRect.moveTop(textRect.bottom());
     }
 
     if (!isDirOrArchive && (d->mDetails & PreviewItemDelegate::ImageSizeDetail)) {
         if (fullSize.isValid()) {
             const QString text = i18nc("@item:intable %1 is image width, %2 is image height", "%1x%2", fullSize.width(), fullSize.height());
             d->drawText(painter, textRect, fgColor, text);
             textRect.moveTop(textRect.bottom());
         }
     }
 
     if (!isDirOrArchive && (d->mDetails & PreviewItemDelegate::FileSizeDetail)) {
         const KIO::filesize_t size = fileItem.size();
         if (size > 0) {
             const QString st = KIO::convertSize(size);
             d->drawText(painter, textRect, fgColor, st);
             textRect.moveTop(textRect.bottom());
         }
     }
 
     if (!isDirOrArchive && (d->mDetails & PreviewItemDelegate::RatingDetail)) {
 #ifndef GWENVIEW_SEMANTICINFO_BACKEND_NONE
         d->drawRating(painter, rect, index.data(SemanticInfoDirModel::RatingRole));
 #endif
     }
 
 #ifdef DEBUG_DRAW_CURRENT
     if (d->mView->currentIndex() == index) {
         painter->fillRect(rect.left(), rect.top(), 12, 12, Qt::red);
     }
 #endif
 }
 
 void PreviewItemDelegate::setThumbnailSize(const QSize &value)
 {
     d->mThumbnailSize = value;
     d->updateViewGridSize();
     d->updateContextBar();
     d->mElidedTextCache.clear();
 }
 
 void PreviewItemDelegate::slotSaveClicked()
 {
     Q_EMIT saveDocumentRequested(urlForIndexThumbnailView(d->mIndexUnderCursor));
 }
 
 void PreviewItemDelegate::slotRotateLeftClicked()
 {
     d->selectIndexUnderCursorIfNoMultiSelection();
     Q_EMIT rotateDocumentLeftRequested(urlForIndexThumbnailView(d->mIndexUnderCursor));
 }
 
 void PreviewItemDelegate::slotRotateRightClicked()
 {
     d->selectIndexUnderCursorIfNoMultiSelection();
     Q_EMIT rotateDocumentRightRequested(urlForIndexThumbnailView(d->mIndexUnderCursor));
 }
 
 void PreviewItemDelegate::slotFullScreenClicked()
 {
     Q_EMIT showDocumentInFullScreenRequested(urlForIndexThumbnailView(d->mIndexUnderCursor));
 }
 
 void PreviewItemDelegate::slotToggleSelectionClicked()
 {
     d->mView->selectionModel()->select(d->mIndexUnderCursor, QItemSelectionModel::Toggle);
 }
 
 PreviewItemDelegate::ThumbnailDetails PreviewItemDelegate::thumbnailDetails() const
 {
     return d->mDetails;
 }
 
 void PreviewItemDelegate::setThumbnailDetails(PreviewItemDelegate::ThumbnailDetails details)
 {
     d->mDetails = details;
     d->updateViewGridSize();
     d->mView->scheduleDelayedItemsLayout();
 }
 
 PreviewItemDelegate::ContextBarActions PreviewItemDelegate::contextBarActions() const
 {
     return d->mContextBarActions;
 }
 
 void PreviewItemDelegate::setContextBarActions(PreviewItemDelegate::ContextBarActions actions)
 {
     d->mContextBarActions = actions;
     d->updateContextBar();
 }
 
 Qt::TextElideMode PreviewItemDelegate::textElideMode() const
 {
     return d->mTextElideMode;
 }
 
 void PreviewItemDelegate::setTextElideMode(Qt::TextElideMode mode)
 {
     if (d->mTextElideMode == mode) {
         return;
     }
     d->mTextElideMode = mode;
     d->mElidedTextCache.clear();
     d->mView->viewport()->update();
 }
 
 void PreviewItemDelegate::slotRowsChanged()
 {
     // We need to update hover ui because the current index may have
     // disappeared: for example if the current image is removed with "del".
     QPoint pos = d->mView->viewport()->mapFromGlobal(QCursor::pos());
     QModelIndex index = d->mView->indexAt(pos);
     d->updateHoverUi(index);
 }
 
 QWidget *PreviewItemDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem & /*option*/, const QModelIndex & /*index*/) const
 {
     return new ItemEditor(parent);
 }
 
 void PreviewItemDelegate::setEditorData(QWidget *widget, const QModelIndex &index) const
 {
     auto edit = qobject_cast<ItemEditor *>(widget);
     if (!edit) {
         return;
     }
     edit->setText(index.data().toString());
 }
 
 void PreviewItemDelegate::updateEditorGeometry(QWidget *widget, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     auto edit = qobject_cast<ItemEditor *>(widget);
     if (!edit) {
         return;
     }
     QString text = index.data().toString();
     int textWidth = edit->fontMetrics().boundingRect(QLatin1String("  ") + text + QLatin1String("  ")).width();
     QRect textRect(option.rect.left() + (option.rect.width() - textWidth) / 2,
                    option.rect.top() + 2 * ITEM_MARGIN_DELEGATE + d->mThumbnailSize.height(),
                    textWidth,
                    edit->sizeHint().height());
 
     edit->setGeometry(textRect);
 }
 
 void PreviewItemDelegate::setModelData(QWidget *widget, QAbstractItemModel *model, const QModelIndex &index) const
 {
     auto edit = qobject_cast<ItemEditor *>(widget);
     if (!edit) {
         return;
     }
     if (index.data().toString() != edit->text()) {
         model->setData(index, edit->text(), Qt::EditRole);
     }
 }
 
 } // namespace
 
 #include "moc_previewitemdelegate.cpp"