diff --git a/libs/ui/KisReferenceImage.cpp b/libs/ui/KisReferenceImage.cpp
index 5e86d9481b..88f589ee5b 100644
--- a/libs/ui/KisReferenceImage.cpp
+++ b/libs/ui/KisReferenceImage.cpp
@@ -1,312 +1,330 @@
 /*
  * 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;
+
+    // Filename within .kra (for embedding)
+    QString internalFilename;
+
+    // File on disk (for linking)
+    QString externalFilename;
 
     QImage image;
     QImage cachedImage;
 
     qreal saturation{1.0};
     int id{-1};
     bool embed{true};
 
     explicit Private(KisReferenceImage *q)
         : q(q)
     {}
 
     bool loadFromFile() {
-        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(src.startsWith("file://"), false);
-        QString filename = src.mid(7);
-        return image.load(filename);
+        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!externalFilename.isEmpty(), false);
+        return image.load(externalFilename);
     }
 
     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, QWidget *parent)
 {
     KisReferenceImage *reference = new KisReferenceImage();
-    reference->d->src = QString("file://") + filename;
+    reference->d->externalFilename = filename;
     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));
         }
 
         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://"));
+    KIS_SAFE_ASSERT_RECOVER_RETURN(embed || !d->externalFilename.isEmpty());
     d->embed = embed;
 }
 
 bool KisReferenceImage::embed()
 {
     return d->embed;
 }
 
 bool KisReferenceImage::hasLocalFile()
 {
-    return d->src.startsWith("file://");
+    return !d->externalFilename.isEmpty();
 }
 
-QString KisReferenceImage::url() const
+QString KisReferenceImage::filename() const
 {
-    return d->src;
+    return d->externalFilename;
 }
 
-void KisReferenceImage::setUrl(const QString &url)
+QString KisReferenceImage::internalFile() const
 {
-    d->src = url;
+    return d->internalFilename;
+}
+
+
+void KisReferenceImage::setFilename(const QString &filename)
+{
+    d->externalFilename = filename;
     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);
+        d->internalFilename = QString("reference_images/%1.png").arg(id);
     }
-    element.setAttribute("src", d->src);
+    
+    const QString src = d->embed ? d->internalFilename : (QString("file://") + d->externalFilename);
+    element.setAttribute("src", 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://");
+
+    if (src.startsWith("file://")) {
+        reference->d->externalFilename = src.mid(7);
+        reference->d->embed = false;
+    } else {
+        reference->d->internalFilename = src;
+        reference->d->embed = true;
+    }
 
     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)) {
+    if (!store->open(d->internalFilename)) {
         return false;
     }
 
     bool saved = false;
 
     KoStoreDevice storeDev(store);
     if (storeDev.open(QIODevice::WriteOnly)) {
         saved = d->image.save(&storeDev, "PNG");
     }
 
     return store->close() && saved;
 }
 
 bool KisReferenceImage::loadImage(KoStore *store)
 {
-    if (d->src.startsWith("file://")) {
+    if (!d->embed) {
         return d->loadFromFile();
     }
 
-    if (!store->open(d->src)) {
+    if (!store->open(d->internalFilename)) {
         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 def2e5e033..4e7193acaf 100644
--- a/libs/ui/KisReferenceImage.h
+++ b/libs/ui/KisReferenceImage.h
@@ -1,95 +1,96 @@
 /*
  * 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;
 
     /**
      * 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 setFilename(const QString &filename);
+    QString filename() const;
+    QString internalFile() 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/plugins/impex/libkra/kis_kra_load_visitor.cpp b/plugins/impex/libkra/kis_kra_load_visitor.cpp
index e01d6270e7..049828daa1 100644
--- a/plugins/impex/libkra/kis_kra_load_visitor.cpp
+++ b/plugins/impex/libkra/kis_kra_load_visitor.cpp
@@ -1,745 +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);
 
             while (!reference->loadImage(m_store)) {
-                if (!reference->hasLocalFile()) {
-                    m_errorMessages << i18n("Could not load embedded reference image %1 ", reference->url());
+                if (reference->embed()) {
+                    m_errorMessages << i18n("Could not load embedded reference image %1 ", reference->internalFile());
                     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());
+                        "Do you want to select another location?", reference->filename());
 
                     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);
+                        reference->setFilename(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/impex/libkra/kis_kra_save_visitor.cpp b/plugins/impex/libkra/kis_kra_save_visitor.cpp
index 28e9cb0e55..4258c9303d 100644
--- a/plugins/impex/libkra/kis_kra_save_visitor.cpp
+++ b/plugins/impex/libkra/kis_kra_save_visitor.cpp
@@ -1,549 +1,549 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *  Copyright (c) 2007-2008 Boudewijn Rempt <boud@valdyas.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, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_kra_save_visitor.h"
 #include "kis_kra_tags.h"
 
 #include <QBuffer>
 #include <QByteArray>
 
 #include <KoColorProfile.h>
 #include <KoStore.h>
 #include <KoColorSpace.h>
 
 #include <filter/kis_filter_configuration.h>
 #include <generator/kis_generator_layer.h>
 #include <kis_adjustment_layer.h>
 #include <kis_annotation.h>
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_selection.h>
 #include <kis_shape_layer.h>
 #include <KisReferenceImagesLayer.h>
 #include <KisReferenceImage.h>
 #include <kis_file_layer.h>
 #include <kis_clone_layer.h>
 #include <kis_mask.h>
 #include <kis_filter_mask.h>
 #include <kis_transform_mask.h>
 #include <kis_transform_mask_params_interface.h>
 #include <kis_transparency_mask.h>
 #include <kis_selection_mask.h>
 #include "lazybrush/kis_colorize_mask.h"
 #include <kis_selection_component.h>
 #include <kis_pixel_selection.h>
 #include <metadata/kis_meta_data_store.h>
 #include <metadata/kis_meta_data_io_backend.h>
 
 #include "kis_config.h"
 #include "kis_store_paintdevice_writer.h"
 #include "flake/kis_shape_selection.h"
 
 #include "kis_raster_keyframe_channel.h"
 #include "kis_paint_device_frames_interface.h"
 
 #include "lazybrush/kis_lazy_fill_tools.h"
 #include <KoStoreDevice.h>
 #include "kis_colorize_dom_utils.h"
 #include "kis_dom_utils.h"
 
 
 using namespace KRA;
 
 KisKraSaveVisitor::KisKraSaveVisitor(KoStore *store, const QString & name, QMap<const KisNode*, QString> nodeFileNames)
     : KisNodeVisitor()
     , m_store(store)
     , m_external(false)
     , m_name(name)
     , m_nodeFileNames(nodeFileNames)
     , m_writer(new KisStorePaintDeviceWriter(store))
 {
 }
 
 KisKraSaveVisitor::~KisKraSaveVisitor()
 {
     delete m_writer;
 }
 
 void KisKraSaveVisitor::setExternalUri(const QString &uri)
 {
     m_external = true;
     m_uri = uri;
 }
 
 bool KisKraSaveVisitor::visit(KisExternalLayer * layer)
 {
     bool result = false;
     if (auto* referencesLayer = dynamic_cast<KisReferenceImagesLayer*>(layer)) {
         result = true;
         Q_FOREACH(KoShape *shape, referencesLayer->shapes()) {
             auto *reference = dynamic_cast<KisReferenceImage*>(shape);
             KIS_ASSERT_RECOVER_RETURN_VALUE(reference, false);
             bool saved = reference->saveImage(m_store);
             if (!saved) {
-                m_errorMessages << i18n("Failed to save reference image %1.", reference->url());
+                m_errorMessages << i18n("Failed to save reference image %1.", reference->internalFile());
                 result = false;
             }
         }
     }
     else if (KisShapeLayer *shapeLayer = dynamic_cast<KisShapeLayer*>(layer)) {
         if (!saveMetaData(layer)) {
             m_errorMessages << i18n("Failed to save the metadata for layer %1.", layer->name());
             return false;
         }
         m_store->pushDirectory();
         QString location = getLocation(layer, DOT_SHAPE_LAYER);
         result = m_store->enterDirectory(location);
         if (!result) {
             m_errorMessages << i18n("Failed to open %1.", location);
         }
         else {
             result = shapeLayer->saveLayer(m_store);
             m_store->popDirectory();
         }
     }
     else if (KisFileLayer *fileLayer = dynamic_cast<KisFileLayer*>(layer)) {
         Q_UNUSED(fileLayer); // We don't save data for file layers, but we still want to save the masks.
         result = true;
     }
     return result && visitAllInverse(layer);
 }
 
 bool KisKraSaveVisitor::visit(KisPaintLayer *layer)
 {
     if (!savePaintDevice(layer->paintDevice(), getLocation(layer))) {
         m_errorMessages << i18n("Failed to save the pixel data for layer %1.", layer->name());
         return false;
     }
     if (!saveAnnotations(layer)) {
         m_errorMessages << i18n("Failed to save the annotations for layer %1.", layer->name());
         return false;
     }
     if (!saveMetaData(layer)) {
         m_errorMessages << i18n("Failed to save the metadata for layer %1.", layer->name());
         return false;
     }
     return visitAllInverse(layer);
 }
 
 bool KisKraSaveVisitor::visit(KisGroupLayer *layer)
 {
     if (!saveMetaData(layer)) {
         m_errorMessages << i18n("Failed to save the metadata for layer %1.", layer->name());
         return false;
     }
     return visitAllInverse(layer);
 }
 
 bool KisKraSaveVisitor::visit(KisAdjustmentLayer* layer)
 {
     if (!layer->filter()) {
         m_errorMessages << i18n("Failed to save the filter layer %1: it has no filter.", layer->name());
         return false;
     }
     if (!saveSelection(layer)) {
         m_errorMessages << i18n("Failed to save the selection for filter layer %1.", layer->name());
         return false;
     }
     if (!saveFilterConfiguration(layer)) {
         m_errorMessages << i18n("Failed to save the filter configuration for filter layer %1.", layer->name());
         return false;
     }
     if (!saveMetaData(layer)) {
         m_errorMessages << i18n("Failed to save the metadata for layer %1.", layer->name());
         return false;
     }
     return visitAllInverse(layer);
 }
 
 bool KisKraSaveVisitor::visit(KisGeneratorLayer * layer)
 {
     if (!saveSelection(layer)) {
         m_errorMessages << i18n("Failed to save the selection for layer %1.", layer->name());
         return false;
     }
     if (!saveFilterConfiguration(layer)) {
         m_errorMessages << i18n("Failed to save the generator configuration for layer %1.", layer->name());
         return false;
     }
     if (!saveMetaData(layer)) {
         m_errorMessages << i18n("Failed to save the metadata for layer %1.", layer->name());
         return false;
     }
     return visitAllInverse(layer);
 }
 
 bool KisKraSaveVisitor::visit(KisCloneLayer *layer)
 {
     // Clone layers do not have a profile
     if (!saveMetaData(layer)) {
         m_errorMessages << i18n("Failed to save the metadata for layer %1.", layer->name());
         return false;
     }
     return visitAllInverse(layer);
 }
 
 bool KisKraSaveVisitor::visit(KisFilterMask *mask)
 {
     if (!mask->filter()) {
         m_errorMessages << i18n("Failed to save filter mask %1. It has no filter.", mask->name());
         return false;
     }
     if (!saveSelection(mask)) {
         m_errorMessages << i18n("Failed to save the selection for filter mask %1.", mask->name());
         return false;
     }
     if (!saveFilterConfiguration(mask)) {
         m_errorMessages << i18n("Failed to save the filter configuration for filter mask %1.", mask->name());
         return false;
     }
     return true;
 }
 
 bool KisKraSaveVisitor::visit(KisTransformMask *mask)
 {
     QDomDocument doc("transform_params");
 
     QDomElement root = doc.createElement("transform_params");
 
     QDomElement main = doc.createElement("main");
     main.setAttribute("id", mask->transformParams()->id());
 
     QDomElement data = doc.createElement("data");
     mask->transformParams()->toXML(&data);
 
     doc.appendChild(root);
     root.appendChild(main);
     root.appendChild(data);
 
     QString location = getLocation(mask, DOT_TRANSFORMCONFIG);
     if (m_store->open(location)) {
         QByteArray a = doc.toByteArray();
         bool retval = m_store->write(a) == a.size();
 
         if (!retval) {
             warnFile << "Could not write transform mask configuration";
         }
         if (!m_store->close()) {
             warnFile << "Could not close store after writing transform mask configuration";
             retval = false;
         }
         return retval;
     }
     return false;
 }
 
 bool KisKraSaveVisitor::visit(KisTransparencyMask *mask)
 {
     if (!saveSelection(mask)) {
         m_errorMessages << i18n("Failed to save the selection for transparency mask %1.", mask->name());
         return false;
     }
     return true;
 }
 
 bool KisKraSaveVisitor::visit(KisSelectionMask *mask)
 {
     if (!saveSelection(mask)) {
         m_errorMessages << i18n("Failed to save the selection for local selection %1.", mask->name());
         return false;
     }
     return true;
 }
 
 bool KisKraSaveVisitor::visit(KisColorizeMask *mask)
 {
     m_store->pushDirectory();
     QString location = getLocation(mask, DOT_COLORIZE_MASK);
     bool result = m_store->enterDirectory(location);
 
     if (!result) {
         m_errorMessages << i18n("Failed to open %1.", location);
         return false;
     }
 
     if (!m_store->open("content.xml"))
         return false;
 
     KoStoreDevice storeDev(m_store);
 
     QDomDocument doc("doc");
     QDomElement root = doc.createElement("colorize");
     doc.appendChild(root);
     KisDomUtils::saveValue(&root, COLORIZE_KEYSTROKES_SECTION, QVector<KisLazyFillTools::KeyStroke>::fromList(mask->fetchKeyStrokesDirect()));
 
     QTextStream stream(&storeDev);
     stream << doc;
 
     if (!m_store->close())
         return false;
 
     int i = 0;
     Q_FOREACH (const KisLazyFillTools::KeyStroke &stroke, mask->fetchKeyStrokesDirect()) {
         const QString fileName = QString("%1_%2").arg(COLORIZE_KEYSTROKE).arg(i++);
         savePaintDevice(stroke.dev, fileName);
     }
 
     savePaintDevice(mask->coloringProjection(), COLORIZE_COLORING_DEVICE);
 
     m_store->popDirectory();
 
     return true;
 }
 
 QStringList KisKraSaveVisitor::errorMessages() const
 {
     return m_errorMessages;
 }
 
 struct SimpleDevicePolicy
 {
     bool write(KisPaintDeviceSP dev, KisPaintDeviceWriter &store) {
         return dev->write(store);
     }
 
     KoColor defaultPixel(KisPaintDeviceSP dev) const {
         return dev->defaultPixel();
     }
 };
 
 struct FramedDevicePolicy
 {
     FramedDevicePolicy(int frameId)
         :  m_frameId(frameId) {}
 
     bool write(KisPaintDeviceSP dev, KisPaintDeviceWriter &store) {
         return dev->framesInterface()->writeFrame(store, m_frameId);
     }
 
     KoColor defaultPixel(KisPaintDeviceSP dev) const {
         return dev->framesInterface()->frameDefaultPixel(m_frameId);
     }
 
     int m_frameId;
 };
 
 bool KisKraSaveVisitor::savePaintDevice(KisPaintDeviceSP device,
                                         QString location)
 {
     // Layer data
     KisConfig cfg;
     m_store->setCompressionEnabled(cfg.compressKra());
 
     KisPaintDeviceFramesInterface *frameInterface = device->framesInterface();
     QList<int> frames;
 
     if (frameInterface) {
         frames = frameInterface->frames();
     }
 
     if (!frameInterface || frames.count() <= 1) {
         savePaintDeviceFrame(device, location, SimpleDevicePolicy());
     } else {
         KisRasterKeyframeChannel *keyframeChannel = device->keyframeChannel();
 
         for (int i = 0; i < frames.count(); i++) {
             int id = frames[i];
 
             QString frameFilename = getLocation(keyframeChannel->frameFilename(id));
             Q_ASSERT(!frameFilename.isEmpty());
 
             if (!savePaintDeviceFrame(device, frameFilename, FramedDevicePolicy(id))) {
                 return false;
             }
         }
     }
 
     m_store->setCompressionEnabled(true);
     return true;
 }
 
 
 template<class DevicePolicy>
 bool KisKraSaveVisitor::savePaintDeviceFrame(KisPaintDeviceSP device, QString location, DevicePolicy policy)
 {
     if (m_store->open(location)) {
         if (!policy.write(device, *m_writer)) {
             device->disconnect();
             m_store->close();
             return false;
         }
 
         m_store->close();
     }
     if (m_store->open(location + ".defaultpixel")) {
         m_store->write((char*)policy.defaultPixel(device).data(), device->colorSpace()->pixelSize());
         m_store->close();
     }
 
     return true;
 }
 
 bool KisKraSaveVisitor::saveAnnotations(KisLayer* layer)
 {
     if (!layer) return false;
     if (!layer->paintDevice()) return false;
     if (!layer->paintDevice()->colorSpace()) return false;
 
     if (layer->paintDevice()->colorSpace()->profile()) {
         const KoColorProfile *profile = layer->paintDevice()->colorSpace()->profile();
         KisAnnotationSP annotation;
         if (profile) {
             QByteArray profileRawData = profile->rawData();
             if (!profileRawData.isEmpty()) {
                 if (profile->type() == "icc") {
                     annotation = new KisAnnotation(ICC, profile->name(), profile->rawData());
                 } else {
                     annotation = new KisAnnotation(PROFILE, profile->name(), profile->rawData());
                 }
             }
         }
 
         if (annotation) {
             // save layer profile
             if (m_store->open(getLocation(layer, DOT_ICC))) {
                 m_store->write(annotation->annotation());
                 m_store->close();
             } else {
                 return false;
             }
         }
     }
     return true;
 
 }
 bool KisKraSaveVisitor::saveSelection(KisNode* node)
 {
     KisSelectionSP selection;
     if (node->inherits("KisMask")) {
         selection = static_cast<KisMask*>(node)->selection();
     } else if (node->inherits("KisAdjustmentLayer")) {
         selection = static_cast<KisAdjustmentLayer*>(node)->internalSelection();
     } else if (node->inherits("KisGeneratorLayer")) {
         selection = static_cast<KisGeneratorLayer*>(node)->internalSelection();
     } else {
         return false;
     }
 
     bool retval = true;
 
     if (selection->hasPixelSelection()) {
         KisPaintDeviceSP dev = selection->pixelSelection();
         if (!savePaintDevice(dev, getLocation(node, DOT_PIXEL_SELECTION))) {
             m_errorMessages << i18n("Failed to save the pixel selection data for layer %1.", node->name());
             retval = false;
         }
     }
     if (selection->hasShapeSelection()) {
         m_store->pushDirectory();
         retval = m_store->enterDirectory(getLocation(node, DOT_SHAPE_SELECTION));
         if (retval) {
             KisShapeSelection* shapeSelection = dynamic_cast<KisShapeSelection*>(selection->shapeSelection());
             if (!shapeSelection) {
                 retval = false;
             }
 
             if (retval && !shapeSelection->saveSelection(m_store)) {
                 m_errorMessages << i18n("Failed to save the vector selection data for layer %1.", node->name());
                 retval = false;
             }
         }
         m_store->popDirectory();
     }
     return retval;
 }
 
 bool KisKraSaveVisitor::saveFilterConfiguration(KisNode* node)
 {
     KisNodeFilterInterface *filterInterface =
             dynamic_cast<KisNodeFilterInterface*>(node);
 
     KisFilterConfigurationSP filter;
 
     if (filterInterface) {
         filter = filterInterface->filter();
     }
 
     bool retval = false;
 
     if (filter) {
         QString location = getLocation(node, DOT_FILTERCONFIG);
         if (m_store->open(location)) {
             QString s = filter->toXML();
             retval = (m_store->write(s.toUtf8(), qstrlen(s.toUtf8())) == qstrlen(s.toUtf8())); m_store->close();
         }
     }
     return retval;
 }
 
 bool KisKraSaveVisitor::saveMetaData(KisNode* node)
 {
     if (!node->inherits("KisLayer")) return true;
 
     KisMetaData::Store* metadata = (static_cast<KisLayer*>(node))->metaData();
     if (metadata->isEmpty()) return true;
 
     // Serialize all the types of metadata there are
     KisMetaData::IOBackend* backend = KisMetaData::IOBackendRegistry::instance()->get("xmp");
     if (!backend->supportSaving()) {
         dbgFile << "Backend " << backend->id() << " does not support saving.";
         return false;
     }
 
     QString location = getLocation(node, QString(".") + backend->id() +  DOT_METADATA);
     dbgFile << "going to save " << backend->id() << ", " << backend->name() << " to " << location;
 
     QBuffer buffer;
     // not that the metadata backends every return anything but true...
     bool retval = backend->saveTo(metadata, &buffer);
 
     if (!retval) {
         m_errorMessages << i18n("The metadata backend failed to save the metadata for %1", node->name());
     }
     else {
         QByteArray data = buffer.data();
         dbgFile << "\t information size is" << data.size();
 
         if (data.size() > 0 && m_store->open(location)) {
             retval = m_store->write(data,  data.size());
             m_store->close();
         }
         if (!retval) {
             m_errorMessages << i18n("Could not write for %1 metadata to the file.", node->name());
         }
     }
     return retval;
 }
 
 QString KisKraSaveVisitor::getLocation(KisNode* node, const QString& suffix)
 {
 
     Q_ASSERT(m_nodeFileNames.contains(node));
     return getLocation(m_nodeFileNames[node], suffix);
 }
 
 QString KisKraSaveVisitor::getLocation(const QString &filename, const QString& suffix)
 {
     QString location = m_external ? QString() : m_uri;
     location += m_name + LAYER_PATH + filename + suffix;
     return location;
 }
diff --git a/plugins/tools/defaulttool/referenceimagestool/KisReferenceImageCollection.cpp b/plugins/tools/defaulttool/referenceimagestool/KisReferenceImageCollection.cpp
index 652c1799d7..e6785be1b7 100644
--- a/plugins/tools/defaulttool/referenceimagestool/KisReferenceImageCollection.cpp
+++ b/plugins/tools/defaulttool/referenceimagestool/KisReferenceImageCollection.cpp
@@ -1,113 +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);
 
         if (reference->loadImage(store.data())) {
             references.append(reference);
         } else {
-            failures << reference->url();
+            failures << (reference->embed() ? reference->internalFile() : reference->filename());
             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;
 }