diff --git a/libs/flake/resources/KoGamutMask.cpp b/libs/flake/resources/KoGamutMask.cpp
index d295438271..2ea52ca51b 100644
--- a/libs/flake/resources/KoGamutMask.cpp
+++ b/libs/flake/resources/KoGamutMask.cpp
@@ -1,426 +1,452 @@
 /*
  *  Copyright (c) 2018 Anna Medonosova <anna.medonosova@gmail.com>
  *
  *  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 "KoGamutMask.h"
 
 #include <cstring>
 
 #include <QVector>
 #include <QString>
 #include <QFile>
 #include <QList>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QByteArray>
 #include <QBuffer>
 
 #include <FlakeDebug.h>
 
 #include <KoStore.h>
 #include <KoStoreDevice.h>
 #include <KoDocumentResourceManager.h>
 #include <SvgParser.h>
 #include <SvgWriter.h>
 #include <KoShape.h>
 #include <KisGamutMaskViewConverter.h>
 #include <kis_assert.h>
 
 
 KoGamutMaskShape::KoGamutMaskShape(KoShape* shape)
     : m_maskShape(shape)
     , m_shapePaintingContext(KoShapePaintingContext())
 {
 }
 
 KoGamutMaskShape::KoGamutMaskShape() {};
 KoGamutMaskShape::~KoGamutMaskShape() {};
 
 KoShape* KoGamutMaskShape::koShape()
 {
     return m_maskShape;
 }
 
 bool KoGamutMaskShape::coordIsClear(const QPointF& coord, const KoViewConverter& viewConverter, int maskRotation) const
 {
     // apply mask rotation to coord
     const KisGamutMaskViewConverter& converter = dynamic_cast<const KisGamutMaskViewConverter&>(viewConverter);
     QPointF centerPoint(converter.viewSize().width()*0.5, converter.viewSize().height()*0.5);
 
     QTransform rotationTransform;
     rotationTransform.translate(centerPoint.x(), centerPoint.y());
     rotationTransform.rotate(-maskRotation);
     rotationTransform.translate(-centerPoint.x(), -centerPoint.y());
 
     QPointF rotatedCoord = rotationTransform.map(coord);
     QPointF translatedPoint = viewConverter.viewToDocument(rotatedCoord);
 
     bool isClear = m_maskShape->hitTest(translatedPoint);
 
     return isClear;
 }
 
 void KoGamutMaskShape::paint(QPainter &painter, const KoViewConverter& viewConverter, int maskRotation)
 {
     painter.save();
 
     // apply mask rotation before drawing
     QPointF centerPoint(painter.viewport().width()*0.5, painter.viewport().height()*0.5);
     painter.translate(centerPoint);
     painter.rotate(maskRotation);
     painter.translate(-centerPoint);
     painter.setTransform(m_maskShape->absoluteTransformation(&viewConverter) * painter.transform());
     m_maskShape->paint(painter, viewConverter, m_shapePaintingContext);
     painter.restore();
 }
 
 void KoGamutMaskShape::paintStroke(QPainter &painter, const KoViewConverter &viewConverter, int maskRotation)
 {
     painter.save();
 
     // apply mask rotation before drawing
     QPointF centerPoint(painter.viewport().width()*0.5, painter.viewport().height()*0.5);
     painter.translate(centerPoint);
     painter.rotate(maskRotation);
     painter.translate(-centerPoint);
 
     painter.setTransform(m_maskShape->absoluteTransformation(&viewConverter) * painter.transform());
     m_maskShape->paintStroke(painter, viewConverter, m_shapePaintingContext);
     painter.restore();
 
 }
 
 struct Q_DECL_HIDDEN KoGamutMask::Private {
     QString name;
     QString title;
     QString description;
     QByteArray data;
     QVector<KoGamutMaskShape*> maskShapes;
     QVector<KoGamutMaskShape*> previewShapes;
     QSizeF maskSize;
     int rotation;
 };
 
 KoGamutMask::KoGamutMask(const QString& filename)
     : KoResource(filename)
     , d(new Private())
 {
     d->maskSize = QSizeF(144.0,144.0);
     setRotation(0);
 }
 
 KoGamutMask::KoGamutMask()
     : KoResource(QString())
     , d(new Private())
 {
     d->maskSize = QSizeF(144.0,144.0);
     setRotation(0);
 }
 
 KoGamutMask::KoGamutMask(KoGamutMask* rhs)
     : QObject(0)
     , KoResource(QString())
     , d(new Private())
 {
     setFilename(rhs->filename());
     setTitle(rhs->title());
     setDescription(rhs->description());
     d->maskSize = rhs->d->maskSize;
 
     QList<KoShape*> newShapes;
     for(KoShape* sh: rhs->koShapes()) {
         newShapes.append(sh->cloneShape());
     }
 
     setMaskShapes(newShapes);
 
     setValid(true);
 }
 
 
 bool KoGamutMask::coordIsClear(const QPointF& coord, KoViewConverter &viewConverter, bool preview)
 {
     QVector<KoGamutMaskShape*>* shapeVector;
 
     if (preview && !d->previewShapes.isEmpty()) {
         shapeVector = &d->previewShapes;
     } else {
         shapeVector = &d->maskShapes;
     }
 
     for(KoGamutMaskShape* shape: *shapeVector) {
         if (shape->coordIsClear(coord, viewConverter, rotation()) == true) {
             return true;
         }
     }
 
     return false;
 }
 
 void KoGamutMask::paint(QPainter &painter, KoViewConverter& viewConverter, bool preview)
 {
     QVector<KoGamutMaskShape*>* shapeVector;
 
     if (preview && !d->previewShapes.isEmpty()) {
         shapeVector = &d->previewShapes;
     } else {
         shapeVector = &d->maskShapes;
     }
 
     for(KoGamutMaskShape* shape: *shapeVector) {
         shape->paint(painter, viewConverter, rotation());
     }
 }
 
 void KoGamutMask::paintStroke(QPainter &painter, KoViewConverter &viewConverter, bool preview)
 {
     QVector<KoGamutMaskShape*>* shapeVector;
 
     if (preview && !d->previewShapes.isEmpty()) {
         shapeVector = &d->previewShapes;
     } else {
         shapeVector = &d->maskShapes;
     }
 
     for(KoGamutMaskShape* shape: *shapeVector) {
         shape->paintStroke(painter, viewConverter, rotation());
     }
 }
 
 bool KoGamutMask::load()
 {
     QFile file(filename());
     if (file.size() == 0) return false;
     if (!file.open(QIODevice::ReadOnly)) {
         warnFlake << "Can't open file " << filename();
         return false;
     }
     bool res = loadFromDevice(&file);
     file.close();
     return res;
 }
 
 bool KoGamutMask::loadFromDevice(QIODevice *dev)
 {
     if (!dev->isOpen()) dev->open(QIODevice::ReadOnly);
 
     d->data = dev->readAll();
 
     // TODO: test
     KIS_ASSERT_RECOVER_RETURN_VALUE(d->data.size() != 0, false);
 
     if (filename().isNull()) {
         warnFlake << "Cannot load gamut mask" << name() << "there is no filename set";
         return false;
     }
 
     if (d->data.isNull()) {
         QFile file(filename());
         if (file.size() == 0) {
             warnFlake << "Cannot load gamut mask" << name() << "there is no data available";
             return false;
         }
 
         file.open(QIODevice::ReadOnly);
         d->data = file.readAll();
         file.close();
     }
 
     QBuffer buf(&d->data);
     buf.open(QBuffer::ReadOnly);
 
     KoStore* store(KoStore::createStore(&buf, KoStore::Read, "application/x-krita-gamutmask", KoStore::Zip));
     if (!store || store->bad()) return false;
 
     bool storeOpened = store->open("gamutmask.svg");
     if (!storeOpened) { return false; }
 
     QByteArray data;
     data.resize(store->size());
     QByteArray ba = store->read(store->size());
     store->close();
 
     QString errorMsg;
     int errorLine = 0;
     int errorColumn = 0;
 
     KoXmlDocument xmlDocument = SvgParser::createDocumentFromSvg(ba, &errorMsg, &errorLine, &errorColumn);
     if (xmlDocument.isNull()) {
 
         errorFlake << "Parsing error in " << filename() << "! Aborting!" << endl
         << " In line: " << errorLine << ", column: " << errorColumn << endl
         << " Error message: " << errorMsg << endl;
         errorFlake << "Parsing error in the main document at line" << errorLine
                    << ", column" << errorColumn << endl
                    << "Error message: " << errorMsg;
 
         return false;
     }
 
     KoDocumentResourceManager manager;
     SvgParser parser(&manager);
     parser.setResolution(QRectF(0,0,100,100), 72); // initialize with default values
     QSizeF fragmentSize;
 
     QList<KoShape*> shapes = parser.parseSvg(xmlDocument.documentElement(), &fragmentSize);
 
     d->maskSize = fragmentSize;
 
     d->title = parser.documentTitle();
     setName(d->title);
     d->description = parser.documentDescription();
 
     setMaskShapes(shapes);
 
     if (store->open("preview.png")) {
         KoStoreDevice previewDev(store);
         previewDev.open(QIODevice::ReadOnly);
 
         QImage preview = QImage();
         preview.load(&previewDev, "PNG");
         setImage(preview);
 
         (void)store->close();
     }
 
     buf.close();
 
     setValid(true);
 
     return true;
 }
 
 void KoGamutMask::setMaskShapes(QList<KoShape*> shapes)
 {
     setMaskShapesToVector(shapes, d->maskShapes);
 }
 
 bool KoGamutMask::save()
 {
     QFile file(filename());
     if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
         return false;
     }
     saveToDevice(&file);
     file.close();
 
     return true;
 }
 
 QList<KoShape*> KoGamutMask::koShapes() const
 {
     QList<KoShape*> shapes;
     for(KoGamutMaskShape* maskShape: d->maskShapes) {
         shapes.append(maskShape->koShape());
     }
 
     return shapes;
 }
 
 bool KoGamutMask::saveToDevice(QIODevice *dev) const
 {
     KoStore* store(KoStore::createStore(dev, KoStore::Write, "application/x-krita-gamutmask", KoStore::Zip));
     if (!store || store->bad()) return false;
 
     QList<KoShape*> shapes = koShapes();
 
     std::sort(shapes.begin(), shapes.end(), KoShape::compareShapeZIndex);
 
     if (!store->open("gamutmask.svg")) {
         return false;
     }
 
     KoStoreDevice storeDev(store);
     storeDev.open(QIODevice::WriteOnly);
 
     SvgWriter writer(shapes);
     writer.setDocumentTitle(d->title);
     writer.setDocumentDescription(d->description);
 
     writer.save(storeDev, d->maskSize);
 
     if (!store->close()) { return false; }
 
 
     if (!store->open("preview.png")) {
         return false;
     }
 
     KoStoreDevice previewDev(store);
     previewDev.open(QIODevice::WriteOnly);
 
     image().save(&previewDev, "PNG");
     if (!store->close()) { return false; }
 
     return store->finalize();
 }
 
+bool KoGamutMask::loadFromByteArray(QByteArray data)
+{
+    QBuffer buf(&data);
+    buf.open(QIODevice::ReadOnly);
+    return loadFromDevice(&buf);
+}
+
+QByteArray KoGamutMask::toByteArray()
+{
+    QBuffer saveBuffer;
+    saveBuffer.open(QIODevice::WriteOnly);
+
+    if (!saveToDevice(&saveBuffer)) {
+        warnFlake << "KoGamutMask::toByteArray(): saving gamut mask failed:" << name();
+        return QByteArray();
+    }
+
+    saveBuffer.close();
+
+    saveBuffer.open(QIODevice::ReadOnly);
+    QByteArray data = saveBuffer.readAll();
+    saveBuffer.close();
+
+    return data;
+}
+
 QString KoGamutMask::title()
 {
     return d->title;
 }
 
 void KoGamutMask::setTitle(QString title)
 {
     d->title = title;
     setName(title);
 }
 
 QString KoGamutMask::description()
 {
     return d->description;
 }
 
 void KoGamutMask::setDescription(QString description)
 {
     d->description = description;
 }
 
 int KoGamutMask::rotation()
 {
     return d->rotation;
 }
 
 void KoGamutMask::setRotation(int rotation)
 {
     d->rotation = rotation;
 }
 
 QSizeF KoGamutMask::maskSize()
 {
     return d->maskSize;
 }
 
 void KoGamutMask::setPreviewMaskShapes(QList<KoShape*> shapes)
 {
     setMaskShapesToVector(shapes, d->previewShapes);
 }
 
 void KoGamutMask::setMaskShapesToVector(QList<KoShape *> shapes, QVector<KoGamutMaskShape *> &targetVector)
 {
     targetVector.clear();
 
     for(KoShape* sh: shapes) {
         KoGamutMaskShape* maskShape = new KoGamutMaskShape(sh);
         targetVector.append(maskShape);
     }
 }
 
 // clean up when ending mask preview
 void KoGamutMask::clearPreview()
 {
     d->previewShapes.clear();
 }
diff --git a/libs/flake/resources/KoGamutMask.h b/libs/flake/resources/KoGamutMask.h
index 87ae77d708..fad4bd7267 100644
--- a/libs/flake/resources/KoGamutMask.h
+++ b/libs/flake/resources/KoGamutMask.h
@@ -1,100 +1,102 @@
 /*
  *  Copyright (c) 2018 Anna Medonosova <anna.medonosova@gmail.com>
  *
  *  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.
  */
 
 #ifndef KOGAMUTMASK_H
 #define KOGAMUTMASK_H
 
 #include <QPainter>
 #include <QString>
 #include <QVector>
 #include <cmath>
 
 #include <FlakeDebug.h>
 #include <resources/KoResource.h>
 #include <KoShape.h>
 #include <KisGamutMaskViewConverter.h>
 #include <KoShapePaintingContext.h>
 
 class KoViewConverter;
 
 class KoGamutMaskShape
 {
 public:
     KoGamutMaskShape(KoShape* shape);
     KoGamutMaskShape();
     ~KoGamutMaskShape();
 
     bool coordIsClear(const QPointF& coord, const KoViewConverter& viewConverter, int maskRotation) const;
     QPainterPath outline();
     void paint(QPainter &painter, const KoViewConverter& viewConverter, int maskRotation);
     void paintStroke(QPainter &painter, const KoViewConverter& viewConverter, int maskRotation);
     KoShape* koShape();
 
 private:
     KoShape* m_maskShape;
     KoShapePaintingContext m_shapePaintingContext;
 };
 
 
 /**
  * @brief The resource type for gamut masks used by the artistic color selector
  */
 class KRITAFLAKE_EXPORT KoGamutMask : public QObject, public KoResource
 {
     Q_OBJECT
 
 public:
     KoGamutMask(const QString &filename);
     KoGamutMask();
     KoGamutMask(KoGamutMask *rhs);
 
     bool coordIsClear(const QPointF& coord, KoViewConverter& viewConverter, bool preview);
 
     bool load() override __attribute__((optimize(0)));
     bool loadFromDevice(QIODevice *dev) override;
     bool save() override;
     bool saveToDevice(QIODevice* dev) const override;
+    bool loadFromByteArray(QByteArray data);
+    QByteArray toByteArray();
 
     void paint(QPainter &painter, KoViewConverter& viewConverter, bool preview);
     void paintStroke(QPainter &painter, KoViewConverter& viewConverter, bool preview);
 
     QString title();
     void setTitle(QString title);
 
     QString description();
     void setDescription(QString description);
 
     int rotation();
     void setRotation(int rotation);
 
     QSizeF maskSize();
 
     void setMaskShapes(QList<KoShape*> shapes);   
     void setPreviewMaskShapes(QList<KoShape*> shapes);
 
     QList<KoShape*> koShapes() const;
 
     void clearPreview();
 
 private:
     void setMaskShapesToVector(QList<KoShape*> shapes, QVector<KoGamutMaskShape*>& targetVector);
 
     struct Private;
     Private* const d;
 };
 
 #endif // KOGAMUTMASK_H
