diff --git a/lib/documentview/documentview.cpp b/lib/documentview/documentview.cpp
index 8022d76f..8fd8447f 100644
--- a/lib/documentview/documentview.cpp
+++ b/lib/documentview/documentview.cpp
@@ -1,823 +1,827 @@
 // 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 <QGraphicsLinearLayout>
 #include <QGraphicsProxyWidget>
 #include <QGraphicsScene>
 #include <QGraphicsSceneMouseEvent>
 #include <QGraphicsSceneWheelEvent>
 #include <QGraphicsOpacityEffect>
 #include <QPainter>
 #include <QPropertyAnimation>
 #include <QPointer>
 #include <QDebug>
 #include <QIcon>
 #include <QUrl>
 
 // KDE
 #include <KLocalizedString>
 
 // Local
 #include <lib/document/document.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/hud/hudbutton.h>
 #include <lib/hud/hudwidget.h>
 #include <lib/graphicswidgetfloater.h>
 #include <lib/gvdebug.h>
 #include <lib/gwenviewconfig.h>
 #include <lib/mimetypeutils.h>
 #include <lib/signalblocker.h>
 
 namespace Gwenview
 {
 
 #undef ENABLE_LOG
 #undef LOG
 //#define ENABLE_LOG
 #ifdef ENABLE_LOG
 #define LOG(x) //qDebug() << 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;
     int mSortKey; // Used to sort views when displayed in compare mode
     HudWidget* mHud;
     BirdEyeView* mBirdEyeView;
     QPointer<QPropertyAnimation> mMoveAnimation;
     QPointer<QPropertyAnimation> mFadeAnimation;
     QGraphicsOpacityEffect* mOpacityEffect;
 
     LoadingIndicator* mLoadingIndicator;
 
     QScopedPointer<AbstractDocumentViewAdapter> mAdapter;
     QList<qreal> mZoomSnapValues;
     Document::Ptr mDocument;
     DocumentView::Setup mSetup;
     bool mCurrent;
     bool mCompareMode;
     int controlWheelAccumulatedDelta;
 
     void setCurrentAdapter(AbstractDocumentViewAdapter* adapter)
     {
         Q_ASSERT(adapter);
         mAdapter.reset(adapter);
 
         adapter->widget()->setParentItem(q);
         resizeAdapterWidget();
 
         if (adapter->canZoom()) {
             QObject::connect(adapter, SIGNAL(zoomChanged(qreal)),
                              q, SLOT(slotZoomChanged(qreal)));
             QObject::connect(adapter, SIGNAL(zoomInRequested(QPointF)),
                              q, SLOT(zoomIn(QPointF)));
             QObject::connect(adapter, SIGNAL(zoomOutRequested(QPointF)),
                              q, SLOT(zoomOut(QPointF)));
             QObject::connect(adapter, SIGNAL(zoomToFitChanged(bool)),
                              q, SIGNAL(zoomToFitChanged(bool)));
             QObject::connect(adapter, SIGNAL(zoomToFillChanged(bool)),
                              q, SIGNAL(zoomToFillChanged(bool)));
         }
         QObject::connect(adapter, SIGNAL(scrollPosChanged()),
                          q, SIGNAL(positionChanged()));
         QObject::connect(adapter, SIGNAL(previousImageRequested()),
                          q, SIGNAL(previousImageRequested()));
         QObject::connect(adapter, SIGNAL(nextImageRequested()),
                          q, SIGNAL(nextImageRequested()));
         QObject::connect(adapter, SIGNAL(toggleFullScreenRequested()),
                          q, SIGNAL(toggleFullScreenRequested()));
         QObject::connect(adapter, SIGNAL(completed()),
                          q, SLOT(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->adapterChanged();
         q->positionChanged();
         if (adapter->canZoom()) {
             if (adapter->zoomToFit()) {
                 q->zoomToFitChanged(true);
             } else if (adapter->zoomToFill()) {
                 q->zoomToFillChanged(true);
             } else {
                 q->zoomChanged(adapter->zoom());
             }
         }
         if (adapter->rasterImageView()) {
             QObject::connect(adapter->rasterImageView(), SIGNAL(currentToolChanged(AbstractRasterImageViewTool*)),
                              q, SIGNAL(currentToolChanged(AbstractRasterImageViewTool*)));
         }
     }
 
     void setupLoadingIndicator()
     {
         mLoadingIndicator = new LoadingIndicator(q);
         GraphicsWidgetFloater* floater = new GraphicsWidgetFloater(q);
         floater->setChildWidget(mLoadingIndicator);
     }
 
     HudButton* createHudButton(const QString& text, const char* iconName, bool showText)
     {
         HudButton* 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"), "user-trash", false);
         HudButton* deselectButton = createHudButton(i18nc("@action:button", "Deselect"), "list-remove", true);
 
         QGraphicsWidget* content = new QGraphicsWidget;
         QGraphicsLinearLayout* layout = new QGraphicsLinearLayout(content);
         layout->addItem(trashButton);
         layout->addItem(deselectButton);
 
         mHud = new HudWidget(q);
         mHud->init(content, HudWidget::OptionNone);
         GraphicsWidgetFloater* floater = new GraphicsWidgetFloater(q);
         floater->setChildWidget(mHud);
         floater->setAlignment(Qt::AlignBottom | Qt::AlignHCenter);
 
         QObject::connect(trashButton, SIGNAL(clicked()), q, SLOT(emitHudTrashClicked()));
         QObject::connect(deselectButton, SIGNAL(clicked()), q, SLOT(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) {
             emit q->captionUpdateRequested(caption);
             return;
         }
 
         caption = doc->url().fileName();
         QSize size = doc->size();
         if (size.isValid()) {
             caption +=
                 QString(" - %1x%2")
                 .arg(size.width())
                 .arg(size.height());
             if (mAdapter->canZoom()) {
                 int intZoom = qRound(mAdapter->zoom() * 100);
                 caption += QString(" - %1%")
                            .arg(intZoom);
             }
         }
         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()
     {
         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->minimumZoomChanged(min);
     }
 
     void showLoadingIndicator()
     {
         if (!mLoadingIndicator) {
             setupLoadingIndicator();
         }
         mLoadingIndicator->show();
         mLoadingIndicator->setZValue(1);
     }
 
     void hideLoadingIndicator()
     {
         if (!mLoadingIndicator) {
             return;
         }
         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
         QPropertyAnimation* anim = new QPropertyAnimation(mOpacityEffect, "opacity");
         anim->setStartValue(mOpacityEffect->opacity());
         anim->setEndValue(value);
         if (qFuzzyCompare(value, 1)) {
             QObject::connect(anim, SIGNAL(finished()),
                             q, SLOT(slotFadeInFinished()));
         }
         QObject::connect(anim, SIGNAL(finished()), q, SIGNAL(isAnimatedChanged()));
         anim->setDuration(DocumentView::AnimDuration);
         mFadeAnimation = anim;
         q->isAnimatedChanged();
         anim->start(QAbstractAnimation::DeleteWhenStopped);
     }
 };
 
 DocumentView::DocumentView(QGraphicsScene* scene)
 : d(new DocumentViewPrivate)
 {
     setFlag(ItemIsFocusable);
     setFlag(ItemIsSelectable);
     setFlag(ItemClipsChildrenToShape);
 
     d->q = this;
     d->mLoadingIndicator = 0;
     d->mBirdEyeView = 0;
     d->mCurrent = false;
     d->mCompareMode = false;
     d->controlWheelAccumulatedDelta = 0;
 
     // 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);
     setGraphicsEffect(d->mOpacityEffect);
 
     scene->addItem(this);
 
     d->setupHud();
     d->setCurrentAdapter(new EmptyAdapter);
 }
 
 DocumentView::~DocumentView()
 {
     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 = 0;
     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:
         qWarning() << "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(), 0, this, 0);
     }
     d->mSetup = setup;
     d->mDocument = DocumentFactory::instance()->load(url);
     connect(d->mDocument.data(), SIGNAL(busyChanged(QUrl,bool)), SLOT(slotBusyChanged(QUrl,bool)));
 
     if (d->mDocument->loadingState() < Document::KindDetermined) {
         MessageViewAdapter* messageViewAdapter = qobject_cast<MessageViewAdapter*>(d->mAdapter.data());
         if (messageViewAdapter) {
             messageViewAdapter->setInfoMessage(QString());
         }
         d->showLoadingIndicator();
         connect(d->mDocument.data(), SIGNAL(kindDetermined(QUrl)),
                 SLOT(finishOpenUrl()));
     } else {
         QMetaObject::invokeMethod(this, "finishOpenUrl", Qt::QueuedConnection);
     }
     d->setupBirdEyeView();
 }
 
 void DocumentView::finishOpenUrl()
 {
     disconnect(d->mDocument.data(), SIGNAL(kindDetermined(QUrl)),
                this, SLOT(finishOpenUrl()));
     GV_RETURN_IF_FAIL(d->mDocument->loadingState() >= Document::KindDetermined);
 
     if (d->mDocument->loadingState() == Document::LoadingFailed) {
         slotLoadingFailed();
         return;
     }
     createAdapterForDocument();
 
     connect(d->mDocument.data(), SIGNAL(loadingFailed(QUrl)),
             SLOT(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);
         }
     }
     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();
     MessageViewAdapter* 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);
     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::setZoomToFill(bool on)
 {
     if (on == d->mAdapter->zoomToFill()) {
         return;
     }
     d->mAdapter->setZoomToFill(on);
 }
 
 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.);
 }
 
 void DocumentView::zoomIn(const QPointF& center)
 {
     qreal currentZoom = d->mAdapter->zoom();
 
     Q_FOREACH(qreal zoom, d->mZoomSnapValues) {
         if (zoom > currentZoom + REAL_DELTA) {
             d->setZoom(zoom, center);
             return;
         }
     }
 }
 
 void DocumentView::zoomOut(const QPointF& center)
 {
     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();
     zoomChanged(zoom);
 }
 
 void DocumentView::setZoom(qreal zoom)
 {
     d->setZoom(zoom);
 }
 
 qreal DocumentView::zoom() const
 {
     return d->mAdapter->zoom();
 }
 
 void DocumentView::resizeEvent(QGraphicsSceneResizeEvent *event)
 {
     d->resizeAdapterWidget();
     d->updateZoomSnapValues();
     QGraphicsWidget::resizeEvent(event);
 }
 
 void DocumentView::wheelEvent(QGraphicsSceneWheelEvent* event)
 {
     if (d->mAdapter->canZoom() && event->modifiers() & Qt::ControlModifier) {
         d->controlWheelAccumulatedDelta += event->delta();
         // Ctrl + wheel => zoom in or out
         if (d->controlWheelAccumulatedDelta >= QWheelEvent::DefaultDeltasPerStep) {
             zoomIn(event->pos());
             d->controlWheelAccumulatedDelta = 0;
         } else if (d->controlWheelAccumulatedDelta <= -QWheelEvent::DefaultDeltasPerStep) {
             zoomOut(event->pos());
             d->controlWheelAccumulatedDelta = 0;
         }
         return;
     }
     if (GwenviewConfig::mouseWheelBehavior() == MouseWheelBehavior::Browse
         && event->modifiers() == Qt::NoModifier) {
         d->controlWheelAccumulatedDelta += event->delta();
         // Browse with mouse wheel
         if (d->controlWheelAccumulatedDelta >= QWheelEvent::DefaultDeltasPerStep) {
             previousImageRequested();
             d->controlWheelAccumulatedDelta = 0;
         } else if (d->controlWheelAccumulatedDelta <= -QWheelEvent::DefaultDeltasPerStep) {
             nextImageRequested();
             d->controlWheelAccumulatedDelta = 0;
         }
         return;
     }
     // Scroll
     qreal dx = 0;
     // 16 = pixels for one line
     // 120: see QWheelEvent::delta() doc
     qreal dy = -qApp->wheelScrollLines() * 16 * event->delta() / 120;
     if (event->orientation() == Qt::Horizontal) {
         qSwap(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) {
         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) {
-        QRectF visibleRect = mapRectFromItem(d->mAdapter->widget(), d->mAdapter->visibleDocumentRect());
         painter->save();
         painter->setBrush(Qt::NoBrush);
         painter->setPen(QPen(palette().highlight().color(), 2));
         painter->setRenderHint(QPainter::Antialiasing);
-        QRectF selectionRect = visibleRect.adjusted(-2, -2, 2, 2);
+        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()
 {
     hudDeselectClicked(this);
 }
 
 void DocumentView::emitHudTrashClicked()
 {
     hudTrashClicked(this);
 }
 
 void DocumentView::emitFocused()
 {
     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)
 {
     QPropertyAnimation* anim = new QPropertyAnimation(this, "geometry");
     anim->setStartValue(geometry());
     anim->setEndValue(rect);
     anim->setDuration(DocumentView::AnimDuration);
     connect(anim, SIGNAL(finished()), SIGNAL(isAnimatedChanged()));
     d->mMoveAnimation = anim;
     isAnimatedChanged();
     anim->start(QAbstractAnimation::DeleteWhenStopped);
 }
 
 QPropertyAnimation* DocumentView::fadeIn()
 {
     d->fadeTo(1);
     return d->mFadeAnimation.data();
 }
 
 void DocumentView::fadeOut()
 {
     d->fadeTo(0);
 }
 
 void DocumentView::slotFadeInFinished()
 {
     fadeInFinished(this);
 }
 
 bool DocumentView::isAnimated() const
 {
     return d->mMoveAnimation || d->mFadeAnimation;
 }
 
 bool DocumentView::sceneEventFilter(QGraphicsItem*, QEvent* event)
 {
     if (event->type() == QEvent::GraphicsSceneMousePress) {
         QMetaObject::invokeMethod(this, "emitFocused", Qt::QueuedConnection);
     } else if (event->type() == QEvent::GraphicsSceneHoverMove) {
         if (d->mBirdEyeView) {
             d->mBirdEyeView->onMouseMoved();
         }
     }
     return false;
 }
 
 AbstractRasterImageViewTool* DocumentView::currentTool() const
 {
     return imageView() ? imageView()->currentTool() : 0;
 }
 
 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);
 }
 
 } // namespace
