diff --git a/libs/ui/KisReferenceImage.cpp b/libs/ui/KisReferenceImage.cpp
index d67e2f12df..89280e35d5 100644
--- a/libs/ui/KisReferenceImage.cpp
+++ b/libs/ui/KisReferenceImage.cpp
@@ -1,294 +1,314 @@
 /*
  * Copyright (C) 2017 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisReferenceImage.h"
 
 #include <QImage>
+#include <QMessageBox>
 #include <QPainter>
 
 #include <kundo2command.h>
 #include <KoStore.h>
 #include <KoStoreDevice.h>
 #include <KoTosContainer_p.h>
-
 #include <krita_utils.h>
 #include <kis_coordinates_converter.h>
 #include <kis_dom_utils.h>
 #include <SvgUtil.h>
 #include <libs/flake/svg/parsers/SvgTransformParser.h>
 
 struct KisReferenceImage::Private {
     KisReferenceImage *q;
     QString src;
 
     QImage image;
     QImage cachedImage;
 
     qreal saturation{1.0};
     int id{-1};
     bool embed{true};
 
     explicit Private(KisReferenceImage *q)
         : q(q)
     {}
 
-    void loadFromFile() {
-        KIS_SAFE_ASSERT_RECOVER_RETURN(src.startsWith("file://"));
+    bool loadFromFile() {
+        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(src.startsWith("file://"), false);
         QString filename = src.mid(7);
-        image.load(filename);
+        return image.load(filename);
     }
 
     void updateCache() {
         if (saturation < 1.0) {
             cachedImage = KritaUtils::convertQImageToGrayA(image);
 
             if (saturation > 0.0) {
                 QPainter gc2(&cachedImage);
                 gc2.setOpacity(saturation);
                 gc2.drawImage(QPoint(), image);
             }
         } else {
             cachedImage = image;
         }
     }
 };
 
 
 KisReferenceImage::SetSaturationCommand::SetSaturationCommand(const QList<KoShape *> &shapes, qreal newSaturation, KUndo2Command *parent)
     : KUndo2Command(kundo2_i18n("Set saturation"), parent)
     , newSaturation(newSaturation)
 {
     images.reserve(shapes.count());
 
     Q_FOREACH(auto *shape, shapes) {
         auto *reference = dynamic_cast<KisReferenceImage*>(shape);
         KIS_SAFE_ASSERT_RECOVER_BREAK(reference);
         images.append(reference);
     }
 
     Q_FOREACH(auto *image, images) {
         oldSaturations.append(image->saturation());
     }
 }
 
 void KisReferenceImage::SetSaturationCommand::undo()
 {
     auto saturationIterator = oldSaturations.begin();
     Q_FOREACH(auto *image, images) {
         image->setSaturation(*saturationIterator);
         image->update();
         saturationIterator++;
     }
 }
 
 void KisReferenceImage::SetSaturationCommand::redo()
 {
     Q_FOREACH(auto *image, images) {
         image->setSaturation(newSaturation);
         image->update();
     }
 }
 
 KisReferenceImage::KisReferenceImage()
     : d(new Private(this))
 {
     setKeepAspectRatio(true);
 }
 
 KisReferenceImage::KisReferenceImage(const KisReferenceImage &rhs)
     : KoTosContainer(new KoTosContainerPrivate(*rhs.d_func(), this))
     , d(new Private(*rhs.d))
 {}
 
 KisReferenceImage::~KisReferenceImage()
 {}
 
-KisReferenceImage * KisReferenceImage::fromFile(const QString &filename, const KisCoordinatesConverter &converter)
+KisReferenceImage * KisReferenceImage::fromFile(const QString &filename, const KisCoordinatesConverter &converter, QWidget *parent)
 {
     KisReferenceImage *reference = new KisReferenceImage();
     reference->d->src = QString("file://") + filename;
-    reference->d->loadFromFile();
+    bool ok = reference->d->loadFromFile();
+
+    if (ok) {
+        QRect r = QRect(QPoint(), reference->d->image.size());
+        QSizeF shapeSize = converter.imageToDocument(r).size();
+        reference->setSize(shapeSize);
+    } else {
+        delete reference;
+
+        if (parent) {
+            QMessageBox::critical(parent, i18nc("@title:window", "Krita"), i18n("Could not load %1.", filename));
+        }
 
-    QRect r = QRect(QPoint(), reference->d->image.size());
-    QSizeF shapeSize = converter.imageToDocument(r).size();
-    reference->setSize(shapeSize);
+        return nullptr;
+    }
 
     return reference;
 }
 
 void KisReferenceImage::paint(QPainter &gc, const KoViewConverter &converter, KoShapePaintingContext &/*paintcontext*/)
 {
     if (!parent()) return;
 
     gc.save();
 
     applyConversion(gc, converter);
 
     QSizeF shapeSize = size();
     QTransform transform = QTransform::fromScale(shapeSize.width() / d->image.width(), shapeSize.height() / d->image.height());
 
     if (d->cachedImage.isNull()) {
         d->updateCache();
     }
 
     gc.setRenderHint(QPainter::SmoothPixmapTransform);
     gc.setClipRect(QRectF(QPointF(), shapeSize), Qt::IntersectClip);
     gc.setTransform(transform, true);
     gc.drawImage(QPoint(), d->cachedImage);
 
     gc.restore();
 }
 
 void KisReferenceImage::setSaturation(qreal saturation)
 {
     d->saturation = saturation;
     d->cachedImage = QImage();
 }
 
 qreal KisReferenceImage::saturation() const
 {
     return d->saturation;
 }
 
 void KisReferenceImage::setEmbed(bool embed)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(embed || d->src.startsWith("file://"));
     d->embed = embed;
 }
 
 bool KisReferenceImage::embed()
 {
     return d->embed;
 }
 
 bool KisReferenceImage::hasLocalFile()
 {
     return d->src.startsWith("file://");
 }
 
+QString KisReferenceImage::url() const
+{
+    return d->src;
+}
+
+void KisReferenceImage::setUrl(const QString &url)
+{
+    d->src = url;
+    d->embed = false;
+}
+
 QColor KisReferenceImage::getPixel(QPointF position)
 {
     const QSizeF shapeSize = size();
     const QTransform scale = QTransform::fromScale(d->image.width() / shapeSize.width(), d->image.height() / shapeSize.height());
 
     const QTransform transform = absoluteTransformation(nullptr).inverted() * scale;
     const QPointF localPosition = position * transform;
 
     if (d->cachedImage.isNull()) {
         d->updateCache();
     }
 
     return d->cachedImage.pixelColor(localPosition.toPoint());
 }
 
 void KisReferenceImage::saveXml(QDomDocument &document, QDomElement &parentElement, int id)
 {
     d->id = id;
 
     QDomElement element = document.createElement("referenceimage");
 
     if (d->embed) {
         d->src = QString("reference_images/%1.png").arg(id);
     }
     element.setAttribute("src", d->src);
 
     const QSizeF &shapeSize = size();
     element.setAttribute("width", KisDomUtils::toString(shapeSize.width()));
     element.setAttribute("height", KisDomUtils::toString(shapeSize.height()));
     element.setAttribute("keepAspectRatio", keepAspectRatio() ? "true" : "false");
     element.setAttribute("transform", SvgUtil::transformToString(transform()));
 
     element.setAttribute("opacity", KisDomUtils::toString(1.0 - transparency()));
     element.setAttribute("saturation", KisDomUtils::toString(d->saturation));
 
     parentElement.appendChild(element);
 }
 
 KisReferenceImage * KisReferenceImage::fromXml(const QDomElement &elem)
 {
     auto *reference = new KisReferenceImage();
 
     const QString &src = elem.attribute("src");
     reference->d->src = src;
     reference->d->embed = !src.startsWith("file://");
 
     qreal width = KisDomUtils::toDouble(elem.attribute("width", "100"));
     qreal height = KisDomUtils::toDouble(elem.attribute("height", "100"));
     reference->setSize(QSizeF(width, height));
     reference->setKeepAspectRatio(elem.attribute("keepAspectRatio", "true").toLower() == "true");
 
     auto transform = SvgTransformParser(elem.attribute("transform")).transform();
     reference->setTransformation(transform);
 
     qreal opacity = KisDomUtils::toDouble(elem.attribute("opacity", "1"));
     reference->setTransparency(1.0 - opacity);
 
     qreal saturation = KisDomUtils::toDouble(elem.attribute("opacity", "1"));
     reference->setSaturation(saturation);
 
     return reference;
 }
 
 bool KisReferenceImage::saveImage(KoStore *store) const
 {
     if (!d->embed) return true;
 
     if (!store->open(d->src)) {
         return false;
     }
 
     KoStoreDevice storeDev(store);
     if (!storeDev.open(QIODevice::WriteOnly)) {
         return false;
     }
 
     if (!d->image.save(&storeDev, "PNG")) {
         return false;
     }
 
     return store->close();
 }
 
 bool KisReferenceImage::loadImage(KoStore *store)
 {
     if (d->src.startsWith("file://")) {
-        d->loadFromFile();
-        return true;
+        return d->loadFromFile();
     }
 
     if (!store->open(d->src)) {
         return false;
     }
 
     KoStoreDevice storeDev(store);
     if (!storeDev.open(QIODevice::ReadOnly)) {
         return false;
     }
 
     if (!d->image.load(&storeDev, "PNG")) {
         return false;
     }
 
     return store->close();
 }
 
 KoShape *KisReferenceImage::cloneShape() const
 {
     return new KisReferenceImage(*this);
 }