diff --git a/libs/ui/KisDocument.cpp b/libs/ui/KisDocument.cpp
index ea75ea536d..9b6d47bc95 100644
--- a/libs/ui/KisDocument.cpp
+++ b/libs/ui/KisDocument.cpp
@@ -1,1857 +1,1871 @@
 /* This file is part of the Krita project
  *
  * 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 "KisMainWindow.h" // XXX: remove
 #include <QMessageBox> // XXX: remove
 
 #include <KisMimeDatabase.h>
 
 #include <KoCanvasBase.h>
 #include <KoColor.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoDocumentInfoDlg.h>
 #include <KoDocumentInfo.h>
 #include <KoDpi.h>
 #include <KoUnit.h>
 #include <KoID.h>
 #include <KoOdfReadStore.h>
 #include <KoProgressProxy.h>
 #include <KoProgressUpdater.h>
 #include <KoSelection.h>
 #include <KoShape.h>
 #include <KoShapeController.h>
 #include <KoStore.h>
 #include <KoUpdater.h>
 #include <KoXmlWriter.h>
 #include <KoXmlReader.h>
 #include <KoStoreDevice.h>
 #include <KoDialog.h>
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kdesktopfile.h>
 #include <kconfiggroup.h>
 #include <QTemporaryFile>
 #include <kbackup.h>
 
 #include <QTextBrowser>
 #include <QApplication>
 #include <QBuffer>
 #include <QStandardPaths>
 #include <QDir>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QFileInfo>
 #include <QImage>
 #include <QList>
 #include <QPainter>
 #include <QRect>
 #include <QScopedPointer>
 #include <QSize>
 #include <QStringList>
 #include <QtGlobal>
 #include <QTimer>
 #include <QWidget>
 #include <QFuture>
 #include <QFutureWatcher>
 
 // Krita Image
 #include <kis_config.h>
 #include <flake/kis_shape_layer.h>
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_name_server.h>
 #include <kis_paint_layer.h>
 #include <kis_painter.h>
 #include <kis_selection.h>
 #include <kis_fill_painter.h>
 #include <kis_document_undo_store.h>
 #include <kis_idle_watcher.h>
 #include <kis_signal_auto_connection.h>
 #include <kis_canvas_widget_base.h>
 #include "kis_layer_utils.h"
 
 // Local
 #include "KisViewManager.h"
 #include "kis_clipboard.h"
 #include "widgets/kis_custom_image_widget.h"
 #include "canvas/kis_canvas2.h"
 #include "flake/kis_shape_controller.h"
 #include "kis_statusbar.h"
 #include "widgets/kis_progress_widget.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisResourceServerProvider.h"
 #include "kis_node_manager.h"
 #include "KisPart.h"
 #include "KisApplication.h"
 #include "KisDocument.h"
 #include "KisImportExportManager.h"
 #include "KisView.h"
 #include "kis_grid_config.h"
 #include "kis_guides_config.h"
 #include "kis_image_barrier_lock_adapter.h"
 #include "KisReferenceImagesLayer.h"
 
 #include <mutex>
 #include "kis_config_notifier.h"
 #include "kis_async_action_feedback.h"
 #include "KisCloneDocumentStroke.h"
 
 
 // Define the protocol used here for embedded documents' URL
 // This used to "store" but QUrl didn't like it,
 // so let's simply make it "tar" !
 #define STORE_PROTOCOL "tar"
 // The internal path is a hack to make QUrl happy and for document children
 #define INTERNAL_PROTOCOL "intern"
 #define INTERNAL_PREFIX "intern:/"
 // Warning, keep it sync in koStore.cc
 
 #include <unistd.h>
 
 using namespace std;
 
 namespace {
 constexpr int errorMessageTimeout = 5000;
 constexpr int successMessageTimeout = 1000;
 }
 
 
 /**********************************************************
  *
  * KisDocument
  *
  **********************************************************/
 
 //static
 QString KisDocument::newObjectName()
 {
     static int s_docIFNumber = 0;
     QString name; name.setNum(s_docIFNumber++); name.prepend("document_");
     return name;
 }
 
 
 class UndoStack : public KUndo2Stack
 {
 public:
     UndoStack(KisDocument *doc)
         : KUndo2Stack(doc),
           m_doc(doc)
     {
     }
 
     void setIndex(int idx) override {
         KisImageWSP image = this->image();
         image->requestStrokeCancellation();
         if(image->tryBarrierLock()) {
             KUndo2Stack::setIndex(idx);
             image->unlock();
         }
     }
 
     void notifySetIndexChangedOneCommand() override {
         KisImageWSP image = this->image();
         image->unlock();
 
         /**
          * Some very weird commands may emit blocking signals to
          * the GUI (e.g. KisGuiContextCommand). Here is the best thing
          * we can do to avoid the deadlock
          */
         while(!image->tryBarrierLock()) {
             QApplication::processEvents();
         }
     }
 
     void undo() override {
         KisImageWSP image = this->image();
         image->requestUndoDuringStroke();
 
         if (image->tryUndoUnfinishedLod0Stroke() == UNDO_OK) {
             return;
         }
 
         if(image->tryBarrierLock()) {
             KUndo2Stack::undo();
             image->unlock();
         }
     }
 
     void redo() override {
         KisImageWSP image = this->image();
         if(image->tryBarrierLock()) {
             KUndo2Stack::redo();
             image->unlock();
         }
     }
 
 private:
     KisImageWSP image() {
         KisImageWSP currentImage = m_doc->image();
         Q_ASSERT(currentImage);
         return currentImage;
     }
 
 private:
     KisDocument *m_doc;
 };
 
 class Q_DECL_HIDDEN KisDocument::Private
 {
 public:
     Private(KisDocument *q)
         : docInfo(new KoDocumentInfo(q)) // deleted by QObject
         , importExportManager(new KisImportExportManager(q)) // deleted manually
         , autoSaveTimer(new QTimer(q))
         , undoStack(new UndoStack(q)) // deleted by QObject
         , m_bAutoDetectedMime(false)
         , modified(false)
         , readwrite(true)
         , firstMod(QDateTime::currentDateTime())
         , lastMod(firstMod)
         , nserver(new KisNameServer(1))
         , imageIdleWatcher(2000 /*ms*/)
         , globalAssistantsColor(KisConfig(true).defaultAssistantsColor())
+        , gamutMask(nullptr)
         , savingLock(&savingMutex)
         , batchMode(false)
     {
         if (QLocale().measurementSystem() == QLocale::ImperialSystem) {
             unit = KoUnit::Inch;
         } else {
             unit = KoUnit::Centimeter;
         }
     }
 
     Private(const Private &rhs, KisDocument *q)
         : docInfo(new KoDocumentInfo(*rhs.docInfo, q))
         , unit(rhs.unit)
         , importExportManager(new KisImportExportManager(q))
         , mimeType(rhs.mimeType)
         , outputMimeType(rhs.outputMimeType)
         , autoSaveTimer(new QTimer(q))
         , undoStack(new UndoStack(q))
         , guidesConfig(rhs.guidesConfig)
         , m_bAutoDetectedMime(rhs.m_bAutoDetectedMime)
         , m_url(rhs.m_url)
         , m_file(rhs.m_file)
         , modified(rhs.modified)
         , readwrite(rhs.readwrite)
         , firstMod(rhs.firstMod)
         , lastMod(rhs.lastMod)
         , nserver(new KisNameServer(*rhs.nserver))
         , preActivatedNode(0) // the node is from another hierarchy!
         , imageIdleWatcher(2000 /*ms*/)
         , assistants(rhs.assistants) // WARNING: assistants should not store pointers to the document!
         , globalAssistantsColor(rhs.globalAssistantsColor)
         , paletteList(rhs.paletteList)
+        , gamutMask(rhs.gamutMask)
         , gridConfig(rhs.gridConfig)
         , savingLock(&savingMutex)
         , batchMode(rhs.batchMode)
     {
         // TODO: clone assistants
     }
 
     ~Private() {
         // Don't delete m_d->shapeController because it's in a QObject hierarchy.
         delete nserver;
     }
 
     KoDocumentInfo *docInfo = 0;
 
     KoUnit unit;
 
     KisImportExportManager *importExportManager = 0; // The filter-manager to use when loading/saving [for the options]
 
     QByteArray mimeType; // The actual mimetype of the document
     QByteArray outputMimeType; // The mimetype to use when saving
 
     QTimer *autoSaveTimer;
     QString lastErrorMessage; // see openFile()
     QString lastWarningMessage;
     int autoSaveDelay = 300; // in seconds, 0 to disable.
     bool modifiedAfterAutosave = false;
     bool isAutosaving = false;
     bool disregardAutosaveFailure = false;
     int autoSaveFailureCount = 0;
 
     KUndo2Stack *undoStack = 0;
 
     KisGuidesConfig guidesConfig;
 
     bool m_bAutoDetectedMime = false; // whether the mimetype in the arguments was detected by the part itself
     QUrl m_url; // local url - the one displayed to the user.
     QString m_file; // Local file - the only one the part implementation should deal with.
 
     QMutex savingMutex;
 
     bool modified = false;
     bool readwrite = false;
 
     QDateTime firstMod;
     QDateTime lastMod;
 
     KisNameServer *nserver;
 
     KisImageSP image;
     KisImageSP savingImage;
 
     KisNodeWSP preActivatedNode;
     KisShapeController* shapeController = 0;
     KoShapeController* koShapeController = 0;
     KisIdleWatcher imageIdleWatcher;
     QScopedPointer<KisSignalAutoConnection> imageIdleConnection;
 
     QList<KisPaintingAssistantSP> assistants;
 
     QColor globalAssistantsColor;
 
     KisSharedPtr<KisReferenceImagesLayer> referenceImagesLayer;
 
     QList<KoColorSet*> paletteList;
 
+    KoGamutMask* gamutMask;
+
     KisGridConfig gridConfig;
 
     StdLockableWrapper<QMutex> savingLock;
 
     bool modifiedWhileSaving = false;
     QScopedPointer<KisDocument> backgroundSaveDocument;
     QPointer<KoUpdater> savingUpdater;
     QFuture<KisImportExportFilter::ConversionStatus> childSavingFuture;
     KritaUtils::ExportFileJob backgroundSaveJob;
 
     bool isRecovered = false;
 
     bool batchMode { false };
 
     void setImageAndInitIdleWatcher(KisImageSP _image) {
         image = _image;
 
         imageIdleWatcher.setTrackedImage(image);
 
         if (image) {
             imageIdleConnection.reset(
                         new KisSignalAutoConnection(
                             &imageIdleWatcher, SIGNAL(startedIdleMode()),
                             image.data(), SLOT(explicitRegenerateLevelOfDetail())));
         }
     }
 
     class StrippedSafeSavingLocker;
 };
 
 class KisDocument::Private::StrippedSafeSavingLocker {
 public:
     StrippedSafeSavingLocker(QMutex *savingMutex, KisImageSP image)
         : m_locked(false)
         , m_image(image)
         , m_savingLock(savingMutex)
         , m_imageLock(image, true)
 
     {
         /**
          * Initial try to lock both objects. Locking the image guards
          * us from any image composition threads running in the
          * background, while savingMutex guards us from entering the
          * saving code twice by autosave and main threads.
          *
          * Since we are trying to lock multiple objects, so we should
          * do it in a safe manner.
          */
         m_locked = std::try_lock(m_imageLock, m_savingLock) < 0;
 
         if (!m_locked) {
             m_image->requestStrokeEnd();
             QApplication::processEvents();
 
             // one more try...
             m_locked = std::try_lock(m_imageLock, m_savingLock) < 0;
         }
     }
 
     ~StrippedSafeSavingLocker() {
          if (m_locked) {
              m_imageLock.unlock();
              m_savingLock.unlock();
          }
      }
 
     bool successfullyLocked() const {
         return m_locked;
     }
 
 private:
     bool m_locked;
     KisImageSP m_image;
     StdLockableWrapper<QMutex> m_savingLock;
     KisImageBarrierLockAdapter m_imageLock;
 };
 
 KisDocument::KisDocument()
     : d(new Private(this))
 {
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     connect(d->undoStack, SIGNAL(cleanChanged(bool)), this, SLOT(slotUndoStackCleanChanged(bool)));
     connect(d->autoSaveTimer, SIGNAL(timeout()), this, SLOT(slotAutoSave()));
     setObjectName(newObjectName());
 
     // preload the krita resources
     KisResourceServerProvider::instance();
 
     d->shapeController = new KisShapeController(this, d->nserver),
     d->koShapeController = new KoShapeController(0, d->shapeController),
 
     slotConfigChanged();
 }
 
 KisDocument::KisDocument(const KisDocument &rhs)
     : QObject(),
       d(new Private(*rhs.d, this))
 {
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     connect(d->undoStack, SIGNAL(cleanChanged(bool)), this, SLOT(slotUndoStackCleanChanged(bool)));
     connect(d->autoSaveTimer, SIGNAL(timeout()), this, SLOT(slotAutoSave()));
     setObjectName(rhs.objectName());
 
     d->shapeController = new KisShapeController(this, d->nserver),
     d->koShapeController = new KoShapeController(0, d->shapeController),
 
     slotConfigChanged();
 
     // clone the image with keeping the GUIDs of the layers intact
     // NOTE: we expect the image to be locked!
     setCurrentImage(rhs.image()->clone(true), false);
 
     if (rhs.d->preActivatedNode) {
         // since we clone uuid's, we can use them for lacating new
         // nodes. Otherwise we would need to use findSymmetricClone()
         d->preActivatedNode =
                 KisLayerUtils::findNodeByUuid(d->image->root(), rhs.d->preActivatedNode->uuid());
     }
 }
 
 KisDocument::~KisDocument()
 {
     // wait until all the pending operations are in progress
     waitForSavingToComplete();
 
     /**
      * Push a timebomb, which will try to release the memory after
      * the document has been deleted
      */
     KisPaintDevice::createMemoryReleaseObject()->deleteLater();
 
     d->autoSaveTimer->disconnect(this);
     d->autoSaveTimer->stop();
 
     delete d->importExportManager;
 
     // Despite being QObject they needs to be deleted before the image
     delete d->shapeController;
 
     delete d->koShapeController;
 
     if (d->image) {
         d->image->notifyAboutToBeDeleted();
 
         /**
          * WARNING: We should wait for all the internal image jobs to
          * finish before entering KisImage's destructor. The problem is,
          * while execution of KisImage::~KisImage, all the weak shared
          * pointers pointing to the image enter an inconsistent
          * state(!). The shared counter is already zero and destruction
          * has started, but the weak reference doesn't know about it,
          * because KisShared::~KisShared hasn't been executed yet. So all
          * the threads running in background and having weak pointers will
          * enter the KisImage's destructor as well.
          */
 
         d->image->requestStrokeCancellation();
         d->image->waitForDone();
 
         // clear undo commands that can still point to the image
         d->undoStack->clear();
         d->image->waitForDone();
 
         KisImageWSP sanityCheckPointer = d->image;
         Q_UNUSED(sanityCheckPointer);
 
         // The following line trigger the deletion of the image
         d->image.clear();
 
         // check if the image has actually been deleted
         KIS_SAFE_ASSERT_RECOVER_NOOP(!sanityCheckPointer.isValid());
     }
 
     delete d;
 }
 
 bool KisDocument::reload()
 {
     // XXX: reimplement!
     return false;
 }
 
 KisDocument *KisDocument::clone()
 {
     return new KisDocument(*this);
 }
 
 bool KisDocument::exportDocumentImpl(const KritaUtils::ExportFileJob &job, KisPropertiesConfigurationSP exportConfiguration)
 {
     QFileInfo filePathInfo(job.filePath);
 
     if (filePathInfo.exists() && !filePathInfo.isWritable()) {
         slotCompleteSavingDocument(job,
                                    KisImportExportFilter::CreationError,
                                    i18n("%1 cannot be written to. Please save under a different name.", job.filePath));
         return false;
     }
 
     KisConfig cfg(true);
     if (cfg.backupFile() && filePathInfo.exists()) {
         KBackup::backupFile(job.filePath);
     }
 
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!job.mimeType.isEmpty(), false);
 
     const QString actionName =
         job.flags & KritaUtils::SaveIsExporting ?
         i18n("Exporting Document...") :
         i18n("Saving Document...");
 
     bool started =
         initiateSavingInBackground(actionName,
                                    this, SLOT(slotCompleteSavingDocument(KritaUtils::ExportFileJob,KisImportExportFilter::ConversionStatus,QString)),
                                    job, exportConfiguration);
 
     if (!started) {
         emit canceled(QString());
     }
 
     return started;
 }
 
 bool KisDocument::exportDocument(const QUrl &url, const QByteArray &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     using namespace KritaUtils;
 
     SaveFlags flags = SaveIsExporting;
     if (showWarnings) {
         flags |= SaveShowWarnings;
     }
 
     return exportDocumentImpl(KritaUtils::ExportFileJob(url.toLocalFile(),
                                                         mimeType,
                                                         flags),
                               exportConfiguration);
 
 }
 
 bool KisDocument::saveAs(const QUrl &url, const QByteArray &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     using namespace KritaUtils;
 
     return exportDocumentImpl(ExportFileJob(url.toLocalFile(),
                                             mimeType,
                                             showWarnings ? SaveShowWarnings : SaveNone),
                               exportConfiguration);
 }
 
 bool KisDocument::save(bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     return saveAs(url(), mimeType(), showWarnings, exportConfiguration);
 }
 
 QByteArray KisDocument::serializeToNativeByteArray()
 {
     QByteArray byteArray;
     QBuffer buffer(&byteArray);
 
     QScopedPointer<KisImportExportFilter> filter(KisImportExportManager::filterForMimeType(nativeFormatMimeType(), KisImportExportManager::Export));
     filter->setBatchMode(true);
     filter->setMimeType(nativeFormatMimeType());
 
     Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
     if (!locker.successfullyLocked()) {
         return byteArray;
     }
 
     d->savingImage = d->image;
 
     if (filter->convert(this, &buffer) != KisImportExportFilter::OK) {
         qWarning() << "serializeToByteArray():: Could not export to our native format";
     }
 
     return byteArray;
 }
 
 void KisDocument::slotCompleteSavingDocument(const KritaUtils::ExportFileJob &job, KisImportExportFilter::ConversionStatus status, const QString &errorMessage)
 {
     if (status == KisImportExportFilter::UserCancelled)
         return;
 
     const QString fileName = QFileInfo(job.filePath).fileName();
 
     if (status != KisImportExportFilter::OK) {
         emit statusBarMessage(i18nc("%1 --- failing file name, %2 --- error message",
                                     "Error during saving %1: %2",
                                     fileName,
                                     exportErrorToUserMessage(status, errorMessage)), errorMessageTimeout);
 
         if (!fileBatchMode()) {
             const QString filePath = job.filePath;
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not save %1\nReason: %2", filePath, exportErrorToUserMessage(status, errorMessage)));
         }
     } else {
         if (!(job.flags & KritaUtils::SaveIsExporting)) {
             const QString existingAutoSaveBaseName = localFilePath();
             const bool wasRecovered = isRecovered();
 
             setUrl(QUrl::fromLocalFile(job.filePath));
             setLocalFilePath(job.filePath);
             setMimeType(job.mimeType);
             updateEditingTime(true);
 
             if (!d->modifiedWhileSaving) {
                 /**
                  * If undo stack is already clean/empty, it doesn't emit any
                  * signals, so we might forget update document modified state
                  * (which was set, e.g. while recovering an autosave file)
                  */
 
                 if (d->undoStack->isClean()) {
                     setModified(false);
                 } else {
                     d->undoStack->setClean();
                 }
             }
             setRecovered(false);
             removeAutoSaveFiles(existingAutoSaveBaseName, wasRecovered);
         }
 
         emit completed();
         emit sigSavingFinished();
 
         emit statusBarMessage(i18n("Finished saving %1", fileName), successMessageTimeout);
     }
 }
 
 QByteArray KisDocument::mimeType() const
 {
     return d->mimeType;
 }
 
 void KisDocument::setMimeType(const QByteArray & mimeType)
 {
     d->mimeType = mimeType;
 }
 
 bool KisDocument::fileBatchMode() const
 {
     return d->batchMode;
 }
 
 void KisDocument::setFileBatchMode(const bool batchMode)
 {
     d->batchMode = batchMode;
 }
 
 KisDocument* KisDocument::lockAndCloneForSaving()
 {
     // force update of all the asynchronous nodes before cloning
     QApplication::processEvents();
     KisLayerUtils::forceAllDelayedNodesUpdate(d->image->root());
 
     KisMainWindow *window = KisPart::instance()->currentMainwindow();
     if (window) {
         if (window->viewManager()) {
             if (!window->viewManager()->blockUntilOperationsFinished(d->image)) {
                 return 0;
             }
         }
     }
 
     Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
     if (!locker.successfullyLocked()) {
         return 0;
     }
 
     return new KisDocument(*this);
 }
 
 bool KisDocument::exportDocumentSync(const QUrl &url, const QByteArray &mimeType, KisPropertiesConfigurationSP exportConfiguration)
 {
     Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
     if (!locker.successfullyLocked()) {
         return false;
     }
 
     d->savingImage = d->image;
 
     const QString fileName = url.toLocalFile();
 
     KisImportExportFilter::ConversionStatus status =
         d->importExportManager->
             exportDocument(fileName, fileName, mimeType, false, exportConfiguration);
 
     d->savingImage = 0;
 
     return status == KisImportExportFilter::OK;
 }
 
 bool KisDocument::initiateSavingInBackground(const QString actionName,
                                              const QObject *receiverObject, const char *receiverMethod,
                                              const KritaUtils::ExportFileJob &job,
                                              KisPropertiesConfigurationSP exportConfiguration)
 {
     return initiateSavingInBackground(actionName, receiverObject, receiverMethod,
                                       job, exportConfiguration, std::unique_ptr<KisDocument>());
 }
 
 bool KisDocument::initiateSavingInBackground(const QString actionName,
                                              const QObject *receiverObject, const char *receiverMethod,
                                              const KritaUtils::ExportFileJob &job,
                                              KisPropertiesConfigurationSP exportConfiguration,
                                              std::unique_ptr<KisDocument> &&optionalClonedDocument)
 {
     KIS_ASSERT_RECOVER_RETURN_VALUE(job.isValid(), false);
 
     QScopedPointer<KisDocument> clonedDocument;
 
     if (!optionalClonedDocument) {
         clonedDocument.reset(lockAndCloneForSaving());
     } else {
         clonedDocument.reset(optionalClonedDocument.release());
     }
 
     // we block saving until the current saving is finished!
     if (!clonedDocument || !d->savingMutex.tryLock()) {
         return false;
     }
 
     KIS_ASSERT_RECOVER_RETURN_VALUE(!d->backgroundSaveDocument, false);
     KIS_ASSERT_RECOVER_RETURN_VALUE(!d->backgroundSaveJob.isValid(), false);
     d->backgroundSaveDocument.reset(clonedDocument.take());
     d->backgroundSaveJob = job;
     d->modifiedWhileSaving = false;
 
     if (d->backgroundSaveJob.flags & KritaUtils::SaveInAutosaveMode) {
         d->backgroundSaveDocument->d->isAutosaving = true;
     }
 
     connect(d->backgroundSaveDocument.data(),
             SIGNAL(sigBackgroundSavingFinished(KisImportExportFilter::ConversionStatus,QString)),
             this,
             SLOT(slotChildCompletedSavingInBackground(KisImportExportFilter::ConversionStatus,QString)));
 
 
     connect(this, SIGNAL(sigCompleteBackgroundSaving(KritaUtils::ExportFileJob,KisImportExportFilter::ConversionStatus,QString)),
             receiverObject, receiverMethod, Qt::UniqueConnection);
 
     bool started =
         d->backgroundSaveDocument->startExportInBackground(actionName,
                                                            job.filePath,
                                                            job.filePath,
                                                            job.mimeType,
                                                            job.flags & KritaUtils::SaveShowWarnings,
                                                            exportConfiguration);
 
     if (!started) {
         // the state should have been deinitialized in slotChildCompletedSavingInBackground()
 
         KIS_SAFE_ASSERT_RECOVER (!d->backgroundSaveDocument && !d->backgroundSaveJob.isValid()) {
             d->backgroundSaveDocument.take()->deleteLater();
             d->savingMutex.unlock();
             d->backgroundSaveJob = KritaUtils::ExportFileJob();
         }
     }
 
     return started;
 }
 
 
 void KisDocument::slotChildCompletedSavingInBackground(KisImportExportFilter::ConversionStatus status, const QString &errorMessage)
 {
     KIS_SAFE_ASSERT_RECOVER(!d->savingMutex.tryLock()) {
         d->savingMutex.unlock();
         return;
     }
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(d->backgroundSaveDocument);
 
     if (d->backgroundSaveJob.flags & KritaUtils::SaveInAutosaveMode) {
         d->backgroundSaveDocument->d->isAutosaving = false;
     }
 
     d->backgroundSaveDocument.take()->deleteLater();
     d->savingMutex.unlock();
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(d->backgroundSaveJob.isValid());
     const KritaUtils::ExportFileJob job = d->backgroundSaveJob;
     d->backgroundSaveJob = KritaUtils::ExportFileJob();
 
     emit sigCompleteBackgroundSaving(job, status, errorMessage);
 }
 
 void KisDocument::slotAutoSaveImpl(std::unique_ptr<KisDocument> &&optionalClonedDocument)
 {
     if (!d->modified || !d->modifiedAfterAutosave) return;
     const QString autoSaveFileName = generateAutoSaveFileName(localFilePath());
 
     emit statusBarMessage(i18n("Autosaving... %1", autoSaveFileName), successMessageTimeout);
 
     const bool hadClonedDocument = bool(optionalClonedDocument);
     bool started = false;
 
     if (d->image->isIdle() || hadClonedDocument) {
         started = initiateSavingInBackground(i18n("Autosaving..."),
                                              this, SLOT(slotCompleteAutoSaving(KritaUtils::ExportFileJob,KisImportExportFilter::ConversionStatus,QString)),
                                              KritaUtils::ExportFileJob(autoSaveFileName, nativeFormatMimeType(), KritaUtils::SaveIsExporting | KritaUtils::SaveInAutosaveMode),
                                              0,
                                              std::move(optionalClonedDocument));
     } else {
         emit statusBarMessage(i18n("Autosaving postponed: document is busy..."), errorMessageTimeout);
     }
 
     if (!started && !hadClonedDocument && d->autoSaveFailureCount >= 3) {
         KisCloneDocumentStroke *stroke = new KisCloneDocumentStroke(this);
         connect(stroke, SIGNAL(sigDocumentCloned(KisDocument*)),
                 this, SLOT(slotInitiateAsyncAutosaving(KisDocument*)),
                 Qt::BlockingQueuedConnection);
 
         KisStrokeId strokeId = d->image->startStroke(stroke);
         d->image->endStroke(strokeId);
 
         setInfiniteAutoSaveInterval();
 
     } else if (!started) {
         setEmergencyAutoSaveInterval();
     } else {
         d->modifiedAfterAutosave = false;
     }
 }
 
 void KisDocument::slotAutoSave()
 {
     slotAutoSaveImpl(std::unique_ptr<KisDocument>());
 }
 
 void KisDocument::slotInitiateAsyncAutosaving(KisDocument *clonedDocument)
 {
     slotAutoSaveImpl(std::unique_ptr<KisDocument>(clonedDocument));
 }
 
 void KisDocument::slotCompleteAutoSaving(const KritaUtils::ExportFileJob &job, KisImportExportFilter::ConversionStatus status, const QString &errorMessage)
 {
     Q_UNUSED(job);
 
     const QString fileName = QFileInfo(job.filePath).fileName();
 
     if (status != KisImportExportFilter::OK) {
         setEmergencyAutoSaveInterval();
         emit statusBarMessage(i18nc("%1 --- failing file name, %2 --- error message",
                                     "Error during autosaving %1: %2",
                                     fileName,
                                     exportErrorToUserMessage(status, errorMessage)), errorMessageTimeout);
     } else {
         KisConfig cfg(true);
         d->autoSaveDelay = cfg.autoSaveInterval();
 
         if (!d->modifiedWhileSaving) {
             d->autoSaveTimer->stop(); // until the next change
             d->autoSaveFailureCount = 0;
         } else {
             setNormalAutoSaveInterval();
         }
 
         emit statusBarMessage(i18n("Finished autosaving %1", fileName), successMessageTimeout);
     }
 }
 
 bool KisDocument::startExportInBackground(const QString &actionName,
                                           const QString &location,
                                           const QString &realLocation,
                                           const QByteArray &mimeType,
                                           bool showWarnings,
                                           KisPropertiesConfigurationSP exportConfiguration)
 {
     d->savingImage = d->image;
 
     KisMainWindow *window = KisPart::instance()->currentMainwindow();
     if (window) {
         if (window->viewManager()) {
             d->savingUpdater = window->viewManager()->createThreadedUpdater(actionName);
             d->importExportManager->setUpdater(d->savingUpdater);
         }
     }
 
     KisImportExportFilter::ConversionStatus initializationStatus;
     d->childSavingFuture =
         d->importExportManager->exportDocumentAsyc(location,
                                                    realLocation,
                                                    mimeType,
                                                    initializationStatus,
                                                    showWarnings,
                                                    exportConfiguration);
 
     if (initializationStatus != KisImportExportFilter::ConversionStatus::OK) {
         if (d->savingUpdater) {
             d->savingUpdater->cancel();
         }
         d->savingImage.clear();
         emit sigBackgroundSavingFinished(initializationStatus, this->errorMessage());
         return false;
     }
 
     typedef QFutureWatcher<KisImportExportFilter::ConversionStatus> StatusWatcher;
     StatusWatcher *watcher = new StatusWatcher();
     watcher->setFuture(d->childSavingFuture);
 
     connect(watcher, SIGNAL(finished()), SLOT(finishExportInBackground()));
     connect(watcher, SIGNAL(finished()), watcher, SLOT(deleteLater()));
 
     return true;
 }
 
 void KisDocument::finishExportInBackground()
 {
     KIS_SAFE_ASSERT_RECOVER(d->childSavingFuture.isFinished()) {
         emit sigBackgroundSavingFinished(KisImportExportFilter::InternalError, "");
         return;
     }
 
     KisImportExportFilter::ConversionStatus status =
         d->childSavingFuture.result();
     const QString errorMessage = this->errorMessage();
 
     d->savingImage.clear();
     d->childSavingFuture = QFuture<KisImportExportFilter::ConversionStatus>();
     d->lastErrorMessage.clear();
 
     if (d->savingUpdater) {
         d->savingUpdater->setProgress(100);
     }
 
     emit sigBackgroundSavingFinished(status, errorMessage);
 }
 
 void KisDocument::setReadWrite(bool readwrite)
 {
     d->readwrite = readwrite;
     setNormalAutoSaveInterval();
 
     Q_FOREACH (KisMainWindow *mainWindow, KisPart::instance()->mainWindows()) {
         mainWindow->setReadWrite(readwrite);
     }
 }
 
 void KisDocument::setAutoSaveDelay(int delay)
 {
     if (isReadWrite() && delay > 0) {
         d->autoSaveTimer->start(delay * 1000);
     } else {
         d->autoSaveTimer->stop();
     }
 }
 
 void KisDocument::setNormalAutoSaveInterval()
 {
     setAutoSaveDelay(d->autoSaveDelay);
     d->autoSaveFailureCount = 0;
 }
 
 void KisDocument::setEmergencyAutoSaveInterval()
 {
     const int emergencyAutoSaveInterval = 10; /* sec */
     setAutoSaveDelay(emergencyAutoSaveInterval);
     d->autoSaveFailureCount++;
 }
 
 void KisDocument::setInfiniteAutoSaveInterval()
 {
     setAutoSaveDelay(-1);
 }
 
 KoDocumentInfo *KisDocument::documentInfo() const
 {
     return d->docInfo;
 }
 
 bool KisDocument::isModified() const
 {
     return d->modified;
 }
 
 QPixmap KisDocument::generatePreview(const QSize& size)
 {
     KisImageSP image = d->image;
     if (d->savingImage) image = d->savingImage;
 
     if (image) {
         QRect bounds = image->bounds();
         QSize newSize = bounds.size();
         newSize.scale(size, Qt::KeepAspectRatio);
         QPixmap px = QPixmap::fromImage(image->convertToQImage(newSize, 0));
         if (px.size() == QSize(0,0)) {
             px = QPixmap(newSize);
             QPainter gc(&px);
             QBrush checkBrush = QBrush(KisCanvasWidgetBase::createCheckersImage(newSize.width() / 5));
             gc.fillRect(px.rect(), checkBrush);
             gc.end();
         }
         return px;
     }
     return QPixmap(size);
 }
 
 QString KisDocument::generateAutoSaveFileName(const QString & path) const
 {
     QString retval;
 
     // Using the extension allows to avoid relying on the mime magic when opening
     const QString extension (".kra");
     QRegularExpression autosavePattern("^\\..+-autosave.kra$");
 
     QFileInfo fi(path);
     QString dir = fi.absolutePath();
     QString filename = fi.fileName();
 
     if (path.isEmpty() || autosavePattern.match(filename).hasMatch()) {
         // Never saved?
 #ifdef Q_OS_WIN
         // On Windows, use the temp location (https://bugs.kde.org/show_bug.cgi?id=314921)
         retval = QString("%1%2.%3-%4-%5-autosave%6").arg(QDir::tempPath()).arg(QDir::separator()).arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension);
 #else
         // On Linux, use a temp file in $HOME then. Mark it with the pid so two instances don't overwrite each other's autosave file
         retval = QString("%1%2.%3-%4-%5-autosave%6").arg(QDir::homePath()).arg(QDir::separator()).arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension);
 #endif
     } else {
         retval = QString("%1%2.%3-autosave%4").arg(dir).arg(QDir::separator()).arg(filename).arg(extension);
     }
 
     //qDebug() << "generateAutoSaveFileName() for path" << path << ":" << retval;
     return retval;
 }
 
 bool KisDocument::importDocument(const QUrl &_url)
 {
     bool ret;
 
     dbgUI << "url=" << _url.url();
 
     // open...
     ret = openUrl(_url);
 
     // reset url & m_file (kindly? set by KisParts::openUrl()) to simulate a
     // File --> Import
     if (ret) {
         dbgUI << "success, resetting url";
         resetURL();
         setTitleModified();
     }
 
     return ret;
 }
 
 
 bool KisDocument::openUrl(const QUrl &_url, OpenFlags flags)
 {
     if (!_url.isLocalFile()) {
         return false;
     }
     dbgUI << "url=" << _url.url();
     d->lastErrorMessage.clear();
 
     // Reimplemented, to add a check for autosave files and to improve error reporting
     if (!_url.isValid()) {
         d->lastErrorMessage = i18n("Malformed URL\n%1", _url.url());  // ## used anywhere ?
         return false;
     }
 
     QUrl url(_url);
     bool autosaveOpened = false;
     if (url.isLocalFile() && !fileBatchMode()) {
         QString file = url.toLocalFile();
         QString asf = generateAutoSaveFileName(file);
         if (QFile::exists(asf)) {
             KisApplication *kisApp = static_cast<KisApplication*>(qApp);
             kisApp->hideSplashScreen();
             //dbgUI <<"asf=" << asf;
             // ## TODO compare timestamps ?
             int res = QMessageBox::warning(0,
                                            i18nc("@title:window", "Krita"),
                                            i18n("An autosaved file exists for this document.\nDo you want to open the autosaved file instead?"),
                                            QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel, QMessageBox::Yes);
             switch (res) {
             case QMessageBox::Yes :
                 url.setPath(asf);
                 autosaveOpened = true;
                 break;
             case QMessageBox::No :
                 QFile::remove(asf);
                 break;
             default: // Cancel
                 return false;
             }
         }
     }
 
     bool ret = openUrlInternal(url);
 
     if (autosaveOpened || flags & RecoveryFile) {
         setReadWrite(true); // enable save button
         setModified(true);
         setRecovered(true);
     }
     else {
         if (!(flags & DontAddToRecent)) {
             KisPart::instance()->addRecentURLToAllMainWindows(_url);
         }
 
         if (ret) {
             // Detect readonly local-files; remote files are assumed to be writable
             QFileInfo fi(url.toLocalFile());
             setReadWrite(fi.isWritable());
         }
 
         setRecovered(false);
     }
 
     return ret;
 }
 
 class DlgLoadMessages : public KoDialog {
 public:
     DlgLoadMessages(const QString &title, const QString &message, const QStringList &warnings) {
         setWindowTitle(title);
         setWindowIcon(KisIconUtils::loadIcon("warning"));
         QWidget *page = new QWidget(this);
         QVBoxLayout *layout = new QVBoxLayout(page);
         QHBoxLayout *hlayout = new QHBoxLayout();
         QLabel *labelWarning= new QLabel();
         labelWarning->setPixmap(KisIconUtils::loadIcon("warning").pixmap(32, 32));
         hlayout->addWidget(labelWarning);
         hlayout->addWidget(new QLabel(message));
         layout->addLayout(hlayout);
         QTextBrowser *browser = new QTextBrowser();
         QString warning = "<html><body><p><b>";
         if (warnings.size() == 1) {
             warning += "</b> Reason:</p>";
         }
         else {
             warning += "</b> Reasons:</p>";
         }
         warning += "<p/><ul>";
 
         Q_FOREACH(const QString &w, warnings) {
             warning += "\n<li>" + w + "</li>";
         }
         warning += "</ul>";
         browser->setHtml(warning);
         browser->setMinimumHeight(200);
         browser->setMinimumWidth(400);
         layout->addWidget(browser);
         setMainWidget(page);
         setButtons(KoDialog::Ok);
         resize(minimumSize());
     }
 };
 
 bool KisDocument::openFile()
 {
     //dbgUI <<"for" << localFilePath();
     if (!QFile::exists(localFilePath())) {
         QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("File %1 does not exist.", localFilePath()));
         return false;
     }
 
     QString filename = localFilePath();
     QString typeName = mimeType();
 
     if (typeName.isEmpty()) {
         typeName = KisMimeDatabase::mimeTypeForFile(filename);
     }
 
     //qDebug() << "mimetypes 4:" << typeName;
 
     // Allow to open backup files, don't keep the mimetype application/x-trash.
     if (typeName == "application/x-trash") {
         QString path = filename;
         while (path.length() > 0) {
             path.chop(1);
             typeName = KisMimeDatabase::mimeTypeForFile(path);
             //qDebug() << "\t" << path << typeName;
             if (!typeName.isEmpty()) {
                 break;
             }
         }
         //qDebug() << "chopped" << filename  << "to" << path << "Was trash, is" << typeName;
     }
     dbgUI << localFilePath() << "type:" << typeName;
 
     KisMainWindow *window = KisPart::instance()->currentMainwindow();
     if (window && window->viewManager()) {
         KoUpdaterPtr updater = window->viewManager()->createUnthreadedUpdater(i18n("Opening document"));
         d->importExportManager->setUpdater(updater);
     }
 
     KisImportExportFilter::ConversionStatus status;
 
     status = d->importExportManager->importDocument(localFilePath(), typeName);
 
     if (status != KisImportExportFilter::OK) {
         QString msg = KisImportExportFilter::conversionStatusString(status);
         if (!msg.isEmpty()) {
             DlgLoadMessages dlg(i18nc("@title:window", "Krita"),
                                 i18n("Could not open %2.\nReason: %1.", msg, prettyPathOrUrl()),
                                 errorMessage().split("\n") + warningMessage().split("\n"));
             dlg.exec();
         }
         return false;
     }
     else if (!warningMessage().isEmpty()) {
         DlgLoadMessages dlg(i18nc("@title:window", "Krita"),
                             i18n("There were problems opening %1.", prettyPathOrUrl()),
                             warningMessage().split("\n"));
         dlg.exec();
         setUrl(QUrl());
     }
 
     setMimeTypeAfterLoading(typeName);
     emit sigLoadingFinished();
 
     undoStack()->clear();
 
     return true;
 }
 
 // shared between openFile and koMainWindow's "create new empty document" code
 void KisDocument::setMimeTypeAfterLoading(const QString& mimeType)
 {
     d->mimeType = mimeType.toLatin1();
     d->outputMimeType = d->mimeType;
 }
 
 
 bool KisDocument::loadNativeFormat(const QString & file_)
 {
     return openUrl(QUrl::fromLocalFile(file_));
 }
 
 void KisDocument::setModified(bool mod)
 {
     if (mod) {
         updateEditingTime(false);
     }
 
     if (d->isAutosaving)   // ignore setModified calls due to autosaving
         return;
 
     if ( !d->readwrite && d->modified ) {
         errKrita << "Can't set a read-only document to 'modified' !" << endl;
         return;
     }
 
     //dbgUI<<" url:" << url.path();
     //dbgUI<<" mod="<<mod<<" MParts mod="<<KisParts::ReadWritePart::isModified()<<" isModified="<<isModified();
 
     if (mod && !d->autoSaveTimer->isActive()) {
         // First change since last autosave -> start the autosave timer
         setNormalAutoSaveInterval();
     }
     d->modifiedAfterAutosave = mod;
     d->modifiedWhileSaving = mod;
 
     if (mod == isModified())
         return;
 
     d->modified = mod;
 
     if (mod) {
         documentInfo()->updateParameters();
     }
 
     // This influences the title
     setTitleModified();
     emit modified(mod);
 }
 
 void KisDocument::setRecovered(bool value)
 {
     d->isRecovered = value;
 }
 
 bool KisDocument::isRecovered() const
 {
     return d->isRecovered;
 }
 
 void KisDocument::updateEditingTime(bool forceStoreElapsed)
 {
     QDateTime now = QDateTime::currentDateTime();
     int firstModDelta = d->firstMod.secsTo(now);
     int lastModDelta = d->lastMod.secsTo(now);
 
     if (lastModDelta > 30) {
         d->docInfo->setAboutInfo("editing-time", QString::number(d->docInfo->aboutInfo("editing-time").toInt() + d->firstMod.secsTo(d->lastMod)));
         d->firstMod = now;
     } else if (firstModDelta > 60 || forceStoreElapsed) {
         d->docInfo->setAboutInfo("editing-time", QString::number(d->docInfo->aboutInfo("editing-time").toInt() + firstModDelta));
         d->firstMod = now;
     }
 
     d->lastMod = now;
 }
 
 QString KisDocument::prettyPathOrUrl() const
 {
     QString _url(url().toDisplayString());
 #ifdef Q_OS_WIN
     if (url().isLocalFile()) {
         _url = QDir::toNativeSeparators(_url);
     }
 #endif
     return _url;
 }
 
 // Get caption from document info (title(), in about page)
 QString KisDocument::caption() const
 {
     QString c;
     const QString _url(url().fileName());
 
     // if URL is empty...it is probably an unsaved file
     if (_url.isEmpty()) {
         c = " [" + i18n("Not Saved") + "] ";
     } else {
         c = _url; // Fall back to document URL
     }
 
     return c;
 }
 
 void KisDocument::setTitleModified()
 {
     emit titleModified(caption(), isModified());
 }
 
 QDomDocument KisDocument::createDomDocument(const QString& tagName, const QString& version) const
 {
     return createDomDocument("krita", tagName, version);
 }
 
 //static
 QDomDocument KisDocument::createDomDocument(const QString& appName, const QString& tagName, const QString& version)
 {
     QDomImplementation impl;
     QString url = QString("http://www.calligra.org/DTD/%1-%2.dtd").arg(appName).arg(version);
     QDomDocumentType dtype = impl.createDocumentType(tagName,
                                                      QString("-//KDE//DTD %1 %2//EN").arg(appName).arg(version),
                                                      url);
     // The namespace URN doesn't need to include the version number.
     QString namespaceURN = QString("http://www.calligra.org/DTD/%1").arg(appName);
     QDomDocument doc = impl.createDocument(namespaceURN, tagName, dtype);
     doc.insertBefore(doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"UTF-8\""), doc.documentElement());
     return doc;
 }
 
 bool KisDocument::isNativeFormat(const QByteArray& mimetype) const
 {
     if (mimetype == nativeFormatMimeType())
         return true;
     return extraNativeMimeTypes().contains(mimetype);
 }
 
 void KisDocument::setErrorMessage(const QString& errMsg)
 {
     d->lastErrorMessage = errMsg;
 }
 
 QString KisDocument::errorMessage() const
 {
     return d->lastErrorMessage;
 }
 
 void KisDocument::setWarningMessage(const QString& warningMsg)
 {
     d->lastWarningMessage = warningMsg;
 }
 
 QString KisDocument::warningMessage() const
 {
     return d->lastWarningMessage;
 }
 
 
 void KisDocument::removeAutoSaveFiles(const QString &autosaveBaseName, bool wasRecovered)
 {
     //qDebug() << "removeAutoSaveFiles";
     // Eliminate any auto-save file
     QString asf = generateAutoSaveFileName(autosaveBaseName);   // the one in the current dir
 
     //qDebug() << "\tfilename:" << asf << "exists:" << QFile::exists(asf);
     if (QFile::exists(asf)) {
         //qDebug() << "\tremoving autosavefile" << asf;
         QFile::remove(asf);
     }
     asf = generateAutoSaveFileName(QString());   // and the one in $HOME
 
     //qDebug() << "Autsavefile in $home" << asf;
     if (QFile::exists(asf)) {
         //qDebug() << "\tremoving autsavefile 2" << asf;
         QFile::remove(asf);
     }
 
     QRegularExpression autosavePattern("^\\..+-autosave.kra$");
 
     if (wasRecovered &&
         !autosaveBaseName.isEmpty() &&
         autosavePattern.match(QFileInfo(autosaveBaseName).fileName()).hasMatch() &&
         QFile::exists(autosaveBaseName)) {
 
         QFile::remove(autosaveBaseName);
     }
 }
 
 KoUnit KisDocument::unit() const
 {
     return d->unit;
 }
 
 void KisDocument::setUnit(const KoUnit &unit)
 {
     if (d->unit != unit) {
         d->unit = unit;
         emit unitChanged(unit);
     }
 }
 
 KUndo2Stack *KisDocument::undoStack()
 {
     return d->undoStack;
 }
 
 KisImportExportManager *KisDocument::importExportManager() const
 {
     return d->importExportManager;
 }
 
 void KisDocument::addCommand(KUndo2Command *command)
 {
     if (command)
         d->undoStack->push(command);
 }
 
 void KisDocument::beginMacro(const KUndo2MagicString & text)
 {
     d->undoStack->beginMacro(text);
 }
 
 void KisDocument::endMacro()
 {
     d->undoStack->endMacro();
 }
 
 void KisDocument::slotUndoStackCleanChanged(bool value)
 {
     setModified(!value);
 }
 
 void KisDocument::slotConfigChanged()
 {
     KisConfig cfg(true);
     d->undoStack->setUndoLimit(cfg.undoStackLimit());
     d->autoSaveDelay = cfg.autoSaveInterval();
     setNormalAutoSaveInterval();
 }
 
 void KisDocument::clearUndoHistory()
 {
     d->undoStack->clear();
 }
 
 KisGridConfig KisDocument::gridConfig() const
 {
     return d->gridConfig;
 }
 
 void KisDocument::setGridConfig(const KisGridConfig &config)
 {
     d->gridConfig = config;
 }
 
 QList<KoColorSet *> &KisDocument::paletteList()
 {
     return d->paletteList;
 }
 
 void KisDocument::setPaletteList(const QList<KoColorSet *> &paletteList)
 {
     d->paletteList = paletteList;
 }
 
