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

 // 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 "documentview.h"
 
 // C++ Standard library
 #include <cmath>
 
 // Qt
 #include <QApplication>
 #include <QDrag>
 #include <QGestureEvent>
 #include <QGraphicsLinearLayout>
 #include <QGraphicsOpacityEffect>
 #include <QGraphicsProxyWidget>
 #include <QGraphicsScene>
 #include <QGraphicsSceneMouseEvent>
 #include <QGraphicsSceneWheelEvent>
 #include <QGraphicsView>
 #include <QIcon>
 #include <QLibraryInfo>
 #include <QMimeData>
 #include <QPainter>
 #include <QPointer>
 #include <QPropertyAnimation>
 #include <QStyleHints>
 #include <QTimer>
 #include <QUrl>
 
 // KF
 #include <KFileItem>
 #include <KLocalizedString>
 #include <KUrlMimeData>
 
 // Local
 #include "gwenview_lib_debug.h"
 #include <lib/document/documentfactory.h>
 #include <lib/documentview/abstractrasterimageviewtool.h>
 #include <lib/documentview/birdeyeview.h>
 #include <lib/documentview/loadingindicator.h>
 #include <lib/documentview/messageviewadapter.h>
 #include <lib/documentview/rasterimageview.h>
 #include <lib/documentview/rasterimageviewadapter.h>
 #include <lib/documentview/svgviewadapter.h>
 #include <lib/documentview/videoviewadapter.h>
 #include <lib/graphicswidgetfloater.h>
 #include <lib/gvdebug.h>
 #include <lib/gwenviewconfig.h>
 #include <lib/hud/hudbutton.h>
 #include <lib/hud/hudwidget.h>
 #include <lib/mimetypeutils.h>
 #include <lib/thumbnailprovider/thumbnailprovider.h>
 #include <lib/thumbnailview/dragpixmapgenerator.h>
 #include <lib/touch/touch.h>
 #ifndef GWENVIEW_NO_WAYLAND_GESTURES
 #include <lib/waylandgestures/waylandgestures.h>
 #endif
 #include <lib/urlutils.h>
 #include <transformimageoperation.h>
 
 namespace Gwenview
 {
 #undef ENABLE_LOG
 #undef LOG
 // #define ENABLE_LOG
 #ifdef ENABLE_LOG
 #define LOG(x) // qCDebug(GWENVIEW_LIB_LOG) << x
 #else
 #define LOG(x) ;
 #endif
 
 static const qreal REAL_DELTA = 0.001;
 static const qreal MAXIMUM_ZOOM_VALUE = qreal(DocumentView::MaximumZoom);
 static const auto MINSTEP = sqrt(0.5);
 static const auto MAXSTEP = sqrt(2.0);
 
 static const int COMPARE_MARGIN = 4;
 
 const int DocumentView::MaximumZoom = 16;
 const int DocumentView::AnimDuration = 250;
 
 struct DocumentViewPrivate {
     DocumentView *q = nullptr;
     int mSortKey; // Used to sort views when displayed in compare mode
     HudWidget *mHud = nullptr;
     BirdEyeView *mBirdEyeView = nullptr;
     QPointer<QPropertyAnimation> mMoveAnimation;
     QPointer<QPropertyAnimation> mFadeAnimation;
     QGraphicsOpacityEffect *mOpacityEffect = nullptr;
 
     LoadingIndicator *mLoadingIndicator = nullptr;
     /** Delays showing the loading indicator. This is to avoid that we show a few annoying frames of
      * a loading indicator even though the loading might be pretty much instantaneous. */
     QTimer *mLoadingIndicatorDelay = nullptr;
 
     QScopedPointer<AbstractDocumentViewAdapter> mAdapter;
     QList<qreal> mZoomSnapValues;
     Document::Ptr mDocument;
     DocumentView::Setup mSetup;
     bool mCurrent;
     bool mCompareMode;
     int controlWheelAccumulatedDelta;
 
     QPointF mDragStartPosition;
     QPointer<ThumbnailProvider> mDragThumbnailProvider;
     QPointer<QDrag> mDrag;
 
     Touch *mTouch = nullptr;
 #ifndef GWENVIEW_NO_WAYLAND_GESTURES
     WaylandGestures *mWaylandGestures = nullptr;
 #endif
     int mMinTimeBetweenPinch;
 
     void setCurrentAdapter(AbstractDocumentViewAdapter *adapter)
     {
         Q_ASSERT(adapter);
         mAdapter.reset(adapter);
 
         adapter->widget()->setParentItem(q);
         resizeAdapterWidget();
 
         if (adapter->canZoom()) {
             QObject::connect(adapter, &AbstractDocumentViewAdapter::zoomChanged, q, &DocumentView::slotZoomChanged);
             QObject::connect(adapter, &AbstractDocumentViewAdapter::zoomInRequested, q, &DocumentView::zoomIn);
             QObject::connect(adapter, &AbstractDocumentViewAdapter::zoomOutRequested, q, &DocumentView::zoomOut);
             QObject::connect(adapter, &AbstractDocumentViewAdapter::zoomToFitChanged, q, &DocumentView::zoomToFitChanged);
             QObject::connect(adapter, &AbstractDocumentViewAdapter::zoomToFillChanged, q, &DocumentView::zoomToFillChanged);
         }
         QObject::connect(adapter, &AbstractDocumentViewAdapter::scrollPosChanged, q, &DocumentView::positionChanged);
         QObject::connect(adapter, &AbstractDocumentViewAdapter::previousImageRequested, q, &DocumentView::previousImageRequested);
         QObject::connect(adapter, &AbstractDocumentViewAdapter::nextImageRequested, q, &DocumentView::nextImageRequested);
         QObject::connect(adapter, &AbstractDocumentViewAdapter::toggleFullScreenRequested, q, &DocumentView::toggleFullScreenRequested);
         QObject::connect(adapter, &AbstractDocumentViewAdapter::completed, q, &DocumentView::slotCompleted);
 
         adapter->loadConfig();
 
         adapter->widget()->installSceneEventFilter(q);
         if (mCurrent) {
             adapter->widget()->setFocus();
         }
 
         if (mSetup.valid && adapter->canZoom()) {
             adapter->setZoomToFit(mSetup.zoomToFit);
             adapter->setZoomToFill(mSetup.zoomToFill);
             if (!mSetup.zoomToFit && !mSetup.zoomToFill) {
                 adapter->setZoom(mSetup.zoom);
                 adapter->setScrollPos(mSetup.position);
             }
         }
         Q_EMIT q->adapterChanged();
         Q_EMIT q->positionChanged();
         if (adapter->canZoom()) {
             if (adapter->zoomToFit()) {
                 Q_EMIT q->zoomToFitChanged(true);
             } else if (adapter->zoomToFill()) {
                 Q_EMIT q->zoomToFillChanged(true);
             } else {
                 Q_EMIT q->zoomChanged(adapter->zoom());
             }
         }
         if (adapter->rasterImageView()) {
             QObject::connect(adapter->rasterImageView(), &RasterImageView::currentToolChanged, q, &DocumentView::currentToolChanged);
         }
     }
 
     void setupLoadingIndicator()
     {
         mLoadingIndicator = new LoadingIndicator(q);
         auto floater = new GraphicsWidgetFloater(q);
         floater->setChildWidget(mLoadingIndicator);
         mLoadingIndicator->setZValue(1);
         mLoadingIndicator->hide();
 
         mLoadingIndicatorDelay = new QTimer(q);
         mLoadingIndicatorDelay->setSingleShot(true);
         QObject::connect(mLoadingIndicatorDelay, &QTimer::timeout, mLoadingIndicator, [this]() {
             mLoadingIndicator->show();
             Q_EMIT q->indicateLoadingToUser();
         });
     }
 
     HudButton *createHudButton(const QString &text, const QString &iconName, bool showText)
     {
         auto button = new HudButton;
         if (showText) {
             button->setText(text);
         } else {
             button->setToolTip(text);
         }
         button->setIcon(QIcon::fromTheme(iconName));
         return button;
     }
 
     void setupHud()
     {
         HudButton *trashButton = createHudButton(i18nc("@info:tooltip", "Trash"), QStringLiteral("user-trash"), false);
         HudButton *deselectButton = createHudButton(i18nc("@action:button", "Deselect"), QStringLiteral("list-remove"), true);
 
         auto content = new QGraphicsWidget;
         auto layout = new QGraphicsLinearLayout(content);
         layout->addItem(trashButton);
         layout->addItem(deselectButton);
 
         mHud = new HudWidget(q);
         mHud->init(content, HudWidget::OptionNone);
         auto floater = new GraphicsWidgetFloater(q);
         floater->setChildWidget(mHud);
         floater->setAlignment(Qt::AlignBottom | Qt::AlignHCenter);
 
         QObject::connect(trashButton, &HudButton::clicked, q, &DocumentView::emitHudTrashClicked);
         QObject::connect(deselectButton, &HudButton::clicked, q, &DocumentView::emitHudDeselectClicked);
 
         mHud->hide();
     }
 
     void setupBirdEyeView()
     {
         if (mBirdEyeView) {
             delete mBirdEyeView;
         }
         mBirdEyeView = new BirdEyeView(q);
         mBirdEyeView->setZValue(1);
     }
 
     void updateCaption()
     {
         if (!mCurrent) {
             return;
         }
         QString caption;
 
         Document::Ptr doc = mAdapter->document();
         if (!doc) {
             Q_EMIT q->captionUpdateRequested(caption);
             return;
         }
 
         caption = doc->url().fileName();
         QSize size = doc->size();
         if (size.isValid()) {
             caption += QStringLiteral(" - ");
             caption += i18nc("@item:intable %1 is image width, %2 is image height", "%1x%2", size.width(), size.height());
             if (mAdapter->canZoom()) {
                 int intZoom = qRound(mAdapter->zoom() * 100);
                 caption += QStringLiteral(" - ");
                 caption += i18nc("Percent value", "%1%", intZoom);
             }
         }
         Q_EMIT q->captionUpdateRequested(caption);
     }
 
     void uncheckZoomToFit()
     {
         if (mAdapter->zoomToFit()) {
             mAdapter->setZoomToFit(false);
         }
     }
 
     void uncheckZoomToFill()
     {
         if (mAdapter->zoomToFill()) {
             mAdapter->setZoomToFill(false);
         }
     }
 
     void setZoom(qreal zoom, const QPointF &center = QPointF(-1, -1))
     {
         uncheckZoomToFit();
         uncheckZoomToFill();
         zoom = qBound(q->minimumZoom(), zoom, MAXIMUM_ZOOM_VALUE);
         mAdapter->setZoom(zoom, center);
     }
 
     void updateZoomSnapValues()
     {
         const qreal min = q->minimumZoom();
 
         mZoomSnapValues.clear();
         for (qreal zoom = MINSTEP; zoom > min; zoom *= MINSTEP) {
             mZoomSnapValues << zoom;
         }
         mZoomSnapValues << min;
 
         std::reverse(mZoomSnapValues.begin(), mZoomSnapValues.end());
 
         for (qreal zoom = 1; zoom < MAXIMUM_ZOOM_VALUE; zoom *= MAXSTEP) {
             mZoomSnapValues << zoom;
         }
         mZoomSnapValues << MAXIMUM_ZOOM_VALUE;
 
         Q_EMIT q->minimumZoomChanged(min);
     }
 
     void showLoadingIndicator()
     {
         if (!mLoadingIndicator) {
             setupLoadingIndicator();
         }
         mLoadingIndicatorDelay->start(400);
     }
 
     void hideLoadingIndicator()
     {
         if (!mLoadingIndicator) {
             return;
         }
         mLoadingIndicatorDelay->stop();
         mLoadingIndicator->hide();
     }
 
     void resizeAdapterWidget()
     {
         QRectF rect = QRectF(QPointF(0, 0), q->boundingRect().size());
         if (mCompareMode) {
             rect.adjust(COMPARE_MARGIN, COMPARE_MARGIN, -COMPARE_MARGIN, -COMPARE_MARGIN);
         }
         mAdapter->widget()->setGeometry(rect);
     }
 
     void fadeTo(qreal value)
     {
         if (mFadeAnimation.data()) {
             qreal endValue = mFadeAnimation.data()->endValue().toReal();
             if (qFuzzyCompare(value, endValue)) {
                 // Same end value, don't change the actual animation
                 return;
             }
         }
         // Create a new fade animation
         auto anim = new QPropertyAnimation(mOpacityEffect, "opacity");
         anim->setStartValue(mOpacityEffect->opacity());
         anim->setEndValue(value);
         if (qFuzzyCompare(value, 1)) {
             QObject::connect(anim, &QAbstractAnimation::finished, q, &DocumentView::slotFadeInFinished);
         }
         QObject::connect(anim, &QAbstractAnimation::finished, q, &DocumentView::isAnimatedChanged);
         anim->setDuration(DocumentView::AnimDuration);
         mFadeAnimation = anim;
         Q_EMIT q->isAnimatedChanged();
         anim->start(QAbstractAnimation::DeleteWhenStopped);
     }
 
     bool canPan() const
     {
         if (!q->canZoom()) {
             return false;
         }
 
         const QSize zoomedImageSize = mDocument->size() * q->zoom();
         const QSize viewPortSize = q->boundingRect().size().toSize();
         const bool imageWiderThanViewport = zoomedImageSize.width() > viewPortSize.width();
         const bool imageTallerThanViewport = zoomedImageSize.height() > viewPortSize.height();
         return (imageWiderThanViewport || imageTallerThanViewport);
     }
 
     void setDragPixmap(const QPixmap &pix)
     {
         if (mDrag) {
             DragPixmapGenerator::DragPixmap dragPixmap = DragPixmapGenerator::generate({pix}, 1);
             mDrag->setPixmap(dragPixmap.pix);
             mDrag->setHotSpot(dragPixmap.hotSpot);
         }
     }
 
     void executeDrag()
     {
         if (mDrag) {
             if (mAdapter->imageView()) {
                 mAdapter->imageView()->resetDragCursor();
             }
             mDrag->exec(Qt::MoveAction | Qt::CopyAction | Qt::LinkAction, Qt::CopyAction);
         }
     }
 
     void initDragThumbnailProvider()
     {
         mDragThumbnailProvider = new ThumbnailProvider();
         QObject::connect(mDragThumbnailProvider, &ThumbnailProvider::thumbnailLoaded, q, &DocumentView::dragThumbnailLoaded);
         QObject::connect(mDragThumbnailProvider, &ThumbnailProvider::thumbnailLoadingFailed, q, &DocumentView::dragThumbnailLoadingFailed);
     }
 
     void startDragIfSensible()
     {
         if (q->document()->loadingState() == Document::LoadingFailed) {
             return;
         }
 
         if (q->currentTool()) {
             return;
         }
 
         if (mDrag) {
             mDrag->deleteLater();
         }
         mDrag = new QDrag(q);
         const auto itemList = KFileItemList({KFileItem(q->document()->url())});
         auto *mimeData = MimeTypeUtils::selectionMimeData(itemList, MimeTypeUtils::DropTarget);
         KUrlMimeData::exportUrlsToPortal(mimeData);
         mDrag->setMimeData(mimeData);
 
         if (q->document()->isModified()) {
             setDragPixmap(QPixmap::fromImage(q->document()->image()));
             executeDrag();
         } else {
             // Drag is triggered on success or failure of thumbnail generation
             if (mDragThumbnailProvider.isNull()) {
                 initDragThumbnailProvider();
             }
             mDragThumbnailProvider->appendItems(itemList);
         }
     }
 
     QPointF cursorPosition()
     {
         const QGraphicsScene *sc = q->scene();
         if (sc) {
             const auto views = sc->views();
             for (const QGraphicsView *view : views) {
                 if (view->underMouse()) {
                     return q->mapFromScene(view->mapFromGlobal(QCursor::pos()));
                 }
             }
         }
         return QPointF(-1, -1);
     }
 };
 
 DocumentView::DocumentView(QGraphicsScene *scene)
     : d(new DocumentViewPrivate)
 {
     setFlag(ItemIsFocusable);
     setFlag(ItemIsSelectable);
     setFlag(ItemClipsChildrenToShape);
 
     d->q = this;
     d->mLoadingIndicator = nullptr;
     d->mBirdEyeView = nullptr;
     d->mCurrent = false;
     d->mCompareMode = false;
     d->controlWheelAccumulatedDelta = 0;
     d->mDragStartPosition = QPointF(0, 0);
     d->mDrag = nullptr;
 
 #ifndef GWENVIEW_NO_WAYLAND_GESTURES
     if (QApplication::platformName() == QStringLiteral("wayland")) {
         d->mWaylandGestures = new WaylandGestures();
         connect(d->mWaylandGestures, &WaylandGestures::pinchGestureStarted, [this]() {
             d->mWaylandGestures->setStartZoom(zoom());
         });
         connect(d->mWaylandGestures, &WaylandGestures::pinchZoomChanged, [this](double zoom) {
             d->setZoom(zoom, d->cursorPosition());
         });
     }
 #endif
 
     d->mTouch = new Touch(this);
     setAcceptTouchEvents(true);
     connect(d->mTouch, &Touch::doubleTapTriggered, this, &DocumentView::toggleFullScreenRequested);
     connect(d->mTouch, &Touch::twoFingerTapTriggered, this, &DocumentView::contextMenuRequested);
     connect(d->mTouch, &Touch::pinchGestureStarted, this, &DocumentView::setPinchParameter);
     connect(d->mTouch, &Touch::pinchZoomTriggered, this, &DocumentView::zoomGesture);
     connect(d->mTouch, &Touch::pinchRotateTriggered, this, &DocumentView::rotationsGesture);
     connect(d->mTouch, &Touch::swipeRightTriggered, this, &DocumentView::swipeRight);
     connect(d->mTouch, &Touch::swipeLeftTriggered, this, &DocumentView::swipeLeft);
     connect(d->mTouch, &Touch::PanTriggered, this, &DocumentView::panGesture);
     connect(d->mTouch, &Touch::tapHoldAndMovingTriggered, this, &DocumentView::startDragFromTouch);
 
     // We use an opacity effect instead of using the opacity property directly, because the latter operates at
     // the painter level, which means if you draw multiple layers in paint(), all layers get the specified
     // opacity, resulting in all layers being visible when 0 < opacity < 1.
     // QGraphicsEffects on the other hand, operate after all painting is done, therefore 'flattening' all layers.
     // This is important for fade effects, where we don't want any background layers visible during the fade.
     d->mOpacityEffect = new QGraphicsOpacityEffect(this);
     d->mOpacityEffect->setOpacity(0);
 
     // QTBUG-74963. QGraphicsOpacityEffect cause painting an image as non-highdpi.
     if (qFuzzyCompare(qApp->devicePixelRatio(), 1.0) || QLibraryInfo::version() >= QVersionNumber(5, 12, 4))
         setGraphicsEffect(d->mOpacityEffect);
 
     scene->addItem(this);
 
     d->setupHud();
     d->setCurrentAdapter(new EmptyAdapter);
 
     setAcceptDrops(true);
 
     connect(DocumentFactory::instance(), &DocumentFactory::documentChanged, this, [this]() {
         d->updateCaption();
     });
 }
 
 DocumentView::~DocumentView()
 {
     delete d->mTouch;
 #ifndef GWENVIEW_NO_WAYLAND_GESTURES
     delete d->mWaylandGestures;
 #endif
     delete d->mDragThumbnailProvider;
     delete d->mDrag;
     delete d;
 }
 
 void DocumentView::createAdapterForDocument()
 {
     const MimeTypeUtils::Kind documentKind = d->mDocument->kind();
     if (d->mAdapter && documentKind == d->mAdapter->kind() && documentKind != MimeTypeUtils::KIND_UNKNOWN) {
         // Do not reuse for KIND_UNKNOWN: we may need to change the message
         LOG("Reusing current adapter");
         return;
     }
     AbstractDocumentViewAdapter *adapter = nullptr;
     switch (documentKind) {
     case MimeTypeUtils::KIND_RASTER_IMAGE:
         adapter = new RasterImageViewAdapter;
         break;
     case MimeTypeUtils::KIND_SVG_IMAGE:
         adapter = new SvgViewAdapter;
         break;
     case MimeTypeUtils::KIND_VIDEO:
         adapter = new VideoViewAdapter;
         connect(adapter, SIGNAL(videoFinished()), SIGNAL(videoFinished()));
         break;
     case MimeTypeUtils::KIND_UNKNOWN:
         adapter = new MessageViewAdapter;
         static_cast<MessageViewAdapter *>(adapter)->setErrorMessage(i18n("Gwenview does not know how to display this kind of document"));
         break;
     default:
         qCWarning(GWENVIEW_LIB_LOG) << "should not be called for documentKind=" << documentKind;
         adapter = new MessageViewAdapter;
         break;
     }
 
     d->setCurrentAdapter(adapter);
 }
 
 void DocumentView::openUrl(const QUrl &url, const DocumentView::Setup &setup)
 {
     if (d->mDocument) {
         if (url == d->mDocument->url()) {
             return;
         }
         disconnect(d->mDocument.data(), nullptr, this, nullptr);
     }
 
     // because some loading will be going on right now, also display the indicator after a small delay
     // it will be hidden again in slotBusyChanged()
     d->showLoadingIndicator();
 
     d->mSetup = setup;
     d->mDocument = DocumentFactory::instance()->load(url);
     connect(d->mDocument.data(), &Document::busyChanged, this, &DocumentView::slotBusyChanged);
     connect(d->mDocument.data(), &Document::modified, this, [this]() {
         d->updateZoomSnapValues();
     });
 
     if (d->mDocument->loadingState() < Document::KindDetermined) {
         auto messageViewAdapter = qobject_cast<MessageViewAdapter *>(d->mAdapter.data());
         if (messageViewAdapter) {
             messageViewAdapter->setInfoMessage(QString());
         }
         connect(d->mDocument.data(), &Document::kindDetermined, this, &DocumentView::finishOpenUrl);
     } else {
         QMetaObject::invokeMethod(this, &DocumentView::finishOpenUrl, Qt::QueuedConnection);
     }
 
     if (GwenviewConfig::birdEyeViewEnabled()) {
         d->setupBirdEyeView();
     }
 }
 
 void DocumentView::finishOpenUrl()
 {
     disconnect(d->mDocument.data(), &Document::kindDetermined, this, &DocumentView::finishOpenUrl);
     GV_RETURN_IF_FAIL(d->mDocument->loadingState() >= Document::KindDetermined);
 
     if (d->mDocument->loadingState() == Document::LoadingFailed) {
         slotLoadingFailed();
         return;
     }
     createAdapterForDocument();
 
     connect(d->mDocument.data(), &Document::loadingFailed, this, &DocumentView::slotLoadingFailed);
     d->mAdapter->setDocument(d->mDocument);
     d->updateCaption();
 }
 
 void DocumentView::loadAdapterConfig()
 {
     d->mAdapter->loadConfig();
 }
 
 RasterImageView *DocumentView::imageView() const
 {
     return d->mAdapter->rasterImageView();
 }
 
 void DocumentView::slotCompleted()
 {
     d->hideLoadingIndicator();
     d->updateCaption();
     d->updateZoomSnapValues();
     if (!d->mAdapter->zoomToFit() || !d->mAdapter->zoomToFill()) {
         qreal min = minimumZoom();
         if (d->mAdapter->zoom() < min) {
             d->mAdapter->setZoom(min);
         }
     }
     Q_EMIT completed();
 }
 
 DocumentView::Setup DocumentView::setup() const
 {
     Setup setup;
     if (d->mAdapter->canZoom()) {
         setup.valid = true;
         setup.zoomToFit = zoomToFit();
         setup.zoomToFill = zoomToFill();
         if (!setup.zoomToFit && !setup.zoomToFill) {
             setup.zoom = zoom();
             setup.position = position();
         }
     }
     return setup;
 }
 
 void DocumentView::slotLoadingFailed()
 {
     d->hideLoadingIndicator();
     auto adapter = new MessageViewAdapter;
     adapter->setDocument(d->mDocument);
     QString message = xi18n("Loading <filename>%1</filename> failed", d->mDocument->url().fileName());
     adapter->setErrorMessage(message, d->mDocument->errorString());
     d->setCurrentAdapter(adapter);
     Q_EMIT completed();
 }
 
 bool DocumentView::canZoom() const
 {
     return d->mAdapter->canZoom();
 }
 
 void DocumentView::setZoomToFit(bool on)
 {
     if (on == d->mAdapter->zoomToFit()) {
         return;
     }
     d->mAdapter->setZoomToFit(on);
 }
 
 void DocumentView::toggleZoomToFit()
 {
     const bool zoomToFitOn = d->mAdapter->zoomToFit();
     d->mAdapter->setZoomToFit(!zoomToFitOn);
     if (zoomToFitOn) {
         d->setZoom(1., d->cursorPosition());
     }
 }
 
 void DocumentView::setZoomToFill(bool on)
 {
     if (on == d->mAdapter->zoomToFill()) {
         return;
     }
     d->mAdapter->setZoomToFill(on, d->cursorPosition());
 }
 
 void DocumentView::toggleZoomToFill()
 {
     const bool zoomToFillOn = d->mAdapter->zoomToFill();
     d->mAdapter->setZoomToFill(!zoomToFillOn, d->cursorPosition());
     if (zoomToFillOn) {
         d->setZoom(1., d->cursorPosition());
     }
 }
 
 void DocumentView::toggleBirdEyeView()
 {
     if (d->mBirdEyeView) {
         BirdEyeView *tmp = d->mBirdEyeView;
         d->mBirdEyeView = nullptr;
         delete tmp;
     } else {
         d->setupBirdEyeView();
     }
 
     GwenviewConfig::setBirdEyeViewEnabled(!GwenviewConfig::birdEyeViewEnabled());
 }
 
 void DocumentView::setBackgroundColorMode(BackgroundColorMode colorMode)
 {
     GwenviewConfig::setBackgroundColorMode(colorMode);
     Q_EMIT backgroundColorModeChanged(colorMode);
 }
 
 bool DocumentView::zoomToFit() const
 {
     return d->mAdapter->zoomToFit();
 }
 
 bool DocumentView::zoomToFill() const
 {
     return d->mAdapter->zoomToFill();
 }
 
 void DocumentView::zoomActualSize()
 {
     d->uncheckZoomToFit();
     d->uncheckZoomToFill();
     d->mAdapter->setZoom(1., d->cursorPosition());
 }
 
 void DocumentView::zoomIn(QPointF center)
 {
     if (center == QPointF(-1, -1)) {
         center = d->cursorPosition();
     }
     qreal currentZoom = d->mAdapter->zoom();
 
     for (qreal zoom : qAsConst(d->mZoomSnapValues)) {
         if (zoom > currentZoom + REAL_DELTA) {
             d->setZoom(zoom, center);
             return;
         }
     }
 }
 
 void DocumentView::zoomContinuous(int delta, QPointF center)
 {
     if (center == QPointF(-1, -1)) {
         center = d->cursorPosition();
     }
     const qreal currentZoom = d->mAdapter->zoom();
 
     // multiplies by sqrt(2) for every mouse wheel step
     const qreal newZoom = currentZoom * pow(2, 0.5 * float(delta) / QWheelEvent::DefaultDeltasPerStep);
     d->setZoom(newZoom, center);
     return;
 }
 
 void DocumentView::zoomOut(QPointF center)
 {
     if (center == QPointF(-1, -1)) {
         center = d->cursorPosition();
     }
     qreal currentZoom = d->mAdapter->zoom();
 
     QListIterator<qreal> it(d->mZoomSnapValues);
     it.toBack();
     while (it.hasPrevious()) {
         qreal zoom = it.previous();
         if (zoom < currentZoom - REAL_DELTA) {
             d->setZoom(zoom, center);
             return;
         }
     }
 }
 
 void DocumentView::slotZoomChanged(qreal zoom)
 {
     d->updateCaption();
     Q_EMIT zoomChanged(zoom);
 }
 
 void DocumentView::setZoom(qreal zoom)
 {
     d->setZoom(zoom);
 }
 
 qreal DocumentView::zoom() const
 {
     return d->mAdapter->zoom();
 }
 
 void DocumentView::setPinchParameter(qint64 timeStamp)
 {
     Q_UNUSED(timeStamp);
     const qreal sensitivityModifier = 0.85;
     const qreal rotationThreshold = 40;
     d->mTouch->setZoomParameter(sensitivityModifier, zoom());
     d->mTouch->setRotationThreshold(rotationThreshold);
     d->mMinTimeBetweenPinch = 0;
 }
 
 void DocumentView::zoomGesture(qreal zoom, const QPoint &zoomCenter, qint64 timeStamp)
 {
     qint64 now = QDateTime::currentMSecsSinceEpoch();
     const qint64 diff = now - timeStamp;
 
     // in Wayland we can get the gesture event more frequently, to reduce CPU power we don't use every event
     // to calculate and paint a new image (mMinTimeBetweenPinch).To determine the exact minimum waiting time between two
     // pinch events, we use the difference between the time stamps. If the difference is too high we increase the minimum waiting time.
     // The maximal waiting time is 40 milliseconds, this is equal to 25 frames per second.
     if (diff > 40) {
         d->mMinTimeBetweenPinch = (d->mMinTimeBetweenPinch * 2) + 1;
         if (d->mMinTimeBetweenPinch > 40) {
             d->mMinTimeBetweenPinch = 40;
         }
     }
 
     if (diff > d->mMinTimeBetweenPinch) {
         if (zoom >= 0.0 && d->mAdapter->canZoom()) {
             d->setZoom(zoom, zoomCenter);
         }
     }
 }
 
 void DocumentView::rotationsGesture(qreal rotation)
 {
     if (rotation > 0.0) {
         auto op = new TransformImageOperation(ROT_90);
         op->applyToDocument(d->mDocument);
     } else if (rotation < 0.0) {
         auto op = new TransformImageOperation(ROT_270);
         op->applyToDocument(d->mDocument);
     }
 }
 
 void DocumentView::swipeRight()
 {
     const QPoint scrollPos = d->mAdapter->scrollPos().toPoint();
     if (scrollPos.x() <= 1) {
         Q_EMIT d->mAdapter->previousImageRequested();
     }
 }
 
 void DocumentView::swipeLeft()
 {
     const QSizeF dipSize = d->mAdapter->imageView()->dipDocumentSize();
     const QPoint scrollPos = d->mAdapter->scrollPos().toPoint();
     const int width = dipSize.width() * d->mAdapter->zoom();
     const QRect visibleRect = d->mAdapter->visibleDocumentRect().toRect();
     const int x = scrollPos.x() + visibleRect.width();
     if (x >= (width - 1)) {
         Q_EMIT d->mAdapter->nextImageRequested();
     }
 }
 
 void DocumentView::panGesture(const QPointF &delta)
 {
     d->mAdapter->setScrollPos(d->mAdapter->scrollPos() + delta);
 }
 
 void DocumentView::startDragFromTouch(const QPoint &)
 {
     d->startDragIfSensible();
 }
 
 void DocumentView::resizeEvent(QGraphicsSceneResizeEvent *event)
 {
     d->resizeAdapterWidget();
     d->updateZoomSnapValues();
     QGraphicsWidget::resizeEvent(event);
 }
 
 void DocumentView::mousePressEvent(QGraphicsSceneMouseEvent *event)
 {
     // Don't let (presumably double click handling in) the superclass swallow the second of two
     // quickly following middle/side clicks, preventing fast toggle & navigation. We wouldn't even
     // get a double click event - handling that could be somewhat cleaner.
     if (d->mAdapter->canZoom() && event->button() == Qt::MiddleButton) {
         if (event->modifiers() == Qt::NoModifier) {
             event->accept();
             toggleZoomToFit();
             return;
         } else if (event->modifiers() == Qt::SHIFT) {
             event->accept();
             toggleZoomToFill();
             return;
         }
     }
     else if (event->button() == Qt::BackButton) {
         event->accept();
         Q_EMIT previousImageRequested();
         return;
     }
     else if (event->button() == Qt::ForwardButton) {
         event->accept();
         Q_EMIT nextImageRequested();
         return;
     }
 
     QGraphicsWidget::mousePressEvent(event);
 }
 
 void DocumentView::wheelEvent(QGraphicsSceneWheelEvent *event)
 {
     if (d->mAdapter->canZoom()) {
         if ((event->modifiers() & Qt::ControlModifier)
             || (GwenviewConfig::mouseWheelBehavior() == MouseWheelBehavior::Zoom && event->modifiers() == Qt::NoModifier)) {
             zoomContinuous(event->delta(), event->pos());
             // Ctrl + wheel => zoom in or out
             return;
         }
     }
     if (GwenviewConfig::mouseWheelBehavior() == MouseWheelBehavior::Browse && event->modifiers() == Qt::NoModifier) {
         d->controlWheelAccumulatedDelta += event->delta();
         // Browse with mouse wheel
         if (d->controlWheelAccumulatedDelta >= QWheelEvent::DefaultDeltasPerStep) {
             Q_EMIT previousImageRequested();
             d->controlWheelAccumulatedDelta = 0;
         } else if (d->controlWheelAccumulatedDelta <= -QWheelEvent::DefaultDeltasPerStep) {
             Q_EMIT nextImageRequested();
             d->controlWheelAccumulatedDelta = 0;
         }
         return;
     }
     // Scroll
     qreal dx = 0;
     // 16 = pixels for one line
     // 120: see QWheelEvent::angleDelta().y() doc
     qreal dy = -qApp->wheelScrollLines() * 16 * event->delta() / 120;
     if (event->orientation() == Qt::Horizontal) {
         std::swap(dx, dy);
     }
     d->mAdapter->setScrollPos(d->mAdapter->scrollPos() + QPointF(dx, dy));
 }
 
 void DocumentView::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
 {
     // Filter out context menu if Ctrl is down to avoid showing it when
     // zooming out with Ctrl + Right button
     if (event->modifiers() != Qt::ControlModifier) {
         Q_EMIT contextMenuRequested();
     }
 }
 
 void DocumentView::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/)
 {
     // Fill background manually, because setAutoFillBackground(true) fill with QPalette::Window,
     // but our palettes use QPalette::Base for the background color/texture
     painter->fillRect(rect(), palette().base());
 
     // Selection indicator/highlight
     if (d->mCompareMode && d->mCurrent) {
         painter->save();
         painter->setBrush(Qt::NoBrush);
         painter->setPen(QPen(palette().highlight().color(), 2));
         painter->setRenderHint(QPainter::Antialiasing);
         const QRectF visibleRectF = mapRectFromItem(d->mAdapter->widget(), d->mAdapter->visibleDocumentRect());
         // Round the point and size independently. This is different than calling toRect(),
         // and is necessary to keep consistent rects, otherwise the selection rect can be
         // drawn 1 pixel too big or small.
         const QRect visibleRect = QRect(visibleRectF.topLeft().toPoint(), visibleRectF.size().toSize());
         const QRect selectionRect = visibleRect.adjusted(-1, -1, 1, 1);
         painter->drawRoundedRect(selectionRect, 3, 3);
         painter->restore();
     }
 }
 
 void DocumentView::slotBusyChanged(const QUrl &, bool busy)
 {
     if (busy) {
         d->showLoadingIndicator();
     } else {
         d->hideLoadingIndicator();
     }
 }
 
 qreal DocumentView::minimumZoom() const
 {
     // There is no point zooming out less than zoomToFit, but make sure it does
     // not get too small either
     return qBound(qreal(0.001), d->mAdapter->computeZoomToFit(), qreal(1.));
 }
 
 void DocumentView::setCompareMode(bool compare)
 {
     d->mCompareMode = compare;
     if (compare) {
         d->mHud->show();
         d->mHud->setZValue(1);
     } else {
         d->mHud->hide();
     }
 }
 
 void DocumentView::setCurrent(bool value)
 {
     d->mCurrent = value;
     if (value) {
         d->mAdapter->widget()->setFocus();
         d->updateCaption();
     }
     update();
 }
 
 bool DocumentView::isCurrent() const
 {
     return d->mCurrent;
 }
 
 QPoint DocumentView::position() const
 {
     return d->mAdapter->scrollPos().toPoint();
 }
 
 void DocumentView::setPosition(const QPoint &pos)
 {
     d->mAdapter->setScrollPos(pos);
 }
 
 Document::Ptr DocumentView::document() const
 {
     return d->mDocument;
 }
 
 QUrl DocumentView::url() const
 {
     Document::Ptr doc = d->mDocument;
     return doc ? doc->url() : QUrl();
 }
 
 void DocumentView::emitHudDeselectClicked()
 {
     Q_EMIT hudDeselectClicked(this);
 }
 
 void DocumentView::emitHudTrashClicked()
 {
     Q_EMIT hudTrashClicked(this);
 }
 
 void DocumentView::emitFocused()
 {
     Q_EMIT focused(this);
 }
 
 void DocumentView::setGeometry(const QRectF &rect)
 {
     QGraphicsWidget::setGeometry(rect);
     if (d->mBirdEyeView) {
         d->mBirdEyeView->slotZoomOrSizeChanged();
     }
 }
 
 void DocumentView::moveTo(const QRect &rect)
 {
     if (d->mMoveAnimation) {
         d->mMoveAnimation.data()->setEndValue(rect);
     } else {
         setGeometry(rect);
     }
 }
 
 void DocumentView::moveToAnimated(const QRect &rect)
 {
     auto anim = new QPropertyAnimation(this, "geometry");
     anim->setStartValue(geometry());
     anim->setEndValue(rect);
     anim->setDuration(DocumentView::AnimDuration);
     connect(anim, &QAbstractAnimation::finished, this, &DocumentView::isAnimatedChanged);
     d->mMoveAnimation = anim;
     Q_EMIT isAnimatedChanged();
     anim->start(QAbstractAnimation::DeleteWhenStopped);
 }
 
 QPropertyAnimation *DocumentView::fadeIn()
 {
     d->fadeTo(1);
     return d->mFadeAnimation.data();
 }
 
 void DocumentView::fadeOut()
 {
     d->fadeTo(0);
 }
 
 void DocumentView::slotFadeInFinished()
 {
     Q_EMIT fadeInFinished(this);
 }
 
 bool DocumentView::isAnimated() const
 {
     return d->mMoveAnimation || d->mFadeAnimation;
 }
 
 bool DocumentView::sceneEventFilter(QGraphicsItem *, QEvent *event)
 {
     if (event->type() == QEvent::GraphicsSceneMousePress) {
         const QGraphicsSceneMouseEvent *mouseEvent = static_cast<QGraphicsSceneMouseEvent *>(event);
         if (mouseEvent->button() == Qt::LeftButton) {
             d->mDragStartPosition = mouseEvent->pos();
         }
         QMetaObject::invokeMethod(this, &DocumentView::emitFocused, Qt::QueuedConnection);
     } else if (event->type() == QEvent::GraphicsSceneHoverMove) {
         if (d->mBirdEyeView) {
             d->mBirdEyeView->onMouseMoved();
         }
     } else if (event->type() == QEvent::GraphicsSceneMouseMove) {
         const QGraphicsSceneMouseEvent *mouseEvent = static_cast<QGraphicsSceneMouseEvent *>(event);
         // in some older version of Qt, Qt synthesize a mouse event from the touch event
         // we need to suppress this.
         // I need this for my working system (OpenSUSE Leap 15.0, Qt 5.9.4)
         if (mouseEvent->source() == Qt::MouseEventSynthesizedByQt) {
             return true;
         }
         // We need to check if the Left mouse button is pressed, otherwise this can lead
         // to starting a drag & drop sequence using the Forward/Backward mouse buttons
         if (!mouseEvent->buttons().testFlag(Qt::LeftButton)) {
             return false;
         }
         const qreal dragDistance = (mouseEvent->pos() - d->mDragStartPosition).manhattanLength();
         const qreal minDistanceToStartDrag = QGuiApplication::styleHints()->startDragDistance();
         if (!d->canPan() && dragDistance >= minDistanceToStartDrag) {
             d->startDragIfSensible();
         }
     }
     return false;
 }
 
 AbstractRasterImageViewTool *DocumentView::currentTool() const
 {
     return imageView() ? imageView()->currentTool() : nullptr;
 }
 
 int DocumentView::sortKey() const
 {
     return d->mSortKey;
 }
 
 void DocumentView::setSortKey(int sortKey)
 {
     d->mSortKey = sortKey;
 }
 
 void DocumentView::hideAndDeleteLater()
 {
     hide();
     deleteLater();
 }
 
 void DocumentView::setGraphicsEffectOpacity(qreal opacity)
 {
     d->mOpacityEffect->setOpacity(opacity);
 }
 
 void DocumentView::dragEnterEvent(QGraphicsSceneDragDropEvent *event)
 {
     QGraphicsWidget::dragEnterEvent(event);
 
     const auto urls = KUrlMimeData::urlsFromMimeData(event->mimeData());
     bool acceptDrag = !urls.isEmpty();
     if (urls.size() == 1 && urls.first() == url()) {
         // Do not allow dragging a single image onto itself
         acceptDrag = false;
     }
     event->setAccepted(acceptDrag);
 }
 
 void DocumentView::dropEvent(QGraphicsSceneDragDropEvent *event)
 {
     QGraphicsWidget::dropEvent(event);
     // Since we're capturing drops in View mode, we only support one url
     const QUrl url = KUrlMimeData::urlsFromMimeData(event->mimeData()).first();
     if (UrlUtils::urlIsDirectory(url)) {
         Q_EMIT openDirUrlRequested(url);
     } else {
         Q_EMIT openUrlRequested(url);
     }
 }
 
 void DocumentView::dragThumbnailLoaded(const KFileItem &item, const QPixmap &pix)
 {
     d->setDragPixmap(pix);
     d->executeDrag();
     d->mDragThumbnailProvider->removeItems(KFileItemList({item}));
 }
 
 void DocumentView::dragThumbnailLoadingFailed(const KFileItem &item)
 {
     d->executeDrag();
     d->mDragThumbnailProvider->removeItems(KFileItemList({item}));
 }
 
 } // namespace
 
 #include "moc_documentview.cpp"