diff --git a/lib/documentview/rasterimageview.cpp b/lib/documentview/rasterimageview.cpp
index 0d8bf6c0..142da691 100644
--- a/lib/documentview/rasterimageview.cpp
+++ b/lib/documentview/rasterimageview.cpp
@@ -1,565 +1,566 @@
 // vim: set tabstop=4 shiftwidth=4 expandtab:
 /*
 Gwenview: an image viewer
 Copyright 2011 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 "rasterimageview.h"
 
 // Local
 #include <lib/documentview/abstractrasterimageviewtool.h>
 #include <lib/imagescaler.h>
 #include <lib/cms/cmsprofile.h>
 #include <lib/gvdebug.h>
 
 // KDE
 
 // Qt
 #include <QGraphicsSceneMouseEvent>
 #include <QPainter>
 #include <QTimer>
 #include <QPointer>
 #include <QDebug>
 
 
 namespace Gwenview
 {
 
 struct RasterImageViewPrivate
 {
     RasterImageView* q;
     ImageScaler* mScaler;
     bool mEmittedCompleted;
 
     // Config
     AbstractImageView::AlphaBackgroundMode mAlphaBackgroundMode;
     QColor mAlphaBackgroundColor;
     cmsUInt32Number mRenderingIntent;
     bool mEnlargeSmallerImages;
     // /Config
 
     bool mBufferIsEmpty;
     QPixmap mCurrentBuffer;
     // The alternate buffer is useful when scrolling: existing content is copied
     // to mAlternateBuffer and buffers are swapped. This avoids allocating a new
     // QPixmap every time the image is scrolled.
     QPixmap mAlternateBuffer;
 
     QTimer* mUpdateTimer;
 
     QPointer<AbstractRasterImageViewTool> mTool;
 
     bool mApplyDisplayTransform; // Defaults to true. Can be set to false if there is no need or no way to apply color profile
     cmsHTRANSFORM mDisplayTransform;
 
     void updateDisplayTransform(QImage::Format format)
     {
         GV_RETURN_IF_FAIL(format != QImage::Format_Invalid);
         mApplyDisplayTransform = false;
         if (mDisplayTransform) {
             cmsDeleteTransform(mDisplayTransform);
         }
         mDisplayTransform = 0;
 
         Cms::Profile::Ptr profile = q->document()->cmsProfile();
         if (!profile) {
             // The assumption that something unmarked is *probably* sRGB is better than failing to apply any transform when one
             // has a wide-gamut screen.
             profile = Cms::Profile::getSRgbProfile();
         }
         Cms::Profile::Ptr monitorProfile = Cms::Profile::getMonitorProfile();
         if (!monitorProfile) {
             qWarning() << "Could not get monitor color profile";
             return;
         }
 
         cmsUInt32Number cmsFormat = 0;
         switch (format) {
         case QImage::Format_RGB32:
         case QImage::Format_ARGB32:
             cmsFormat = TYPE_BGRA_8;
             break;
 #if QT_VERSION >= QT_VERSION_CHECK(5, 5, 0)
         case QImage::Format_Grayscale8:
             cmsFormat = TYPE_GRAY_8;
             break;
 #endif
         default:
             qWarning() << "Gwenview can only apply color profile on RGB32 or ARGB32 images";
             return;
         }
 
         mDisplayTransform = cmsCreateTransform(profile->handle(), cmsFormat,
                                                monitorProfile->handle(), cmsFormat,
                                                mRenderingIntent, cmsFLAGS_BLACKPOINTCOMPENSATION);
         mApplyDisplayTransform = true;
     }
 
     void setupUpdateTimer()
     {
         mUpdateTimer = new QTimer(q);
         mUpdateTimer->setInterval(500);
         mUpdateTimer->setSingleShot(true);
         QObject::connect(mUpdateTimer, SIGNAL(timeout()), q, SLOT(updateBuffer()));
     }
 
     void startAnimationIfNecessary()
     {
         if (q->document() && q->isVisible()) {
             q->document()->startAnimation();
         }
     }
 
     QRectF mapViewportToZoomedImage(const QRectF& viewportRect) const
     {
         return QRectF(
                    viewportRect.topLeft() - q->imageOffset() + q->scrollPos(),
                    viewportRect.size()
                );
     }
 
     void setScalerRegionToVisibleRect()
     {
         QRectF rect = mapViewportToZoomedImage(q->boundingRect());
         mScaler->setDestinationRegion(QRegion(rect.toRect()));
     }
 
     void resizeBuffer()
     {
         QSize size = q->visibleImageSize().toSize();
         if (size == mCurrentBuffer.size()) {
             return;
         }
         if (!size.isValid()) {
             mAlternateBuffer = QPixmap();
             mCurrentBuffer = QPixmap();
             return;
         }
 
         mAlternateBuffer = QPixmap(size);
         mAlternateBuffer.fill(Qt::transparent);
         {
             QPainter painter(&mAlternateBuffer);
             painter.drawPixmap(0, 0, mCurrentBuffer);
         }
         qSwap(mAlternateBuffer, mCurrentBuffer);
 
         mAlternateBuffer = QPixmap();
     }
 
     void drawAlphaBackground(QPainter* painter, const QRect& viewportRect, const QPoint& zoomedImageTopLeft, QPixmap texture)
     {
         switch (mAlphaBackgroundMode) {
             case AbstractImageView::AlphaBackgroundNone:
                 painter->fillRect(viewportRect, Qt::transparent);
                 break;
             case AbstractImageView::AlphaBackgroundCheckBoard:
             {
                 const QPoint textureOffset(
                     zoomedImageTopLeft.x() % texture.width(),
                     zoomedImageTopLeft.y() % texture.height());
                 painter->drawTiledPixmap(
                     viewportRect,
                     texture,
                     textureOffset);
                 break;
             }
             case AbstractImageView::AlphaBackgroundSolid:
                 painter->fillRect(viewportRect, mAlphaBackgroundColor);
                 break;
             default:
                 Q_ASSERT(0);
         }
     }
 };
 
 RasterImageView::RasterImageView(QGraphicsItem* parent)
 : AbstractImageView(parent)
 , d(new RasterImageViewPrivate)
 {
     d->q = this;
     d->mEmittedCompleted = false;
     d->mApplyDisplayTransform = true;
     d->mDisplayTransform = 0;
 
     d->mAlphaBackgroundMode = AlphaBackgroundNone;
     d->mAlphaBackgroundColor = Qt::black;
     d->mRenderingIntent = INTENT_PERCEPTUAL;
     d->mEnlargeSmallerImages = false;
 
     d->mBufferIsEmpty = true;
     d->mScaler = new ImageScaler(this);
     connect(d->mScaler, &ImageScaler::scaledRect, this, &RasterImageView::updateFromScaler);
 
     d->setupUpdateTimer();
 }
 
 RasterImageView::~RasterImageView()
 {
     if (d->mTool) {
         d->mTool.data()->toolDeactivated();
     }
     if (d->mDisplayTransform) {
         cmsDeleteTransform(d->mDisplayTransform);
     }
     delete d;
 }
 
 void RasterImageView::setAlphaBackgroundMode(AlphaBackgroundMode mode)
 {
     d->mAlphaBackgroundMode = mode;
     if (document() && document()->hasAlphaChannel()) {
         d->mCurrentBuffer = QPixmap();
         updateBuffer();
     }
 }
 
 void RasterImageView::setAlphaBackgroundColor(const QColor& color)
 {
     d->mAlphaBackgroundColor = color;
     if (document() && document()->hasAlphaChannel()) {
         d->mCurrentBuffer = QPixmap();
         updateBuffer();
     }
 }
 
 void RasterImageView::setRenderingIntent(const RenderingIntent::Enum& renderingIntent)
 {
     if (d->mRenderingIntent != renderingIntent) {
         d->mRenderingIntent = renderingIntent;
         updateBuffer();
     }
 }
 
 void RasterImageView::loadFromDocument()
 {
     Document::Ptr doc = document();
     if (!doc) {
         return;
     }
 
     connect(doc.data(), SIGNAL(metaInfoLoaded(QUrl)),
             SLOT(slotDocumentMetaInfoLoaded()));
     connect(doc.data(), SIGNAL(isAnimatedUpdated()),
             SLOT(slotDocumentIsAnimatedUpdated()));
 
     const Document::LoadingState state = doc->loadingState();
     if (state == Document::MetaInfoLoaded || state == Document::Loaded) {
         slotDocumentMetaInfoLoaded();
     }
 }
 
 void RasterImageView::slotDocumentMetaInfoLoaded()
 {
     if (document()->size().isValid()) {
         QMetaObject::invokeMethod(this, "finishSetDocument", Qt::QueuedConnection);
     } else {
         // Could not retrieve image size from meta info, we need to load the
         // full image now.
         connect(document().data(), SIGNAL(loaded(QUrl)),
                 SLOT(finishSetDocument()));
         document()->startLoadingFullImage();
     }
 }
 
 void RasterImageView::finishSetDocument()
 {
     GV_RETURN_IF_FAIL(document()->size().isValid());
 
     d->mScaler->setDocument(document());
     d->resizeBuffer();
     applyPendingScrollPos();
 
     connect(document().data(), SIGNAL(imageRectUpdated(QRect)),
             SLOT(updateImageRect(QRect)));
 
     if (zoomToFit()) {
         // Force the update otherwise if computeZoomToFit() returns 1, setZoom()
         // will think zoom has not changed and won't update the image
         setZoom(computeZoomToFit(), QPointF(-1, -1), ForceUpdate);
     } else if (zoomToFill()) {
         setZoom(computeZoomToFill(), QPointF(-1, -1), ForceUpdate);
     } else {
         updateBuffer();
     }
 
     d->startAnimationIfNecessary();
     update();
 }
 
 void RasterImageView::updateImageRect(const QRect& imageRect)
 {
     QRectF viewRect = mapToView(imageRect);
     if (!viewRect.intersects(boundingRect())) {
         return;
     }
 
     if (zoomToFit()) {
         setZoom(computeZoomToFit());
     } else if (zoomToFill()) {
         setZoom(computeZoomToFill());
     }
 
     d->setScalerRegionToVisibleRect();
     update();
     emit imageRectUpdated();
 }
 
 void RasterImageView::slotDocumentIsAnimatedUpdated()
 {
     d->startAnimationIfNecessary();
 }
 
 void RasterImageView::updateFromScaler(int zoomedImageLeft, int zoomedImageTop, const QImage& image)
 {
     if (d->mApplyDisplayTransform) {
         d->updateDisplayTransform(image.format());
         if (d->mDisplayTransform) {
             quint8 *bytes = const_cast<quint8*>(image.bits());
             cmsDoTransform(d->mDisplayTransform, bytes, bytes, image.width() * image.height());
         }
     }
 
     d->resizeBuffer();
     int viewportLeft = zoomedImageLeft - scrollPos().x();
     int viewportTop = zoomedImageTop - scrollPos().y();
     d->mBufferIsEmpty = false;
     {
         QPainter painter(&d->mCurrentBuffer);
         painter.setCompositionMode(QPainter::CompositionMode_Source);
         if (document()->hasAlphaChannel()) {
             d->drawAlphaBackground(
                 &painter, QRect(viewportLeft, viewportTop, image.width(), image.height()),
                 QPoint(zoomedImageLeft, zoomedImageTop),
                 alphaBackgroundTexture()
             );
             // This is required so transparent pixels don't replace our background
             painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
         }
         painter.drawImage(viewportLeft, viewportTop, image);
     }
     update();
 
     if (!d->mEmittedCompleted) {
         d->mEmittedCompleted = true;
         completed();
     }
 }
 
 void RasterImageView::onZoomChanged()
 {
     // If we zoom more than twice, then assume the user wants to see the real
     // pixels, for example to fine tune a crop operation
     if (zoom() < 2.) {
         d->mScaler->setTransformationMode(Qt::SmoothTransformation);
     } else {
         d->mScaler->setTransformationMode(Qt::FastTransformation);
     }
     if (!d->mUpdateTimer->isActive()) {
         updateBuffer();
     }
 }
 
 void RasterImageView::onImageOffsetChanged()
 {
     update();
 }
 
 void RasterImageView::onScrollPosChanged(const QPointF& oldPos)
 {
     QPointF delta = scrollPos() - oldPos;
 
     // Scroll existing
     {
         if (d->mAlternateBuffer.size() != d->mCurrentBuffer.size()) {
             d->mAlternateBuffer = QPixmap(d->mCurrentBuffer.size());
         }
         d->mAlternateBuffer.fill(Qt::transparent);
         QPainter painter(&d->mAlternateBuffer);
         painter.drawPixmap(-delta, d->mCurrentBuffer);
     }
     qSwap(d->mCurrentBuffer, d->mAlternateBuffer);
 
     // Scale missing parts
     QRegion bufferRegion = QRegion(d->mCurrentBuffer.rect().translated(scrollPos().toPoint()));
     QRegion updateRegion = bufferRegion - bufferRegion.translated(-delta.toPoint());
     updateBuffer(updateRegion);
     update();
 }
 
 void RasterImageView::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
 {
     QPointF topLeft = imageOffset();
     if (zoomToFit()) {
         // In zoomToFit mode, scale crudely the buffer to fit the screen. This
         // provide an approximate rendered which will be replaced when the scheduled
         // proper scale is ready.
-        QSizeF size = documentSize() * zoom();
-        painter->drawPixmap(topLeft.x(), topLeft.y(), size.width(), size.height(), d->mCurrentBuffer);
+        // Round point and size independently, to keep consistency with the below (non zoomToFit) painting
+        const QRect rect = QRect(topLeft.toPoint(), (documentSize() * zoom()).toSize());
+        painter->drawPixmap(rect, d->mCurrentBuffer);
     } else {
-        painter->drawPixmap(topLeft, d->mCurrentBuffer);
+        painter->drawPixmap(topLeft.toPoint(), d->mCurrentBuffer);
     }
 
     if (d->mTool) {
         d->mTool.data()->paint(painter);
     }
 
     // Debug
 #if 0
     QSizeF visibleSize = documentSize() * zoom();
     painter->setPen(Qt::red);
     painter->drawRect(topLeft.x(), topLeft.y(), visibleSize.width() - 1, visibleSize.height() - 1);
 
     painter->setPen(Qt::blue);
     painter->drawRect(topLeft.x(), topLeft.y(), d->mCurrentBuffer.width() - 1, d->mCurrentBuffer.height() - 1);
 #endif
 }
 
 void RasterImageView::resizeEvent(QGraphicsSceneResizeEvent* event)
 {
     // If we are in zoomToFit mode and have something in our buffer, delay the
     // update: paint() will paint a scaled version of the buffer until resizing
     // is done. This is much faster than rescaling the whole image for each
     // resize event we receive.
     // mUpdateTimer must be started before calling AbstractImageView::resizeEvent()
     // because AbstractImageView::resizeEvent() will call onZoomChanged(), which
     // will trigger an immediate update unless the mUpdateTimer is active.
     if (zoomToFit() && !d->mBufferIsEmpty) {
         d->mUpdateTimer->start();
     } else if (zoomToFill() && !d->mBufferIsEmpty) {
         d->mUpdateTimer->start();
     }
     AbstractImageView::resizeEvent(event);
     if (!zoomToFit()) {
         // Only update buffer if we are not in zoomToFit mode: if we are
         // onZoomChanged() will have already updated the buffer.
         updateBuffer();
     } else if (!zoomToFill()) {
         updateBuffer();
     }
 }
 
 void RasterImageView::updateBuffer(const QRegion& region)
 {
     d->mUpdateTimer->stop();
     d->mScaler->setZoom(zoom());
     if (region.isEmpty()) {
         d->setScalerRegionToVisibleRect();
     } else {
         d->mScaler->setDestinationRegion(region);
     }
 }
 
 void RasterImageView::setCurrentTool(AbstractRasterImageViewTool* tool)
 {
     if (d->mTool) {
         d->mTool.data()->toolDeactivated();
         d->mTool.data()->deleteLater();
     }
     d->mTool = tool;
     if (d->mTool) {
         d->mTool.data()->toolActivated();
     }
     updateCursor();
     currentToolChanged(tool);
     update();
 }
 
 AbstractRasterImageViewTool* RasterImageView::currentTool() const
 {
     return d->mTool.data();
 }
 
 void RasterImageView::mousePressEvent(QGraphicsSceneMouseEvent* event)
 {
     if (d->mTool) {
         d->mTool.data()->mousePressEvent(event);
         if (event->isAccepted()) {
             return;
         }
     }
     AbstractImageView::mousePressEvent(event);
 }
 
 void RasterImageView::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
 {
     if (d->mTool) {
         d->mTool.data()->mouseMoveEvent(event);
         if (event->isAccepted()) {
             return;
         }
     }
     AbstractImageView::mouseMoveEvent(event);
 }
 
 void RasterImageView::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)
 {
     if (d->mTool) {
         d->mTool.data()->mouseReleaseEvent(event);
         if (event->isAccepted()) {
             return;
         }
     }
     AbstractImageView::mouseReleaseEvent(event);
 }
 
 void RasterImageView::wheelEvent(QGraphicsSceneWheelEvent* event)
 {
     if (d->mTool) {
         d->mTool.data()->wheelEvent(event);
         if (event->isAccepted()) {
             return;
         }
     }
     AbstractImageView::wheelEvent(event);
 }
 
 void RasterImageView::keyPressEvent(QKeyEvent* event)
 {
     if (d->mTool) {
         d->mTool.data()->keyPressEvent(event);
         if (event->isAccepted()) {
             return;
         }
     }
     AbstractImageView::keyPressEvent(event);
 }
 
 void RasterImageView::keyReleaseEvent(QKeyEvent* event)
 {
     if (d->mTool) {
         d->mTool.data()->keyReleaseEvent(event);
         if (event->isAccepted()) {
             return;
         }
     }
     AbstractImageView::keyReleaseEvent(event);
 }
 
 void RasterImageView::hoverMoveEvent(QGraphicsSceneHoverEvent* event)
 {
     if (d->mTool) {
         d->mTool.data()->hoverMoveEvent(event);
         if (event->isAccepted()) {
             return;
         }
     }
     AbstractImageView::hoverMoveEvent(event);
 }
 
 } // namespace
diff --git a/lib/documentview/svgviewadapter.cpp b/lib/documentview/svgviewadapter.cpp
index f61500bb..5bb5148c 100644
--- a/lib/documentview/svgviewadapter.cpp
+++ b/lib/documentview/svgviewadapter.cpp
@@ -1,257 +1,262 @@
 // 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 "svgviewadapter.h"
 
 // Qt
 #include <QCursor>
 #include <QGraphicsSvgItem>
 #include <QGraphicsTextItem>
 #include <QGraphicsWidget>
 #include <QPainter>
 #include <QSvgRenderer>
 #include <QDebug>
 
 // KDE
 
 // Local
 #include "document/documentfactory.h"
 #include <qgraphicssceneevent.h>
 #include <lib/gvdebug.h>
 #include <lib/gwenviewconfig.h>
 
 namespace Gwenview
 {
 
 /// SvgImageView ////
 SvgImageView::SvgImageView(QGraphicsItem* parent)
 : AbstractImageView(parent)
 , mSvgItem(new QGraphicsSvgItem(this))
 , mAlphaBackgroundMode(AbstractImageView::AlphaBackgroundCheckBoard)
 , mAlphaBackgroundColor(Qt::black)
 , mImageFullyLoaded(false)
 {
+    // At certain scales, the SVG can render outside its own bounds up to 1 pixel
+    // This clips it so it isn't drawn outside the background or over the selection rect
+    mSvgItem->setFlag(ItemClipsToShape);
+
     // So we aren't unnecessarily drawing the background for every paint()
     setCacheMode(QGraphicsItem::DeviceCoordinateCache);
 }
 
 void SvgImageView::loadFromDocument()
 {
     Document::Ptr doc = document();
     GV_RETURN_IF_FAIL(doc);
 
     if (doc->loadingState() < Document::Loaded) {
         connect(doc.data(), SIGNAL(loaded(QUrl)),
             SLOT(finishLoadFromDocument()));
     } else {
         QMetaObject::invokeMethod(this, "finishLoadFromDocument", Qt::QueuedConnection);
     }
 }
 
 void SvgImageView::finishLoadFromDocument()
 {
     QSvgRenderer* renderer = document()->svgRenderer();
     GV_RETURN_IF_FAIL(renderer);
     mSvgItem->setSharedRenderer(renderer);
     if (zoomToFit()) {
         setZoom(computeZoomToFit(), QPointF(-1, -1), ForceUpdate);
     } else if (zoomToFill()) {
         setZoom(computeZoomToFill(), QPointF(-1, -1), ForceUpdate);
     } else {
         mSvgItem->setScale(zoom());
     }
     applyPendingScrollPos();
     completed();
     mImageFullyLoaded = true;
 }
 
 void SvgImageView::onZoomChanged()
 {
     mSvgItem->setScale(zoom());
     adjustItemPos();
 }
 
 void SvgImageView::onImageOffsetChanged()
 {
     adjustItemPos();
 }
 
 void SvgImageView::onScrollPosChanged(const QPointF& /* oldPos */)
 {
     adjustItemPos();
 }
 
 void SvgImageView::adjustItemPos()
 {
-    mSvgItem->setPos(imageOffset() - scrollPos());
+    mSvgItem->setPos((imageOffset() - scrollPos()).toPoint());
     update();
 }
 
 void SvgImageView::setAlphaBackgroundMode(AbstractImageView::AlphaBackgroundMode mode)
 {
     mAlphaBackgroundMode = mode;
     update();
 }
 
 void SvgImageView::setAlphaBackgroundColor(const QColor& color)
 {
     mAlphaBackgroundColor = color;
     update();
 }
 
 void SvgImageView::drawAlphaBackground(QPainter* painter)
 {
-    const QRectF imageRect = QRectF(imageOffset(), visibleImageSize());
+    // The point and size must be rounded to integers independently, to keep consistency with RasterImageView
+    const QRect imageRect = QRect(imageOffset().toPoint(), visibleImageSize().toSize());
 
     switch (mAlphaBackgroundMode) {
         case AbstractImageView::AlphaBackgroundNone:
             // Unlike RasterImageView, SVGs are rendered directly on the image view,
             // therefore we can simply not draw a background
             break;
         case AbstractImageView::AlphaBackgroundCheckBoard:
             painter->drawTiledPixmap(imageRect, alphaBackgroundTexture(), scrollPos());
             break;
         case AbstractImageView::AlphaBackgroundSolid:
             painter->fillRect(imageRect, mAlphaBackgroundColor);
             break;
         default:
             Q_ASSERT(0);
     }
 }
 
 void SvgImageView::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
 {
     if (mImageFullyLoaded) {
         drawAlphaBackground(painter);
     }
 }
 
 //// SvgViewAdapter ////
 struct SvgViewAdapterPrivate
 {
     SvgImageView* mView;
 };
 
 SvgViewAdapter::SvgViewAdapter()
 : d(new SvgViewAdapterPrivate)
 {
     d->mView = new SvgImageView;
     setWidget(d->mView);
     connect(d->mView, &SvgImageView::zoomChanged, this, &SvgViewAdapter::zoomChanged);
     connect(d->mView, &SvgImageView::zoomToFitChanged, this, &SvgViewAdapter::zoomToFitChanged);
     connect(d->mView, &SvgImageView::zoomToFillChanged, this, &SvgViewAdapter::zoomToFillChanged);
     connect(d->mView, &SvgImageView::zoomInRequested, this, &SvgViewAdapter::zoomInRequested);
     connect(d->mView, &SvgImageView::zoomOutRequested, this, &SvgViewAdapter::zoomOutRequested);
     connect(d->mView, &SvgImageView::scrollPosChanged, this, &SvgViewAdapter::scrollPosChanged);
     connect(d->mView, &SvgImageView::completed, this, &SvgViewAdapter::completed);
     connect(d->mView, &SvgImageView::previousImageRequested, this, &SvgViewAdapter::previousImageRequested);
     connect(d->mView, &SvgImageView::nextImageRequested, this, &SvgViewAdapter::nextImageRequested);
     connect(d->mView, &SvgImageView::toggleFullScreenRequested, this, &SvgViewAdapter::toggleFullScreenRequested);
 }
 
 SvgViewAdapter::~SvgViewAdapter()
 {
     delete d;
 }
 
 QCursor SvgViewAdapter::cursor() const
 {
     return widget()->cursor();
 }
 
 void SvgViewAdapter::setCursor(const QCursor& cursor)
 {
     widget()->setCursor(cursor);
 }
 
 void SvgViewAdapter::setDocument(Document::Ptr doc)
 {
     d->mView->setDocument(doc);
 }
 
 Document::Ptr SvgViewAdapter::document() const
 {
     return d->mView->document();
 }
 
 void SvgViewAdapter::loadConfig()
 {
     d->mView->setAlphaBackgroundMode(GwenviewConfig::alphaBackgroundMode());
     d->mView->setAlphaBackgroundColor(GwenviewConfig::alphaBackgroundColor());
     d->mView->setEnlargeSmallerImages(GwenviewConfig::enlargeSmallerImages());
 }
 
 void SvgViewAdapter::setZoomToFit(bool on)
 {
     d->mView->setZoomToFit(on);
 }
 
 void SvgViewAdapter::setZoomToFill(bool on)
 {
     d->mView->setZoomToFill(on);
 }
 
 bool SvgViewAdapter::zoomToFit() const
 {
     return d->mView->zoomToFit();
 }
 
 bool SvgViewAdapter::zoomToFill() const
 {
     return d->mView->zoomToFill();
 }
 
 qreal SvgViewAdapter::zoom() const
 {
     return d->mView->zoom();
 }
 
 void SvgViewAdapter::setZoom(qreal zoom, const QPointF& center)
 {
     d->mView->setZoom(zoom, center);
 }
 
 qreal SvgViewAdapter::computeZoomToFit() const
 {
     return d->mView->computeZoomToFit();
 }
 
 qreal SvgViewAdapter::computeZoomToFill() const
 {
     return d->mView->computeZoomToFill();
 }
 
 QPointF SvgViewAdapter::scrollPos() const
 {
     return d->mView->scrollPos();
 }
 
 void SvgViewAdapter::setScrollPos(const QPointF& pos)
 {
     d->mView->setScrollPos(pos);
 }
 
 QRectF SvgViewAdapter::visibleDocumentRect() const
 {
     return QRectF(d->mView->imageOffset(), d->mView->visibleImageSize());
 }
 
 } // namespace