+KoGamutMask* KisDocument::gamutMask()
+{
+    return d->gamutMask;
+}
+
+void KisDocument::setGamutMask(KoGamutMask* gamutMask)
+{
+    d->gamutMask = gamutMask;
+}
+
 const KisGuidesConfig& KisDocument::guidesConfig() const
 {
     return d->guidesConfig;
 }
 
 void KisDocument::setGuidesConfig(const KisGuidesConfig &data)
 {
     if (d->guidesConfig == data) return;
 
     d->guidesConfig = data;
     emit sigGuidesConfigChanged(d->guidesConfig);
 }
 
 void KisDocument::resetURL() {
     setUrl(QUrl());
     setLocalFilePath(QString());
 }
 
 KoDocumentInfoDlg *KisDocument::createDocumentInfoDialog(QWidget *parent, KoDocumentInfo *docInfo) const
 {
     return new KoDocumentInfoDlg(parent, docInfo);
 }
 
 bool KisDocument::isReadWrite() const
 {
     return d->readwrite;
 }
 
 QUrl KisDocument::url() const
 {
     return d->m_url;
 }
 
 bool KisDocument::closeUrl(bool promptToSave)
 {
     if (promptToSave) {
         if ( isReadWrite() && isModified()) {
             Q_FOREACH (KisView *view, KisPart::instance()->views()) {
                 if (view && view->document() == this) {
                     if (!view->queryClose()) {
                         return false;
                     }
                 }
             }
         }
     }
     // Not modified => ok and delete temp file.
     d->mimeType = QByteArray();
 
     // It always succeeds for a read-only part,
     // but the return value exists for reimplementations
     // (e.g. pressing cancel for a modified read-write part)
     return true;
 }
 
 
 
 void KisDocument::setUrl(const QUrl &url)
 {
     d->m_url = url;
 }
 
 QString KisDocument::localFilePath() const
 {
     return d->m_file;
 }
 
 
 void KisDocument::setLocalFilePath( const QString &localFilePath )
 {
     d->m_file = localFilePath;
 }
 
 bool KisDocument::openUrlInternal(const QUrl &url)
 {
     if ( !url.isValid() )
         return false;
 
     if (d->m_bAutoDetectedMime) {
         d->mimeType = QByteArray();
         d->m_bAutoDetectedMime = false;
     }
 
     QByteArray mimetype = d->mimeType;
 
     if ( !closeUrl() )
         return false;
 
     d->mimeType = mimetype;
     setUrl(url);
 
     d->m_file.clear();
 
     if (d->m_url.isLocalFile()) {
         d->m_file = d->m_url.toLocalFile();
         bool ret;
         // set the mimetype only if it was not already set (for example, by the host application)
         if (d->mimeType.isEmpty()) {
             // get the mimetype of the file
             // using findByUrl() to avoid another string -> url conversion
             QString mime = KisMimeDatabase::mimeTypeForFile(d->m_url.toLocalFile());
             d->mimeType = mime.toLocal8Bit();
             d->m_bAutoDetectedMime = true;
         }
 
         setUrl(d->m_url);
         ret = openFile();
 
         if (ret) {
             emit completed();
         } else {
             emit canceled(QString());
         }
         return ret;
     }
     return false;
 }
 
 bool KisDocument::newImage(const QString& name,
                            qint32 width, qint32 height,
                            const KoColorSpace* cs,
                            const KoColor &bgColor, bool backgroundAsLayer,
                            int numberOfLayers,
                            const QString &description, const double imageResolution)
 {
     Q_ASSERT(cs);
 
     KisImageSP image;
     KisPaintLayerSP layer;
 
     if (!cs) return false;
 
     QApplication::setOverrideCursor(Qt::BusyCursor);
 
     image = new KisImage(createUndoStore(), width, height, cs, name);
 
     Q_CHECK_PTR(image);
 
     connect(image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
     image->setResolution(imageResolution, imageResolution);
 
     image->assignImageProfile(cs->profile());
     documentInfo()->setAboutInfo("title", name);
     documentInfo()->setAboutInfo("abstract", description);
 
     layer = new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
     Q_CHECK_PTR(layer);
 
     if (backgroundAsLayer) {
         image->setDefaultProjectionColor(KoColor(cs));
 
         if (bgColor.opacityU8() == OPACITY_OPAQUE_U8) {
             layer->paintDevice()->setDefaultPixel(bgColor);
         } else {
             // Hack: with a semi-transparent background color, the projection isn't composited right if we just set the default pixel
             KisFillPainter painter;
             painter.begin(layer->paintDevice());
             painter.fillRect(0, 0, width, height, bgColor, bgColor.opacityU8());
         }
     } else {
         image->setDefaultProjectionColor(bgColor);
     }
     layer->setDirty(QRect(0, 0, width, height));
 
     image->addNode(layer.data(), image->rootLayer().data());
     setCurrentImage(image);
 
     for(int i = 1; i < numberOfLayers; ++i) {
         KisPaintLayerSP layer = new KisPaintLayer(image, image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
         image->addNode(layer, image->root(), i);
         layer->setDirty(QRect(0, 0, width, height));
     }
 
     KisConfig cfg(false);
     cfg.defImageWidth(width);
     cfg.defImageHeight(height);
     cfg.defImageResolution(imageResolution);
     cfg.defColorModel(image->colorSpace()->colorModelId().id());
     cfg.setDefaultColorDepth(image->colorSpace()->colorDepthId().id());
     cfg.defColorProfile(image->colorSpace()->profile()->name());
 
     QApplication::restoreOverrideCursor();
 
     return true;
 }
 
 bool KisDocument::isSaving() const
 {
     const bool result = d->savingMutex.tryLock();
     if (result) {
         d->savingMutex.unlock();
     }
     return !result;
 }
 
 void KisDocument::waitForSavingToComplete()
 {
     if (isSaving()) {
         KisAsyncActionFeedback f(i18nc("progress dialog message when the user closes the document that is being saved", "Waiting for saving to complete..."), 0);
         f.waitForMutex(&d->savingMutex);
     }
 }
 
 KoShapeControllerBase *KisDocument::shapeController() const
 {
     return d->shapeController;
 }
 
 KoShapeLayer* KisDocument::shapeForNode(KisNodeSP layer) const
 {
     return d->shapeController->shapeForNode(layer);
 }
 
 QList<KisPaintingAssistantSP> KisDocument::assistants() const
 {
     return d->assistants;
 }
 
 void KisDocument::setAssistants(const QList<KisPaintingAssistantSP> &value)
 {
     d->assistants = value;
 }
 
 KisSharedPtr<KisReferenceImagesLayer> KisDocument::referenceImagesLayer() const
 {
     return d->referenceImagesLayer.data();
 }
 
 void KisDocument::setReferenceImagesLayer(KisSharedPtr<KisReferenceImagesLayer> layer, bool updateImage)
 {
     if (d->referenceImagesLayer) {
         d->referenceImagesLayer->disconnect(this);
     }
 
     if (updateImage) {
         if (layer) {
             d->image->addNode(layer);
         } else {
             d->image->removeNode(d->referenceImagesLayer);
         }
     }
 
     d->referenceImagesLayer = layer;
 
     if (d->referenceImagesLayer) {
         connect(d->referenceImagesLayer, SIGNAL(sigUpdateCanvas(QRectF)),
                 this, SIGNAL(sigReferenceImagesChanged()));
     }
 }
 
 void KisDocument::setPreActivatedNode(KisNodeSP activatedNode)
 {
     d->preActivatedNode = activatedNode;
 }
 
 KisNodeSP KisDocument::preActivatedNode() const
 {
     return d->preActivatedNode;
 }
 
 KisImageWSP KisDocument::image() const
 {
     return d->image;
 }
 
 KisImageSP KisDocument::savingImage() const
 {
     return d->savingImage;
 }
 
 
 void KisDocument::setCurrentImage(KisImageSP image, bool forceInitialUpdate)
 {
     if (d->image) {
         // Disconnect existing sig/slot connections
         d->image->setUndoStore(new KisDumbUndoStore());
         d->image->disconnect(this);
         d->shapeController->setImage(0);
         d->image = 0;
     }
 
     if (!image) return;
 
     d->setImageAndInitIdleWatcher(image);
     d->image->setUndoStore(new KisDocumentUndoStore(this));
     d->shapeController->setImage(image);
     setModified(false);
     connect(d->image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
 
     if (forceInitialUpdate) {
         d->image->initialRefreshGraph();
     }
 }
 
 void KisDocument::hackPreliminarySetImage(KisImageSP image)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!d->image);
 
     d->setImageAndInitIdleWatcher(image);
     d->shapeController->setImage(image);
 }
 
 void KisDocument::setImageModified()
 {
     setModified(true);
 }
 
 
 KisUndoStore* KisDocument::createUndoStore()
 {
     return new KisDocumentUndoStore(this);
 }
 
 bool KisDocument::isAutosaving() const
 {
     return d->isAutosaving;
 }
 
 QString KisDocument::exportErrorToUserMessage(KisImportExportFilter::ConversionStatus status, const QString &errorMessage)
 {
     return errorMessage.isEmpty() ? KisImportExportFilter::conversionStatusString(status) : errorMessage;
 }
 
 void KisDocument::setAssistantsGlobalColor(QColor color)
 {
     d->globalAssistantsColor = color;
 }
 
 QColor KisDocument::assistantsGlobalColor()
 {
     return d->globalAssistantsColor;
 }
 
 QRectF KisDocument::documentBounds() const
 {
     QRectF bounds = d->image->bounds();
 
     if (d->referenceImagesLayer) {
         bounds |= d->referenceImagesLayer->boundingImageRect();
     }
 
     return bounds;
 }
diff --git a/libs/ui/KisDocument.h b/libs/ui/KisDocument.h
index 11f80ba458..6e9667889f 100644
--- a/libs/ui/KisDocument.h
+++ b/libs/ui/KisDocument.h
@@ -1,655 +1,659 @@
 /* This file is part of the Krita project
  *
  * 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.
  */
 
 #ifndef KISDOCUMENT_H
 #define KISDOCUMENT_H
 
 #include <QDateTime>
 #include <QTransform>
 #include <QList>
 
 #include <klocalizedstring.h>
 
 #include <KoPageLayout.h>
 #include <KoDocumentBase.h>
 #include <kundo2stack.h>
 #include <KoColorSet.h>
 
 #include <kis_image.h>
 #include <KisImportExportFilter.h>
 #include <kis_properties_configuration.h>
 #include <kis_types.h>
 #include <kis_painting_assistant.h>
 #include <KisReferenceImage.h>
 #include <kis_debug.h>
 #include <KisImportExportUtils.h>
 
 #include "kritaui_export.h"
 
 #include <memory>
 
 class QString;
 
 class KUndo2Command;
 class KoUnit;
 
 class KoColor;
 class KoColorSpace;
 class KoShapeControllerBase;
 class KoShapeLayer;
 class KoStore;
 class KoOdfReadStore;
 class KoDocumentInfo;
 class KoDocumentInfoDlg;
 class KisImportExportManager;
 class KisUndoStore;
 class KisPart;
 class KisGridConfig;
 class KisGuidesConfig;
 class QDomDocument;
 class KisReferenceImagesLayer;
+class KoGamutMask;
 
 #define KIS_MIME_TYPE "application/x-krita"
 
 /**
  *  The %Calligra document class
  *
  *  This class provides some functionality each %Calligra document should have.
  *
  *  @short The %Calligra document class
  */
 class KRITAUI_EXPORT KisDocument : public QObject, public KoDocumentBase
 {
     Q_OBJECT
 
 protected:
 
     explicit KisDocument();
 
     /**
      * @brief KisDocument makes a deep copy of the document \p rhs.
      *        The caller *must* ensure that the image is properly
      *        locked and is in consistent state before asking for
      *        cloning.
      * @param rhs the source document to copy from
      */
     explicit KisDocument(const KisDocument &rhs);
 
 public:
     enum OpenFlag {
         None = 0,
         DontAddToRecent = 0x1,
         RecoveryFile = 0x2
     };
     Q_DECLARE_FLAGS(OpenFlags, OpenFlag)
 
     /**
      *  Destructor.
      *
      * The destructor does not delete any attached KisView objects and it does not
      * delete the attached widget as returned by widget().
      */
     ~KisDocument() override;
 
     /**
      * @brief reload Reloads the document from the original url
      * @return the result of loading the document
      */
     bool reload();
 
 
     /**
      * @brief creates a clone of the document and returns it. Please make sure that you
      * hold all the necessary locks on the image before asking for a clone!
      */
     KisDocument* clone();
 
     /**
      * @brief openUrl Open an URL
      * @param url The URL to open
      * @param flags Control specific behavior
      * @return success status
      */
     bool openUrl(const QUrl &url, OpenFlags flags = None);
 
     /**
      * Opens the document given by @p url, without storing the URL
      * in the KisDocument.
      * Call this instead of openUrl() to implement KisMainWindow's
      * File --> Import feature.
      *
      * @note This will call openUrl(). To differentiate this from an ordinary
      *       Open operation (in any reimplementation of openUrl() or openFile())
      *       call isImporting().
      */
     bool importDocument(const QUrl &url);
 
     /**
      * Saves the document as @p url without changing the state of the
      * KisDocument (URL, modified flag etc.). Call this instead of
      * KisParts::ReadWritePart::saveAs() to implement KisMainWindow's
      * File --> Export feature.
      */
     bool exportDocument(const QUrl &url, const QByteArray &mimeType, bool showWarnings = false, KisPropertiesConfigurationSP exportConfiguration = 0);
 
     bool exportDocumentSync(const QUrl &url, const QByteArray &mimeType, KisPropertiesConfigurationSP exportConfiguration = 0);
 
 private:
     bool exportDocumentImpl(const KritaUtils::ExportFileJob &job, KisPropertiesConfigurationSP exportConfiguration);
 
 public:
     /**
      * @brief Sets whether the document can be edited or is read only.
      *
      * This recursively applied to all child documents and
      * KisView::updateReadWrite is called for every attached
      * view.
      */
     void setReadWrite(bool readwrite = true);
 
     /**
      * To be preferred when a document exists. It is fast when calling
      * it multiple times since it caches the result that readNativeFormatMimeType()
      * delivers.
      * This comes from the X-KDE-NativeMimeType key in the .desktop file.
      */
     static QByteArray nativeFormatMimeType() { return KIS_MIME_TYPE; }
 
     /// Checks whether a given mimetype can be handled natively.
     bool isNativeFormat(const QByteArray& mimetype) const;
 
     /// Returns a list of the mimetypes considered "native", i.e. which can
     /// be saved by KisDocument without a filter, in *addition* to the main one
     static QStringList extraNativeMimeTypes() { return QStringList() << KIS_MIME_TYPE; }
 
     /**
      * Returns the actual mimetype of the document
      */
     QByteArray mimeType() const override;
 
     /**
      * @brief Sets the mime type for the document.
      *
      * When choosing "save as" this is also the mime type
      * selected by default.
      */
     void setMimeType(const QByteArray & mimeType) override;
 
     /**
      * @return true if file operations should inhibit the option dialog
      */
     bool fileBatchMode() const;
 
     /**
      * @param batchMode if true, do not show the option dialog for file operations.
      */
     void setFileBatchMode(const bool batchMode);
 
     /**
      * Sets the error message to be shown to the user (use i18n()!)
      * when loading or saving fails.
      * If you asked the user about something and they chose "Cancel",
      */
     void setErrorMessage(const QString& errMsg);
 
     /**
      * Return the last error message. Usually KisDocument takes care of
      * showing it; this method is mostly provided for non-interactive use.
      */
     QString errorMessage() const;
 
     /**
      * Sets the warning message to be shown to the user (use i18n()!)
      * when loading or saving fails.
      */
     void setWarningMessage(const QString& warningMsg);
 
     /**
      * Return the last warning message set by loading or saving. Warnings
      * mean that the document could not be completely loaded, but the errors
      * were not absolutely fatal.
      */
     QString warningMessage() const;
 
     /**
      * @brief Generates a preview picture of the document
      * @note The preview is used in the File Dialog and also to create the Thumbnail
      */
     QPixmap generatePreview(const QSize& size);
 
     /**
      *  Tells the document that its title has been modified, either because
      *  the modified status changes (this is done by setModified() ) or
      *  because the URL or the document-info's title changed.
      */
     void setTitleModified();
 
     /**
      *  @brief Sets the document to empty.
      *
      *  Used after loading a template
      *  (which is not empty, but not the user's input).
      *
      *  @see isEmpty()
      */
     void setEmpty(bool empty = true);
 
     /**
      *  Return a correctly created QDomDocument for this KisDocument,
      *  including processing instruction, complete DOCTYPE tag (with systemId and publicId), and root element.
      *  @param tagName the name of the tag for the root element
      *  @param version the DTD version (usually the application's version).
      */
     QDomDocument createDomDocument(const QString& tagName, const QString& version) const;
 
     /**
      *  Return a correctly created QDomDocument for an old (1.3-style) %Calligra document,
      *  including processing instruction, complete DOCTYPE tag (with systemId and publicId), and root element.
      *  This static method can be used e.g. by filters.
      *  @param appName the app's instance name, e.g. words, kspread, kpresenter etc.
      *  @param tagName the name of the tag for the root element, e.g. DOC for words/kpresenter.
      *  @param version the DTD version (usually the application's version).
      */
     static QDomDocument createDomDocument(const QString& appName, const QString& tagName, const QString& version);
 
    /**
      *  Loads a document in the native format from a given URL.
      *  Reimplement if your native format isn't XML.
      *
      *  @param file the file to load - usually KReadOnlyPart::m_file or the result of a filter
      */
     bool loadNativeFormat(const QString & file);
 
     /**
      * Set standard autosave interval that is set by a config file
      */
     void setNormalAutoSaveInterval();
 
     /**
      * Set emergency interval that autosave uses when the image is busy,
      * by default it is 10 sec
      */
     void setEmergencyAutoSaveInterval();
 
     /**
      * Disable autosave
      */
     void setInfiniteAutoSaveInterval();
 
     /**
      * @return the information concerning this document.
      * @see KoDocumentInfo
      */
     KoDocumentInfo *documentInfo() const;
 
     /**
      * Performs a cleanup of unneeded backup files
      */
     void removeAutoSaveFiles(const QString &autosaveBaseName, bool wasRecovered);
 
     /**
      * Returns true if this document or any of its internal child documents are modified.
      */
     bool isModified() const override;
 
     /**
      * @return caption of the document
      *
      * Caption is of the form "[title] - [url]",
      * built out of the document info (title) and pretty-printed
      * document URL.
      * If the title is not present, only the URL it returned.
      */
     QString caption() const;
 
     /**
      * Sets the document URL to empty URL
      * KParts doesn't allow this, but %Calligra apps have e.g. templates
      * After using loadNativeFormat on a template, one wants
      * to set the url to QUrl()
      */
     void resetURL();
 
     /**
      * @internal (public for KisMainWindow)
      */
     void setMimeTypeAfterLoading(const QString& mimeType);
 
     /**
      * Returns the unit used to display all measures/distances.
      */
     KoUnit unit() const;
 
     /**
      * Sets the unit used to display all measures/distances.
      */
     void setUnit(const KoUnit &unit);
 
     KisGridConfig gridConfig() const;
     void setGridConfig(const KisGridConfig &config);
 
     /// returns the guides data for this document.
     const KisGuidesConfig& guidesConfig() const;
     void setGuidesConfig(const KisGuidesConfig &data);
 
     QList<KoColorSet *> &paletteList();
     void setPaletteList(const QList<KoColorSet *> &paletteList);
 
+    KoGamutMask* gamutMask();
+    void setGamutMask(KoGamutMask* gamutMask);
+
     void clearUndoHistory();
 
 
     /**
      *  Sets the modified flag on the document. This means that it has
      *  to be saved or not before deleting it.
      */
     void setModified(bool _mod);
 
     void setRecovered(bool value);
     bool isRecovered() const;
 
     void updateEditingTime(bool forceStoreElapsed);
 
     /**
      * Returns the global undo stack
      */
     KUndo2Stack *undoStack();
 
 
     /**
      * @brief importExportManager gives access to the internal import/export manager
      * @return the document's import/export manager
      */
     KisImportExportManager *importExportManager() const;
 
     /**
      * @brief serializeToNativeByteArray daves the document into a .kra file wtitten
      * to a memory-based byte-array
      * @return a byte array containing the .kra file
      */
     QByteArray serializeToNativeByteArray();
 
 
     /**
      * @brief isInSaving shown if the document has any (background) saving process or not
      * @return true if there is some saving in action
      */
     bool isInSaving() const;
 
 public Q_SLOTS:
 
     /**
      * Adds a command to the undo stack and executes it by calling the redo() function.
      * @param command command to add to the undo stack
      */
     void addCommand(KUndo2Command *command);
 
     /**
      * Begins recording of a macro command. At the end endMacro needs to be called.
      * @param text command description
      */
     void beginMacro(const KUndo2MagicString &text);
 
     /**
      * Ends the recording of a macro command.
      */
     void endMacro();
 
 Q_SIGNALS:
 
     /**
      * This signal is emitted when the unit is changed by setUnit().
      * It is common to connect views to it, in order to change the displayed units
      * (e.g. in the rulers)
      */
     void unitChanged(const KoUnit &unit);
 
     /**
      * Emitted e.g. at the beginning of a save operation
      * This is emitted by KisDocument and used by KisView to display a statusbar message
      */
     void statusBarMessage(const QString& text, int timeout = 0);
 
     /**
      * Emitted e.g. at the end of a save operation
      * This is emitted by KisDocument and used by KisView to clear the statusbar message
      */
     void clearStatusBarMessage();
 
     /**
     * Emitted when the document is modified
     */
     void modified(bool);
 
     void titleModified(const QString &caption, bool isModified);
 
     void sigLoadingFinished();
 
     void sigSavingFinished();
 
     void sigGuidesConfigChanged(const KisGuidesConfig &config);
 
     void sigBackgroundSavingFinished(KisImportExportFilter::ConversionStatus status, const QString &errorMessage);
 
     void sigCompleteBackgroundSaving(const KritaUtils::ExportFileJob &job, KisImportExportFilter::ConversionStatus status, const QString &errorMessage);
 
     void sigReferenceImagesChanged();
 
 private Q_SLOTS:
     void finishExportInBackground();
     void slotChildCompletedSavingInBackground(KisImportExportFilter::ConversionStatus status, const QString &errorMessage);
     void slotCompleteAutoSaving(const KritaUtils::ExportFileJob &job, KisImportExportFilter::ConversionStatus status, const QString &errorMessage);
 
     void slotCompleteSavingDocument(const KritaUtils::ExportFileJob &job, KisImportExportFilter::ConversionStatus status, const QString &errorMessage);
 
     void slotInitiateAsyncAutosaving(KisDocument *clonedDocument);
 
 private:
 
     friend class KisPart;
     friend class SafeSavingLocker;
 
     bool initiateSavingInBackground(const QString actionName,
                                     const QObject *receiverObject, const char *receiverMethod,
                                     const KritaUtils::ExportFileJob &job,
                                     KisPropertiesConfigurationSP exportConfiguration,
                                     std::unique_ptr<KisDocument> &&optionalClonedDocument);
 
     bool initiateSavingInBackground(const QString actionName,
                                     const QObject *receiverObject, const char *receiverMethod,
                                     const KritaUtils::ExportFileJob &job,
                                     KisPropertiesConfigurationSP exportConfiguration);
 
     bool startExportInBackground(const QString &actionName, const QString &location,
                                  const QString &realLocation,
                                  const QByteArray &mimeType,
                                  bool showWarnings,
                                  KisPropertiesConfigurationSP exportConfiguration);
 
     /**
      * Activate/deactivate/configure the autosave feature.
      * @param delay in seconds, 0 to disable
      */
     void setAutoSaveDelay(int delay);
 
     /**
      * Generate a name for the document.
      */
     QString newObjectName();
 
     QString generateAutoSaveFileName(const QString & path) const;
 
     /**
      *  Loads a document
      *
      *  Applies a filter if necessary, and calls loadNativeFormat in any case
      *  You should not have to reimplement, except for very special cases.
      *
      * NOTE: this method also creates a new KisView instance!
      *
      * This method is called from the KReadOnlyPart::openUrl method.
      */
     bool openFile();
 
 public:
 
     bool isAutosaving() const override;
 
 public:
 
     QString localFilePath() const override;
     void setLocalFilePath( const QString &localFilePath );
 
     KoDocumentInfoDlg* createDocumentInfoDialog(QWidget *parent, KoDocumentInfo *docInfo) const;
 
     bool isReadWrite() const;
 
     QUrl url() const override;
     void setUrl(const QUrl &url) override;
 
     bool closeUrl(bool promptToSave = true);
 
     bool saveAs(const QUrl &url, const QByteArray &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfigration = 0);
 
     /**
      * Create a new image that has this document as a parent and
      * replace the current image with this image.
      */
     bool newImage(const QString& name, qint32 width, qint32 height, const KoColorSpace * cs, const KoColor &bgColor, bool backgroundAsLayer,
                   int numberOfLayers, const QString &imageDescription, const double imageResolution);
 
     bool isSaving() const;
     void waitForSavingToComplete();
 
 
     KisImageWSP image() const;
 
     /**
      * @brief savingImage provides a detached, shallow copy of the original image that must be used when saving.
      * Any strokes in progress will not be applied to this image, so the result might be missing some data. On
      * the other hand, it won't block.
      *
      * @return a shallow copy of the original image, or 0 is saving is not in progress
      */
     KisImageSP savingImage() const;
 
     /**
      * Set the current image to the specified image and turn undo on.
      */
     void setCurrentImage(KisImageSP image, bool forceInitialUpdate = true);
 
     /**
      * Set the image of the document preliminary, before the document
      * has completed loading. Some of the document items (shapes) may want
      * to access image properties (bounds and resolution), so we should provide
      * it to them even before the entire image is loaded.
      *
      * Right now, the only use by KoShapeRegistry::createShapeFromOdf(), remove
      * after it is deprecated.
      */
     void hackPreliminarySetImage(KisImageSP image);
 
     KisUndoStore* createUndoStore();
 
     /**
      * The shape controller matches internal krita image layers with
      * the flake shape hierarchy.
      */
     KoShapeControllerBase * shapeController() const;
 
     KoShapeLayer* shapeForNode(KisNodeSP layer) const;
 
     /**
      * Set the list of nodes that was marked as currently active. Used *only*
      * for saving loading. Never use it for tools or processing.
      */
     void setPreActivatedNode(KisNodeSP activatedNode);
 
     /**
      * @return the node that was set as active during loading. Used *only*
      * for saving loading. Never use it for tools or processing.
      */
     KisNodeSP preActivatedNode() const;
 
     /// @return the list of assistants associated with this document
     QList<KisPaintingAssistantSP> assistants() const;
 
     /// @replace the current list of assistants with @param value
     void setAssistants(const QList<KisPaintingAssistantSP> &value);
 
 
     void setAssistantsGlobalColor(QColor color);
     QColor assistantsGlobalColor();
 
 
 
     /**
      * Get existing reference images layer or null if none exists.
      */
     KisSharedPtr<KisReferenceImagesLayer> referenceImagesLayer() const;
 
     void setReferenceImagesLayer(KisSharedPtr<KisReferenceImagesLayer> layer, bool updateImage);
 
     bool save(bool showWarnings, KisPropertiesConfigurationSP exportConfiguration);
 
     /**
      * Return the bounding box of the image and associated elements (e.g. reference images)
      */
     QRectF documentBounds() const;
 
 Q_SIGNALS:
 
     void completed();
     void canceled(const QString &);
 
 private Q_SLOTS:
 
     void setImageModified();
 
     void slotAutoSave();
 
     void slotUndoStackCleanChanged(bool value);
 
     void slotConfigChanged();
 
 
 private:
     /**
      * @brief try to clone the image. This method handles all the locking for you. If locking
      *        has failed, no cloning happens
      * @return cloned document on success, null otherwise
      */
     KisDocument *lockAndCloneForSaving();
 
     QString exportErrorToUserMessage(KisImportExportFilter::ConversionStatus status, const QString &errorMessage);
 
     QString prettyPathOrUrl() const;
 
     bool openUrlInternal(const QUrl &url);
 
     void slotAutoSaveImpl(std::unique_ptr<KisDocument> &&optionalClonedDocument);
 
     class Private;
     Private *const d;
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(KisDocument::OpenFlags)
 Q_DECLARE_METATYPE(KisDocument*)
 
 #endif
diff --git a/plugins/dockers/gamutmask/gamutmask_dock.cpp b/plugins/dockers/gamutmask/gamutmask_dock.cpp
index 63ef163d12..bf64a8cecd 100644
--- a/plugins/dockers/gamutmask/gamutmask_dock.cpp
+++ b/plugins/dockers/gamutmask/gamutmask_dock.cpp
@@ -1,629 +1,662 @@
 /*
  *  Copyright (c) 2018 Anna Medonosova <anna.medonosova@gmail.com>
  *
  *  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 <kis_debug.h>
 
 #include <klocalizedstring.h>
 #include <KoCanvasResourceProvider.h>
 #include <KoResourceServerProvider.h>
 #include <KoResourceServerObserver.h>
 #include <KoResourceServerAdapter.h>
 #include <KoCanvasBase.h>
 #include <KoColor.h>
 #include <resources/KoGamutMask.h>
 #include <kis_icon_utils.h>
 #include <KisPart.h>
 #include <kis_shape_layer.h>
 #include <kis_types.h>
 #include <KisDocument.h>
 #include <kis_node_selection_adapter.h>
 #include <kis_group_layer.h>
 #include <KisView.h>
 #include <KoResourceItemChooser.h>
 
 #include <QWidget>
 #include <QMenu>
 #include <QButtonGroup>
 #include <QRegularExpressionValidator>
 #include <QRegularExpression>
 #include <QFileInfo>
 #include <QMessageBox>
 
 #include "gamutmask_dock.h"
 #include <KisViewManager.h>
 #include <kis_canvas_resource_provider.h>
 #include <KoColorBackground.h>
 #include <KoShapeStroke.h>
+#include <kis_canvas2.h>
 
 #include <ctime>
 
 #include "ui_wdgGamutMaskChooser.h"
 
 class KisMainWindow;
 
 struct GamutMaskChooserUI: public QWidget, public Ui_wdgGamutMaskChooser
 {
     GamutMaskChooserUI() {
         setupUi(this);
     }
 };
 
 
 GamutMaskDock::GamutMaskDock()
     : QDockWidget(i18n("Gamut Masks"))
     , m_resourceProvider(0)
     , m_selfClosingTemplate(false)
     , m_externalTemplateClose(false)
     , m_creatingNewMask(false)
     , m_templatePrevSaved(false)
     , m_selfSelectingMask(false)
+    , m_blockMaskStoring(false)
     , m_selectedMask(nullptr)
     , m_maskDocument(nullptr)
-    , m_view(nullptr)
+    , m_templateView(nullptr)
 {
     m_dockerUI    = new GamutMaskChooserUI();
 
     m_dockerUI->bnMaskEditor->setIcon(KisIconUtils::loadIcon("dirty-preset"));
     m_dockerUI->bnMaskDelete->setIcon(KisIconUtils::loadIcon("deletelayer"));
     m_dockerUI->bnMaskNew->setIcon(KisIconUtils::loadIcon("list-add"));
     m_dockerUI->bnMaskDuplicate->setIcon(KisIconUtils::loadIcon("duplicatelayer"));
 
     m_dockerUI->maskPropertiesBox->setVisible(false);
     m_dockerUI->bnSaveMask->setIcon(KisIconUtils::loadIcon("document-save"));
     m_dockerUI->bnCancelMaskEdit->setIcon(KisIconUtils::loadIcon("dialog-cancel"));
     m_dockerUI->bnPreviewMask->setIcon(KisIconUtils::loadIcon("visible"));
 
     QRegularExpression maskTitleRegex("^[-_\\(\\)\\sA-Za-z0-9]+$");
     QRegularExpressionValidator* m_maskTitleValidator = new QRegularExpressionValidator(maskTitleRegex, this);
     m_dockerUI->maskTitleEdit->setValidator(m_maskTitleValidator);
 
     KoResourceServer<KoGamutMask>* rServer = KoResourceServerProvider::instance()->gamutMaskServer();
     rServer->addObserver(this);
 
     // gamut mask connections
     connect(m_dockerUI->bnSaveMask        , SIGNAL(clicked())                        , SLOT(slotGamutMaskSave()));
     connect(m_dockerUI->bnCancelMaskEdit        , SIGNAL(clicked())                        , SLOT(slotGamutMaskCancelEdit()));
     connect(m_dockerUI->bnPreviewMask        , SIGNAL(clicked())                        , SLOT(slotGamutMaskPreview()));
 
     connect(m_dockerUI->bnMaskEditor          , SIGNAL(clicked())               , SLOT(slotGamutMaskEdit()));
     connect(m_dockerUI->maskChooser, SIGNAL(sigGamutMaskSelected(KoGamutMask*)), SLOT(slotGamutMaskSelected(KoGamutMask*)));
     connect(m_dockerUI->bnMaskNew          , SIGNAL(clicked())               , SLOT(slotGamutMaskCreateNew()));
     connect(m_dockerUI->bnMaskDelete          , SIGNAL(clicked())               , SLOT(slotGamutMaskDelete()));
     connect(m_dockerUI->bnMaskDuplicate       , SIGNAL(clicked())               , SLOT(slotGamutMaskDuplicate()));
 
     setWidget(m_dockerUI);
 }
 
 GamutMaskDock::~GamutMaskDock()
 {
     KoResourceServer<KoGamutMask>* rServer = KoResourceServerProvider::instance()->gamutMaskServer();
     rServer->removeObserver(this);
 }
 
 void GamutMaskDock::setViewManager(KisViewManager* kisview)
 {
     m_resourceProvider = kisview->resourceProvider();
 
     selectMask(m_resourceProvider->currentGamutMask());
 
     connect(this, SIGNAL(sigGamutMaskSet(KoGamutMask*)), m_resourceProvider, SLOT(slotGamutMaskActivated(KoGamutMask*)));
     connect(this, SIGNAL(sigGamutMaskChanged(KoGamutMask*)), m_resourceProvider, SLOT(slotGamutMaskActivated(KoGamutMask*)));
     connect(this, SIGNAL(sigGamutMaskUnset()), m_resourceProvider, SLOT(slotGamutMaskUnset()));
     connect(this, SIGNAL(sigGamutMaskPreviewUpdate()), m_resourceProvider, SLOT(slotGamutMaskPreviewUpdate()));
     connect(KisPart::instance(), SIGNAL(sigDocumentRemoved(QString)), this, SLOT(slotDocumentRemoved(QString)));
 }
 
 void GamutMaskDock::slotGamutMaskEdit()
 {
     if (!m_selectedMask) {
         return;
     }
     openMaskEditor();
 }
 
 bool GamutMaskDock::openMaskEditor()
 {
     if (!m_selectedMask) {
         return false;
     }
 
     // find the template resource first, so we can abort the action early on
     QString maskTemplateFile = KoResourcePaths::findResource("ko_gamutmasks", "GamutMaskTemplate.kra");
     if (maskTemplateFile.isEmpty() || maskTemplateFile.isNull() || !QFile::exists(maskTemplateFile)) {
         dbgPlugins << "GamutMaskDock::openMaskEditor(): maskTemplateFile (" << maskTemplateFile << ") was not found on the system";
         getUserFeedback(i18n("Could not open gamut mask for editing."),
                         i18n("The editor template was not found."),
                         QMessageBox::Ok, QMessageBox::Ok, QMessageBox::Critical);
         return false;
     }
 
     m_dockerUI->maskPropertiesBox->setVisible(true);
     m_dockerUI->maskPropertiesBox->setEnabled(true);
     m_dockerUI->editControlsBox->setEnabled(false);
     m_dockerUI->editControlsBox->setVisible(false);
 
     m_dockerUI->maskTitleEdit->setText(m_selectedMask->title());
     m_dockerUI->maskDescriptionEdit->setPlainText(m_selectedMask->description());
 
     m_maskDocument = KisPart::instance()->createDocument();
     KisPart::instance()->addDocument(m_maskDocument);
     m_maskDocument->openUrl(QUrl::fromLocalFile(maskTemplateFile), KisDocument::DontAddToRecent);
 
     // template document needs a proper autogenerated filename,
     // to avoid collision with other documents,
     // otherwise bugs happen when slotDocumentRemoved is called
     // (e.g. user closes another view, the template stays open, but the edit operation is canceled)
     m_maskDocument->setInfiniteAutoSaveInterval();
     QString maskPath = QString("%1%2%3_%4.kra")
             .arg(QDir::tempPath())
             .arg(QDir::separator())
             .arg("GamutMaskTemplate")
             .arg(std::time(nullptr));
     m_maskDocument->setUrl(QUrl::fromLocalFile(maskPath));
     m_maskDocument->setLocalFilePath(maskPath);
 
     KisShapeLayerSP shapeLayer = getShapeLayer();
 
     // pass only copies of shapes to the layer,
     // so the originals don't disappear from the mask later
     for (KoShape *shape: m_selectedMask->koShapes()) {
         KoShape* newShape = shape->cloneShape();
         newShape->setStroke(KoShapeStrokeModelSP());
         newShape->setBackground(QSharedPointer<KoColorBackground>(new KoColorBackground(QColor(255,255,255))));
         shapeLayer->addShape(newShape);
     }
 
     m_maskDocument->setPreActivatedNode(shapeLayer);
 
     // set document as active
     KisMainWindow* mainWindow = KisPart::instance()->currentMainwindow();
     KIS_ASSERT(mainWindow);
 
-    m_view = mainWindow->addViewAndNotifyLoadingCompleted(m_maskDocument);
-    KIS_ASSERT(m_view);
+    m_templateView = mainWindow->addViewAndNotifyLoadingCompleted(m_maskDocument);
+    KIS_ASSERT(m_templateView);
 
     for(KisView *view: KisPart::instance()->views()) {
         if (view->document() == m_maskDocument) {
             view->activateWindow();
             break;
         }
     }
 
-    connect(m_view->viewManager(), SIGNAL(viewChanged()), this, SLOT(slotViewChanged()));
+    connect(m_templateView->viewManager(), SIGNAL(viewChanged()), this, SLOT(slotViewChanged()));
     connect(m_maskDocument, SIGNAL(completed()), this, SLOT(slotDocumentSaved()));
 
     return true;
 }
 
 void GamutMaskDock::cancelMaskEdit()
 {
     if (m_creatingNewMask) {
         deleteMask();
     }
 
     if (m_selectedMask) {
         m_selectedMask->clearPreview();
 
         if (m_resourceProvider->currentGamutMask() == m_selectedMask) {
             emit sigGamutMaskChanged(m_selectedMask);
         }
     }
 
     closeMaskDocument();
 }
 
 void GamutMaskDock::selectMask(KoGamutMask *mask, bool notifyItemChooser)
 {
     if (!mask) {
         return;
     }
 
     m_selectedMask = mask;
 
     if (notifyItemChooser) {
         m_selfSelectingMask = true;
         m_dockerUI->maskChooser->setCurrentResource(m_selectedMask);
         m_selfSelectingMask = false;
     }
 
+    if (m_blockMaskStoring) {
+        if (m_canvas) {
+            m_canvas->imageView()->document()->setGamutMask(m_selectedMask);
+        }
+    }
+
     emit sigGamutMaskSet(m_selectedMask);
 }
 
 bool GamutMaskDock::saveSelectedMaskResource()
 {
     if (!m_selectedMask || !m_maskDocument) {
         return false;
     }
 
     bool maskSaved = false;
 
     if (m_selectedMask) {
         QList<KoShape*> shapes = getShapesFromLayer();
 
         if (shapes.count() > 0) {
             m_selectedMask->setMaskShapes(shapes);
 
             m_selectedMask->setImage(
                         m_maskDocument->image()->convertToQImage(m_maskDocument->image()->bounds()
                                                                  , m_maskDocument->image()->profile()
                                                                  )
                         );
 
             m_selectedMask->setDescription(m_dockerUI->maskDescriptionEdit->toPlainText());
 
             m_selectedMask->clearPreview();
             m_selectedMask->save();
             maskSaved = true;
         } else {
             getUserFeedback(i18n("Saving of gamut mask '%1' was aborted.", m_selectedMask->title()),
                             i18n("<p>The mask template is invalid.</p>"
                                  "<p>Please check that:"
                                  "<ul>"
                                  "<li>your template contains a vector layer named 'maskShapesLayer'</li>"
                                  "<li>there are one or more vector shapes on the 'maskShapesLayer'</li>"
                                  "</ul></p>"
                                  ),
                             QMessageBox::Ok, QMessageBox::Ok);
         }
     }
 
     return maskSaved;
 }
 
 void GamutMaskDock::deleteMask()
 {
     KoResourceServer<KoGamutMask>* rServer = KoResourceServerProvider::instance()->gamutMaskServer();
     rServer->removeResourceAndBlacklist(m_selectedMask);
     m_selectedMask = nullptr;
 }
 
 int GamutMaskDock::getUserFeedback(QString text, QString informativeText,
                                    QMessageBox::StandardButtons buttons, QMessageBox::StandardButton defaultButton,
                                    QMessageBox::Icon severity)
 {
     QMessageBox msgBox;
     msgBox.setWindowTitle(i18nc("@title:window", "Krita"));
     msgBox.setText(QString("<p><b>%1</b></p>").arg(text));
     msgBox.setInformativeText(informativeText);
     msgBox.setStandardButtons(buttons);
     msgBox.setDefaultButton(defaultButton);
     msgBox.setIcon(severity);
     int res = msgBox.exec();
 
     return res;
 }
 
 int GamutMaskDock::saveOrCancel(QMessageBox::StandardButton defaultAction)
 {
     int response = 0;
 
     if (m_maskDocument->isModified()) {
         response = getUserFeedback(i18n("Gamut mask <b>'%1'</b> has been modified.", m_selectedMask->title()),
                                    i18n("Do you want to save it?"),
                                    QMessageBox::Cancel | QMessageBox::Close | QMessageBox::Save, defaultAction);
 
     } else if (m_templatePrevSaved && defaultAction != QMessageBox::Close) {
         response = QMessageBox::Save;
 
     } else if (!m_templatePrevSaved) {
         response = QMessageBox::Close;
 
     } else {
         response = defaultAction;
     }
 
     switch (response) {
         case QMessageBox::Save : {
             slotGamutMaskSave();
             break;
     }
         case QMessageBox::Close : {
             cancelMaskEdit();
             break;
         }
     }
 
     return response;
 }
 
 KoGamutMask *GamutMaskDock::createMaskResource(KoGamutMask* sourceMask, QString newTitle)
 {
     m_creatingNewMask = true;
 
     KoGamutMask* newMask = nullptr;
     if (sourceMask) {
         newMask = new KoGamutMask(sourceMask);
         newMask->setImage(sourceMask->image());
     } else {
         newMask = new KoGamutMask();
 
         QString defaultPreviewPath = KoResourcePaths::findResource("ko_gamutmasks", "empty_mask_preview.png");
         KIS_SAFE_ASSERT_RECOVER_NOOP(!(defaultPreviewPath.isEmpty() || defaultPreviewPath.isNull() || !QFile::exists(defaultPreviewPath)));
 
         newMask->setImage(QImage(defaultPreviewPath, "PNG"));
     }
 
     QPair<QString,QFileInfo> maskFile = resolveMaskTitle(newTitle);
     QString maskTitle = maskFile.first;
     QFileInfo fileInfo = maskFile.second;
 
     newMask->setTitle(maskTitle);
     newMask->setFilename(fileInfo.filePath());
 
     newMask->setValid(true);
 
     KoResourceServer<KoGamutMask>* rServer = KoResourceServerProvider::instance()->gamutMaskServer();
     rServer->removeFromBlacklist(newMask);
     rServer->addResource(newMask, false);
 
     return newMask;
 }
 
 QPair<QString, QFileInfo> GamutMaskDock::resolveMaskTitle(QString suggestedTitle)
 {
     KoResourceServer<KoGamutMask>* rServer = KoResourceServerProvider::instance()->gamutMaskServer();
     QString saveLocation = rServer->saveLocation();
     QString processedTitle = suggestedTitle.trimmed();
 
     QString resourceName = processedTitle;
     while (rServer->resourceByName(resourceName)) {
         resourceName = resourceName + QString(" (Copy)");
     }
 
     QString maskTitle = resourceName;
     QString maskFile = maskTitle + ".kgm";
     QString path = saveLocation + maskFile.replace(QRegularExpression("\\s+"), "_");
     QFileInfo fileInfo(path);
 
     return QPair<QString, QFileInfo>(maskTitle, fileInfo);
 }
 
 void GamutMaskDock::closeMaskDocument()
 {
     if (!m_externalTemplateClose) {
         if (m_maskDocument) {
             // set the document to not modified to bypass confirmation dialog
             // the close is already confirmed
             m_maskDocument->setModified(false);
 
             m_maskDocument->closeUrl();
-            m_view->closeView();
-            m_view->deleteLater();
+            m_templateView->closeView();
+            m_templateView->deleteLater();
 
             // set a flag that we are doing it ourselves, so the docker does not react to
             // removing signal from KisPart
             m_selfClosingTemplate = true;
-            KisPart::instance()->removeView(m_view);
+            KisPart::instance()->removeView(m_templateView);
             KisPart::instance()->removeDocument(m_maskDocument);
             m_selfClosingTemplate = false;
         }
     }
 
     m_dockerUI->maskPropertiesBox->setVisible(false);
     m_dockerUI->editControlsBox->setVisible(true);
     m_dockerUI->editControlsBox->setEnabled(true);
 
-    disconnect(m_view->viewManager(), SIGNAL(viewChanged()), this, SLOT(slotViewChanged()));
+    disconnect(m_templateView->viewManager(), SIGNAL(viewChanged()), this, SLOT(slotViewChanged()));
     disconnect(m_maskDocument, SIGNAL(completed()), this, SLOT(slotDocumentSaved()));
 
     // the template file is meant as temporary, if the user saved it, delete now
     if (QFile::exists(m_maskDocument->localFilePath())) {
         QFile::remove(m_maskDocument->localFilePath());
     }
 
     m_maskDocument = nullptr;
-    m_view = nullptr;
+    m_templateView = nullptr;
     m_creatingNewMask = false;
     m_templatePrevSaved = false;
 }
 
 QList<KoShape*> GamutMaskDock::getShapesFromLayer()
 {
     KisShapeLayerSP shapeLayer = getShapeLayer();
 
     // create a deep copy of the shapes to save in the mask,
     // otherwise they vanish when the template closes
     QList<KoShape*> newShapes;
 
     if (shapeLayer) {
         for (KoShape* sh: shapeLayer->shapes()) {
             KoShape* newShape = sh->cloneShape();
             KoShapeStrokeSP border(new KoShapeStroke(0.5f, Qt::white));
             newShape->setStroke(border);
             newShape->setBackground(QSharedPointer<KoColorBackground>(new KoColorBackground(QColor(255,255,255,0))));
             newShapes.append(newShape);
         }
     }
 
     return newShapes;
 }
 
 KisShapeLayerSP GamutMaskDock::getShapeLayer()
 {
     KisNodeSP node = m_maskDocument->image()->rootLayer()->findChildByName("maskShapesLayer");
     return KisShapeLayerSP(dynamic_cast<KisShapeLayer*>(node.data()));
 }
 
 void GamutMaskDock::slotGamutMaskSave()
 {
     if (!m_selectedMask || !m_maskDocument) {
         return;
     }
 
     QString newTitle = m_dockerUI->maskTitleEdit->text();
 
     if (m_selectedMask->title() != newTitle) {
         // title has changed, rename
         KoGamutMask* newMask = createMaskResource(m_selectedMask, newTitle);
 
         // delete old mask and select new
         deleteMask();
         selectMask(newMask);
     }
 
     bool maskSaved = saveSelectedMaskResource();
     if (maskSaved) {
         emit sigGamutMaskSet(m_selectedMask);
         closeMaskDocument();
     }
 }
 
 void GamutMaskDock::slotGamutMaskCancelEdit()
 {
     if (!m_selectedMask) {
         return;
     }
 
     saveOrCancel(QMessageBox::Close);
 }
 
 void GamutMaskDock::slotGamutMaskPreview()
 {
     if (!m_selectedMask) {
         return;
     }
 
     m_selectedMask->setPreviewMaskShapes(getShapesFromLayer());
     emit sigGamutMaskPreviewUpdate();
 }
 
 void GamutMaskDock::slotGamutMaskSelected(KoGamutMask *mask)
 {
     if (!m_selfSelectingMask) {
         if (m_maskDocument) {
             int res = saveOrCancel();
             if (res == QMessageBox::Cancel) {
                 return;
             }
         }
 
         selectMask(mask, false);
     }
 }
 
 void GamutMaskDock::setCanvas(KoCanvasBase *canvas)
 {
+    if (!canvas) {
+        return;
+    }
+
     setEnabled(canvas != 0);
+
+    m_canvas = dynamic_cast<KisCanvas2*>(canvas);
+
+    if (!m_canvas && !m_canvas->imageView()) {
+        return;
+    }
+
+    KoGamutMask* storedMask = m_canvas->imageView()->document()->gamutMask();
+
+    if (storedMask) {
+        KoResourceServer<KoGamutMask>* rServer = KoResourceServerProvider::instance()->gamutMaskServer();
+
+        if (!rServer->resourceByName(storedMask->title())) {
+            rServer->addResource(storedMask, false);
+        }
+
+        m_blockMaskStoring = true;
+        selectMask(storedMask);
+        m_blockMaskStoring = false;
+    }
 }
 
 void GamutMaskDock::unsetCanvas()
 {
     setEnabled(false);
+    m_canvas = nullptr;
 }
 
 
 void GamutMaskDock::unsetResourceServer()
 {
     KoResourceServer<KoGamutMask>* rServer = KoResourceServerProvider::instance()->gamutMaskServer();
     rServer->removeObserver(this);
 }
 
 void GamutMaskDock::removingResource(KoGamutMask *resource)
 {
     // if deleting previously set mask, notify selectors to unset their mask
     if (resource == m_resourceProvider->currentGamutMask()) {
         emit sigGamutMaskUnset();
         m_selectedMask = nullptr;
     }
 }
 
 void GamutMaskDock::resourceChanged(KoGamutMask *resource)
 {
     // if currently set mask has been changed, notify selectors
     if (resource == m_resourceProvider->currentGamutMask()) {
         selectMask(resource);
     }
 }
 
 void GamutMaskDock::slotGamutMaskCreateNew()
 {
     KoGamutMask* newMask = createMaskResource(nullptr, "new mask");
     selectMask(newMask);
 
     bool editorOpened = openMaskEditor();
     if (!editorOpened) {
         deleteMask();
     }
 }
 
 void GamutMaskDock::slotGamutMaskDuplicate()
 {
     if (!m_selectedMask) {
         return;
     }
 
     KoGamutMask* newMask = createMaskResource(m_selectedMask, m_selectedMask->title());
     selectMask(newMask);
 
     bool editorOpened = openMaskEditor();
     if (!editorOpened) {
         deleteMask();
     }
 }
 
 void GamutMaskDock::slotGamutMaskDelete()
 {   
     if (!m_selectedMask) {
         return;
     }
 
     int res = getUserFeedback(i18n("Are you sure you want to delete mask <b>'%1'</b>?"
                                    , m_selectedMask->title()));
 
     if (res == QMessageBox::Yes) {
         deleteMask();
     }
 }
 
 void GamutMaskDock::slotDocumentRemoved(QString filename)
 {
     if (!m_maskDocument) {
         return;
     }
 
     m_externalTemplateClose = true;
 
     // we do not want to run this if it is we who close the file
     if (!m_selfClosingTemplate) {
         // KisPart called, that a document will be removed
         // if it's ours, cancel the mask edit operation
         if (m_maskDocument->url().toLocalFile() == filename) {
             m_maskDocument->waitForSavingToComplete();
             saveOrCancel();
         }
     }
 
     m_externalTemplateClose = false;
 }
 
 void GamutMaskDock::slotViewChanged()
 {
-    if (!m_maskDocument || !m_view) {
+    if (!m_maskDocument || !m_templateView) {
         return;
     }
 
-    if (m_view->viewManager()->document() == m_maskDocument) {
+    if (m_templateView->viewManager()->document() == m_maskDocument) {
         m_dockerUI->maskPropertiesBox->setEnabled(true);
     } else {
         m_dockerUI->maskPropertiesBox->setEnabled(false);
     }
 }
 
 void GamutMaskDock::slotDocumentSaved()
 {
     m_templatePrevSaved = true;
 }
diff --git a/plugins/dockers/gamutmask/gamutmask_dock.h b/plugins/dockers/gamutmask/gamutmask_dock.h
index 43e14d0af7..4a501b02ee 100644
--- a/plugins/dockers/gamutmask/gamutmask_dock.h
+++ b/plugins/dockers/gamutmask/gamutmask_dock.h
@@ -1,125 +1,127 @@
 /*
  *  Copyright (c) 2018 Anna Medonosova <anna.medonosova@gmail.com>
  *
  *  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.
  */
 
 #ifndef H_GAMUT_MASK_DOCK_H
 #define H_GAMUT_MASK_DOCK_H
 
 #include <QDockWidget>
 #include <QPointer>
 #include <QRegExpValidator>
 #include <QMessageBox>
 
 #include <KoCanvasObserverBase.h>
 #include <KoResourceServerProvider.h>
 #include <KoResourceServerAdapter.h>
 #include <KoResourceServerObserver.h>
 #include <resources/KoGamutMask.h>
 #include <KisDocument.h>
 #include <KisView.h>
 #include <kis_types.h>
 #include <KoResourceItemChooser.h>
 
 #include <kis_mainwindow_observer.h>
 
 class KisCanvasResourceProvider;
 class QButtonGroup;
 class QMenu;
 
 struct GamutMaskChooserUI;
 
 class GamutMaskDock: public QDockWidget, public KisMainwindowObserver, public KoResourceServerObserver<KoGamutMask>
 {
     Q_OBJECT
 
 public:
     GamutMaskDock();
     ~GamutMaskDock() override;
     QString observerName() override { return "GamutMaskDock"; }
     void setViewManager(KisViewManager* kisview) override;
     void setCanvas(KoCanvasBase *canvas) override;
     void unsetCanvas() override;
 
 public: // KoResourceServerObserver
     void unsetResourceServer() override;
     void resourceAdded(KoGamutMask* /*resource*/) override {};
     void removingResource(KoGamutMask* resource) override;
     void resourceChanged(KoGamutMask* resource) override;
     void syncTaggedResourceView() override {}
     void syncTagAddition(const QString&) override {}
     void syncTagRemoval(const QString&) override {}
 
 Q_SIGNALS:
     void sigGamutMaskSet(KoGamutMask* mask);
     void sigGamutMaskChanged(KoGamutMask* mask);
     void sigGamutMaskUnset();
     void sigGamutMaskPreviewUpdate();
 
 private Q_SLOTS:
     void slotGamutMaskEdit();
     void slotGamutMaskSave();
     void slotGamutMaskCancelEdit();
     void slotGamutMaskSelected(KoGamutMask* mask);
     void slotGamutMaskPreview();
     void slotGamutMaskCreateNew();
     void slotGamutMaskDuplicate();
     void slotGamutMaskDelete();
 
     void slotDocumentRemoved(QString filename);
     void slotViewChanged();
     void slotDocumentSaved();
 
 private:
     void closeMaskDocument();
     bool openMaskEditor();
     void cancelMaskEdit();
     void selectMask(KoGamutMask* mask, bool notifyItemChooser = true);
     bool saveSelectedMaskResource();
     void deleteMask();
     int getUserFeedback(QString text, QString informativeText = "",
                         QMessageBox::StandardButtons buttons = QMessageBox::Yes | QMessageBox::No,
                         QMessageBox::StandardButton defaultButton = QMessageBox::Yes,
                         QMessageBox::Icon severity = QMessageBox::Warning);
 
     int saveOrCancel(QMessageBox::StandardButton defaultAction = QMessageBox::Save);
 
     KoGamutMask* createMaskResource(KoGamutMask* sourceMask, QString newTitle);
 
     QPair<QString, QFileInfo> resolveMaskTitle(QString suggestedTitle);
 
     QList<KoShape*> getShapesFromLayer();
     KisShapeLayerSP getShapeLayer();
 
     KisCanvasResourceProvider* m_resourceProvider;
 
     bool m_selfClosingTemplate;
     bool m_externalTemplateClose;
     bool m_creatingNewMask;
     bool m_templatePrevSaved;
     bool m_selfSelectingMask;
+    bool m_blockMaskStoring;
 
     GamutMaskChooserUI* m_dockerUI;
     KoResourceItemChooser* m_maskChooser;
 
     KoGamutMask* m_selectedMask;
     QRegExpValidator* m_maskTitleValidator;
 
     KisDocument* m_maskDocument;
-    KisView* m_view;
+    KisView* m_templateView;
+    KisCanvas2* m_canvas;
 };
 
 
 #endif // H_GAMUT_MASK_DOCK_H
diff --git a/plugins/impex/kra/kra_converter.cpp b/plugins/impex/kra/kra_converter.cpp
index 33a76b620a..aad009e730 100644
--- a/plugins/impex/kra/kra_converter.cpp
+++ b/plugins/impex/kra/kra_converter.cpp
@@ -1,360 +1,365 @@
 /*
  * Copyright (C) 2016 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 "kra_converter.h"
 
 #include <QApplication>
 #include <QFileInfo>
 #include <QScopedPointer>
 #include <QUrl>
 
 #include <KoStore.h>
 #include <KoStoreDevice.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoDocumentInfo.h>
 #include <KoXmlWriter.h>
 #include <KoXmlReader.h>
 
 #include <KritaVersionWrapper.h>
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_paint_layer.h>
 #include <kis_png_converter.h>
 #include <KisDocument.h>
 
 static const char CURRENT_DTD_VERSION[] = "2.0";
 
 KraConverter::KraConverter(KisDocument *doc)
     : m_doc(doc)
     , m_image(doc->savingImage())
 {
 }
 
 KraConverter::~KraConverter()
 {
     delete m_store;
     delete m_kraSaver;
     delete m_kraLoader;
 }
 
 KisImageBuilder_Result KraConverter::buildImage(QIODevice *io)
 {
     m_store = KoStore::createStore(io, KoStore::Read, "", KoStore::Zip);
 
     if (m_store->bad()) {
         m_doc->setErrorMessage(i18n("Not a valid Krita file"));
         return KisImageBuilder_RESULT_FAILURE;
     }
 
     bool success;
     {
         if (m_store->hasFile("root") || m_store->hasFile("maindoc.xml")) {   // Fallback to "old" file format (maindoc.xml)
             KoXmlDocument doc;
 
             bool ok = oldLoadAndParse(m_store, "root", doc);
             if (ok)
                 ok = loadXML(doc, m_store);
             if (!ok) {
                 return KisImageBuilder_RESULT_FAILURE;
             }
 
         } else {
             errUI << "ERROR: No maindoc.xml" << endl;
             m_doc->setErrorMessage(i18n("Invalid document: no file 'maindoc.xml'."));
             return KisImageBuilder_RESULT_FAILURE;
         }
 
         if (m_store->hasFile("documentinfo.xml")) {
             KoXmlDocument doc;
             if (oldLoadAndParse(m_store, "documentinfo.xml", doc)) {
                 m_doc->documentInfo()->load(doc);
             }
         }
         success = completeLoading(m_store);
     }
 
     return success ? KisImageBuilder_RESULT_OK : KisImageBuilder_RESULT_FAILURE;
 }
 
 KisImageSP KraConverter::image()
 {
     return m_image;
 }
 
 vKisNodeSP KraConverter::activeNodes()
 {
     return m_activeNodes;
 }
 
 QList<KisPaintingAssistantSP> KraConverter::assistants()
 {
     return m_assistants;
 }
 
 KisImageBuilder_Result KraConverter::buildFile(QIODevice *io, const QString &filename)
 {
     m_store = KoStore::createStore(io, KoStore::Write, m_doc->nativeFormatMimeType(), KoStore::Zip);
 
     if (m_store->bad()) {
         m_doc->setErrorMessage(i18n("Could not create the file for saving"));
         return KisImageBuilder_RESULT_FAILURE;
     }
 
     bool result = false;
 
     m_kraSaver = new KisKraSaver(m_doc, filename);
 
     result = saveRootDocuments(m_store);
 
     if (!result) {
         return KisImageBuilder_RESULT_FAILURE;
     }
 
     result = m_kraSaver->saveKeyframes(m_store, m_doc->url().toLocalFile(), true);
     if (!result) {
         qWarning() << "saving key frames failed";
     }
     result = m_kraSaver->saveBinaryData(m_store, m_image, m_doc->url().toLocalFile(), true, m_doc->isAutosaving());
     if (!result) {
         qWarning() << "saving binary data failed";
     }
     result = m_kraSaver->savePalettes(m_store, m_image, m_doc->url().toLocalFile());
     if (!result) {
         qWarning() << "saving palettes data failed";
     }
 
+    result = m_kraSaver->saveGamutMask(m_store);
+    if (!result) {
+        qWarning() << "saving gamut mask data failed";
+    }
+
     if (!m_store->finalize()) {
         return KisImageBuilder_RESULT_FAILURE;
     }
 
     if (!m_kraSaver->errorMessages().isEmpty()) {
         m_doc->setErrorMessage(m_kraSaver->errorMessages().join(".\n"));
         return KisImageBuilder_RESULT_FAILURE;
     }
     return KisImageBuilder_RESULT_OK;
 }
 
 bool KraConverter::saveRootDocuments(KoStore *store)
 {
     dbgFile << "Saving root";
     if (store->open("root")) {
         KoStoreDevice dev(store);
         if (!saveToStream(&dev) || !store->close()) {
             dbgUI << "saveToStream failed";
             return false;
         }
     } else {
         m_doc->setErrorMessage(i18n("Not able to write '%1'. Partition full?", QString("maindoc.xml")));
         return false;
     }
     bool success = false;
     if (store->open("documentinfo.xml")) {
         QDomDocument doc = KisDocument::createDomDocument("document-info"
                                                           /*DTD name*/, "document-info" /*tag name*/, "1.1");
         doc = m_doc->documentInfo()->save(doc);
         KoStoreDevice dev(store);
         QByteArray s = doc.toByteArray(); // this is already Utf8!
         success = dev.write(s.data(), s.size());
         store->close();
     }
 
     if (store->open("preview.png")) {
         // ### TODO: missing error checking (The partition could be full!)
         savePreview(store);
         (void)store->close();
     }
 
 
     dbgUI << "Saving done of url:" << m_doc->url().toLocalFile();
     // Success
     return success;
 }
 
 bool KraConverter::saveToStream(QIODevice *dev)
 {
     QDomDocument doc = createDomDocument();
     // Save to buffer
     QByteArray s = doc.toByteArray(); // utf8 already
     dev->open(QIODevice::WriteOnly);
     int nwritten = dev->write(s.data(), s.size());
     if (nwritten != (int)s.size()) {
         warnUI << "wrote " << nwritten << "- expected" <<  s.size();
     }
     return nwritten == (int)s.size();
 }
 
 QDomDocument KraConverter::createDomDocument()
 {
     QDomDocument doc = m_doc->createDomDocument("DOC", CURRENT_DTD_VERSION);
     QDomElement root = doc.documentElement();
 
     root.setAttribute("editor", "Krita");
     root.setAttribute("syntaxVersion", "2");
     root.setAttribute("kritaVersion", KritaVersionWrapper::versionString(false));
 
     root.appendChild(m_kraSaver->saveXML(doc, m_image));
 
     if (!m_kraSaver->errorMessages().isEmpty()) {
         m_doc->setErrorMessage(m_kraSaver->errorMessages().join(".\n"));
     }
     return doc;
 }
 
 bool KraConverter::savePreview(KoStore *store)
 {
     QPixmap pix = m_doc->generatePreview(QSize(256, 256));
     QImage preview(pix.toImage().convertToFormat(QImage::Format_ARGB32, Qt::ColorOnly));
     if (preview.size() == QSize(0,0)) {
         QSize newSize = m_doc->savingImage()->bounds().size();
         newSize.scale(QSize(256, 256), Qt::KeepAspectRatio);
         preview = QImage(newSize, QImage::Format_ARGB32);
         preview.fill(QColor(0, 0, 0, 0));
     }
 
     KoStoreDevice io(store);
     if (!io.open(QIODevice::WriteOnly)) {
         return false;
     }
     bool ret = preview.save(&io, "PNG");
     io.close();
     return ret;
 }
 
 
 bool KraConverter::oldLoadAndParse(KoStore *store, const QString &filename, KoXmlDocument &xmldoc)
 {
     //dbgUI <<"Trying to open" << filename;
 
     if (!store->open(filename)) {
         warnUI << "Entry " << filename << " not found!";
         m_doc->setErrorMessage(i18n("Could not find %1", filename));
         return false;
     }
     // Error variables for QDomDocument::setContent
     QString errorMsg;
     int errorLine, errorColumn;
     bool ok = xmldoc.setContent(store->device(), &errorMsg, &errorLine, &errorColumn);
     store->close();
     if (!ok) {
         errUI << "Parsing error in " << filename << "! Aborting!" << endl
               << " In line: " << errorLine << ", column: " << errorColumn << endl
               << " Error message: " << errorMsg << endl;
         m_doc->setErrorMessage(i18n("Parsing error in %1 at line %2, column %3\nError message: %4"
                                    , filename  , errorLine, errorColumn ,
                                    QCoreApplication::translate("QXml", errorMsg.toUtf8(), 0)));
         return false;
     }
     dbgUI << "File" << filename << " loaded and parsed";
     return true;
 }
 
 bool KraConverter::loadXML(const KoXmlDocument &doc, KoStore *store)
 {
     Q_UNUSED(store);
 
     KoXmlElement root;
     KoXmlNode node;
 
     if (doc.doctype().name() != "DOC") {
        m_doc->setErrorMessage(i18n("The format is not supported or the file is corrupted"));
         return false;
     }
     root = doc.documentElement();
     int syntaxVersion = root.attribute("syntaxVersion", "3").toInt();
     if (syntaxVersion > 2) {
        m_doc->setErrorMessage(i18n("The file is too new for this version of Krita (%1).", syntaxVersion));
         return false;
     }
 
     if (!root.hasChildNodes()) {
        m_doc->setErrorMessage(i18n("The file has no layers."));
         return false;
     }
 
     m_kraLoader = new KisKraLoader(m_doc, syntaxVersion);
 
     // reset the old image before loading the next one
     m_doc->setCurrentImage(0, false);
 
     for (node = root.firstChild(); !node.isNull(); node = node.nextSibling()) {
         if (node.isElement()) {
             if (node.nodeName() == "IMAGE") {
                 KoXmlElement elem = node.toElement();
                 if (!(m_image = m_kraLoader->loadXML(elem))) {
                     if (m_kraLoader->errorMessages().isEmpty()) {
                         m_doc->setErrorMessage(i18n("Unknown error."));
                     }
                     else {
                         m_doc->setErrorMessage(m_kraLoader->errorMessages().join("\n"));
                     }
                     return false;
                 }
 
                 // HACK ALERT!
                 m_doc->hackPreliminarySetImage(m_image);
 
                 return true;
             }
             else {
                 if (m_kraLoader->errorMessages().isEmpty()) {
                     m_doc->setErrorMessage(i18n("The file does not contain an image."));
                 }
                 return false;
             }
         }
     }
     return false;
 }
 
 bool KraConverter::completeLoading(KoStore* store)
 {
     if (!m_image) {
         if (m_kraLoader->errorMessages().isEmpty()) {
            m_doc->setErrorMessage(i18n("Unknown error."));
         }
         else {
            m_doc->setErrorMessage(m_kraLoader->errorMessages().join("\n"));
         }
         return false;
     }
 
     m_image->blockUpdates();
 
     m_kraLoader->loadBinaryData(store, m_image, m_doc->localFilePath(), true);
     m_kraLoader->loadPalettes(store, m_doc);
 
     m_image->unblockUpdates();
 
     if (!m_kraLoader->warningMessages().isEmpty()) {
         // warnings do not interrupt loading process, so we do not return here
         m_doc->setWarningMessage(m_kraLoader->warningMessages().join("\n"));
     }
 
     m_activeNodes = m_kraLoader->selectedNodes();
     m_assistants = m_kraLoader->assistants();
 
     return true;
 }
 
 void KraConverter::cancel()
 {
     m_stop = true;
 }
 
 