diff --git a/libs/ui/KisReferenceImage.h b/libs/ui/KisReferenceImage.h
index 67805b90ed..def2e5e033 100644
--- a/libs/ui/KisReferenceImage.h
+++ b/libs/ui/KisReferenceImage.h
@@ -1,87 +1,95 @@
 /*
  * Copyright (C) 2017 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef KISREFERENCEIMAGE_H
 #define KISREFERENCEIMAGE_H
 
 #include <QScopedPointer>
 
 #include <kundo2command.h>
 #include <kritaui_export.h>
 #include <KoTosContainer.h>
 #include <KoColor.h>
 
 class QImage;
 class QPointF;
 class QPainter;
 class QRectF;
 class KoStore;
 class KisCoordinatesConverter;
 class KisCanvas2;
 
 /**
  * @brief The KisReferenceImage class represents a single reference image
  */
 class KRITAUI_EXPORT KisReferenceImage : public KoTosContainer
 {
 public:
     struct KRITAUI_EXPORT SetSaturationCommand : public KUndo2Command {
         QVector<KisReferenceImage*> images;
         QVector<qreal> oldSaturations;
         qreal newSaturation;
 
         explicit SetSaturationCommand(const QList<KoShape *> &images, qreal newSaturation, KUndo2Command *parent = 0);
         void undo() override;
         void redo() override;
     };
 
     KisReferenceImage();
     KisReferenceImage(const KisReferenceImage &rhs);
     ~KisReferenceImage();
 
     KoShape *cloneShape() const override;
 
-    static KisReferenceImage * fromFile(const QString &filename, const KisCoordinatesConverter &converter);
+    /**
+     * Load a reference image from specified file.
+     * If parent is provided and the image cannot be loaded, a warning message will be displayed to user.
+     * @return reference image or null if one could not be loaded
+     */
+    static KisReferenceImage * fromFile(const QString &filename, const KisCoordinatesConverter &converter, QWidget *parent /*= nullptr*/);
 
     void setSaturation(qreal saturation);
     qreal saturation() const;
 
     void setEmbed(bool embed);
     bool embed();
     bool hasLocalFile();
 
+    void setUrl(const QString &url);
+    QString url() const;
+
     void paint(QPainter &gc, const KoViewConverter &converter, KoShapePaintingContext &paintcontext) override;
 
     bool loadOdf(const KoXmlElement &/*element*/, KoShapeLoadingContext &/*context*/) override { return false; }
     void saveOdf(KoShapeSavingContext &/*context*/) const override {}
 
     QColor getPixel(QPointF position);
 
     void saveXml(QDomDocument &document, QDomElement &parentElement, int id);
     bool saveImage(KoStore *store) const;
 
     static KisReferenceImage * fromXml(const QDomElement &elem);
     bool loadImage(KoStore *store);
 
 private:
     struct Private;
     const QScopedPointer<Private> d;
 };
 
 #endif // KISREFERENCEIMAGE_H