diff --git a/plugins/impex/libkra/kis_kra_loader.cpp b/plugins/impex/libkra/kis_kra_loader.cpp
index 514eff3c7a..ccf0d2665f 100644
--- a/plugins/impex/libkra/kis_kra_loader.cpp
+++ b/plugins/impex/libkra/kis_kra_loader.cpp
@@ -1,1247 +1,1293 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2007
  *
  * 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 "kis_kra_loader.h"
 
 #include <QApplication>
 #include <QStringList>
 
 #include <QMessageBox>
 
 #include <QUrl>
 #include <QBuffer>
 
 #include <KoStore.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorProfile.h>
 #include <KoDocumentInfo.h>
 #include <KoFileDialog.h>
 #include <KisImportExportManager.h>
 #include <KoXmlReader.h>
 #include <KoStoreDevice.h>
 #include <KoResourceServerProvider.h>
 
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_registry.h>
 #include <generator/kis_generator.h>
 #include <generator/kis_generator_layer.h>
 #include <generator/kis_generator_registry.h>
 #include <kis_adjustment_layer.h>
 #include <kis_annotation.h>
 #include <kis_base_node.h>
 #include <kis_clone_layer.h>
 #include <kis_debug.h>
 #include <kis_assert.h>
 #include <kis_external_layer_iface.h>
 #include <kis_filter_mask.h>
 #include <kis_transform_mask.h>
 #include "lazybrush/kis_colorize_mask.h"
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_name_server.h>
 #include <kis_paint_layer.h>
 #include <kis_selection.h>
 #include <kis_selection_mask.h>
 #include <kis_shape_layer.h>
 #include <kis_transparency_mask.h>
 #include <kis_layer_composition.h>
 #include <kis_file_layer.h>
 #include <kis_psd_layer_style.h>
 #include <kis_psd_layer_style_resource.h>
 #include "KisResourceServerProvider.h"
 #include "kis_keyframe_channel.h"
 #include <kis_filter_configuration.h>
 #include "KisReferenceImagesLayer.h"
 #include "KisReferenceImage.h"
 #include <KoColorSet.h>
+#include <resources/KoGamutMask.h>
 
 #include "KisDocument.h"
 #include "kis_config.h"
 #include "kis_kra_tags.h"
 #include "kis_kra_utils.h"
 #include "kis_kra_load_visitor.h"
 #include "kis_dom_utils.h"
 #include "kis_image_animation_interface.h"
 #include "kis_time_range.h"
 #include "kis_grid_config.h"
 #include "kis_guides_config.h"
 #include "kis_image_config.h"
 #include "KisProofingConfiguration.h"
 #include "kis_layer_properties_icons.h"
 #include "kis_node_view_color_scheme.h"
 
 /*
 
   Color model id comparison through the ages:
 
 2.4        2.5          2.6         ideal
 
 ALPHA      ALPHA        ALPHA       ALPHAU8
 
 CMYK       CMYK         CMYK        CMYKAU8
            CMYKAF32     CMYKAF32
 CMYKA16    CMYKAU16     CMYKAU16
 
 GRAYA      GRAYA        GRAYA       GRAYAU8
 GrayF32    GRAYAF32     GRAYAF32
 GRAYA16    GRAYAU16     GRAYAU16
 
 LABA       LABA         LABA        LABAU16
            LABAF32      LABAF32
            LABAU8       LABAU8
 
 RGBA       RGBA         RGBA        RGBAU8
 RGBA16     RGBA16       RGBA16      RGBAU16
 RgbAF32    RGBAF32      RGBAF32
 RgbAF16    RgbAF16      RGBAF16
 
 XYZA16     XYZA16       XYZA16      XYZAU16
            XYZA8        XYZA8       XYZAU8
 XyzAF16    XyzAF16      XYZAF16
 XyzAF32    XYZAF32      XYZAF32
 
 YCbCrA     YCBCRA8      YCBCRA8     YCBCRAU8
 YCbCrAU16  YCBCRAU16    YCBCRAU16
            YCBCRF32     YCBCRF32
  */
 
 using namespace KRA;
 
 struct KisKraLoader::Private
 {
 public:
 
     KisDocument* document;
     QString imageName; // used to be stored in the image, is now in the documentInfo block
     QString imageComment; // used to be stored in the image, is now in the documentInfo block
     QMap<KisNode*, QString> layerFilenames; // temp storage during loading
     int syntaxVersion; // version of the fileformat we are loading
     vKisNodeSP selectedNodes; // the nodes that were active when saving the document.
     QMap<QString, QString> assistantsFilenames;
     QList<KisPaintingAssistantSP> assistants;
     QMap<KisNode*, QString> keyframeFilenames;
     QVector<QString> paletteFilenames;
+    QString gamutMaskFilename;
+    int gamutMaskRotation;
     QStringList errorMessages;
     QStringList warningMessages;
 };
 
 void convertColorSpaceNames(QString &colorspacename, QString &profileProductName) {
     if (colorspacename  == "Grayscale + Alpha") {
         colorspacename  = "GRAYA";
         profileProductName.clear();
     }
     else if (colorspacename == "RgbAF32") {
         colorspacename = "RGBAF32";
         profileProductName.clear();
     }
     else if (colorspacename == "RgbAF16") {
         colorspacename = "RGBAF16";
         profileProductName.clear();
     }
     else if (colorspacename == "CMYKA16") {
         colorspacename = "CMYKAU16";
     }
     else if (colorspacename == "GrayF32") {
         colorspacename =  "GRAYAF32";
         profileProductName.clear();
     }
     else if (colorspacename == "GRAYA16") {
         colorspacename  = "GRAYAU16";
     }
     else if (colorspacename == "XyzAF16") {
         colorspacename  = "XYZAF16";
         profileProductName.clear();
     }
     else if (colorspacename == "XyzAF32") {
         colorspacename  = "XYZAF32";
         profileProductName.clear();
     }
     else if (colorspacename == "YCbCrA") {
         colorspacename  = "YCBCRA8";
     }
     else if (colorspacename == "YCbCrAU16") {
         colorspacename  = "YCBCRAU16";
     }
 }
 
 KisKraLoader::KisKraLoader(KisDocument * document, int syntaxVersion)
         : m_d(new Private())
 {
     m_d->document = document;
     m_d->syntaxVersion = syntaxVersion;
 }
 
 
 KisKraLoader::~KisKraLoader()
 {
     delete m_d;
 }
 
 
 KisImageSP KisKraLoader::loadXML(const KoXmlElement& element)
 {
     QString attr;
     KisImageSP image = 0;
     QString name;
     qint32 width;
     qint32 height;
     QString profileProductName;
     double xres;
     double yres;
     QString colorspacename;
     const KoColorSpace * cs;
 
 
     if ((attr = element.attribute(MIME)) == NATIVE_MIMETYPE) {
 
         if ((m_d->imageName = element.attribute(NAME)).isNull()) {
             m_d->errorMessages << i18n("Image does not have a name.");
             return KisImageSP(0);
         }
 
         if ((attr = element.attribute(WIDTH)).isNull()) {
             m_d->errorMessages << i18n("Image does not specify a width.");
             return KisImageSP(0);
         }
         width = KisDomUtils::toInt(attr);
 
         if ((attr = element.attribute(HEIGHT)).isNull()) {
             m_d->errorMessages << i18n("Image does not specify a height.");
             return KisImageSP(0);
         }
 
         height = KisDomUtils::toInt(attr);
 
         m_d->imageComment = element.attribute(DESCRIPTION);
 
         xres = 100.0 / 72.0;
         if (!(attr = element.attribute(X_RESOLUTION)).isNull()) {
             qreal value = KisDomUtils::toDouble(attr);
 
             if (value > 1.0) {
                 xres = value / 72.0;
             }
         }
 
         yres = 100.0 / 72.0;
         if (!(attr = element.attribute(Y_RESOLUTION)).isNull()) {
             qreal value = KisDomUtils::toDouble(attr);
             if (value > 1.0) {
                 yres = value / 72.0;
             }
         }
 
         if ((colorspacename = element.attribute(COLORSPACE_NAME)).isNull()) {
             // An old file: take a reasonable default.
             // Krita didn't support anything else in those
             // days anyway.
             colorspacename = "RGBA";
         }
 
         profileProductName = element.attribute(PROFILE);
         // A hack for an old colorspacename
         convertColorSpaceNames(colorspacename, profileProductName);
 
         QString colorspaceModel = KoColorSpaceRegistry::instance()->colorSpaceColorModelId(colorspacename).id();
         QString colorspaceDepth = KoColorSpaceRegistry::instance()->colorSpaceColorDepthId(colorspacename).id();
 
         if (profileProductName.isNull()) {
             // no mention of profile so get default profile";
             cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, "");
         } else {
             cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, profileProductName);
         }
 
         if (cs == 0) {
             // try once more without the profile
             cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, "");
             if (cs == 0) {
                 m_d->errorMessages << i18n("Image specifies an unsupported color model: %1.", colorspacename);
                 return KisImageSP(0);
             }
         }
         KisProofingConfigurationSP proofingConfig = KisImageConfig(true).defaultProofingconfiguration();
         if (!(attr = element.attribute(PROOFINGPROFILENAME)).isNull()) {
             proofingConfig->proofingProfile = attr;
         }
         if (!(attr = element.attribute(PROOFINGMODEL)).isNull()) {
             proofingConfig->proofingModel = attr;
         }
         if (!(attr = element.attribute(PROOFINGDEPTH)).isNull()) {
             proofingConfig->proofingDepth = attr;
         }
         if (!(attr = element.attribute(PROOFINGINTENT)).isNull()) {
             proofingConfig->intent = (KoColorConversionTransformation::Intent) KisDomUtils::toInt(attr);
         }
 
         if (!(attr = element.attribute(PROOFINGADAPTATIONSTATE)).isNull()) {
             proofingConfig->adaptationState = KisDomUtils::toDouble(attr);
         }
 
         if (m_d->document) {
             image = new KisImage(m_d->document->createUndoStore(), width, height, cs, name);
         }
         else {
             image = new KisImage(0, width, height, cs, name);
         }
         image->setResolution(xres, yres);
         loadNodes(element, image, const_cast<KisGroupLayer*>(image->rootLayer().data()));
 
 
         KoXmlNode child;
         for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
             KoXmlElement e = child.toElement();
 
             if(e.tagName() == CANVASPROJECTIONCOLOR) {
                 if (e.hasAttribute(COLORBYTEDATA)) {
                     QByteArray colorData = QByteArray::fromBase64(e.attribute(COLORBYTEDATA).toLatin1());
                     KoColor color((const quint8*)colorData.data(), image->colorSpace());
                     image->setDefaultProjectionColor(color);
                 }
             }
 
 
             if(e.tagName() == GLOBALASSISTANTSCOLOR) {
                 if (e.hasAttribute(SIMPLECOLORDATA)) {
                     QString colorData = e.attribute(SIMPLECOLORDATA);
                     m_d->document->setAssistantsGlobalColor(KisDomUtils::qStringToQColor(colorData));
                 }
             }
 
 
             if(e.tagName()== PROOFINGWARNINGCOLOR) {
                 QDomDocument dom;
                 KoXml::asQDomElement(dom, e);
                 QDomElement eq = dom.firstChildElement();
                 proofingConfig->warningColor = KoColor::fromXML(eq.firstChildElement(), Integer8BitsColorDepthID.id());
             }
 
             if (e.tagName().toLower() == "animation") {
                 loadAnimationMetadata(e, image);
             }