diff --git a/libs/ui/KisView.cpp b/libs/ui/KisView.cpp
index 84699588e3..ce08cf0764 100644
--- a/libs/ui/KisView.cpp
+++ b/libs/ui/KisView.cpp
@@ -1,1013 +1,1016 @@
 /*
  * Copyright (C) 2014 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisView.h"
 
 #include "KisView_p.h"
 
 #include <KoDockFactoryBase.h>
 #include <KoDockRegistry.h>
 #include <KoDocumentInfo.h>
 #include "KoDocumentInfo.h"
 #include "KoPageLayout.h"
 #include <KoToolManager.h>
 
 #include <kis_icon.h>
 
 #include <kactioncollection.h>
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kselectaction.h>
 #include <kconfiggroup.h>
 #include <kactioncollection.h>
 
 #include <QMenu>
 #include <QMessageBox>
 #include <QUrl>
 #include <QTemporaryFile>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QDockWidget>
 #include <QDragEnterEvent>
 #include <QDropEvent>
 #include <QImage>
 #include <QList>
 #include <QPrintDialog>
 #include <QToolBar>
 #include <QUrl>
 #include <QStatusBar>
 #include <QMoveEvent>
 #include <QTemporaryFile>
 #include <QMdiSubWindow>
 
 #include <kis_image.h>
 #include <kis_node.h>
 
 #include <kis_group_layer.h>
 #include <kis_layer.h>
 #include <kis_mask.h>
 #include <kis_selection.h>
 
 #include "kis_canvas2.h"
 #include "kis_canvas_controller.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_config.h"
 #include "KisDocument.h"
 #include "kis_image_manager.h"
 #include "KisMainWindow.h"
 #include "kis_mimedata.h"
 #include "kis_mirror_axis.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_node_manager.h"
 #include "KisPart.h"
 #include "KisPrintJob.h"
 #include "kis_shape_controller.h"
 #include "kis_tool_freehand.h"
 #include "KisViewManager.h"
 #include "kis_zoom_manager.h"
 #include "kis_statusbar.h"
 #include "kis_painting_assistants_decoration.h"
 #include "KisReferenceImagesDecoration.h"
 #include "kis_progress_widget.h"
 #include "kis_signal_compressor.h"
 #include "kis_filter_manager.h"
 #include "kis_file_layer.h"
 #include "krita_utils.h"
 #include "input/kis_input_manager.h"
 #include "KisRemoteFileFetcher.h"
 
 //static
 QString KisView::newObjectName()
 {
     static int s_viewIFNumber = 0;
     QString name; name.setNum(s_viewIFNumber++); name.prepend("view_");
     return name;
 }
 
 bool KisView::s_firstView = true;
 
 class Q_DECL_HIDDEN KisView::Private
 {
 public:
     Private(KisView *_q,
             KisDocument *document,
             KoCanvasResourceManager *resourceManager,
             KActionCollection *actionCollection)
         : actionCollection(actionCollection)
         , viewConverter()
         , canvasController(_q, actionCollection)
         , canvas(&viewConverter, resourceManager, _q, document->shapeController())
         , zoomManager(_q, &this->viewConverter, &this->canvasController)
         , paintingAssistantsDecoration(new KisPaintingAssistantsDecoration(_q))
         , referenceImagesDecoration(new KisReferenceImagesDecoration(_q, document))
         , floatingMessageCompressor(100, KisSignalCompressor::POSTPONE)
     {
     }
 
     bool inOperation; //in the middle of an operation (no screen refreshing)?
 
     QPointer<KisDocument> document; // our KisDocument
     QWidget *tempActiveWidget = 0;
 
     /**
      * Signals the document has been deleted. Can't use document==0 since this
      * only happens in ~QObject, and views get deleted by ~KisDocument.
      * XXX: either provide a better justification to do things this way, or
      * rework the mechanism.
      */
     bool documentDeleted = false;
 
     KActionCollection* actionCollection;
     KisCoordinatesConverter viewConverter;
     KisCanvasController canvasController;
     KisCanvas2 canvas;
     KisZoomManager zoomManager;
     KisViewManager *viewManager = 0;
     KisNodeSP currentNode;
     KisPaintingAssistantsDecorationSP paintingAssistantsDecoration;
     KisReferenceImagesDecorationSP referenceImagesDecoration;
     bool isCurrent = false;
     bool showFloatingMessage = false;
     QPointer<KisFloatingMessage> savedFloatingMessage;
     KisSignalCompressor floatingMessageCompressor;
     QMdiSubWindow *subWindow{nullptr};
 
     bool softProofing = false;
     bool gamutCheck = false;
 
     // Hmm sorry for polluting the private class with such a big inner class.
     // At the beginning it was a little struct :)
     class StatusBarItem
     {
     public:
 
         StatusBarItem(QWidget * widget, int stretch, bool permanent)
             : m_widget(widget),
               m_stretch(stretch),
               m_permanent(permanent),
               m_connected(false),
               m_hidden(false) {}
 
         bool operator==(const StatusBarItem& rhs) {
             return m_widget == rhs.m_widget;
         }
 
         bool operator!=(const StatusBarItem& rhs) {
             return m_widget != rhs.m_widget;
         }
 
         QWidget * widget() const {
             return m_widget;
         }
 
         void ensureItemShown(QStatusBar * sb) {
             Q_ASSERT(m_widget);
             if (!m_connected) {
                 if (m_permanent)
                     sb->addPermanentWidget(m_widget, m_stretch);
                 else
                     sb->addWidget(m_widget, m_stretch);
 
                 if(!m_hidden)
                     m_widget->show();
 
                 m_connected = true;
             }
         }
         void ensureItemHidden(QStatusBar * sb) {
             if (m_connected) {
                 m_hidden = m_widget->isHidden();
                 sb->removeWidget(m_widget);
                 m_widget->hide();
                 m_connected = false;
             }
         }
     private:
         QWidget * m_widget = 0;
         int m_stretch;
         bool m_permanent;
         bool m_connected = false;
         bool m_hidden = false;
 
     };
 
 };
 
 KisView::KisView(KisDocument *document, KoCanvasResourceManager *resourceManager, KActionCollection *actionCollection, QWidget *parent)
     : QWidget(parent)
     , d(new Private(this, document, resourceManager, actionCollection))
 {
     Q_ASSERT(document);
     connect(document, SIGNAL(titleModified(QString,bool)), this, SIGNAL(titleModified(QString,bool)));
     setObjectName(newObjectName());
 
     d->document = document;
 
     setFocusPolicy(Qt::StrongFocus);
 
     QStatusBar * sb = statusBar();
     if (sb) { // No statusbar in e.g. konqueror
         connect(d->document, SIGNAL(statusBarMessage(const QString&, int)),
                 this, SLOT(slotSavingStatusMessage(const QString&, int)));
         connect(d->document, SIGNAL(clearStatusBarMessage()),
                 this, SLOT(slotClearStatusText()));
     }
 
     d->canvas.setup();
 
     KisConfig cfg;
 
     d->canvasController.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     d->canvasController.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     d->canvasController.setVastScrolling(cfg.vastScrolling());
     d->canvasController.setCanvas(&d->canvas);
 
     d->zoomManager.setup(d->actionCollection);
 
 
     connect(&d->canvasController, SIGNAL(documentSizeChanged()), &d->zoomManager, SLOT(slotScrollAreaSizeChanged()));
     setAcceptDrops(true);
 
     connect(d->document, SIGNAL(sigLoadingFinished()), this, SLOT(slotLoadingFinished()));
     connect(d->document, SIGNAL(sigSavingFinished()), this, SLOT(slotSavingFinished()));
 
     d->canvas.addDecoration(d->referenceImagesDecoration);
     d->referenceImagesDecoration->setVisible(true);
 
     d->canvas.addDecoration(d->paintingAssistantsDecoration);
     d->paintingAssistantsDecoration->setVisible(true);
 
     d->showFloatingMessage = cfg.showCanvasMessages();
 }
 
 KisView::~KisView()
 {
     if (d->viewManager) {
         if (d->viewManager->filterManager()->isStrokeRunning()) {
             d->viewManager->filterManager()->cancel();
         }
 
         d->viewManager->mainWindow()->notifyChildViewDestroyed(this);
     }
 
     KoToolManager::instance()->removeCanvasController(&d->canvasController);
     d->canvasController.setCanvas(0);
 
     KisPart::instance()->removeView(this);
     delete d;
 }
 
 void KisView::notifyCurrentStateChanged(bool isCurrent)
 {
     d->isCurrent = isCurrent;
 
     if (!d->isCurrent && d->savedFloatingMessage) {
         d->savedFloatingMessage->removeMessage();
     }
 
     KisInputManager *inputManager = globalInputManager();
     if (d->isCurrent) {
         inputManager->attachPriorityEventFilter(&d->canvasController);
     } else {
         inputManager->detachPriorityEventFilter(&d->canvasController);
     }
 }
 
 void KisView::setShowFloatingMessage(bool show)
 {
     d->showFloatingMessage = show;
 }
 
 void KisView::showFloatingMessageImpl(const QString &message, const QIcon& icon, int timeout, KisFloatingMessage::Priority priority, int alignment)
 {
     if (!d->viewManager) return;
 
     if(d->isCurrent && d->showFloatingMessage && d->viewManager->qtMainWindow()) {
         if (d->savedFloatingMessage) {
             d->savedFloatingMessage->tryOverrideMessage(message, icon, timeout, priority, alignment);
         } else {
             d->savedFloatingMessage = new KisFloatingMessage(message, this->canvasBase()->canvasWidget(), false, timeout, priority, alignment);
             d->savedFloatingMessage->setShowOverParent(true);
             d->savedFloatingMessage->setIcon(icon);
 
             connect(&d->floatingMessageCompressor, SIGNAL(timeout()), d->savedFloatingMessage, SLOT(showMessage()));
             d->floatingMessageCompressor.start();
         }
     }
 }
 
 bool KisView::canvasIsMirrored() const
 {
     return d->canvas.xAxisMirrored() || d->canvas.yAxisMirrored();
 }
 
 void KisView::setViewManager(KisViewManager *view)
 {
     d->viewManager = view;
 
     KoToolManager::instance()->addController(&d->canvasController);
     KoToolManager::instance()->registerToolActions(d->actionCollection, &d->canvasController);
     dynamic_cast<KisShapeController*>(d->document->shapeController())->setInitialShapeForCanvas(&d->canvas);
 
     if (resourceProvider()) {
         resourceProvider()->slotImageSizeChanged();
     }
 
     if (d->viewManager && d->viewManager->nodeManager()) {
         d->viewManager->nodeManager()->nodesUpdated();
     }
 
     connect(image(), SIGNAL(sigSizeChanged(const QPointF&, const QPointF&)), this, SLOT(slotImageSizeChanged(const QPointF&, const QPointF&)));
     connect(image(), SIGNAL(sigResolutionChanged(double,double)), this, SLOT(slotImageResolutionChanged()));
 
     // executed in a context of an image thread
     connect(image(), SIGNAL(sigNodeAddedAsync(KisNodeSP)),
             SLOT(slotImageNodeAdded(KisNodeSP)),
             Qt::DirectConnection);
 
     // executed in a context of the gui thread
     connect(this, SIGNAL(sigContinueAddNode(KisNodeSP)),
             SLOT(slotContinueAddNode(KisNodeSP)),
             Qt::AutoConnection);
 
     // executed in a context of an image thread
     connect(image(), SIGNAL(sigRemoveNodeAsync(KisNodeSP)),
             SLOT(slotImageNodeRemoved(KisNodeSP)),
             Qt::DirectConnection);
 
     // executed in a context of the gui thread
     connect(this, SIGNAL(sigContinueRemoveNode(KisNodeSP)),
             SLOT(slotContinueRemoveNode(KisNodeSP)),
             Qt::AutoConnection);
 
     d->viewManager->updateGUI();
 
     KoToolManager::instance()->switchToolRequested("KritaShape/KisToolBrush");
 }
 
 KisViewManager* KisView::viewManager() const
 {
     return d->viewManager;
 }
 
 void KisView::slotImageNodeAdded(KisNodeSP node)
 {
     emit sigContinueAddNode(node);
 }
 
 void KisView::slotContinueAddNode(KisNodeSP newActiveNode)
 {
     /**
      * When deleting the last layer, root node got selected. We should
      * fix it when the first layer is added back.
      *
      * Here we basically reimplement what Qt's view/model do. But
      * since they are not connected, we should do it manually.
      */
 
     if (!d->isCurrent &&
             (!d->currentNode || !d->currentNode->parent())) {
 
         d->currentNode = newActiveNode;
     }
 }
 
 
 void KisView::slotImageNodeRemoved(KisNodeSP node)
 {
     emit sigContinueRemoveNode(KritaUtils::nearestNodeAfterRemoval(node));
 }
 
 void KisView::slotContinueRemoveNode(KisNodeSP newActiveNode)
 {
     if (!d->isCurrent) {
         d->currentNode = newActiveNode;
     }
 }
 
 KoZoomController *KisView::zoomController() const
 {
     return d->zoomManager.zoomController();
 }
 
 KisZoomManager *KisView::zoomManager() const
 {
     return &d->zoomManager;
 }
 
 KisCanvasController *KisView::canvasController() const
 {
     return &d->canvasController;
 }
 
 KisCanvasResourceProvider *KisView::resourceProvider() const
 {
     if (d->viewManager) {
         return d->viewManager->resourceProvider();
     }
     return 0;
 }
 
 KisInputManager* KisView::globalInputManager() const
 {
     return d->viewManager ? d->viewManager->inputManager() : 0;
 }
 
 KisCanvas2 *KisView::canvasBase() const
 {
     return &d->canvas;
 }
 
 KisImageWSP KisView::image() const
 {
     if (d->document) {
         return d->document->image();
     }
     return 0;
 }
 
 KisCoordinatesConverter *KisView::viewConverter() const
 {
     return &d->viewConverter;
 }
 
 void KisView::dragEnterEvent(QDragEnterEvent *event)
 {
     if (event->mimeData()->hasImage()
             || event->mimeData()->hasUrls()
             || event->mimeData()->hasFormat("application/x-krita-node")) {
         event->accept();
 
         // activate view if it should accept the drop
         this->setFocus();
     } else {
         event->ignore();
     }
 }
 
 void KisView::dropEvent(QDropEvent *event)
 {
     KisImageWSP kisimage = image();
     Q_ASSERT(kisimage);
 
     QPoint cursorPos = canvasBase()->coordinatesConverter()->widgetToImage(event->pos()).toPoint();
     QRect imageBounds = kisimage->bounds();
     QPoint pasteCenter;
     bool forceRecenter;
 
     if (event->keyboardModifiers() & Qt::ShiftModifier &&
             imageBounds.contains(cursorPos)) {
 
         pasteCenter = cursorPos;
         forceRecenter = true;
     } else {
         pasteCenter = imageBounds.center();
         forceRecenter = false;
     }
     if (event->mimeData()->hasFormat("application/x-krita-node") ||
             event->mimeData()->hasImage())
     {
         KisShapeController *kritaShapeController =
                 dynamic_cast<KisShapeController*>(d->document->shapeController());
 
         QList<KisNodeSP> nodes =
                 KisMimeData::loadNodes(event->mimeData(), imageBounds,
                                        pasteCenter, forceRecenter,
                                        kisimage, kritaShapeController);
 
         Q_FOREACH (KisNodeSP node, nodes) {
             if (node) {
                 KisNodeCommandsAdapter adapter(viewManager());
                 if (!viewManager()->nodeManager()->activeLayer()) {
                     adapter.addNode(node, kisimage->rootLayer() , 0);
                 } else {
                     adapter.addNode(node,
                                     viewManager()->nodeManager()->activeLayer()->parent(),
                                     viewManager()->nodeManager()->activeLayer());
                 }
             }
         }
     }
     else if (event->mimeData()->hasUrls()) {
 
         QList<QUrl> urls = event->mimeData()->urls();
         if (urls.length() > 0) {
 
             QMenu popup;
             popup.setObjectName("drop_popup");
 
             QAction *insertAsNewLayer = new QAction(i18n("Insert as New Layer"), &popup);
             QAction *insertManyLayers = new QAction(i18n("Insert Many Layers"), &popup);
 
             QAction *insertAsNewFileLayer = new QAction(i18n("Insert as New File Layer"), &popup);
             QAction *insertManyFileLayers = new QAction(i18n("Insert Many File Layers"), &popup);
 
             QAction *openInNewDocument = new QAction(i18n("Open in New Document"), &popup);
             QAction *openManyDocuments = new QAction(i18n("Open Many Documents"), &popup);
 
             QAction *insertAsReferenceImage = new QAction(i18n("Insert as Reference Image"), &popup);
             QAction *insertAsReferenceImages = new QAction(i18n("Insert as Reference Images"), &popup);
 
             QAction *cancel = new QAction(i18n("Cancel"), &popup);
 
             popup.addAction(insertAsNewLayer);
             popup.addAction(insertAsNewFileLayer);
             popup.addAction(openInNewDocument);
             popup.addAction(insertAsReferenceImage);
 
             popup.addAction(insertManyLayers);
             popup.addAction(insertManyFileLayers);
             popup.addAction(openManyDocuments);
             popup.addAction(insertAsReferenceImages);
 
             insertAsNewLayer->setEnabled(image() && urls.count() == 1);
             insertAsNewFileLayer->setEnabled(image() && urls.count() == 1);
             openInNewDocument->setEnabled(urls.count() == 1);
             insertAsReferenceImage->setEnabled(image() && urls.count() == 1);
 
             insertManyLayers->setEnabled(image() && urls.count() > 1);
             insertManyFileLayers->setEnabled(image() && urls.count() > 1);
             openManyDocuments->setEnabled(urls.count() > 1);
             insertAsReferenceImages->setEnabled(image() && urls.count() > 1);
 
             popup.addSeparator();
             popup.addAction(cancel);
 
             QAction *action = popup.exec(QCursor::pos());
             if (action != 0 && action != cancel) {
                 QTemporaryFile *tmp = 0;
                 for (QUrl url : urls) {
 
                     if (!url.isLocalFile()) {
                         // download the file and substitute the url
                         KisRemoteFileFetcher fetcher;
                         tmp = new QTemporaryFile();
                         tmp->setAutoRemove(true);
                         if (!fetcher.fetchFile(url, tmp)) {
                             qDebug() << "Fetching" << url << "failed";
                             continue;
                         }
                         url = url.fromLocalFile(tmp->fileName());
                     }
                     if (url.isLocalFile()) {
                         if (action == insertAsNewLayer || action == insertManyLayers) {
                             d->viewManager->imageManager()->importImage(url);
                             activateWindow();
                         }
                         else if (action == insertAsNewFileLayer || action == insertManyFileLayers) {
                             KisNodeCommandsAdapter adapter(viewManager());
                             KisFileLayer *fileLayer = new KisFileLayer(image(), "", url.toLocalFile(),
                                                                        KisFileLayer::None, image()->nextLayerName(), OPACITY_OPAQUE_U8);
                             adapter.addNode(fileLayer, viewManager()->activeNode()->parent(), viewManager()->activeNode());
                         }
                         else if (action == openInNewDocument || action == openManyDocuments) {
                             if (mainWindow()) {
                                 mainWindow()->openDocument(url, KisMainWindow::None);
                             }
                         }
                         else if (action == insertAsReferenceImage || action == insertAsReferenceImages) {
-                            auto *reference = KisReferenceImage::fromFile(url.toLocalFile(), d->viewConverter);
-                            reference->setPosition(d->viewConverter.imageToDocument(cursorPos));
-                            d->referenceImagesDecoration->addReferenceImage(reference);
+                            auto *reference = KisReferenceImage::fromFile(url.toLocalFile(), d->viewConverter, this);
 
-                            KoToolManager::instance()->switchToolRequested("ToolReferenceImages");
+                            if (reference) {
+                                reference->setPosition(d->viewConverter.imageToDocument(cursorPos));
+                                d->referenceImagesDecoration->addReferenceImage(reference);
+
+                                KoToolManager::instance()->switchToolRequested("ToolReferenceImages");
+                            }
                         }
 
                     }
                     delete tmp;
                     tmp = 0;
                 }
             }
         }
     }
 
 }
 
 KisDocument *KisView::document() const
 {
     return d->document;
 }
 
 void KisView::setDocument(KisDocument *document)
 {
     d->document->disconnect(this);
     d->document = document;
     QStatusBar *sb = statusBar();
     if (sb) { // No statusbar in e.g. konqueror
         connect(d->document, SIGNAL(statusBarMessage(const QString&, int)),
                 this, SLOT(slotSavingStatusMessage(const QString&, int)));
         connect(d->document, SIGNAL(clearStatusBarMessage()),
                 this, SLOT(slotClearStatusText()));
     }
 }
 
 void KisView::setDocumentDeleted()
 {
     d->documentDeleted = true;
 }
 
 QPrintDialog *KisView::createPrintDialog(KisPrintJob *printJob, QWidget *parent)
 {
     Q_UNUSED(parent);
     QPrintDialog *printDialog = new QPrintDialog(&printJob->printer(), this);
     printDialog->setMinMax(printJob->printer().fromPage(), printJob->printer().toPage());
     printDialog->setEnabledOptions(printJob->printDialogOptions());
     return printDialog;
 }
 
 
 KisMainWindow * KisView::mainWindow() const
 {
     return dynamic_cast<KisMainWindow *>(window());
 }
 
 void KisView::setSubWindow(QMdiSubWindow *subWindow)
 {
     d->subWindow = subWindow;
 }
 
 QStatusBar * KisView::statusBar() const
 {
     KisMainWindow *mw = mainWindow();
     return mw ? mw->statusBar() : 0;
 }
 
 void KisView::slotSavingStatusMessage(const QString &text, int timeout, bool isAutoSaving)
 {
     QStatusBar *sb = statusBar();
     if (sb) {
         sb->showMessage(text, timeout);
     }
 
     KisConfig cfg;
 
     if (!sb || sb->isHidden() ||
         (!isAutoSaving && cfg.forceShowSaveMessages()) ||
         (cfg.forceShowAutosaveMessages() && isAutoSaving)) {
 
         viewManager()->showFloatingMessage(text, QIcon());
     }
 }
 
 void KisView::slotClearStatusText()
 {
     QStatusBar *sb = statusBar();
     if (sb) {
         sb->clearMessage();
     }
 }
 
 QList<QAction*> KisView::createChangeUnitActions(bool addPixelUnit)
 {
     UnitActionGroup* unitActions = new UnitActionGroup(d->document, addPixelUnit, this);
     return unitActions->actions();
 }
 
 void KisView::closeEvent(QCloseEvent *event)
 {
     // Check whether we're the last (user visible) view
     int viewCount = KisPart::instance()->viewCount(document());
     if (viewCount > 1 || !isVisible()) {
         // there are others still, so don't bother the user
         event->accept();
         return;
     }
 
     if (queryClose()) {
         d->viewManager->statusBar()->setView(0);
         event->accept();
         return;
     }
 
     event->ignore();
 
 }
 
 bool KisView::queryClose()
 {
     if (!document())
         return true;
 
     document()->waitForSavingToComplete();
 
     if (document()->isModified()) {
         QString name;
         if (document()->documentInfo()) {
             name = document()->documentInfo()->aboutInfo("title");
         }
         if (name.isEmpty())
             name = document()->url().fileName();
 
         if (name.isEmpty())
             name = i18n("Untitled");
 
         int res = QMessageBox::warning(this,
                                        i18nc("@title:window", "Krita"),
                                        i18n("<p>The document <b>'%1'</b> has been modified.</p><p>Do you want to save it?</p>", name),
                                        QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel, QMessageBox::Yes);
 
         switch (res) {
         case QMessageBox::Yes : {
             bool isNative = (document()->mimeType() == document()->nativeFormatMimeType());
             if (!viewManager()->mainWindow()->saveDocument(document(), !isNative, false))
                 return false;
             break;
         }
         case QMessageBox::No : {
             KisImageSP image = document()->image();
             image->requestStrokeCancellation();
             viewManager()->blockUntilOperationsFinishedForced(image);
 
             document()->removeAutoSaveFiles();
             document()->setModified(false);   // Now when queryClose() is called by closeEvent it won't do anything.
             break;
         }
         default : // case QMessageBox::Cancel :
             return false;
         }
     }
 
     return true;
 
 }
 
 void KisView::resetImageSizeAndScroll(bool changeCentering,
                                       const QPointF &oldImageStillPoint,
                                       const QPointF &newImageStillPoint)
 {
     const KisCoordinatesConverter *converter = d->canvas.coordinatesConverter();
 
     QPointF oldPreferredCenter = d->canvasController.preferredCenter();
 
     /**
      * Calculating the still point in old coordinates depending on the
      * parameters given
      */
 
     QPointF oldStillPoint;
 
     if (changeCentering) {
         oldStillPoint =
                 converter->imageToWidget(oldImageStillPoint) +
                 converter->documentOffset();
     } else {
         QSize oldDocumentSize = d->canvasController.documentSize();
         oldStillPoint = QPointF(0.5 * oldDocumentSize.width(), 0.5 * oldDocumentSize.height());
     }
 
     /**
      * Updating the document size
      */
 
     QSizeF size(image()->width() / image()->xRes(), image()->height() / image()->yRes());
     KoZoomController *zc = d->zoomManager.zoomController();
     zc->setZoom(KoZoomMode::ZOOM_CONSTANT, zc->zoomAction()->effectiveZoom());
     zc->setPageSize(size);
     zc->setDocumentSize(size, true);
 
     /**
      * Calculating the still point in new coordinates depending on the
      * parameters given
      */
 
     QPointF newStillPoint;
 
     if (changeCentering) {
         newStillPoint =
                 converter->imageToWidget(newImageStillPoint) +
                 converter->documentOffset();
     } else {
         QSize newDocumentSize = d->canvasController.documentSize();
         newStillPoint = QPointF(0.5 * newDocumentSize.width(), 0.5 * newDocumentSize.height());
     }
 
     d->canvasController.setPreferredCenter(oldPreferredCenter - oldStillPoint + newStillPoint);
 }
 
 void KisView::syncLastActiveNodeToDocument()
 {
     KisDocument *doc = document();
     if (doc) {
         doc->setPreActivatedNode(d->currentNode);
     }
 }
 
 void KisView::saveViewState(KisPropertiesConfiguration &config) const
 {
     config.setProperty("file", d->document->url());
     config.setProperty("window", mainWindow()->windowStateConfig().name());
 
     if (d->subWindow) {
         config.setProperty("geometry", d->subWindow->saveGeometry().toBase64());
     }
 
     config.setProperty("zoomMode", (int)zoomController()->zoomMode());
     config.setProperty("zoom", d->canvas.coordinatesConverter()->zoom());
 
     d->canvasController.saveCanvasState(config);
 }
 
 void KisView::restoreViewState(const KisPropertiesConfiguration &config)
 {
     if (d->subWindow) {
         QByteArray geometry = QByteArray::fromBase64(config.getString("geometry", "").toLatin1());
         d->subWindow->restoreGeometry(QByteArray::fromBase64(geometry));
     }
 
     qreal zoom = config.getFloat("zoom", 1.0f);
     int zoomMode = config.getInt("zoomMode", (int)KoZoomMode::ZOOM_PAGE);
     d->zoomManager.zoomController()->setZoom((KoZoomMode::Mode)zoomMode, zoom);
     d->canvasController.restoreCanvasState(config);
 }
 
 void KisView::setCurrentNode(KisNodeSP node)
 {
     d->currentNode = node;
     d->canvas.slotTrySwitchShapeManager();
 
     syncLastActiveNodeToDocument();
 }
 
 KisNodeSP KisView::currentNode() const
 {
     return d->currentNode;
 }
 
 KisLayerSP KisView::currentLayer() const
 {
     KisNodeSP node;
     KisMaskSP mask = currentMask();
     if (mask) {
         node = mask->parent();
     }
     else {
         node = d->currentNode;
     }
     return qobject_cast<KisLayer*>(node.data());
 }
 
 KisMaskSP KisView::currentMask() const
 {
     return dynamic_cast<KisMask*>(d->currentNode.data());
 }
 
 KisSelectionSP KisView::selection()
 {
     KisLayerSP layer = currentLayer();
     if (layer)
         return layer->selection(); // falls through to the global
     // selection, or 0 in the end
     if (image()) {
         return image()->globalSelection();
     }
     return 0;
 }
 
 void KisView::slotSoftProofing(bool softProofing)
 {
     d->softProofing = softProofing;
     QString message;
     if (canvasBase()->image()->colorSpace()->colorDepthId().id().contains("F"))
     {
         message = i18n("Soft Proofing doesn't work in floating point.");
         viewManager()->showFloatingMessage(message,QIcon());
         return;
     }
     if (softProofing){
         message = i18n("Soft Proofing turned on.");
     } else {
         message = i18n("Soft Proofing turned off.");
     }
     viewManager()->showFloatingMessage(message,QIcon());
     canvasBase()->slotSoftProofing(softProofing);
 }
 
 void KisView::slotGamutCheck(bool gamutCheck)
 {
     d->gamutCheck = gamutCheck;
     QString message;
     if (canvasBase()->image()->colorSpace()->colorDepthId().id().contains("F"))
     {
         message = i18n("Gamut Warnings don't work in floating point.");
         viewManager()->showFloatingMessage(message,QIcon());
         return;
     }
 
     if (gamutCheck){
         message = i18n("Gamut Warnings turned on.");
         if (!d->softProofing){
             message += "\n "+i18n("But Soft Proofing is still off.");
         }
     } else {
         message = i18n("Gamut Warnings turned off.");
     }
     viewManager()->showFloatingMessage(message,QIcon());
     canvasBase()->slotGamutCheck(gamutCheck);
 }
 
 bool KisView::softProofing()
 {
     return d->softProofing;
 }
 
 bool KisView::gamutCheck()
 {
     return d->gamutCheck;
 }
 
 void KisView::slotLoadingFinished()
 {
     if (!document()) return;
 
     /**
      * Cold-start of image size/resolution signals
      */
     slotImageResolutionChanged();
 
     if (image()->locked()) {
         // If this is the first view on the image, the image will have been locked
         // so unlock it.
         image()->blockSignals(false);
         image()->unlock();
     }
 
     canvasBase()->initializeImage();
 
     /**
      * Dirty hack alert
      */
     d->zoomManager.zoomController()->setAspectMode(true);
 
     if (viewConverter()) {
         viewConverter()->setZoomMode(KoZoomMode::ZOOM_PAGE);
     }
     connect(image(), SIGNAL(sigColorSpaceChanged(const KoColorSpace*)), this, SIGNAL(sigColorSpaceChanged(const KoColorSpace*)));
     connect(image(), SIGNAL(sigProfileChanged(const KoColorProfile*)), this, SIGNAL(sigProfileChanged(const KoColorProfile*)));
     connect(image(), SIGNAL(sigSizeChanged(QPointF,QPointF)), this, SIGNAL(sigSizeChanged(QPointF,QPointF)));
 
     KisNodeSP activeNode = document()->preActivatedNode();
 
     if (!activeNode) {
         activeNode = image()->rootLayer()->lastChild();
     }
 
     while (activeNode && !activeNode->inherits("KisLayer")) {
         activeNode = activeNode->prevSibling();
     }
 
     setCurrentNode(activeNode);
     zoomManager()->updateImageBoundsSnapping();
 }
 
 void KisView::slotSavingFinished()
 {
     if (d->viewManager && d->viewManager->mainWindow()) {
         d->viewManager->mainWindow()->updateCaption();
     }
 }
 
 KisPrintJob * KisView::createPrintJob()
 {
     return new KisPrintJob(image());
 }
 
 void KisView::slotImageResolutionChanged()
 {
     resetImageSizeAndScroll(false);
     zoomManager()->updateImageBoundsSnapping();
     zoomManager()->updateGUI();
 
     // update KoUnit value for the document
     if (resourceProvider()) {
         resourceProvider()->resourceManager()->
                 setResource(KoCanvasResourceManager::Unit, d->canvas.unit());
     }
 }
 
 void KisView::slotImageSizeChanged(const QPointF &oldStillPoint, const QPointF &newStillPoint)
 {
     resetImageSizeAndScroll(true, oldStillPoint, newStillPoint);
     zoomManager()->updateImageBoundsSnapping();
     zoomManager()->updateGUI();
 }
 
 void KisView::closeView()
 {
     d->subWindow->close();
 }