+
+            if (e.tagName() == GAMUTMASK_ROOT) {
+                loadGamutMaskMetadata(e);
+            }
         }
 
         image->setProofingConfiguration(proofingConfig);
 
         for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
             KoXmlElement e = child.toElement();
             if(e.tagName() == "compositions") {
                 loadCompositions(e, image);
             }
         }
     }
     KoXmlNode child;
 
     for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
         KoXmlElement e = child.toElement();
         if (e.tagName() == "grid") {
             loadGrid(e);
         } else if (e.tagName() == "guides") {
             loadGuides(e);
         } else if (e.tagName() == "assistants") {
             loadAssistantsList(e);
         } else if (e.tagName() == "audio") {
             loadAudio(e, image);
         }
     }
 
     // reading palettes from XML
     for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
         QDomElement e = child.toElement();
         if (e.tagName() == PALETTES) {
             for (QDomElement paletteElement = e.lastChildElement();
                  !paletteElement.isNull();
                  paletteElement = paletteElement.previousSiblingElement()) {
                 QString paletteName = paletteElement.attribute("filename");
                 m_d->paletteFilenames.append(paletteName);
             }
             break;
         }
     }
 
 
     return image;
 }
 
 void KisKraLoader::loadBinaryData(KoStore * store, KisImageSP image, const QString & uri, bool external)
 {
     // icc profile: if present, this overrides the profile product name loaded in loadXML.
     QString location = external ? QString() : uri;
     location += m_d->imageName + ICC_PATH;
     if (store->hasFile(location)) {
         if (store->open(location)) {
             QByteArray data; data.resize(store->size());
             bool res = (store->read(data.data(), store->size()) > -1);
             store->close();
             if (res) {
                 const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(image->colorSpace()->colorModelId().id(), image->colorSpace()->colorDepthId().id(), data);
                 if (profile && profile->valid()) {
                     res = image->assignImageProfile(profile);
                 }
                 if (!res) {
                     const QString defaultProfileId = KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(image->colorSpace()->id());
                     profile = KoColorSpaceRegistry::instance()->profileByName(defaultProfileId);
                     Q_ASSERT(profile && profile->valid());
                     image->assignImageProfile(profile);
                 }
             }
         }
     }
     //load the embed proofing profile, it only needs to be loaded into Krita, not assigned.
     location = external ? QString() : uri;
     location += m_d->imageName + ICC_PROOFING_PATH;
     if (store->hasFile(location)) {
         if (store->open(location)) {
             QByteArray proofingData;
             proofingData.resize(store->size());
             bool proofingProfileRes = (store->read(proofingData.data(), store->size())>-1);
             store->close();
 
             KisProofingConfigurationSP proofingConfig = image->proofingConfiguration();
             if (!proofingConfig) {
                 proofingConfig = KisImageConfig(true).defaultProofingconfiguration();
             }
 
             if (proofingProfileRes) {
                 const KoColorProfile *proofingProfile = KoColorSpaceRegistry::instance()->createColorProfile(proofingConfig->proofingModel, proofingConfig->proofingDepth, proofingData);
                 if (proofingProfile->valid()){
                     KoColorSpaceRegistry::instance()->addProfile(proofingProfile);
                 }
             }
         }
     }
 
 
     // Load the layers data: if there is a profile associated with a layer it will be set now.
     KisKraLoadVisitor visitor(image, store, m_d->document->shapeController(), m_d->layerFilenames, m_d->keyframeFilenames, m_d->imageName, m_d->syntaxVersion);
 
     if (external) {
         visitor.setExternalUri(uri);
     }
 
     image->rootLayer()->accept(visitor);
     if (!visitor.errorMessages().isEmpty()) {
         m_d->errorMessages.append(visitor.errorMessages());
     }
     if (!visitor.warningMessages().isEmpty()) {
         m_d->warningMessages.append(visitor.warningMessages());
     }
 
     // annotations
     // exif
     location = external ? QString() : uri;
     location += m_d->imageName + EXIF_PATH;
     if (store->hasFile(location)) {
         QByteArray data;
         store->open(location);
         data = store->read(store->size());
         store->close();
         image->addAnnotation(KisAnnotationSP(new KisAnnotation("exif", "", data)));
     }
 
 
     // layer styles
     location = external ? QString() : uri;
     location += m_d->imageName + LAYER_STYLES_PATH;
     if (store->hasFile(location)) {
         KisPSDLayerStyleCollectionResource *collection =
             new KisPSDLayerStyleCollectionResource("Embedded Styles.asl");
 
         collection->setName(i18nc("Auto-generated layer style collection name for embedded styles (collection)", "<%1> (embedded)", m_d->imageName));
 
         KIS_ASSERT_RECOVER_NOOP(!collection->valid());
 
         store->open(location);
         {
             KoStoreDevice device(store);
             device.open(QIODevice::ReadOnly);
 
             /**
              * ASL loading code cannot work with non-sequential IO devices,
              * so convert the device beforehand!
              */
             QByteArray buf = device.readAll();
             QBuffer raDevice(&buf);
             raDevice.open(QIODevice::ReadOnly);
             collection->loadFromDevice(&raDevice);
         }
         store->close();
 
         if (collection->valid()) {
             KoResourceServer<KisPSDLayerStyleCollectionResource> *server = KisResourceServerProvider::instance()->layerStyleCollectionServer();
             server->addResource(collection, false);
 
             collection->assignAllLayerStyles(image->root());
         } else {
             warnKrita << "WARNING: Couldn't load layer styles library from .kra!";
             delete collection;
         }
     }
 
     if (m_d->document && m_d->document->documentInfo()->aboutInfo("title").isNull())
         m_d->document->documentInfo()->setAboutInfo("title", m_d->imageName);
     if (m_d->document && m_d->document->documentInfo()->aboutInfo("comment").isNull())
         m_d->document->documentInfo()->setAboutInfo("comment", m_d->imageComment);
 
     loadAssistants(store, uri, external);
+    loadGamutMask(store);
 }
 
 void KisKraLoader::loadPalettes(KoStore *store, KisDocument *doc)
 {
     QList<KoColorSet*> list;
     Q_FOREACH (const QString &filename, m_d->paletteFilenames) {
         KoColorSet *newPalette = new KoColorSet(filename);
         store->open(m_d->imageName + PALETTE_PATH + filename);
         QByteArray data = store->read(store->size());
         newPalette->fromByteArray(data);
         newPalette->setIsGlobal(false);
         newPalette->setIsEditable(true);
         store->close();
         list.append(newPalette);
     }
     doc->setPaletteList(list);
 }
 
 vKisNodeSP KisKraLoader::selectedNodes() const
 {
     return m_d->selectedNodes;
 }
 
 QList<KisPaintingAssistantSP> KisKraLoader::assistants() const
 {
     return m_d->assistants;
 }
 
 QStringList KisKraLoader::errorMessages() const
 {
     return m_d->errorMessages;
 }
 
 QStringList KisKraLoader::warningMessages() const
 {
     return m_d->warningMessages;
 }
 
 
 void KisKraLoader::loadAssistants(KoStore *store, const QString &uri, bool external)
 {
     QString file_path;
     QString location;
     QMap<int ,KisPaintingAssistantHandleSP> handleMap;
     KisPaintingAssistant* assistant = 0;
     const QColor globalColor = m_d->document->assistantsGlobalColor();
 
     QMap<QString,QString>::const_iterator loadedAssistant = m_d->assistantsFilenames.constBegin();
     while (loadedAssistant != m_d->assistantsFilenames.constEnd()){
         const KisPaintingAssistantFactory* factory = KisPaintingAssistantFactoryRegistry::instance()->get(loadedAssistant.value());
         if (factory) {
             assistant = factory->createPaintingAssistant();
             location = external ? QString() : uri;
             location += m_d->imageName + ASSISTANTS_PATH;
             file_path = location + loadedAssistant.key();
             assistant->loadXml(store, handleMap, file_path);
             assistant->setAssistantGlobalColorCache(globalColor);
 
             //If an assistant has too few handles than it should according to it's own setup, just don't load it//
             if (assistant->handles().size()==assistant->numHandles()){
                 m_d->assistants.append(toQShared(assistant));
             }
         }
         loadedAssistant++;
     }
 }
 
 void KisKraLoader::loadAnimationMetadata(const KoXmlElement &element, KisImageSP image)
 {
     QDomDocument qDom;
     KoXml::asQDomElement(qDom, element);
     QDomElement qElement = qDom.firstChildElement();
 
     float framerate;
     KisTimeRange range;
     int currentTime;
 
     KisImageAnimationInterface *animation = image->animationInterface();
 
     if (KisDomUtils::loadValue(qElement, "framerate", &framerate)) {
         animation->setFramerate(framerate);
     }
 
     if (KisDomUtils::loadValue(qElement, "range", &range)) {
         animation->setFullClipRange(range);
     }
 
     if (KisDomUtils::loadValue(qElement, "currentTime", &currentTime)) {
         animation->switchCurrentTimeAsync(currentTime);
     }
 }
 
 KisNodeSP KisKraLoader::loadNodes(const KoXmlElement& element, KisImageSP image, KisNodeSP parent)
 {
 
     KoXmlNode node = element.firstChild();
     KoXmlNode child;
 
     if (!node.isNull()) {
 
         if (node.isElement()) {
 
             if (node.nodeName().toUpper() == LAYERS.toUpper() || node.nodeName().toUpper() == MASKS.toUpper()) {
                 for (child = node.lastChild(); !child.isNull(); child = child.previousSibling()) {
                     KisNodeSP node = loadNode(child.toElement(), image);
                     if (node) {
                         image->nextLayerName(); // Make sure the nameserver is current with the number of nodes.
                         image->addNode(node, parent);
                         if (node->inherits("KisLayer") && KoXml::childNodesCount(child) > 0) {
                             loadNodes(child.toElement(), image, node);
                         }
                     }
                 }
             }
         }
     }
 
     return parent;
 }
 
 KisNodeSP KisKraLoader::loadNode(const KoXmlElement& element, KisImageSP image)
 {
     // Nota bene: If you add new properties to layers, you should
     // ALWAYS define a default value in case the property is not
     // present in the layer definition: this helps a LOT with backward
     // compatibility.
     QString name = element.attribute(NAME, "No Name");
 
     QUuid id = QUuid(element.attribute(UUID, QUuid().toString()));
 
     qint32 x = element.attribute(X, "0").toInt();
     qint32 y = element.attribute(Y, "0").toInt();
 
     qint32 opacity = element.attribute(OPACITY, QString::number(OPACITY_OPAQUE_U8)).toInt();
     if (opacity < OPACITY_TRANSPARENT_U8) opacity = OPACITY_TRANSPARENT_U8;
     if (opacity > OPACITY_OPAQUE_U8) opacity = OPACITY_OPAQUE_U8;
 
     const KoColorSpace* colorSpace = 0;
     if ((element.attribute(COLORSPACE_NAME)).isNull()) {
         dbgFile << "No attribute color space for layer: " << name;
         colorSpace = image->colorSpace();
     }
     else {
         QString colorspacename = element.attribute(COLORSPACE_NAME);
         QString profileProductName;
 
         convertColorSpaceNames(colorspacename, profileProductName);
 
         QString colorspaceModel = KoColorSpaceRegistry::instance()->colorSpaceColorModelId(colorspacename).id();
         QString colorspaceDepth = KoColorSpaceRegistry::instance()->colorSpaceColorDepthId(colorspacename).id();
         dbgFile << "Searching color space: " << colorspacename << colorspaceModel << colorspaceDepth << " for layer: " << name;
         // use default profile - it will be replaced later in completeLoading
 
         colorSpace = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, "");
         dbgFile << "found colorspace" << colorSpace;
         if (!colorSpace) {
             m_d->warningMessages << i18n("Layer %1 specifies an unsupported color model: %2.", name, colorspacename);
             return 0;
         }
     }
 
     const bool visible = element.attribute(VISIBLE, "1") == "0" ? false : true;
     const bool locked = element.attribute(LOCKED, "0") == "0" ? false : true;
     const bool collapsed = element.attribute(COLLAPSED, "0") == "0" ? false : true;
     int colorLabelIndex = element.attribute(COLOR_LABEL, "0").toInt();
     QVector<QColor> labels = KisNodeViewColorScheme::instance()->allColorLabels();
     if (colorLabelIndex >= labels.size()) {
         colorLabelIndex = labels.size() - 1;
     }
 
     // Now find out the layer type and do specific handling
     QString nodeType;
 
     if (m_d->syntaxVersion == 1) {
         nodeType = element.attribute("layertype");
         if (nodeType.isEmpty()) {
             nodeType = PAINT_LAYER;
         }
     }
     else {
         nodeType = element.attribute(NODE_TYPE);
     }
 
     if (nodeType.isEmpty()) {
         m_d->warningMessages << i18n("Layer %1 has an unsupported type.", name);
         return 0;
     }
 
 
     KisNodeSP node = 0;
 
     if (nodeType == PAINT_LAYER)
         node = loadPaintLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == GROUP_LAYER)
         node = loadGroupLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == ADJUSTMENT_LAYER)
         node = loadAdjustmentLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == SHAPE_LAYER)
         node = loadShapeLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == GENERATOR_LAYER)
         node = loadGeneratorLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == CLONE_LAYER)
         node = loadCloneLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == FILTER_MASK)
         node = loadFilterMask(element);
     else if (nodeType == TRANSFORM_MASK)
         node = loadTransformMask(element);
     else if (nodeType == TRANSPARENCY_MASK)
         node = loadTransparencyMask(element);
     else if (nodeType == SELECTION_MASK)
         node = loadSelectionMask(image, element);
     else if (nodeType == COLORIZE_MASK)
         node = loadColorizeMask(image, element, colorSpace);
     else if (nodeType == FILE_LAYER)
         node = loadFileLayer(element, image, name, opacity);
     else if (nodeType == REFERENCE_IMAGES_LAYER)
         node = loadReferenceImagesLayer(element, image);
     else {
         m_d->warningMessages << i18n("Layer %1 has an unsupported type: %2.", name, nodeType);
         return 0;
     }
 
     // Loading the node went wrong. Return empty node and leave to
     // upstream to complain to the user
     if (!node) {
         m_d->warningMessages << i18n("Failure loading layer %1 of type: %2.", name, nodeType);
         return 0;
     }
 
     node->setVisible(visible, true);
     node->setUserLocked(locked);
     node->setCollapsed(collapsed);
     node->setColorLabelIndex(colorLabelIndex);
     node->setX(x);
     node->setY(y);
     node->setName(name);
 
     if (! id.isNull())          // if no uuid in file, new one has been generated already
         node->setUuid(id);
 
     if (node->inherits("KisLayer") || node->inherits("KisColorizeMask")) {
         QString compositeOpName = element.attribute(COMPOSITE_OP, "normal");
         node->setCompositeOpId(compositeOpName);
     }
 
     if (node->inherits("KisLayer")) {
         KisLayer* layer           = qobject_cast<KisLayer*>(node.data());
         QBitArray channelFlags    = stringToFlags(element.attribute(CHANNEL_FLAGS, ""), colorSpace->channelCount());
         layer->setChannelFlags(channelFlags);
 
         if (element.hasAttribute(LAYER_STYLE_UUID)) {
             QString uuidString = element.attribute(LAYER_STYLE_UUID);
             QUuid uuid(uuidString);
             if (!uuid.isNull()) {
                 KisPSDLayerStyleSP dumbLayerStyle(new KisPSDLayerStyle());
                 dumbLayerStyle->setUuid(uuid);
                 layer->setLayerStyle(dumbLayerStyle);
             } else {
                 warnKrita << "WARNING: Layer style for layer" << layer->name() << "contains invalid UUID" << uuidString;
             }
         }
     }
 
     if (node->inherits("KisGroupLayer")) {
         if (element.hasAttribute(PASS_THROUGH_MODE)) {
             bool value = element.attribute(PASS_THROUGH_MODE, "0") != "0";
 
             KisGroupLayer *group = qobject_cast<KisGroupLayer*>(node.data());
             group->setPassThroughMode(value);
         }
     }
 
     const bool timelineEnabled = element.attribute(VISIBLE_IN_TIMELINE, "0") == "0" ? false : true;
     node->setUseInTimeline(timelineEnabled);
 
     if (node->inherits("KisPaintLayer")) {
         KisPaintLayer* layer            = qobject_cast<KisPaintLayer*>(node.data());
         QBitArray      channelLockFlags = stringToFlags(element.attribute(CHANNEL_LOCK_FLAGS, ""), colorSpace->channelCount());
         layer->setChannelLockFlags(channelLockFlags);
 
         bool onionEnabled = element.attribute(ONION_SKIN_ENABLED, "0") == "0" ? false : true;
         layer->setOnionSkinEnabled(onionEnabled);
     }
 
     if (element.attribute(FILE_NAME).isNull()) {
         m_d->layerFilenames[node.data()] = name;
     }
     else {
         m_d->layerFilenames[node.data()] = element.attribute(FILE_NAME);
     }
 
     if (element.hasAttribute("selected") && element.attribute("selected") == "true")  {
         m_d->selectedNodes.append(node);
     }
 
     if (element.hasAttribute(KEYFRAME_FILE)) {
         m_d->keyframeFilenames.insert(node.data(), element.attribute(KEYFRAME_FILE));
     }
 
     return node;
 }
 
 
 KisNodeSP KisKraLoader::loadPaintLayer(const KoXmlElement& element, KisImageSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(element);
     KisPaintLayer* layer;
 
     layer = new KisPaintLayer(image, name, opacity, cs);
     Q_CHECK_PTR(layer);
     return layer;
 
 }
 
 KisNodeSP KisKraLoader::loadFileLayer(const KoXmlElement& element, KisImageSP image, const QString& name, quint32 opacity)
 {
     QString filename = element.attribute("source", QString());
     if (filename.isNull()) return 0;
     bool scale = (element.attribute("scale", "true")  == "true");
     int scalingMethod = element.attribute("scalingmethod", "-1").toInt();
     if (scalingMethod < 0) {
         if (scale) {
             scalingMethod = KisFileLayer::ToImagePPI;
         }
         else {
             scalingMethod = KisFileLayer::None;
         }
     }
 
     QString documentPath;
     if (m_d->document) {
         documentPath = m_d->document->url().toLocalFile();
     }
     QFileInfo info(documentPath);
     QString basePath = info.absolutePath();
 
     QString fullPath = QDir(basePath).filePath(QDir::cleanPath(filename));
     if (!QFileInfo(fullPath).exists()) {
 
         qApp->setOverrideCursor(Qt::ArrowCursor);
         QString msg = i18nc(
             "@info",
             "The file associated to a file layer with the name \"%1\" is not found.\n\n"
             "Expected path:\n"
             "%2\n\n"
             "Do you want to locate it manually?", name, fullPath);
 
         int result = QMessageBox::warning(0, i18nc("@title:window", "File not found"), msg, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
         if (result == QMessageBox::Yes) {
 
             KoFileDialog dialog(0, KoFileDialog::OpenFile, "OpenDocument");
             dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
             dialog.setDefaultDir(basePath);
             QString url = dialog.filename();
 
             if (!QFileInfo(basePath).exists()) {
                 filename = url;
             } else {
                 QDir d(basePath);
                 filename = d.relativeFilePath(url);
             }
         }
 
         qApp->restoreOverrideCursor();
     }
 
     KisLayer *layer = new KisFileLayer(image, basePath, filename, (KisFileLayer::ScalingMethod)scalingMethod, name, opacity);
     Q_CHECK_PTR(layer);
 
     return layer;
 }
 
 KisNodeSP KisKraLoader::loadGroupLayer(const KoXmlElement& element, KisImageSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(element);
     Q_UNUSED(cs);
     QString attr;
     KisGroupLayer* layer;
 
     layer = new KisGroupLayer(image, name, opacity);
     Q_CHECK_PTR(layer);
 
     return layer;
 
 }
 
 KisNodeSP KisKraLoader::loadAdjustmentLayer(const KoXmlElement& element, KisImageSP image,
         const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     // XXX: do something with filterversion?
     Q_UNUSED(cs);
     QString attr;
     KisAdjustmentLayer* layer;
     QString filtername;
     QString legacy = filtername;
 
     if ((filtername = element.attribute(FILTER_NAME)).isNull()) {
         // XXX: Invalid adjustmentlayer! We should warn about it!
         warnFile << "No filter in adjustment layer";
         return 0;
     }
 
     //get deprecated filters.
     if (filtername=="brightnesscontrast") {
         legacy = filtername;
         filtername = "perchannel";
     }
     if (filtername=="left edge detections"
             || filtername=="right edge detections"
             || filtername=="top edge detections"
             || filtername=="bottom edge detections") {
         legacy = filtername;
         filtername = "edge detection";
     }
 
     KisFilterSP f = KisFilterRegistry::instance()->value(filtername);
     if (!f) {
         warnFile << "No filter for filtername" << filtername << "";
         return 0; // XXX: We don't have this filter. We should warn about it!
     }
 
     KisFilterConfigurationSP  kfc = f->defaultConfiguration();
     kfc->setProperty("legacy", legacy);
     if (legacy=="brightnesscontrast") {
         kfc->setProperty("colorModel", cs->colorModelId().id());
     }
 
     // We'll load the configuration and the selection later.
     layer = new KisAdjustmentLayer(image, name, kfc, 0);
     Q_CHECK_PTR(layer);
 
     layer->setOpacity(opacity);
 
     return layer;
 
 }
 
 
 KisNodeSP KisKraLoader::loadShapeLayer(const KoXmlElement& element, KisImageSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
 
     Q_UNUSED(element);
     Q_UNUSED(cs);
 
     QString attr;
     KoShapeControllerBase * shapeController = 0;
     if (m_d->document) {
         shapeController = m_d->document->shapeController();
     }
     KisShapeLayer* layer = new KisShapeLayer(shapeController, image, name, opacity);
     Q_CHECK_PTR(layer);
 
     return layer;
 
 }
 
 
 KisNodeSP KisKraLoader::loadGeneratorLayer(const KoXmlElement& element, KisImageSP image,
         const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(cs);
     // XXX: do something with generator version?
     KisGeneratorLayer* layer;
     QString generatorname = element.attribute(GENERATOR_NAME);
 
     if (generatorname.isNull()) {
         // XXX: Invalid generator layer! We should warn about it!
         warnFile << "No generator in generator layer";
         return 0;
     }
 
     KisGeneratorSP generator = KisGeneratorRegistry::instance()->value(generatorname);
     if (!generator) {
         warnFile << "No generator for generatorname" << generatorname << "";
         return 0; // XXX: We don't have this generator. We should warn about it!
     }
 
     KisFilterConfigurationSP  kgc = generator->defaultConfiguration();
 
     // We'll load the configuration and the selection later.
     layer = new KisGeneratorLayer(image, name, kgc, 0);
     Q_CHECK_PTR(layer);
 
     layer->setOpacity(opacity);
 
     return layer;
 
 }
 
 KisNodeSP KisKraLoader::loadCloneLayer(const KoXmlElement& element, KisImageSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(cs);
 
     KisCloneLayerSP layer = new KisCloneLayer(0, image, name, opacity);
 
     KisNodeUuidInfo info;
     if (! (element.attribute(CLONE_FROM_UUID)).isNull()) {
         info = KisNodeUuidInfo(QUuid(element.attribute(CLONE_FROM_UUID)));
     } else {
         if ((element.attribute(CLONE_FROM)).isNull()) {
             return 0;
         } else {
             info = KisNodeUuidInfo(element.attribute(CLONE_FROM));
         }
     }
     layer->setCopyFromInfo(info);
 
     if ((element.attribute(CLONE_TYPE)).isNull()) {
         return 0;
     } else {
         layer->setCopyType((CopyLayerType) element.attribute(CLONE_TYPE).toInt());
     }
 
     return layer;
 }
 
 
 KisNodeSP KisKraLoader::loadFilterMask(const KoXmlElement& element)
 {
     QString attr;
     KisFilterMask* mask;
     QString filtername;
 
     // XXX: should we check the version?
 
     if ((filtername = element.attribute(FILTER_NAME)).isNull()) {
         // XXX: Invalid filter layer! We should warn about it!
         warnFile << "No filter in filter layer";
         return 0;
     }
 
     KisFilterSP f = KisFilterRegistry::instance()->value(filtername);
     if (!f) {
         warnFile << "No filter for filtername" << filtername << "";
         return 0; // XXX: We don't have this filter. We should warn about it!
     }
 
     KisFilterConfigurationSP  kfc = f->defaultConfiguration();
 
     // We'll load the configuration and the selection later.
     mask = new KisFilterMask();
     mask->setFilter(kfc);
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
 KisNodeSP KisKraLoader::loadTransformMask(const KoXmlElement& element)
 {
     Q_UNUSED(element);
 
     KisTransformMask* mask;
 
     /**
      * We'll load the transform configuration later on a stage
      * of binary data loading
      */
     mask = new KisTransformMask();
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
 KisNodeSP KisKraLoader::loadTransparencyMask(const KoXmlElement& element)
 {
     Q_UNUSED(element);
     KisTransparencyMask* mask = new KisTransparencyMask();
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
 KisNodeSP KisKraLoader::loadSelectionMask(KisImageSP image, const KoXmlElement& element)
 {
     KisSelectionMaskSP mask = new KisSelectionMask(image);
     bool active = element.attribute(ACTIVE, "1") == "0" ? false : true;
     mask->setActive(active);
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
 KisNodeSP KisKraLoader::loadColorizeMask(KisImageSP image, const KoXmlElement& element, const KoColorSpace *colorSpace)
 {
     KisColorizeMaskSP mask = new KisColorizeMask();
     const bool editKeystrokes = element.attribute(COLORIZE_EDIT_KEYSTROKES, "1") == "0" ? false : true;
     const bool showColoring = element.attribute(COLORIZE_SHOW_COLORING, "1") == "0" ? false : true;
 
     KisLayerPropertiesIcons::setNodeProperty(mask, KisLayerPropertiesIcons::colorizeEditKeyStrokes, editKeystrokes, image);
     KisLayerPropertiesIcons::setNodeProperty(mask, KisLayerPropertiesIcons::colorizeShowColoring, showColoring, image);
 
     const bool useEdgeDetection = KisDomUtils::toInt(element.attribute(COLORIZE_USE_EDGE_DETECTION, "0"));
     const qreal edgeDetectionSize = KisDomUtils::toDouble(element.attribute(COLORIZE_EDGE_DETECTION_SIZE, "4"));
     const qreal radius = KisDomUtils::toDouble(element.attribute(COLORIZE_FUZZY_RADIUS, "0"));
     const int cleanUp = KisDomUtils::toInt(element.attribute(COLORIZE_CLEANUP, "0"));
     const bool limitToDevice = KisDomUtils::toInt(element.attribute(COLORIZE_LIMIT_TO_DEVICE, "0"));
 
     mask->setUseEdgeDetection(useEdgeDetection);
     mask->setEdgeDetectionSize(edgeDetectionSize);
     mask->setFuzzyRadius(radius);
     mask->setCleanUpAmount(qreal(cleanUp) / 100.0);
     mask->setLimitToDeviceBounds(limitToDevice);
 
     delete mask->setColorSpace(colorSpace);
     mask->setImage(image);
 
     return mask;
 }
 
 void KisKraLoader::loadCompositions(const KoXmlElement& elem, KisImageSP image)
 {
     KoXmlNode child;
 
     for (child = elem.firstChild(); !child.isNull(); child = child.nextSibling()) {
 
         KoXmlElement e = child.toElement();
         QString name = e.attribute("name");
         bool exportEnabled = e.attribute("exportEnabled", "1") == "0" ? false : true;
 
         KisLayerCompositionSP composition(new KisLayerComposition(image, name));
         composition->setExportEnabled(exportEnabled);
 
         KoXmlNode value;
         for (value = child.lastChild(); !value.isNull(); value = value.previousSibling()) {
             KoXmlElement e = value.toElement();
             QUuid uuid(e.attribute("uuid"));
             bool visible = e.attribute("visible", "1") == "0" ? false : true;
             composition->setVisible(uuid, visible);
             bool collapsed = e.attribute("collapsed", "1") == "0" ? false : true;
             composition->setCollapsed(uuid, collapsed);
         }
 
         image->addComposition(composition);
     }
 }
 
 void KisKraLoader::loadAssistantsList(const KoXmlElement &elem)
 {
     KoXmlNode child;
     int count = 0;
     for (child = elem.firstChild(); !child.isNull(); child = child.nextSibling()) {
         KoXmlElement e = child.toElement();
         QString type = e.attribute("type");
         QString file_name = e.attribute("filename");
         m_d->assistantsFilenames.insert(file_name,type);
         count++;
 
     }
 }
 
 void KisKraLoader::loadGrid(const KoXmlElement& elem)
 {
     QDomDocument dom;
     KoXml::asQDomElement(dom, elem);
     QDomElement domElement = dom.firstChildElement();
 
     KisGridConfig config;
     config.loadDynamicDataFromXml(domElement);
     config.loadStaticData();
     m_d->document->setGridConfig(config);
 }
 
 void KisKraLoader::loadGuides(const KoXmlElement& elem)
 {
     QDomDocument dom;
     KoXml::asQDomElement(dom, elem);
     QDomElement domElement = dom.firstChildElement();
 
     KisGuidesConfig guides;
     guides.loadFromXml(domElement);
     m_d->document->setGuidesConfig(guides);
 }
 
 void KisKraLoader::loadAudio(const KoXmlElement& elem, KisImageSP image)
 {
     QDomDocument dom;
     KoXml::asQDomElement(dom, elem);
     QDomElement qElement = dom.firstChildElement();
 
     QString fileName;
     if (KisDomUtils::loadValue(qElement, "masterChannelPath", &fileName)) {
         fileName = QDir::toNativeSeparators(fileName);
 
         QDir baseDirectory = QFileInfo(m_d->document->localFilePath()).absoluteDir();
         fileName = baseDirectory.absoluteFilePath(fileName);
 
         QFileInfo info(fileName);
 
         if (!info.exists()) {
             qApp->setOverrideCursor(Qt::ArrowCursor);
             QString msg = i18nc(
                 "@info",
                 "Audio channel file \"%1\" doesn't exist!\n\n"
                 "Expected path:\n"
                 "%2\n\n"
                 "Do you want to locate it manually?", info.fileName(), info.absoluteFilePath());
 
             int result = QMessageBox::warning(0, i18nc("@title:window", "File not found"), msg, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
             if (result == QMessageBox::Yes) {
                 info.setFile(KisImportExportManager::askForAudioFileName(info.absolutePath(), 0));
             }
 
             qApp->restoreOverrideCursor();
         }
 
         if (info.exists()) {
             image->animationInterface()->setAudioChannelFileName(info.absoluteFilePath());
         }
     }
 
     bool audioMuted = false;
     if (KisDomUtils::loadValue(qElement, "audioMuted", &audioMuted)) {
         image->animationInterface()->setAudioMuted(audioMuted);
     }
 
     qreal audioVolume = 0.5;
     if (KisDomUtils::loadValue(qElement, "audioVolume", &audioVolume)) {
         image->animationInterface()->setAudioVolume(audioVolume);
     }
 }
 
+void KisKraLoader::loadGamutMaskMetadata(const KoXmlElement &elem)
+{
+    KoXmlNode child;
+
+    for (child = elem.firstChild(); !child.isNull(); child = child.nextSibling()) {
+        KoXmlElement e = child.toElement();
+        if (e.tagName() == GAMUTMASK_RESOURCE) {
+            m_d->gamutMaskFilename = e.attribute("filename");
+            m_d->gamutMaskRotation = e.attribute("rotation").toInt();
+        }
+        // todo: selector settings
+    }
+}
+
 KisNodeSP KisKraLoader::loadReferenceImagesLayer(const KoXmlElement &elem, KisImageSP image)
 {
     KisSharedPtr<KisReferenceImagesLayer> layer =
         new KisReferenceImagesLayer(m_d->document->shapeController(), image);
 
     m_d->document->setReferenceImagesLayer(layer, false);
 
     for (QDomElement child = elem.firstChildElement(); !child.isNull(); child = child.nextSiblingElement()) {
         if (child.nodeName().toLower() == "referenceimage") {
             auto* reference = KisReferenceImage::fromXml(child);
             layer->addShape(reference);
         }
     }
 
     return layer;
 }
+
+void KisKraLoader::loadGamutMask(KoStore* store)
+{
+    if (m_d->gamutMaskFilename.isEmpty()) {
+        return;
+    }
+
+    QString gamutMaskPath = QString("%1%2%3")
+            .arg(m_d->imageName)
+            .arg(GAMUTMASK_PATH)
+            .arg(m_d->gamutMaskFilename);
+
+    KoGamutMask* mask = new KoGamutMask(m_d->gamutMaskFilename);
+
+    if (store->open(gamutMaskPath)) {
+        mask->loadFromByteArray(store->read(store->size()));
+        store->close();
+
+        mask->setRotation(m_d->gamutMaskRotation);
+        mask->setTitle(QString("%1 %2").arg(mask->title()).arg("[document]"));
+
+        m_d->document->setGamutMask(mask);
+    }
+}
diff --git a/plugins/impex/libkra/kis_kra_loader.h b/plugins/impex/libkra/kis_kra_loader.h
index 237ce4ccd5..6df8b0b780 100644
--- a/plugins/impex/libkra/kis_kra_loader.h
+++ b/plugins/impex/libkra/kis_kra_loader.h
@@ -1,121 +1,125 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2007
  *
  * 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 KIS_KRA_LOADER_H
 #define KIS_KRA_LOADER_H
 
 class QString;
 class QStringList;
 
 #include "KoXmlReaderForward.h"
 class KoStore;
 
 class KisDocument;
 class KoColorSpace;
 class KisPaintingAssistant;
 
 #include <kis_types.h>
 #include "kritalibkra_export.h"
 /**
  * Load old-style 1.x .kra files. Updated for 2.0, let's try to stay
  * compatible. But 2.0 won't be able to save 1.x .kra files unless we
  * implement an export filter.
  */
 class KRITALIBKRA_EXPORT KisKraLoader
 {
 
 public:
 
     KisKraLoader(KisDocument * document, int syntaxVersion);
 
     ~KisKraLoader();
 
     /**
      * Loading is done in two steps: first all xml is loaded, then, in finishLoading,
      * the actual layer data is loaded.
      */
     KisImageSP loadXML(const KoXmlElement& elem);
 
     void loadBinaryData(KoStore* store, KisImageSP image, const QString & uri, bool external);
 
     void loadPalettes(KoStore *store, KisDocument *doc);
 
     vKisNodeSP selectedNodes() const;
 
     // it's neater to follow the same design as with selectedNodes, so let's have a getter here
     QList<KisPaintingAssistantSP> assistants() const;
 
     /// if empty, loading didn't fail...
     QStringList errorMessages() const;
 
     /// if not empty, loading didn't fail, but there are problems
     QStringList warningMessages() const;
 
 private:
 
     // this needs to be private, for neatness sake
     void loadAssistants(KoStore* store, const QString & uri, bool external);
 
     void loadAnimationMetadata(const KoXmlElement& element, KisImageSP image);
 
     KisNodeSP loadNodes(const KoXmlElement& element, KisImageSP image, KisNodeSP parent);
 
     KisNodeSP loadNode(const KoXmlElement& elem, KisImageSP image);
 
     KisNodeSP loadPaintLayer(const KoXmlElement& elem, KisImageSP image, const QString& name, const KoColorSpace* cs, quint32 opacity);
 
     KisNodeSP loadGroupLayer(const KoXmlElement& elem, KisImageSP image, const QString& name, const KoColorSpace* cs, quint32 opacity);
 
     KisNodeSP loadAdjustmentLayer(const KoXmlElement& elem, KisImageSP image, const QString& name, const KoColorSpace* cs, quint32 opacity);
 
     KisNodeSP loadShapeLayer(const KoXmlElement& elem, KisImageSP image, const QString& name, const KoColorSpace* cs, quint32 opacity);
 
     KisNodeSP loadGeneratorLayer(const KoXmlElement& elem, KisImageSP image, const QString& name, const KoColorSpace* cs, quint32 opacity);
 
     KisNodeSP loadCloneLayer(const KoXmlElement& elem, KisImageSP image, const QString& name, const KoColorSpace* cs, quint32 opacity);
 
     KisNodeSP loadFilterMask(const KoXmlElement& elem);
 
     KisNodeSP loadTransformMask(const KoXmlElement& elem);
 
     KisNodeSP loadTransparencyMask(const KoXmlElement& elem);
 
     KisNodeSP loadSelectionMask(KisImageSP image, const KoXmlElement& elem);
 
     KisNodeSP loadColorizeMask(KisImageSP image, const KoXmlElement& elem, const KoColorSpace *colorSpace);
 
     KisNodeSP loadFileLayer(const KoXmlElement& elem, KisImageSP image, const QString& name, quint32 opacity);
 
     KisNodeSP loadReferenceImagesLayer(const KoXmlElement& elem, KisImageSP image);
 
     void loadNodeKeyframes(KoStore *store, const QString &location, KisNodeSP node);
 
     void loadCompositions(const KoXmlElement& elem, KisImageSP image);
 
     void loadAssistantsList(const KoXmlElement& elem);
     void loadGrid(const KoXmlElement& elem);
     void loadGuides(const KoXmlElement& elem);
     void loadAudio(const KoXmlElement& elem, KisImageSP image);
+
+    void loadGamutMaskMetadata(const KoXmlElement& elem);
+    void loadGamutMask(KoStore* store);
+
 private:
 
     struct Private;
     Private * const m_d;
 
 };
 
 #endif
diff --git a/plugins/impex/libkra/kis_kra_saver.cpp b/plugins/impex/libkra/kis_kra_saver.cpp
index cebf9b4038..efd4dcaceb 100644
--- a/plugins/impex/libkra/kis_kra_saver.cpp
+++ b/plugins/impex/libkra/kis_kra_saver.cpp
@@ -1,512 +1,564 @@
 /* This file is part of the KDE project
  * Copyright 2008 (C) 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 "kis_kra_saver.h"
 
 #include "kis_kra_tags.h"
 #include "kis_kra_save_visitor.h"
 #include "kis_kra_savexml_visitor.h"
 
 #include <QDomDocument>
 #include <QDomElement>
 #include <QString>
 #include <QStringList>
 #include <QScopedPointer>
 
 #include <QUrl>
 #include <QBuffer>
 
 #include <KoDocumentInfo.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpace.h>
 #include <KoColorProfile.h>
 #include <KoColor.h>
 #include <KoColorSet.h>
 #include <KoResourceServer.h>
 #include <KoResourceServerProvider.h>
 #include <KoStore.h>
 #include <KoStoreDevice.h>
 
 #include <kis_annotation.h>
 #include <kis_image.h>
 #include <kis_image_animation_interface.h>
 #include <kis_group_layer.h>
 #include <kis_layer.h>
 #include <kis_adjustment_layer.h>
 #include <kis_layer_composition.h>
 #include <kis_painting_assistants_decoration.h>
 #include <kis_psd_layer_style_resource.h>
 #include "kis_png_converter.h"
 #include "kis_keyframe_channel.h"
 #include <kis_time_range.h>
 #include "KisDocument.h"
 #include <string>
 #include "kis_dom_utils.h"
 #include "kis_grid_config.h"
 #include "kis_guides_config.h"
 #include "KisProofingConfiguration.h"
 
 #include <QFileInfo>
 #include <QDir>
 
 
 using namespace KRA;
 
 struct KisKraSaver::Private
 {
 public:
     KisDocument* doc;
     QMap<const KisNode*, QString> nodeFileNames;
     QMap<const KisNode*, QString> keyframeFilenames;
     QString imageName;
     QString filename;
     QStringList errorMessages;
 };
 
 KisKraSaver::KisKraSaver(KisDocument* document, const QString &filename)
         : m_d(new Private)
 {
     m_d->doc = document;
     m_d->filename = filename;
 
     m_d->imageName = m_d->doc->documentInfo()->aboutInfo("title");
     if (m_d->imageName.isEmpty()) {
         m_d->imageName = i18n("Unnamed");
     }
 }
 
 KisKraSaver::~KisKraSaver()
 {
     delete m_d;
 }
 
 QDomElement KisKraSaver::saveXML(QDomDocument& doc,  KisImageSP image)
 {
     QDomElement imageElement = doc.createElement("IMAGE");
 
     Q_ASSERT(image);
     imageElement.setAttribute(NAME, m_d->imageName);
     imageElement.setAttribute(MIME, NATIVE_MIMETYPE);
     imageElement.setAttribute(WIDTH, KisDomUtils::toString(image->width()));
     imageElement.setAttribute(HEIGHT, KisDomUtils::toString(image->height()));
     imageElement.setAttribute(COLORSPACE_NAME, image->colorSpace()->id());
     imageElement.setAttribute(DESCRIPTION, m_d->doc->documentInfo()->aboutInfo("comment"));
     // XXX: Save profile as blob inside the image, instead of the product name.
     if (image->profile() && image->profile()-> valid()) {
         imageElement.setAttribute(PROFILE, image->profile()->name());
     }
     imageElement.setAttribute(X_RESOLUTION, KisDomUtils::toString(image->xRes()*72.0));
     imageElement.setAttribute(Y_RESOLUTION, KisDomUtils::toString(image->yRes()*72.0));
     //now the proofing options:
     if (image->proofingConfiguration()) {
         imageElement.setAttribute(PROOFINGPROFILENAME, KisDomUtils::toString(image->proofingConfiguration()->proofingProfile));
         imageElement.setAttribute(PROOFINGMODEL, KisDomUtils::toString(image->proofingConfiguration()->proofingModel));
         imageElement.setAttribute(PROOFINGDEPTH, KisDomUtils::toString(image->proofingConfiguration()->proofingDepth));
         imageElement.setAttribute(PROOFINGINTENT, KisDomUtils::toString(image->proofingConfiguration()->intent));
         imageElement.setAttribute(PROOFINGADAPTATIONSTATE, KisDomUtils::toString(image->proofingConfiguration()->adaptationState));
     }
 
     quint32 count = 1; // We don't save the root layer, but it does count
     KisSaveXmlVisitor visitor(doc, imageElement, count, m_d->doc->url().toLocalFile(), true);
     visitor.setSelectedNodes({m_d->doc->preActivatedNode()});
 
     image->rootLayer()->accept(visitor);
     m_d->errorMessages.append(visitor.errorMessages());
 
     m_d->nodeFileNames = visitor.nodeFileNames();
     m_d->keyframeFilenames = visitor.keyframeFileNames();
 
     saveBackgroundColor(doc, imageElement, image);
     saveAssistantsGlobalColor(doc, imageElement);
     saveWarningColor(doc, imageElement, image);
     saveCompositions(doc, imageElement, image);
     saveAssistantsList(doc, imageElement);
     saveGrid(doc, imageElement);
     saveGuides(doc, imageElement);
     saveAudio(doc, imageElement);
     savePalettesToXML(doc, imageElement);
+    saveGamutMaskMetadata(doc, imageElement);
 
     QDomElement animationElement = doc.createElement("animation");
     KisDomUtils::saveValue(&animationElement, "framerate", image->animationInterface()->framerate());
     KisDomUtils::saveValue(&animationElement, "range", image->animationInterface()->fullClipRange());
     KisDomUtils::saveValue(&animationElement, "currentTime", image->animationInterface()->currentUITime());
     imageElement.appendChild(animationElement);
 
     return imageElement;
 }
 
 bool KisKraSaver::savePalettes(KoStore *store, KisImageSP image, const QString &uri)
 {
     Q_UNUSED(image);
     Q_UNUSED(uri);
 
     bool res = false;
     if (m_d->doc->paletteList().size() == 0) {
         return true;
     }
     for (const KoColorSet *palette : m_d->doc->paletteList()) {
         if (!palette->isGlobal()) {
             if (!store->open(m_d->imageName + PALETTE_PATH + palette->filename())) {
                 m_d->errorMessages << i18n("could not save palettes");
                 return false;
             }
             QByteArray ba = palette->toByteArray();
             if (!ba.isEmpty()) {
                 store->write(ba);
             } else {
                 qWarning() << "Cannot save the palette to a byte array:" << palette->name();
             }
             store->close();
             res = true;
         }
     }
     return res;
 }
 
+bool KisKraSaver::saveGamutMask(KoStore* store)
+{
+    // no mask in document -> automatic success
+    if (!m_d->doc->gamutMask()) {
+        return true;
+    }
+
+    QString gamutMaskPath = QString("%1%2%3")
+            .arg(m_d->imageName)
+            .arg(GAMUTMASK_PATH)
+            .arg(m_d->doc->gamutMask()->shortFilename());
+    if (!store->open(gamutMaskPath)) {
+        m_d->errorMessages << i18n("could not save gamut mask");
+        return false;
+    }
+
+    bool res = false;
+    QByteArray resourceData = m_d->doc->gamutMask()->toByteArray();
+    if (!resourceData.isEmpty()) {
+//        res = (store->write(resourceData) == -1) ? false : true;
+        store->write(resourceData);
+        res = true;
+    } else {
+        qWarning() << "Cannot convert gamut mask to byte array:" << m_d->doc->gamutMask()->title();
+        res = false;
+    }
+
+    store->close();
+
+    return res;
+}
+
 void KisKraSaver::savePalettesToXML(QDomDocument &doc, QDomElement &element)
 {
     QDomElement ePalette = doc.createElement(PALETTES);
     for (const KoColorSet *palette : m_d->doc->paletteList()) {
         if (!palette->isGlobal()) {
             QDomElement eFile =  doc.createElement("palette");
             eFile.setAttribute("filename", palette->filename());
             ePalette.appendChild(eFile);
         }
     }
     element.appendChild(ePalette);
 }
 
+
+void KisKraSaver::saveGamutMaskMetadata(QDomDocument& doc, QDomElement& element)
+{
+    if (!m_d->doc->gamutMask()) {
+        return;
+    }
+
+    QDomElement gamutMaskRoot = doc.createElement(GAMUTMASK_ROOT);
+
+    QDomElement gamutMaskResource = doc.createElement(GAMUTMASK_RESOURCE);
+    gamutMaskResource.setAttribute("filename", m_d->doc->gamutMask()->shortFilename());
+    gamutMaskResource.setAttribute("rotation", m_d->doc->gamutMask()->rotation());
+    gamutMaskRoot.appendChild(gamutMaskResource);
+
+    // TODO: save color selector properties
+
+    element.appendChild(gamutMaskRoot);
+}
+
 bool KisKraSaver::saveKeyframes(KoStore *store, const QString &uri, bool external)
 {
     QMap<const KisNode*, QString>::iterator it;
 
     for (it = m_d->keyframeFilenames.begin(); it != m_d->keyframeFilenames.end(); it++) {
         const KisNode *node = it.key();
         QString filename = it.value();
 
         QString location =
                 (external ? QString() : uri)
                 + m_d->imageName + LAYER_PATH + filename;
 
         if (!saveNodeKeyframes(store, location, node)) {
             return false;
         }
     }
 
     return true;
 }
 
 bool KisKraSaver::saveNodeKeyframes(KoStore *store, QString location, const KisNode *node)
 {
     QDomDocument doc = KisDocument::createDomDocument("krita-keyframes", "keyframes", "1.0");
     QDomElement root = doc.documentElement();
 
     KisKeyframeChannel *channel;
     Q_FOREACH (channel, node->keyframeChannels()) {
         QDomElement element = channel->toXML(doc, m_d->nodeFileNames[node]);
         root.appendChild(element);
     }
 
     if (store->open(location)) {
         QByteArray xml = doc.toByteArray();
         store->write(xml);
         store->close();
     } else {
         m_d->errorMessages << i18n("could not save keyframes");
         return false;
     }
 
     return true;
 }
 
 bool KisKraSaver::saveBinaryData(KoStore* store, KisImageSP image, const QString &uri, bool external, bool autosave)
 {
     QString location;
 
     // Save the layers data
     KisKraSaveVisitor visitor(store, m_d->imageName, m_d->nodeFileNames);
 
     if (external)
         visitor.setExternalUri(uri);
 
     image->rootLayer()->accept(visitor);
 
     m_d->errorMessages.append(visitor.errorMessages());
     if (!m_d->errorMessages.isEmpty()) {
         return false;
     }
 
     // saving annotations
     // XXX this only saves EXIF and ICC info. This would probably need
     // a redesign of the dtd of the krita file to do this more generally correct
     // e.g. have <ANNOTATION> tags or so.
     KisAnnotationSP annotation = image->annotation("exif");
     if (annotation) {
         location = external ? QString() : uri;
         location += m_d->imageName + EXIF_PATH;
         if (store->open(location)) {
             store->write(annotation->annotation());
             store->close();
         }
     }
     if (image->profile()) {
         const KoColorProfile *profile = image->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) {
             location = external ? QString() : uri;
             location += m_d->imageName + ICC_PATH;
             if (store->open(location)) {
                 store->write(annotation->annotation());
                 store->close();
             }
         }
     }
 
     //This'll embed the profile used for proofing into the kra file.
     if (image->proofingConfiguration()) {
         const KoColorProfile *proofingProfile = KoColorSpaceRegistry::instance()->profileByName(image->proofingConfiguration()->proofingProfile);
         if (proofingProfile && proofingProfile->valid()) {
             QByteArray proofingProfileRaw = proofingProfile->rawData();
             if (!proofingProfileRaw.isEmpty()) {
                 annotation = new KisAnnotation(ICCPROOFINGPROFILE, proofingProfile->name(), proofingProfile->rawData());
             }
         }
         if (annotation) {
             location = external ? QString() : uri;
             location += m_d->imageName + ICC_PROOFING_PATH;
             if (store->open(location)) {
                 store->write(annotation->annotation());
                 store->close();
             }
         }
 
     }
 
     {
         KisPSDLayerStyleCollectionResource collection("not-nexists.asl");
         KIS_ASSERT_RECOVER_NOOP(!collection.valid());
         collection.collectAllLayerStyles(image->root());
         if (collection.valid()) {
             location = external ? QString() : uri;
             location += m_d->imageName + LAYER_STYLES_PATH;
 
             if (store->open(location)) {
                 QBuffer aslBuffer;
                 aslBuffer.open(QIODevice::WriteOnly);
                 collection.saveToDevice(&aslBuffer);
                 aslBuffer.close();
 
                 store->write(aslBuffer.buffer());
                 store->close();
             }
         }
     }
 
     if (!autosave) {
         KisPaintDeviceSP dev = image->projection();
         KisPNGConverter::saveDeviceToStore("mergedimage.png", image->bounds(), image->xRes(), image->yRes(), dev, store);
     }
 
     saveAssistants(store, uri,external);
     return true;
 }
 
 QStringList KisKraSaver::errorMessages() const
 {
     return m_d->errorMessages;
 }
 
 void KisKraSaver::saveBackgroundColor(QDomDocument& doc, QDomElement& element, KisImageSP image)
 {
     QDomElement e = doc.createElement(CANVASPROJECTIONCOLOR);
     KoColor color = image->defaultProjectionColor();
     QByteArray colorData = QByteArray::fromRawData((const char*)color.data(), color.colorSpace()->pixelSize());
     e.setAttribute(COLORBYTEDATA, QString(colorData.toBase64()));
     element.appendChild(e);
 }
 
 void KisKraSaver::saveAssistantsGlobalColor(QDomDocument& doc, QDomElement& element)
 {
     QDomElement e = doc.createElement(GLOBALASSISTANTSCOLOR);
     QString colorString = KisDomUtils::qColorToQString(m_d->doc->assistantsGlobalColor());
     e.setAttribute(SIMPLECOLORDATA, QString(colorString));
     element.appendChild(e);
 }
 
 void KisKraSaver::saveWarningColor(QDomDocument& doc, QDomElement& element, KisImageSP image)
 {
     if (image->proofingConfiguration()) {
         QDomElement e = doc.createElement(PROOFINGWARNINGCOLOR);
         KoColor color = image->proofingConfiguration()->warningColor;
         color.toXML(doc, e);
         element.appendChild(e);
     }
 }
 
 void KisKraSaver::saveCompositions(QDomDocument& doc, QDomElement& element, KisImageSP image)
 {
     if (!image->compositions().isEmpty()) {
         QDomElement e = doc.createElement("compositions");
         Q_FOREACH (KisLayerCompositionSP composition, image->compositions()) {
             composition->save(doc, e);
         }
         element.appendChild(e);
     }
 }
 
 bool KisKraSaver::saveAssistants(KoStore* store, QString uri, bool external)
 {
     QString location;
     QMap<QString, int> assistantcounters;
     QByteArray data;
 
     QList<KisPaintingAssistantSP> assistants =  m_d->doc->assistants();
     QMap<KisPaintingAssistantHandleSP, int> handlemap;
     if (!assistants.isEmpty()) {
 
         Q_FOREACH (KisPaintingAssistantSP assist, assistants){
             if (!assistantcounters.contains(assist->id())){
                 assistantcounters.insert(assist->id(),0);
             }
             location = external ? QString() : uri;
             location += m_d->imageName + ASSISTANTS_PATH;
             location += QString(assist->id()+"%1.assistant").arg(assistantcounters[assist->id()]);
 
             data = assist->saveXml(handlemap);
             store->open(location);
             store->write(data);
             store->close();
             assistantcounters[assist->id()]++;
         }
 
     }
     return true;
 }
 
 bool KisKraSaver::saveAssistantsList(QDomDocument& doc, QDomElement& element)
 {
     int count_ellipse = 0, count_perspective = 0, count_ruler = 0, count_vanishingpoint = 0,count_infiniteruler = 0, count_parallelruler = 0, count_concentricellipse = 0, count_fisheyepoint = 0, count_spline = 0;
     QList<KisPaintingAssistantSP> assistants =  m_d->doc->assistants();
     if (!assistants.isEmpty()) {
         QDomElement assistantsElement = doc.createElement("assistants");
         Q_FOREACH (KisPaintingAssistantSP assist, assistants){
             if (assist->id() == "ellipse"){
                 assist->saveXmlList(doc, assistantsElement, count_ellipse);
                 count_ellipse++;
             }
             else if (assist->id() == "spline"){
                 assist->saveXmlList(doc, assistantsElement, count_spline);
                 count_spline++;
             }
             else if (assist->id() == "perspective"){
                 assist->saveXmlList(doc, assistantsElement, count_perspective);
                 count_perspective++;
             }
             else if (assist->id() == "vanishing point"){
                 assist->saveXmlList(doc, assistantsElement, count_vanishingpoint);
                 count_vanishingpoint++;
             }
             else if (assist->id() == "infinite ruler"){
                 assist->saveXmlList(doc, assistantsElement, count_infiniteruler);
                 count_infiniteruler++;
             }
             else if (assist->id() == "parallel ruler"){
                 assist->saveXmlList(doc, assistantsElement, count_parallelruler);
                 count_parallelruler++;
             }
             else if (assist->id() == "concentric ellipse"){
                 assist->saveXmlList(doc, assistantsElement, count_concentricellipse);
                 count_concentricellipse++;
             }
             else if (assist->id() == "fisheye-point"){
                 assist->saveXmlList(doc, assistantsElement, count_fisheyepoint);
                 count_fisheyepoint++;
             }
             else if (assist->id() == "ruler"){
                 assist->saveXmlList(doc, assistantsElement, count_ruler);
                 count_ruler++;
             }
         }
         element.appendChild(assistantsElement);
     }
     return true;
 }
 
 bool KisKraSaver::saveGrid(QDomDocument& doc, QDomElement& element)
 {
     KisGridConfig config = m_d->doc->gridConfig();
 
     if (!config.isDefault()) {
         QDomElement gridElement = config.saveDynamicDataToXml(doc, "grid");
         element.appendChild(gridElement);
     }
 
     return true;
 }
 
 bool KisKraSaver::saveGuides(QDomDocument& doc, QDomElement& element)
 {
     KisGuidesConfig guides = m_d->doc->guidesConfig();
 
     if (!guides.isDefault()) {
         QDomElement guidesElement = guides.saveToXml(doc, "guides");
         element.appendChild(guidesElement);
     }
 
     return true;
 }
 
 bool KisKraSaver::saveAudio(QDomDocument& doc, QDomElement& element)
 {
     const KisImageAnimationInterface *interface = m_d->doc->image()->animationInterface();
     QString fileName = interface->audioChannelFileName();
     if (fileName.isEmpty()) return true;
 
     if (!QFileInfo::exists(fileName)) {
         m_d->errorMessages << i18n("Audio channel file %1 doesn't exist!", fileName);
         return false;
     }
 
     const QDir documentDir = QFileInfo(m_d->filename).absoluteDir();
     KIS_ASSERT_RECOVER_RETURN_VALUE(documentDir.exists(), false);
 
     fileName = documentDir.relativeFilePath(fileName);
     fileName = QDir::fromNativeSeparators(fileName);
 
     KIS_ASSERT_RECOVER_RETURN_VALUE(!fileName.isEmpty(), false);
 
     QDomElement audioElement = doc.createElement("audio");
     KisDomUtils::saveValue(&audioElement, "masterChannelPath", fileName);
     KisDomUtils::saveValue(&audioElement, "audioMuted", interface->isAudioMuted());
     KisDomUtils::saveValue(&audioElement, "audioVolume", interface->audioVolume());
     element.appendChild(audioElement);
 
     return true;
 }
 
diff --git a/plugins/impex/libkra/kis_kra_saver.h b/plugins/impex/libkra/kis_kra_saver.h
index 1e95fd1e2d..d6442fce95 100644
--- a/plugins/impex/libkra/kis_kra_saver.h
+++ b/plugins/impex/libkra/kis_kra_saver.h
@@ -1,68 +1,72 @@
 /* This file is part of the KDE project
  * Copyright 2008 (C) 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 KIS_KRA_SAVER
 #define KIS_KRA_SAVER
 
 #include <kis_types.h>
 
 class KisDocument;
 class QDomElement;
 class QDomDocument;
 class KoStore;
 class QString;
 class QStringList;
 
 #include "kritalibkra_export.h"
 
 class KRITALIBKRA_EXPORT KisKraSaver
 {
 public:
 
     KisKraSaver(KisDocument* document, const QString &filename);
 
     ~KisKraSaver();
 
     QDomElement saveXML(QDomDocument& doc,  KisImageSP image);
 
     bool saveKeyframes(KoStore *store, const QString &uri, bool external);
 
     bool saveBinaryData(KoStore* store, KisImageSP image, const QString & uri, bool external, bool includeMerge);
 
     bool savePalettes(KoStore *store, KisImageSP image, const QString &uri);
 
+    bool saveGamutMask(KoStore* store);
+
     /// @return a list with everything that went wrong while saving
     QStringList errorMessages() const;
 
 private:
     void saveBackgroundColor(QDomDocument& doc, QDomElement& element, KisImageSP image);
     void saveAssistantsGlobalColor(QDomDocument& doc, QDomElement& element);
     void saveWarningColor(QDomDocument& doc, QDomElement& element, KisImageSP image);
     void saveCompositions(QDomDocument& doc, QDomElement& element, KisImageSP image);
     bool saveAssistants(KoStore *store,QString uri, bool external);
     bool saveAssistantsList(QDomDocument& doc, QDomElement& element);
     bool saveGrid(QDomDocument& doc, QDomElement& element);
     bool saveGuides(QDomDocument& doc, QDomElement& element);
     bool saveAudio(QDomDocument& doc, QDomElement& element);
     bool saveNodeKeyframes(KoStore *store, QString location, const KisNode *node);
     void savePalettesToXML(QDomDocument& doc, QDomElement &element);
+    void saveGamutMaskMetadata(QDomDocument& doc, QDomElement& element);
+
     struct Private;
     Private * const m_d;
 };
 
 #endif
diff --git a/plugins/impex/libkra/kis_kra_tags.h b/plugins/impex/libkra/kis_kra_tags.h
index ac162c9f4d..6d17199f80 100644
--- a/plugins/impex/libkra/kis_kra_tags.h
+++ b/plugins/impex/libkra/kis_kra_tags.h
@@ -1,144 +1,148 @@
 /* This file is part of the KDE project
  * Copyright 2008 (C) 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 KIS_KRA_TAGS
 #define KIS_KRA_TAGS
 
 #include <QString>
 
 
 /**
  * Tag definitions for our xml file format
  */
 namespace KRA
 {
 
 // mimetype
 const QString NATIVE_MIMETYPE = "application/x-kra";
 
 // xml tags
 const QString SEPARATOR = "/";
 const QString SHAPE_LAYER_PATH = "/shapelayers/";
 const QString EXIF_PATH = "/annotations/exif";
 const QString ICC_PATH = "/annotations/icc";
 const QString ICC_PROOFING_PATH = "/annotations/proofing/icc";
 const QString LAYER_STYLES_PATH = "/annotations/layerstyles.asl";
 const QString ASSISTANTS_PATH = "/assistants/";
 const QString LAYER_PATH = "/layers/";
 const QString PALETTE_PATH = "/palettes/";
+const QString GAMUTMASK_PATH = "/gamutmask/";
 
 const QString ADJUSTMENT_LAYER = "adjustmentlayer";
 const QString CHANNEL_FLAGS = "channelflags";
 const QString CHANNEL_LOCK_FLAGS = "channellockflags";
 const QString CLONE_FROM = "clonefrom";
 const QString CLONE_FROM_UUID = "clonefromuuid";
 const QString CLONE_LAYER = "clonelayer";
 const QString CLONE_TYPE = "clonetype";
 const QString COLORSPACE_NAME = "colorspacename";
 const QString COMPOSITE_OP = "compositeop";
 const QString DESCRIPTION = "description";
 const QString ONION_SKIN_ENABLED = "onionskin";
 const QString VISIBLE_IN_TIMELINE = "intimeline";
 
 const QString DOT_FILTERCONFIG = ".filterconfig";
 const QString DOT_TRANSFORMCONFIG = ".transformconfig";
 const QString DOT_ICC = ".icc";
 const QString DOT_PIXEL_SELECTION = ".pixelselection";
 const QString DOT_SHAPE_SELECTION = ".shapeselection";
 const QString DOT_SHAPE_LAYER = ".shapelayer";
 const QString DOT_COLORIZE_MASK = ".colorizemask";
 const QString DOT_METADATA = ".metadata";
 
 const QString FILE_NAME = "filename";
 const QString FILTER_MASK = "filtermask";
 const QString FILTER_NAME = "filtername";
 const QString FILTER_STATEGY = "filter_strategy";
 const QString FILTER_VERSION = "filterversion";
 const QString GENERATOR_LAYER = "generatorlayer";
 const QString GENERATOR_NAME = "generatorname";
 const QString GENERATOR_VERSION = "generatorversion";
 const QString GROUP_LAYER = "grouplayer";
 const QString HEIGHT = "height";
 const QString ICC = "icc";
 const QString LAYER = "layer";
 const QString LAYERS = "layers";
 const QString NODE_TYPE = "nodetype";
 const QString LOCKED = "locked";
 const QString MASK = "mask";
 const QString MASKS = "masks";
 const QString MIME = "mime";
 const QString NAME = "name";
 const QString OPACITY = "opacity";
 const QString COLLAPSED = "collapsed";
 const QString COLOR_LABEL = "colorlabel";
 const QString PAINT_LAYER = "paintlayer";
 const QString PROFILE = "profile";
 const QString ROTATION = "rotation";
 const QString SELECTION_MASK = "selectionmask";
 const QString SHAPE_LAYER = "shapelayer";
 const QString REFERENCE_IMAGES_LAYER = "referenceimages";
 const QString FILE_LAYER = "filelayer";
 const QString TRANSPARENCY_MASK = "transparencymask";
 const QString COLORIZE_MASK = "colorizemask";
 const QString COLORIZE_SHOW_COLORING = "show-coloring";
 const QString COLORIZE_EDIT_KEYSTROKES = "edit-keystrokes";
 const QString COLORIZE_KEYSTROKE = "keystroke";
 const QString COLORIZE_KEYSTROKE_COLOR = "color";
 const QString COLORIZE_KEYSTROKE_IS_TRANSPARENT = "is-transparent";
 const QString COLORIZE_COLORING_DEVICE = "colorize-coloring";
 const QString COLORIZE_KEYSTROKES_SECTION = "keystrokes";
 const QString COLORIZE_USE_EDGE_DETECTION = "use-edge-detection";
 const QString COLORIZE_EDGE_DETECTION_SIZE = "edge-detection-size";
 const QString COLORIZE_FUZZY_RADIUS = "fuzzy-radius";
 const QString COLORIZE_CLEANUP = "cleanup";
 const QString COLORIZE_LIMIT_TO_DEVICE = "limit-to-device";
 const QString TRANSFORM_MASK = "transformmask";
 const QString UUID = "uuid";
 const QString VISIBLE = "visible";
 const QString WIDTH = "width";
 const QString X = "x";
 const QString X_RESOLUTION = "x-res";
 const QString X_SCALE = "x_scale";
 const QString X_SHEAR = "x_shear";
 const QString X_TRANSLATION = "x_translation";
 const QString Y = "y";
 const QString Y_RESOLUTION = "y-res";
 const QString Y_SCALE = "y_scale";
 const QString Y_SHEAR = "y_shear";
 const QString Y_TRANSLATION = "y_translation";
 const QString ACTIVE = "active";
 const QString LAYER_STYLE_UUID = "layerstyle";
 const QString PASS_THROUGH_MODE = "passthrough";
 const QString KEYFRAME_FILE = "keyframes";
 const QString PROOFINGPROFILENAME = "proofing-profile-name";
 const QString PROOFINGMODEL = "proofing-model";
 const QString PROOFINGDEPTH = "proofing-depth";
 const QString PROOFINGINTENT = "proofing-intent";
 const QString PROOFINGWARNINGCOLOR ="ProofingWarningColor";
 const QString PROOFINGADAPTATIONSTATE = "proofing-adaptation-state";
 const QString ICCPROOFINGPROFILE ="icc-proofing-profile";
 const QString CANVASPROJECTIONCOLOR = "ProjectionBackgroundColor";
 const QString COLORBYTEDATA = "ColorData";
 const QString SIMPLECOLORDATA = "SimpleColorData"; // easier 8-bit color data that works well with XML
 const QString GLOBALASSISTANTSCOLOR = "GlobalAssistantsColor";
 const QString PALETTES = "Palettes";
+
+const QString GAMUTMASK_ROOT = "GamutMask";
+const QString GAMUTMASK_RESOURCE = "GamutMaskResource";
 }
 
 
 
 #endif