diff --git a/plugins/impex/libkra/kis_kra_load_visitor.cpp b/plugins/impex/libkra/kis_kra_load_visitor.cpp
index 272fe128c2..e01d6270e7 100644
--- a/plugins/impex/libkra/kis_kra_load_visitor.cpp
+++ b/plugins/impex/libkra/kis_kra_load_visitor.cpp
@@ -1,715 +1,745 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *
  *  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, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_kra_load_visitor.h"
 #include "kis_kra_tags.h"
 #include "flake/kis_shape_layer.h"
 #include "flake/KisReferenceImagesLayer.h"
 #include "KisReferenceImage.h"
+#include <KisImportExportManager.h>
 
 #include <QRect>
 #include <QBuffer>
 #include <QByteArray>
+#include <QMessageBox>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
+#include <KoFileDialog.h>
 #include <KoStore.h>
 #include <KoColorSpace.h>
 
 // kritaimage
 #include <metadata/kis_meta_data_io_backend.h>
 #include <metadata/kis_meta_data_store.h>
 #include <kis_types.h>
 #include <kis_node_visitor.h>
 #include <kis_image.h>
 #include <kis_selection.h>
 #include <kis_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <kis_adjustment_layer.h>
 #include <filter/kis_filter_configuration.h>
 #include <kis_datamanager.h>
 #include <generator/kis_generator_layer.h>
 #include <kis_pixel_selection.h>
 #include <kis_clone_layer.h>
 #include <kis_filter_mask.h>
 #include <kis_transform_mask.h>
 #include <kis_transform_mask_params_interface.h>
 #include "kis_transform_mask_params_factory_registry.h"
 #include <kis_transparency_mask.h>
 #include <kis_selection_mask.h>
 #include <lazybrush/kis_colorize_mask.h>
 #include <lazybrush/kis_lazy_fill_tools.h>
 #include "kis_shape_selection.h"
 #include "kis_colorize_dom_utils.h"
 #include "kis_dom_utils.h"
 #include "kis_raster_keyframe_channel.h"
 #include "kis_paint_device_frames_interface.h"
 
 using namespace KRA;
 
 QString expandEncodedDirectory(const QString& _intern)
 {
     QString intern = _intern;
 
     QString result;
     int pos;
     while ((pos = intern.indexOf('/')) != -1) {
         if (QChar(intern.at(0)).isDigit())
             result += "part";
         result += intern.left(pos + 1);   // copy numbers (or "pictures") + "/"
         intern = intern.mid(pos + 1);   // remove the dir we just processed
     }
 
     if (!intern.isEmpty() && QChar(intern.at(0)).isDigit())
         result += "part";
     result += intern;
     return result;
 }
 
 
 KisKraLoadVisitor::KisKraLoadVisitor(KisImageSP image,
                                      KoStore *store,
                                      QMap<KisNode *, QString> &layerFilenames,
                                      QMap<KisNode *, QString> &keyframeFilenames,
                                      const QString & name,
                                      int syntaxVersion) :
         KisNodeVisitor(),
         m_layerFilenames(layerFilenames),
         m_keyframeFilenames(keyframeFilenames)
 {
     m_external = false;
     m_image = image;
     m_store = store;
     m_name = name;
     m_store->pushDirectory();
     if (m_name.startsWith("/")) {
         m_name.remove(0, 1);
     }
     if (!m_store->enterDirectory(m_name)) {
         QStringList directories = m_store->directoryList();
         dbgKrita << directories;
         if (directories.size() > 0) {
             dbgFile << "Could not locate the directory, maybe some encoding issue? Grab the first directory, that'll be the image one." << m_name << directories;
             m_name = directories.first();
         }
         else {
             dbgFile << "Could not enter directory" << m_name << ", probably an old-style file with 'part' added.";
             m_name = expandEncodedDirectory(m_name);
         }
     }
     else {
         m_store->popDirectory();
     }
     m_syntaxVersion = syntaxVersion;
 }
 
 void KisKraLoadVisitor::setExternalUri(const QString &uri)
 {
     m_external = true;
     m_uri = uri;
 }
 
 bool KisKraLoadVisitor::visit(KisExternalLayer * layer)
 {
     bool result = false;
 
     if (auto *referencesLayer = dynamic_cast<KisReferenceImagesLayer*>(layer)) {
         Q_FOREACH(KoShape *shape, referencesLayer->shapes()) {
             auto *reference = dynamic_cast<KisReferenceImage*>(shape);
             KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(reference, false);
-            reference->loadImage(m_store);
+
+            while (!reference->loadImage(m_store)) {
+                if (!reference->hasLocalFile()) {
+                    m_errorMessages << i18n("Could not load embedded reference image %1 ", reference->url());
+                    break;
+                } else {
+                    QString msg = i18nc(
+                        "@info",
+                        "A reference image linked to an external file could not be loaded.\n\n"
+                        "Path: %1\n\n"
+                        "Do you want to select another location?", reference->url());
+
+                    int locateManually = QMessageBox::warning(0, i18nc("@title:window", "File not found"), msg, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
+
+                    QString url;
+                    if (locateManually == QMessageBox::Yes) {
+                        KoFileDialog dialog(0, KoFileDialog::OpenFile, "OpenDocument");
+                        dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
+                        url = dialog.filename();
+                    }
+
+                    if (url.isEmpty()) {
+                        break;
+                    } else {
+                        reference->setUrl(QString("file://") + url);
+                    }
+                }
+            }
         }
     } else if (KisShapeLayer *shapeLayer = dynamic_cast<KisShapeLayer*>(layer)) {
 
         if (!loadMetaData(layer)) {
             return false;
         }
 
         m_store->pushDirectory();
         m_store->enterDirectory(getLocation(layer, DOT_SHAPE_LAYER)) ;
         result =  shapeLayer->loadLayer(m_store);
         m_store->popDirectory();
 
     }
 
     result = visitAll(layer) && result;
     return result;
 }
 
 bool KisKraLoadVisitor::visit(KisPaintLayer *layer)
 {
     loadNodeKeyframes(layer);
 
     dbgFile << "Visit: " << layer->name() << " colorSpace: " << layer->colorSpace()->id();
     if (!loadPaintDevice(layer->paintDevice(), getLocation(layer))) {
         return false;
     }
     if (!loadProfile(layer->paintDevice(), getLocation(layer, DOT_ICC))) {
         return false;
     }
     if (!loadMetaData(layer)) {
         return false;
     }
 
     if (m_syntaxVersion == 1) {
         // Check whether there is a file with a .mask extension in the
         // layer directory, if so, it's an old-style transparency mask
         // that should be converted.
         QString location = getLocation(layer, ".mask");
 
         if (m_store->open(location)) {
 
             KisSelectionSP selection = KisSelectionSP(new KisSelection());
             KisPixelSelectionSP pixelSelection = selection->pixelSelection();
             if (!pixelSelection->read(m_store->device())) {
                 pixelSelection->disconnect();
             } else {
                 KisTransparencyMask* mask = new KisTransparencyMask();
                 mask->setSelection(selection);
                 m_image->addNode(mask, layer, layer->firstChild());
             }
             m_store->close();
         }
     }
     bool result = visitAll(layer);
     return result;
 }
 
 bool KisKraLoadVisitor::visit(KisGroupLayer *layer)
 {
     if (*layer->colorSpace() != *m_image->colorSpace()) {
         layer->resetCache(m_image->colorSpace());
     }
 
     if (!loadMetaData(layer)) {
         return false;
     }
 
     bool result = visitAll(layer);
     return result;
 }
 
 bool KisKraLoadVisitor::visit(KisAdjustmentLayer* layer)
 {
     loadNodeKeyframes(layer);
 
     // Adjustmentlayers are tricky: there's the 1.x style and the 2.x
     // style, which has selections with selection components
     bool result = true;
     if (m_syntaxVersion == 1) {
         KisSelectionSP selection = new KisSelection();
         KisPixelSelectionSP pixelSelection = selection->pixelSelection();
         result = loadPaintDevice(pixelSelection, getLocation(layer, ".selection"));
         layer->setInternalSelection(selection);
     } else if (m_syntaxVersion == 2) {
         result = loadSelection(getLocation(layer), layer->internalSelection());
 
     } else {
         // We use the default, empty selection
     }
 
     if (!loadMetaData(layer)) {
         return false;
     }
 
     loadFilterConfiguration(layer->filter().data(), getLocation(layer, DOT_FILTERCONFIG));
 
     result = visitAll(layer);
     return result;
 }
 
 bool KisKraLoadVisitor::visit(KisGeneratorLayer *layer)
 {
     if (!loadMetaData(layer)) {
         return false;
     }
     bool result = true;
 
     loadNodeKeyframes(layer);
     result = loadSelection(getLocation(layer), layer->internalSelection());
     result = loadFilterConfiguration(layer->filter().data(), getLocation(layer, DOT_FILTERCONFIG));
     layer->update();
     result = visitAll(layer);
     return result;
 }
 
 bool KisKraLoadVisitor::visit(KisCloneLayer *layer)
 {
     if (!loadMetaData(layer)) {
         return false;
     }
 
     // the layer might have already been lazily initialized
     // from the mask loading code
     if (layer->copyFrom()) {
         return true;
     }
 
     KisNodeSP srcNode = layer->copyFromInfo().findNode(m_image->rootLayer());
     KisLayerSP srcLayer = qobject_cast<KisLayer*>(srcNode.data());
     Q_ASSERT(srcLayer);
 
     layer->setCopyFrom(srcLayer);
 
     // Clone layers have no data except for their masks
     bool result = visitAll(layer);
     return result;
 }
 
 void KisKraLoadVisitor::initSelectionForMask(KisMask *mask)
 {
     KisLayer *cloneLayer = dynamic_cast<KisCloneLayer*>(mask->parent().data());
     if (cloneLayer) {
         // the clone layers should be initialized out of order
         // and lazily, because their original() is still not
         // initialized
         cloneLayer->accept(*this);
     }
 
     KisLayer *parentLayer = qobject_cast<KisLayer*>(mask->parent().data());
     // the KisKraLoader must have already set the parent for us
     Q_ASSERT(parentLayer);
     mask->initSelection(parentLayer);
 }
 
 bool KisKraLoadVisitor::visit(KisFilterMask *mask)
 {
     initSelectionForMask(mask);
 
     loadNodeKeyframes(mask);
 
     bool result = true;
     result = loadSelection(getLocation(mask), mask->selection());
     result = loadFilterConfiguration(mask->filter().data(), getLocation(mask, DOT_FILTERCONFIG));
     return result;
 }
 
 bool KisKraLoadVisitor::visit(KisTransformMask *mask)
 {
     QString location = getLocation(mask, DOT_TRANSFORMCONFIG);
     if (m_store->hasFile(location)) {
         QByteArray data;
         m_store->open(location);
         data = m_store->read(m_store->size());
         m_store->close();
         if (!data.isEmpty()) {
             QDomDocument doc;
             doc.setContent(data);
 
             QDomElement rootElement = doc.documentElement();
 
             QDomElement main;
 
             if (!KisDomUtils::findOnlyElement(rootElement, "main", &main/*, &m_errorMessages*/)) {
                 return false;
             }
 
             QString id = main.attribute("id", "not-valid");
 
             if (id == "not-valid") {
                 m_errorMessages << i18n("Could not load \"id\" of the transform mask");
                 return false;
             }
 
             QDomElement data;
 
             if (!KisDomUtils::findOnlyElement(rootElement, "data", &data, &m_errorMessages)) {
                 return false;
             }
 
             KisTransformMaskParamsInterfaceSP params =
                 KisTransformMaskParamsFactoryRegistry::instance()->createParams(id, data);
 
             if (!params) {
                 m_errorMessages << i18n("Could not create transform mask params");
                 return false;
             }
 
             mask->setTransformParams(params);
 
             loadNodeKeyframes(mask);
             params->clearChangedFlag();
 
             return true;
         }
     }
 
     return false;
 }
 
 bool KisKraLoadVisitor::visit(KisTransparencyMask *mask)
 {
     initSelectionForMask(mask);
 
     loadNodeKeyframes(mask);
 
     return loadSelection(getLocation(mask), mask->selection());
 }
 
 bool KisKraLoadVisitor::visit(KisSelectionMask *mask)
 {
     initSelectionForMask(mask);
     return loadSelection(getLocation(mask), mask->selection());
 }
 
 bool KisKraLoadVisitor::visit(KisColorizeMask *mask)
 {
     m_store->pushDirectory();
     QString location = getLocation(mask, DOT_COLORIZE_MASK);
     m_store->enterDirectory(location) ;
 
     QByteArray data;
     if (!m_store->extractFile("content.xml", data))
         return false;
 
     QDomDocument doc;
     if (!doc.setContent(data))
         return false;
 
     QVector<KisLazyFillTools::KeyStroke> strokes;
     if (!KisDomUtils::loadValue(doc.documentElement(), COLORIZE_KEYSTROKES_SECTION, &strokes, mask->colorSpace()))
         return false;
 
     int i = 0;
     Q_FOREACH (const KisLazyFillTools::KeyStroke &stroke, strokes) {
         const QString fileName = QString("%1_%2").arg(COLORIZE_KEYSTROKE).arg(i++);
         loadPaintDevice(stroke.dev, fileName);
     }
 
     mask->setKeyStrokesDirect(QList<KisLazyFillTools::KeyStroke>::fromVector(strokes));
 
     loadPaintDevice(mask->coloringProjection(), COLORIZE_COLORING_DEVICE);
     mask->resetCache();
 
     m_store->popDirectory();
     return true;
 }
 
 QStringList KisKraLoadVisitor::errorMessages() const
 {
     return m_errorMessages;
 }
 
 QStringList KisKraLoadVisitor::warningMessages() const
 {
     return m_warningMessages;
 }
 
 struct SimpleDevicePolicy
 {
     bool read(KisPaintDeviceSP dev, QIODevice *stream) {
         return dev->read(stream);
     }
 
     void setDefaultPixel(KisPaintDeviceSP dev, const KoColor &defaultPixel) const {
         return dev->setDefaultPixel(defaultPixel);
     }
 };
 
 struct FramedDevicePolicy
 {
     FramedDevicePolicy(int frameId)
         :  m_frameId(frameId) {}
 
     bool read(KisPaintDeviceSP dev, QIODevice *stream) {
         return dev->framesInterface()->readFrame(stream, m_frameId);
     }
 
     void setDefaultPixel(KisPaintDeviceSP dev, const KoColor &defaultPixel) const {
         return dev->framesInterface()->setFrameDefaultPixel(defaultPixel, m_frameId);
     }
 
     int m_frameId;
 };
 
 bool KisKraLoadVisitor::loadPaintDevice(KisPaintDeviceSP device, const QString& location)
 {
     // Layer data
     KisPaintDeviceFramesInterface *frameInterface = device->framesInterface();
     QList<int> frames;
 
     if (frameInterface) {
         frames = device->framesInterface()->frames();
     }
 
     if (!frameInterface || frames.count() <= 1) {
         return loadPaintDeviceFrame(device, location, SimpleDevicePolicy());
     } else {
         KisRasterKeyframeChannel *keyframeChannel = device->keyframeChannel();
 
         for (int i = 0; i < frames.count(); i++) {
             int id = frames[i];
             if (keyframeChannel->frameFilename(id).isEmpty()) {
                 m_warningMessages << i18n("Could not find keyframe pixel data for frame %1 in %2.").arg(id).arg(location);
             }
             else {
                 Q_ASSERT(!keyframeChannel->frameFilename(id).isEmpty());
                 QString frameFilename = getLocation(keyframeChannel->frameFilename(id));
                 Q_ASSERT(!frameFilename.isEmpty());
 
                 if (!loadPaintDeviceFrame(device, frameFilename, FramedDevicePolicy(id))) {
                     m_warningMessages << i18n("Could not load keyframe pixel data for frame %1 in %2.").arg(id).arg(location);
                 }
             }
         }
     }
 
     return true;
 }
 
 template<class DevicePolicy>
 bool KisKraLoadVisitor::loadPaintDeviceFrame(KisPaintDeviceSP device, const QString &location, DevicePolicy policy)
 {
     {
         const int pixelSize = device->colorSpace()->pixelSize();
         KoColor color(Qt::transparent, device->colorSpace());
 
         if (m_store->open(location + ".defaultpixel")) {
             if (m_store->size() == pixelSize) {
                 m_store->read((char*)color.data(), pixelSize);
             }
 
             m_store->close();
         }
 
         policy.setDefaultPixel(device, color);
     }
 
     if (m_store->open(location)) {
         if (!policy.read(device, m_store->device())) {
             m_warningMessages << i18n("Could not read pixel data: %1.", location);
             device->disconnect();
             m_store->close();
             return true;
         }
         m_store->close();
     } else {
         m_warningMessages << i18n("Could not load pixel data: %1.", location);
         return true;
     }
 
     return true;
 }
 
 
 bool KisKraLoadVisitor::loadProfile(KisPaintDeviceSP device, const QString& location)
 {
 
     if (m_store->hasFile(location)) {
         m_store->open(location);
         QByteArray data; data.resize(m_store->size());
         dbgFile << "Data to load: " << m_store->size() << " from " << location << " with color space " << device->colorSpace()->id();
         int read = m_store->read(data.data(), m_store->size());
         dbgFile << "Profile size: " << data.size() << " " << m_store->atEnd() << " " << m_store->device()->bytesAvailable() << " " << read;
         m_store->close();
         // Create a colorspace with the embedded profile
         const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(device->colorSpace()->colorModelId().id(), device->colorSpace()->colorDepthId().id(), data);
         if (device->setProfile(profile)) {
             return true;
         }
     }
     m_warningMessages << i18n("Could not load profile: %1.", location);
     return true;
 }
 
 bool KisKraLoadVisitor::loadFilterConfiguration(KisFilterConfigurationSP kfc, const QString& location)
 {
     if (m_store->hasFile(location)) {
         QByteArray data;
         m_store->open(location);
         data = m_store->read(m_store->size());
         m_store->close();
         if (!data.isEmpty()) {
             QDomDocument doc;
             doc.setContent(data);
             QDomElement e = doc.documentElement();
             if (e.tagName() == "filterconfig") {
                 kfc->fromLegacyXML(e);
             } else {
                 kfc->fromXML(e);
             }
             loadDeprecatedFilter(kfc);
             return true;
         }
     }
     m_warningMessages << i18n("Could not filter configuration %1.", location);
     return true;
 }
 
 bool KisKraLoadVisitor::loadMetaData(KisNode* node)
 {
     KisLayer* layer = qobject_cast<KisLayer*>(node);
     if (!layer) return true;
 
     KisMetaData::IOBackend* backend = KisMetaData::IOBackendRegistry::instance()->get("xmp");
 
     if (!backend || !backend->supportLoading()) {
         if (backend)
             dbgFile << "Backend " << backend->id() << " does not support loading.";
         else
             dbgFile << "Could not load the XMP backend at all";
         return true;
     }
 
     QString location = getLocation(node, QString(".") + backend->id() +  DOT_METADATA);
     dbgFile << "going to load " << backend->id() << ", " << backend->name() << " from " << location;
 
     if (m_store->hasFile(location)) {
         QByteArray data;
         m_store->open(location);
         data = m_store->read(m_store->size());
         m_store->close();
         QBuffer buffer(&data);
         if (!backend->loadFrom(layer->metaData(), &buffer)) {
             m_warningMessages << i18n("Could not load metadata for layer %1.", layer->name());
         }
     }
     return true;
 }
 
 bool KisKraLoadVisitor::loadSelection(const QString& location, KisSelectionSP dstSelection)
 {
     // by default the selection is expected to be fully transparent
     {
         KisPixelSelectionSP pixelSelection = dstSelection->pixelSelection();
         KoColor transparent(Qt::transparent, pixelSelection->colorSpace());
         pixelSelection->setDefaultPixel(transparent);
     }
 
     // Pixel selection
     bool result = true;
     QString pixelSelectionLocation = location + DOT_PIXEL_SELECTION;
     if (m_store->hasFile(pixelSelectionLocation)) {
         KisPixelSelectionSP pixelSelection = dstSelection->pixelSelection();
         result = loadPaintDevice(pixelSelection, pixelSelectionLocation);
         if (!result) {
             m_warningMessages << i18n("Could not load raster selection %1.", location);
         }
         pixelSelection->invalidateOutlineCache();
     }
 
     // Shape selection
     QString shapeSelectionLocation = location + DOT_SHAPE_SELECTION;
     if (m_store->hasFile(shapeSelectionLocation + "/content.svg") ||
         m_store->hasFile(shapeSelectionLocation + "/content.xml")) {
 
         m_store->pushDirectory();
         m_store->enterDirectory(shapeSelectionLocation) ;
 
         KisShapeSelection* shapeSelection = new KisShapeSelection(m_image, dstSelection);
         dstSelection->setShapeSelection(shapeSelection);
         result = shapeSelection->loadSelection(m_store);
         m_store->popDirectory();
         if (!result) {
             m_warningMessages << i18n("Could not load vector selection %1.", location);
         }
     }
     return true;
 }
 
 QString KisKraLoadVisitor::getLocation(KisNode* node, const QString& suffix)
 {
     return getLocation(m_layerFilenames[node], suffix);
 }
 
 QString KisKraLoadVisitor::getLocation(const QString &filename, const QString& suffix)
 {
     QString location = m_external ? QString() : m_uri;
     location += m_name + LAYER_PATH + filename + suffix;
     return location;
 }
 
 void KisKraLoadVisitor::loadNodeKeyframes(KisNode *node)
 {
     if (!m_keyframeFilenames.contains(node)) return;
 
     node->enableAnimation();
 
     const QString &location = getLocation(m_keyframeFilenames[node]);
 
     if (!m_store->open(location)) {
         m_errorMessages << i18n("Could not load keyframes from %1.", location);
         return;
     }
 
     QString errorMsg;
     int errorLine;
     int errorColumn;
 
     QDomDocument dom;
     bool ok = dom.setContent(m_store->device(), &errorMsg, &errorLine, &errorColumn);
     m_store->close();
 
 
     if (!ok) {
         m_errorMessages << i18n("parsing error in the keyframe file %1 at line %2, column %3\nError message: %4", location, errorLine, errorColumn, i18n(errorMsg.toUtf8()));
         return;
     }
 
     QDomElement root = dom.firstChildElement();
 
     for (QDomElement child = root.firstChildElement(); !child.isNull(); child = child.nextSiblingElement()) {
         if (child.nodeName().toUpper() == "CHANNEL") {
             QString id = child.attribute("name");
 
             KisKeyframeChannel *channel = node->getKeyframeChannel(id, true);
 
             if (!channel) {
                 m_warningMessages << i18n("unknown keyframe channel type: %1 in %2", id, location);
                 continue;
             }
 
             channel->loadXML(child);
         }
     }
 }
 
 void KisKraLoadVisitor::loadDeprecatedFilter(KisFilterConfigurationSP cfg)
 {
     if (cfg->getString("legacy") == "left edge detections") {
         cfg->setProperty("horizRadius", 1);
         cfg->setProperty("vertRadius", 1);
         cfg->setProperty("type", "prewitt");
         cfg->setProperty("output", "yFall");
         cfg->setProperty("lockAspect", true);
         cfg->setProperty("transparency", false);
     } else if (cfg->getString("legacy") == "right edge detections") {
         cfg->setProperty("horizRadius", 1);
         cfg->setProperty("vertRadius", 1);
         cfg->setProperty("type", "prewitt");
         cfg->setProperty("output", "yGrowth");
         cfg->setProperty("lockAspect", true);
         cfg->setProperty("transparency", false);
     } else if (cfg->getString("legacy") == "top edge detections") {
         cfg->setProperty("horizRadius", 1);
         cfg->setProperty("vertRadius", 1);
         cfg->setProperty("type", "prewitt");
         cfg->setProperty("output", "xGrowth");
         cfg->setProperty("lockAspect", true);
         cfg->setProperty("transparency", false);
     } else if (cfg->getString("legacy") == "bottom edge detections") {
         cfg->setProperty("horizRadius", 1);
         cfg->setProperty("vertRadius", 1);
         cfg->setProperty("type", "prewitt");
         cfg->setProperty("output", "xFall");
         cfg->setProperty("lockAspect", true);
         cfg->setProperty("transparency", false);
     }
 }
diff --git a/plugins/tools/defaulttool/referenceimagestool/KisReferenceImageCollection.cpp b/plugins/tools/defaulttool/referenceimagestool/KisReferenceImageCollection.cpp
index e8526477f1..652c1799d7 100644
--- a/plugins/tools/defaulttool/referenceimagestool/KisReferenceImageCollection.cpp
+++ b/plugins/tools/defaulttool/referenceimagestool/KisReferenceImageCollection.cpp
@@ -1,96 +1,113 @@
 /*
  *  Copyright (c) 2018 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  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, Boston, MA 02110-1301, USA.
  */
 #include "KisReferenceImageCollection.h"
 
 #include <QIODevice>
+#include <QMessageBox>
 
 #include <libs/store/KoStore.h>
 #include <KisReferenceImage.h>
 #include <libs/store/KoStoreDevice.h>
 
 const QString METADATA_FILE = "reference_images.xml";
 
 KisReferenceImageCollection::KisReferenceImageCollection(const QVector<KisReferenceImage *> &references)
     : references(references)
 {}
 
 const QVector<KisReferenceImage*> &KisReferenceImageCollection::referenceImages() const
 {
     return references;
 }
 
 bool KisReferenceImageCollection::save(QIODevice *io)
 {
     QScopedPointer<KoStore> store(KoStore::createStore(io, KoStore::Write, "application/x-krita-reference-images]", KoStore::Zip));
     if (store.isNull()) return false;
 
     QDomDocument doc;
     QDomElement root = doc.createElement("referenceimages");
     doc.insertBefore(root, QDomNode());
 
     int nextId = 0;
     Q_FOREACH(KisReferenceImage *reference, references) {
         reference->saveXml(doc, root, nextId++);
 
         if (reference->embed()) {
             bool ok = reference->saveImage(store.data());
             if (!ok) return false;
         }
     }
 
     if (!store->open(METADATA_FILE)) {
         return false;
     }
 
     KoStoreDevice xmlDev(store.data());
     xmlDev.write(doc.toByteArray());
     xmlDev.close();
     store->close();
 
     return true;
 }
 
 bool KisReferenceImageCollection::load(QIODevice *io)
 {
     QScopedPointer<KoStore> store(KoStore::createStore(io, KoStore::Read, "application/x-krita-reference-images", KoStore::Zip));
     if (!store || store->bad()) {
         return false;
     }
 
     if (!store->hasFile(METADATA_FILE) || !store->open(METADATA_FILE)) {
         return false;
     }
 
     QByteArray xml = store->device()->readAll();
     store->close();
 
     QDomDocument doc;
     doc.setContent(xml);
     QDomElement root = doc.documentElement();
 
+    QStringList failures;
+
     QDomElement element = root.firstChildElement("referenceimage");
     while (!element.isNull()) {
         KisReferenceImage *reference = KisReferenceImage::fromXml(element);
-        reference->loadImage(store.data());
-        references.append(reference);
 
+        if (reference->loadImage(store.data())) {
+            references.append(reference);
+        } else {
+            failures << reference->url();
+            delete reference;
+        }
         element = element.nextSiblingElement("referenceimage");
     }
 
+    if (!failures.isEmpty()) {
+        QMessageBox::warning(
+                0,
+                i18nc("@title:window", "Krita"),
+                "The following reference images could not be loaded:\n" + failures.join('\n'),
+                QMessageBox::Ok, QMessageBox::Ok
+        );
+
+    }
+
     return true;
 }
diff --git a/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.cpp b/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.cpp
index d339ce9e79..cfd0ced1fc 100644
--- a/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.cpp
+++ b/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.cpp
@@ -1,262 +1,264 @@
 /*
  * Copyright (c) 2017 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  This library 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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "ToolReferenceImages.h"
 
 #include <QDesktopServices>
 #include <QFile>
 #include <QLayout>
 #include <QMenu>
 #include <QMessageBox>
 #include <QVector>
 
 #include <KoSelection.h>
 #include <KoShapeRegistry.h>
 #include <KoShapeManager.h>
 #include <KoShapeController.h>
 #include <KoFileDialog.h>
 
 #include <kis_canvas2.h>
 #include <kis_canvas_resource_provider.h>
 #include <KisViewManager.h>
 #include <KisDocument.h>
 #include <KisReferenceImagesLayer.h>
 #include <kis_image.h>
 
 #include "ToolReferenceImagesWidget.h"
 #include "KisReferenceImageCollection.h"
 
 ToolReferenceImages::ToolReferenceImages(KoCanvasBase * canvas)
     : DefaultTool(canvas)
 {
     setObjectName("ToolReferenceImages");
 }
 
 ToolReferenceImages::~ToolReferenceImages()
 {
 }
 
 void ToolReferenceImages::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
     DefaultTool::activate(toolActivation, shapes);
 
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     connect(kisCanvas->image(), SIGNAL(sigNodeAddedAsync(KisNodeSP)), this, SLOT(slotNodeAdded(KisNodeSP)));
 
     auto referenceImageLayer = document()->referenceImagesLayer();
     if (referenceImageLayer) {
         setReferenceImageLayer(referenceImageLayer);
     }
 }
 
 void ToolReferenceImages::deactivate()
 {
     DefaultTool::deactivate();
 }
 
 void ToolReferenceImages::slotNodeAdded(KisNodeSP node)
 {
     auto *referenceImagesLayer = dynamic_cast<KisReferenceImagesLayer*>(node.data());
 
     if (referenceImagesLayer) {
         setReferenceImageLayer(referenceImagesLayer);
     }
 }
 
 void ToolReferenceImages::setReferenceImageLayer(KisSharedPtr<KisReferenceImagesLayer> layer)
 {
     m_layer = layer;
     connect(layer.data(), SIGNAL(selectionChanged()), this, SLOT(slotSelectionChanged()));
 }
 
 void ToolReferenceImages::addReferenceImage()
 {
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas)
 
     KoFileDialog dialog(kisCanvas->viewManager()->mainWindow(), KoFileDialog::OpenFile, "OpenReferenceImage");
     dialog.setCaption(i18n("Select a Reference Image"));
 
     QStringList locations = QStandardPaths::standardLocations(QStandardPaths::PicturesLocation);
     if (!locations.isEmpty()) {
         dialog.setDefaultDir(locations.first());
     }
 
     QString filename = dialog.filename();
     if (filename.isEmpty()) return;
     if (!QFileInfo(filename).exists()) return;
 
-    auto *reference = KisReferenceImage::fromFile(filename, *kisCanvas->coordinatesConverter());
+    auto *reference = KisReferenceImage::fromFile(filename, *kisCanvas->coordinatesConverter(), canvas()->canvasWidget());
 
-    KisDocument *doc = document();
-    doc->addCommand(KisReferenceImagesLayer::addReferenceImages(doc, {reference}));
+    if (reference) {
+        KisDocument *doc = document();
+        doc->addCommand(KisReferenceImagesLayer::addReferenceImages(doc, {reference}));
+    }
 }
 
 void ToolReferenceImages::removeAllReferenceImages()
 {
     auto layer = m_layer.toStrongRef();
     if (!layer) return;
 
     canvas()->addCommand(layer->removeReferenceImages(document(), layer->shapes()));
 }
 
 void ToolReferenceImages::loadReferenceImages()
 {
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas)
 
     KoFileDialog dialog(kisCanvas->viewManager()->mainWindow(), KoFileDialog::OpenFile, "OpenReferenceImageCollection");
     dialog.setMimeTypeFilters(QStringList() << "application/x-krita-reference-images");
     dialog.setCaption(i18n("Load Reference Images"));
 
     QStringList locations = QStandardPaths::standardLocations(QStandardPaths::PicturesLocation);
     if (!locations.isEmpty()) {
         dialog.setDefaultDir(locations.first());
     }
 
     QString filename = dialog.filename();
     if (filename.isEmpty()) return;
     if (!QFileInfo(filename).exists()) return;
 
     QFile file(filename);
     if (!file.open(QIODevice::ReadOnly)) {
         QMessageBox::critical(nullptr, i18nc("@title:window", "Krita"), i18n("Could not open '%1'.", filename));
         return;
     }
 
     KisReferenceImageCollection collection;
     if (collection.load(&file)) {
         QList<KoShape*> shapes;
         Q_FOREACH(auto *reference, collection.referenceImages()) {
             shapes.append(reference);
         }
 
         KisDocument *doc = document();
         doc->addCommand(KisReferenceImagesLayer::addReferenceImages(doc, shapes));
     } else {
         QMessageBox::critical(nullptr, i18nc("@title:window", "Krita"), i18n("Could not load reference images from '%1'.", filename));
     }
     file.close();
 }
 
 void ToolReferenceImages::saveReferenceImages()
 {
     auto layer = m_layer.toStrongRef();
     if (!layer || layer->shapeCount() == 0) return;
 
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas)
 
     KoFileDialog dialog(kisCanvas->viewManager()->mainWindow(), KoFileDialog::SaveFile, "SaveReferenceImageCollection");
     dialog.setMimeTypeFilters(QStringList() << "application/x-krita-reference-images");
     dialog.setCaption(i18n("Save Reference Images"));
 
     QStringList locations = QStandardPaths::standardLocations(QStandardPaths::PicturesLocation);
     if (!locations.isEmpty()) {
         dialog.setDefaultDir(locations.first());
     }
 
     QString filename = dialog.filename();
     if (filename.isEmpty()) return;
 
     QFile file(filename);
     if (!file.open(QIODevice::WriteOnly)) {
         QMessageBox::critical(nullptr, i18nc("@title:window", "Krita"), i18n("Could not open '%1' for saving.", filename));
         return;
     }
 
     KisReferenceImageCollection collection(layer->referenceImages());
     bool ok = collection.save(&file);
     file.close();
 
     if (!ok) {
         QMessageBox::critical(nullptr, i18nc("@title:window", "Krita"), i18n("Failed to save reference images.", filename));
     }
 }
 
 void ToolReferenceImages::slotSelectionChanged()
 {
     auto layer = m_layer.toStrongRef();
     if (!layer) return;
 
     m_optionsWidget->selectionChanged(layer->shapeManager()->selection());
     updateActions();
 }
 
 QList<QPointer<QWidget>> ToolReferenceImages::createOptionWidgets()
 {
     // Instead of inheriting DefaultTool's multi-tab implementation, inherit straight from KoToolBase
     return KoToolBase::createOptionWidgets();
 }
 
 QWidget *ToolReferenceImages::createOptionWidget()
 {
     if (!m_optionsWidget) {
         m_optionsWidget = new ToolReferenceImagesWidget(this);
         // See https://bugs.kde.org/show_bug.cgi?id=316896
         QWidget *specialSpacer = new QWidget(m_optionsWidget);
         specialSpacer->setObjectName("SpecialSpacer");
         specialSpacer->setFixedSize(0, 0);
         m_optionsWidget->layout()->addWidget(specialSpacer);
     }
     return m_optionsWidget;
  }
 
 bool ToolReferenceImages::isValidForCurrentLayer() const
 {
     return true;
 }
 
 KoShapeManager *ToolReferenceImages::shapeManager() const
 {
     auto layer = m_layer.toStrongRef();
     return layer ? layer->shapeManager() : nullptr;
 }
 
 KoSelection *ToolReferenceImages::koSelection() const
 {
     auto manager = shapeManager();
     return manager ? manager->selection() : nullptr;
 }
 
 void ToolReferenceImages::updateDistinctiveActions(const QList<KoShape*> &)
 {
     action("object_group")->setEnabled(false);
     action("object_unite")->setEnabled(false);
     action("object_intersect")->setEnabled(false);
     action("object_subtract")->setEnabled(false);
     action("object_split")->setEnabled(false);
     action("object_ungroup")->setEnabled(false);
 }
 
 void ToolReferenceImages::deleteSelection()
 {
     auto layer = m_layer.toStrongRef();
     if (!layer) return;
 
     QList<KoShape *> shapes = koSelection()->selectedShapes();
 
     if (!shapes.empty()) {
         canvas()->addCommand(layer->removeReferenceImages(document(), shapes));
     }
 }
 
 KisDocument *ToolReferenceImages::document() const
 {
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     return kisCanvas->imageView()->document();
 }