diff --git a/libs/ui/KisDocument.cpp b/libs/ui/KisDocument.cpp
index 854d8fa525..a79b9a0bfe 100644
--- a/libs/ui/KisDocument.cpp
+++ b/libs/ui/KisDocument.cpp
@@ -1,2071 +1,2072 @@
 /* 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 <KisImportExportErrorCode.h>
 #include <KoDocumentResourceManager.h>
 
 #include <KisUsageLogger.h>
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kis_generator_layer.h>
 #include <kis_generator_registry.h>
 #include <kdesktopfile.h>
 #include <kconfiggroup.h>
 #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_image_animation_interface.h>
 #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"
 
 #include <KisMirrorAxisConfig.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())
         , 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)
         , mirrorAxisConfig(rhs.mirrorAxisConfig)
         , 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!
+        , assistants(KisPaintingAssistant::cloneAssistantList(rhs.assistants)) // WARNING: assistants should not store pointers to the document!
         , globalAssistantsColor(rhs.globalAssistantsColor)
         , paletteList(rhs.paletteList)
         , 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;
     KisMirrorAxisConfig mirrorAxisConfig;
 
     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;
 
     KisGridConfig gridConfig;
 
     StdLockableWrapper<QMutex> savingLock;
 
     bool modifiedWhileSaving = false;
     QScopedPointer<KisDocument> backgroundSaveDocument;
     QPointer<KoUpdater> savingUpdater;
     QFuture<KisImportExportErrorCode> 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())));
         }
     }
 
     void copyFrom(const Private &rhs, KisDocument *q);
 
     class StrippedSafeSavingLocker;
 };
 
 void KisDocument::Private::copyFrom(const Private &rhs, KisDocument *q)
 {
     delete docInfo;
     docInfo = (new KoDocumentInfo(*rhs.docInfo, q));
     unit = rhs.unit;
-//        , importExportManager(new KisImportExportManager(q))
     mimeType = rhs.mimeType;
     outputMimeType = rhs.outputMimeType;
     // TODO: undo stacks may store pointers to the document and/or image
     // we *have* to destroy the original one
     //delete undoStack;
     //undoStack = new UndoStack(q);
     q->setGuidesConfig(rhs.guidesConfig);
     q->setMirrorAxisConfig(rhs.mirrorAxisConfig);
     m_bAutoDetectedMime = rhs.m_bAutoDetectedMime;
     m_url = rhs.m_url;
     m_file = rhs.m_file;
     q->setModified(rhs.modified);
     readwrite = rhs.readwrite;
     firstMod = rhs.firstMod;
     lastMod = rhs.lastMod;
-    // TODO clone assistants
-    assistants = (rhs.assistants); // WARNING: assistants should not store pointers to the document!
+    // XXX: the display properties will be shared between different snapshots
+    assistants = KisPaintingAssistant::cloneAssistantList(rhs.assistants);
     globalAssistantsColor = rhs.globalAssistantsColor;
     paletteList = rhs.paletteList;
-    gridConfig = rhs.gridConfig;
+    q->setGridConfig(rhs.gridConfig);
     batchMode = rhs.batchMode;
 }
 
 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);
     d->shapeController->resourceManager()->setGlobalShapeController(d->koShapeController);
 
     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);
     d->shapeController->resourceManager()->setGlobalShapeController(d->koShapeController);
 
     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, ImportExportCodes::NoAccessToWrite,
                                    i18n("%1 cannot be written to. Please save under a different name.", job.filePath));
         //return ImportExportCodes::NoAccessToWrite;
         return false;
     }
 
     KisConfig cfg(true);
     if (cfg.backupFile() && filePathInfo.exists()) {
 
         QString backupDir;
 
         switch(cfg.readEntry<int>("backupfilelocation", 0)) {
         case 1:
             backupDir = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
             break;
         case 2:
             backupDir = QStandardPaths::writableLocation(QStandardPaths::TempLocation);
             break;
         default:
             // Do nothing: the empty string is user file location
             break;
         }
 
         int numOfBackupsKept = cfg.readEntry<int>("numberofbackupfiles", 1);
         QString suffix = cfg.readEntry<QString>("backupfilesuffix", "~");
 
         if (numOfBackupsKept == 1) {
             KBackup::simpleBackupFile(job.filePath, backupDir, suffix);
         }
         else if (numOfBackupsKept > 2) {
             KBackup::numberedBackupFile(job.filePath, backupDir, suffix, numOfBackupsKept);
         }
     }
 
     //KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!job.mimeType.isEmpty(), false);
     if (job.mimeType.isEmpty()) {
 
         KisImportExportErrorCode error = ImportExportCodes::FileFormatIncorrect;
         slotCompleteSavingDocument(job, error, error.errorMessage());
         return false;
 
     }
 
     const QString actionName =
         job.flags & KritaUtils::SaveIsExporting ?
         i18n("Exporting Document...") :
         i18n("Saving Document...");
 
     bool started =
         initiateSavingInBackground(actionName,
                                    this, SLOT(slotCompleteSavingDocument(KritaUtils::ExportFileJob, KisImportExportErrorCode ,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;
     }
 
     KisUsageLogger::log(QString("Exporting Document: %1 as %2. %3 * %4 pixels, %5 layers, %6 frames, %7 framerate. Export configuration: %8")
                         .arg(url.toLocalFile())
                         .arg(QString::fromLatin1(mimeType))
                         .arg(d->image->width())
                         .arg(d->image->height())
                         .arg(d->image->nlayers())
                         .arg(d->image->animationInterface()->totalLength())
                         .arg(d->image->animationInterface()->framerate())
                         .arg(exportConfiguration ? exportConfiguration->toXML() : "No configuration"));
 
     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;
 
     KisUsageLogger::log(QString("Saving Document %9 as %1 (mime: %2). %3 * %4 pixels, %5 layers.  %6 frames, %7 framerate. Export configuration: %8")
                         .arg(_url.toLocalFile())
                         .arg(QString::fromLatin1(mimeType))
                         .arg(d->image->width())
                         .arg(d->image->height())
                         .arg(d->image->nlayers())
                         .arg(d->image->animationInterface()->totalLength())
                         .arg(d->image->animationInterface()->framerate())
                         .arg(exportConfiguration ? exportConfiguration->toXML() : "No configuration")
                         .arg(url().toLocalFile()));
 
 
     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).isOk()) {
         qWarning() << "serializeToByteArray():: Could not export to our native format";
     }
 
     return byteArray;
 }
 
 void KisDocument::slotCompleteSavingDocument(const KritaUtils::ExportFileJob &job, KisImportExportErrorCode status, const QString &errorMessage)
 {
     if (status.isCancelled())
         return;
 
     const QString fileName = QFileInfo(job.filePath).fileName();
 
     if (!status.isOk()) {
         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);
 }
 
 void KisDocument::copyFromDocument(const KisDocument &rhs)
 {
     d->copyFrom(*(rhs.d), this);
     connect(d->undoStack, SIGNAL(cleanChanged(bool)), this, SLOT(slotUndoStackCleanChanged(bool)));
     setObjectName(rhs.objectName());
 
     slotConfigChanged();
 
     if (rhs.d->image) {
         d->image->barrierLock(/* readOnly = */ false);
         rhs.d->image->barrierLock(/* readOnly = */ true);
         d->image->copyFromImage(*(rhs.d->image));
         d->image->unlock();
         rhs.d->image->unlock();
         setCurrentImage(d->image, /* forceInitialUpdate = */ true);
     }
 
     if (rhs.d->preActivatedNode) {
         QQueue<KisNodeSP> linearizedNodes;
         KisLayerUtils::recursiveApplyNodes(rhs.d->image->root(),
                                            [&linearizedNodes](KisNodeSP node) {
                                                linearizedNodes.enqueue(node);
                                            });
         KisLayerUtils::recursiveApplyNodes(d->image->root(),
                                            [&linearizedNodes, &rhs, this](KisNodeSP node) {
                                                KisNodeSP refNode = linearizedNodes.dequeue();
                                                if (rhs.d->preActivatedNode.data() == refNode.data()) {
                                                    d->preActivatedNode = node;
                                                }
                                            });
     }
 }
 
 bool KisDocument::exportDocumentSync(const QUrl &url, const QByteArray &mimeType, KisPropertiesConfigurationSP exportConfiguration)
 {
     {
 
         /**
          * The caller guarantees that noone else uses the document (usually,
          * it is a temporary docuent created specifically for exporting), so
          * we don't need to copy or lock the document. Instead we should just
          * ensure the barrier lock is synced and then released.
          */
         Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
         if (!locker.successfullyLocked()) {
             return false;
         }
     }
 
     d->savingImage = d->image;
 
     const QString fileName = url.toLocalFile();
 
     KisImportExportErrorCode status =
             d->importExportManager->
             exportDocument(fileName, fileName, mimeType, false, exportConfiguration);
 
     d->savingImage = 0;
 
     return status.isOk();
 }
 
 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;
     }
 
     auto waitForImage = [] (KisImageSP image) {
         KisMainWindow *window = KisPart::instance()->currentMainwindow();
         if (window) {
             if (window->viewManager()) {
                 window->viewManager()->blockUntilOperationsFinishedForced(image);
             }
         }
     };
 
     {
         KisNodeSP newRoot = clonedDocument->image()->root();
         KIS_SAFE_ASSERT_RECOVER(!KisLayerUtils::hasDelayedNodeWithUpdates(newRoot)) {
             KisLayerUtils::forceAllDelayedNodesUpdate(newRoot);
             waitForImage(clonedDocument->image());
         }
     }
 
     KIS_SAFE_ASSERT_RECOVER(clonedDocument->image()->isIdle()) {
         waitForImage(clonedDocument->image());
     }
 
     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(KisImportExportErrorCode, QString)),
             this,
             SLOT(slotChildCompletedSavingInBackground(KisImportExportErrorCode, QString)));
 
 
     connect(this, SIGNAL(sigCompleteBackgroundSaving(KritaUtils::ExportFileJob, KisImportExportErrorCode, 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(KisImportExportErrorCode 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();
 
     KisUsageLogger::log(QString("Completed saving %1 (mime: %2). Result: %3")
                         .arg(job.filePath)
                         .arg(QString::fromLatin1(job.mimeType))
                         .arg(!status.isOk() ? exportErrorToUserMessage(status, errorMessage) : "OK"));
 
     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, KisImportExportErrorCode, 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, KisImportExportErrorCode status, const QString &errorMessage)
 {
     Q_UNUSED(job);
 
     const QString fileName = QFileInfo(job.filePath).fileName();
 
     if (!status.isOk()) {
         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);
         }
     }
 
     KisImportExportErrorCode initializationStatus(ImportExportCodes::OK);
     d->childSavingFuture =
             d->importExportManager->exportDocumentAsyc(location,
                                                        realLocation,
                                                        mimeType,
                                                        initializationStatus,
                                                        showWarnings,
                                                        exportConfiguration);
 
     if (!initializationStatus.isOk()) {
         if (d->savingUpdater) {
             d->savingUpdater->cancel();
         }
         d->savingImage.clear();
         emit sigBackgroundSavingFinished(initializationStatus, initializationStatus.errorMessage());
         return false;
     }
 
     typedef QFutureWatcher<KisImportExportErrorCode> 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(ImportExportCodes::InternalError, "");
         return;
     }
 
    KisImportExportErrorCode status =
             d->childSavingFuture.result();
     const QString errorMessage = status.errorMessage();
 
     d->savingImage.clear();
     d->childSavingFuture = QFuture<KisImportExportErrorCode>();
     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");
     QString prefix = KisConfig(true).readEntry<bool>("autosavefileshidden") ? QString(".") : QString();
     QRegularExpression autosavePattern1("^\\..+-autosave.kra$");
     QRegularExpression autosavePattern2("^.+-autosave.kra$");
 
     QFileInfo fi(path);
     QString dir = fi.absolutePath();
     QString filename = fi.fileName();
 
     if (path.isEmpty() || autosavePattern1.match(filename).hasMatch() || autosavePattern2.match(filename).hasMatch() || !fi.isWritable()) {
         // 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%7%3-%4-%5-autosave%6").arg(QDir::tempPath()).arg(QDir::separator()).arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension).arg(prefix);
 #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%7%3-%4-%5-autosave%6").arg(QDir::homePath()).arg(QDir::separator()).arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension).arg(prefix);
 #endif
     } else {
         retval = QString("%1%2%5%3-autosave%4").arg(dir).arg(QDir::separator()).arg(filename).arg(extension).arg(prefix);
     }
 
     //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 (ret) {
 
             if (!(flags & DontAddToRecent)) {
                 KisPart::instance()->addRecentURLToAllMainWindows(_url);
             }
 
             // 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();
     KoUpdaterPtr updater;
     if (window && window->viewManager()) {
         updater = window->viewManager()->createUnthreadedUpdater(i18n("Opening document"));
         d->importExportManager->setUpdater(updater);
     }
 
     KisImportExportErrorCode status = d->importExportManager->importDocument(localFilePath(), typeName);
 
     if (!status.isOk()) {
         if (window && window->viewManager()) {
             updater->cancel();
         }
         QString msg = status.errorMessage();
         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);
     }
 
     QList<QRegularExpression> expressions;
 
     expressions << QRegularExpression("^\\..+-autosave.kra$")
                 << QRegularExpression("^.+-autosave.kra$");
 
     Q_FOREACH(const QRegularExpression &rex, expressions) {
         if (wasRecovered &&
                 !autosaveBaseName.isEmpty() &&
                 rex.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);
 
     if (d->undoStack->undoLimit() != cfg.undoStackLimit()) {
         if (!d->undoStack->isClean()) {
             d->undoStack->clear();
         }
         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;
+    if (d->gridConfig != config) {
+        d->gridConfig = config;
+        emit sigGridConfigChanged(config);
+    }
 }
 
 QList<KoColorSet *> &KisDocument::paletteList()
 {
     return d->paletteList;
 }
 
 void KisDocument::setPaletteList(const QList<KoColorSet *> &paletteList)
 {
     d->paletteList = paletteList;
 }
 
 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);
 }
 
 const KisMirrorAxisConfig& KisDocument::mirrorAxisConfig() const
 {
     return d->mirrorAxisConfig;
 }
 
 void KisDocument::setMirrorAxisConfig(const KisMirrorAxisConfig &config)
 {
     if (d->mirrorAxisConfig == config) {
         return;
     }
 
     d->mirrorAxisConfig = config;
     setModified(true);
 
     emit sigMirrorAxisConfigChanged();
 }
 
 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, KisConfig::BackgroundStyle bgStyle,
                            int numberOfLayers,
                            const QString &description, const double imageResolution)
 {
     Q_ASSERT(cs);
 
     KisImageSP image;
 
     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);
 
     KisLayerSP layer;
     if (bgStyle == KisConfig::RASTER_LAYER || bgStyle == KisConfig::FILL_LAYER) {
         KoColor strippedAlpha = bgColor;
         strippedAlpha.setOpacity(OPACITY_OPAQUE_U8);
 
         if (bgStyle == KisConfig::RASTER_LAYER) {
             layer = new KisPaintLayer(image.data(), "Background", OPACITY_OPAQUE_U8, cs);;
             layer->paintDevice()->setDefaultPixel(strippedAlpha);
         } else if (bgStyle == KisConfig::FILL_LAYER) {
             KisFilterConfigurationSP filter_config = KisGeneratorRegistry::instance()->get("color")->defaultConfiguration();
             filter_config->setProperty("color", strippedAlpha.toQColor());
             layer = new KisGeneratorLayer(image.data(), "Background Fill", filter_config, image->globalSelection());
         }
 
         layer->setOpacity(bgColor.opacityU8());
 
         if (numberOfLayers > 1) {
             //Lock bg layer if others are present.
             layer->setUserLocked(true);
         }
     }
     else { // KisConfig::CANVAS_COLOR (needs an unlocked starting layer).
         image->setDefaultProjectionColor(bgColor);
         layer = new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
     }
 
     Q_CHECK_PTR(layer);
     image->addNode(layer.data(), image->rootLayer().data());
     layer->setDirty(QRect(0, 0, width, height));
 
     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());
 
     KisUsageLogger::log(i18n("Created image \"%1\", %2 * %3 pixels, %4 dpi. Color model: %6 %5 (%7). Layers: %8"
                              , name
                              , width, height
                              , imageResolution * 72.0
                              , image->colorSpace()->colorModelId().name(), image->colorSpace()->colorDepthId().name()
                              , image->colorSpace()->profile()->name()
                              , numberOfLayers));
 
     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(KisImportExportErrorCode status, const QString &errorMessage)
 {
     return errorMessage.isEmpty() ? status.errorMessage() : 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 d9afc646b4..5c900aa84d 100644
--- a/libs/ui/KisDocument.h
+++ b/libs/ui/KisDocument.h
@@ -1,670 +1,672 @@
 /* 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 <kis_config.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 KisMirrorAxisConfig;
 class QDomDocument;
 class KisReferenceImagesLayer;
 
 #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);
 
     /**
      * Exports he document is a synchronous way. The caller must ensure that the
      * image is not accessed by any other actors, because the exporting happens
      * without holding the image lock.
      */
     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);
 
     const KisMirrorAxisConfig& mirrorAxisConfig() const;
     void setMirrorAxisConfig(const KisMirrorAxisConfig& config);
 
     QList<KoColorSet *> &paletteList();
     void setPaletteList(const QList<KoColorSet *> &paletteList);
 
     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(KisImportExportErrorCode status, const QString &errorMessage);
 
     void sigCompleteBackgroundSaving(const KritaUtils::ExportFileJob &job, KisImportExportErrorCode status, const QString &errorMessage);
 
     void sigReferenceImagesChanged();
 
     void sigMirrorAxisConfigChanged();
 
+    void sigGridConfigChanged(const KisGridConfig &config);
+
 private Q_SLOTS:
     void finishExportInBackground();
     void slotChildCompletedSavingInBackground(KisImportExportErrorCode status, const QString &errorMessage);
     void slotCompleteAutoSaving(const KritaUtils::ExportFileJob &job, KisImportExportErrorCode status, const QString &errorMessage);
 
     void slotCompleteSavingDocument(const KritaUtils::ExportFileJob &job, KisImportExportErrorCode 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, KisConfig::BackgroundStyle bgStyle,
                   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();
 
 public:
     /**
      * @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();
 
     void copyFromDocument(const KisDocument &rhs);
 
 private:
 
     QString exportErrorToUserMessage(KisImportExportErrorCode 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/libs/ui/canvas/kis_grid_manager.cpp b/libs/ui/canvas/kis_grid_manager.cpp
index 2efdce6d07..1e4132a644 100644
--- a/libs/ui/canvas/kis_grid_manager.cpp
+++ b/libs/ui/canvas/kis_grid_manager.cpp
@@ -1,132 +1,152 @@
 /*
  * This file is part of Krita
  *
  *  Copyright (c) 2006 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_grid_manager.h"
 
 #include <QAction>
 #include <ktoggleaction.h>
 #include <kactioncollection.h>
 #include <klocalizedstring.h>
 
 #include <kis_icon.h>
 
 #include "kis_canvas2.h"
 #include "kis_coordinates_converter.h"
 #include "kis_config.h"
 #include "kis_grid_decoration.h"
 #include "kis_image.h"
 #include "KisViewManager.h"
 #include "KisDocument.h"
 #include "KisView.h"
 #include "kis_grid_config.h"
 #include "kis_signals_blocker.h"
+#include <kis_signal_auto_connection.h>
 
+struct KisGridManager::Private
+{
+    KisAction *toggleGrid;
+    KisAction* toggleSnapToGrid;
+
+    QPointer<KisView> imageView;
+    KisGridDecoration* gridDecoration;
+
+    bool blockModifiedSignal;
+    KisSignalAutoConnectionsStore connections;
+};
 
 KisGridManager::KisGridManager(KisViewManager * parent)
     : QObject(parent)
+    , m_d(new Private)
 {
 
 }
 
 KisGridManager::~KisGridManager()
 {
 
 }
 
 void KisGridManager::setGridConfig(const KisGridConfig &config)
 {
     setGridConfigImpl(config, true);
 }
 
 void KisGridManager::setGridConfigImpl(const KisGridConfig &config, bool /*emitModified*/)
 {
-    if (!m_imageView) return;
+    if (!m_d->imageView) return;
 
     config.saveStaticData();
-    m_imageView->document()->setGridConfig(config);
+    m_d->imageView->document()->setGridConfig(config);
 
-    m_gridDecoration->setGridConfig(config);
-    m_gridDecoration->setVisible(config.showGrid());
+    m_d->gridDecoration->setGridConfig(config);
+    m_d->gridDecoration->setVisible(config.showGrid());
 
-    m_toggleGrid->setChecked(config.showGrid());
-    m_toggleSnapToGrid->setChecked(config.snapToGrid());
+    m_d->toggleGrid->setChecked(config.showGrid());
+    m_d->toggleSnapToGrid->setChecked(config.snapToGrid());
 }
 
 void KisGridManager::setup(KisActionManager* actionManager)
 {
-    m_toggleGrid = actionManager->createAction("view_grid");
-    connect(m_toggleGrid, SIGNAL(toggled(bool)), this, SLOT(slotChangeGridVisibilityTriggered(bool)));
+    m_d->toggleGrid = actionManager->createAction("view_grid");
+    connect(m_d->toggleGrid, SIGNAL(toggled(bool)), this, SLOT(slotChangeGridVisibilityTriggered(bool)));
 
-    m_toggleSnapToGrid  = actionManager->createAction("view_snap_to_grid");
-    connect(m_toggleSnapToGrid, SIGNAL(toggled(bool)), this, SLOT(slotSnapToGridTriggered(bool)));
+    m_d->toggleSnapToGrid  = actionManager->createAction("view_snap_to_grid");
+    connect(m_d->toggleSnapToGrid, SIGNAL(toggled(bool)), this, SLOT(slotSnapToGridTriggered(bool)));
 }
 
 void KisGridManager::updateGUI()
 {
 
 }
 
 void KisGridManager::setView(QPointer<KisView> imageView)
 {
-    if (m_imageView) {
-        m_gridDecoration = 0;
+    if (m_d->imageView) {
+        m_d->connections.clear();
+        m_d->gridDecoration = 0;
     }
 
-    m_imageView = imageView;
+    m_d->imageView = imageView;
 
     if (imageView) {
-        m_gridDecoration = qobject_cast<KisGridDecoration*>(imageView->canvasBase()->decoration("grid").data());
-        if (!m_gridDecoration) {
-            m_gridDecoration = new KisGridDecoration(imageView);
-            imageView->canvasBase()->addDecoration(m_gridDecoration);
+        if (!imageView->document()) {
+            return;
+        }
+
+        m_d->gridDecoration = qobject_cast<KisGridDecoration*>(imageView->canvasBase()->decoration("grid").data());
+        if (!m_d->gridDecoration) {
+            m_d->gridDecoration = new KisGridDecoration(imageView);
+            imageView->canvasBase()->addDecoration(m_d->gridDecoration);
         }
+        m_d->connections.addConnection(imageView->document(), SIGNAL(sigGridConfigChanged(KisGridConfig)),
+                                       this, SIGNAL(sigRequestUpdateGridConfig(KisGridConfig)));
 
         KisGridConfig config = imageView->document()->gridConfig();
         setGridConfigImpl(config, false);
 
-        KisSignalsBlocker blocker(m_toggleGrid, m_toggleSnapToGrid);
+        KisSignalsBlocker blocker(m_d->toggleGrid, m_d->toggleSnapToGrid);
         Q_UNUSED(blocker);
-        m_toggleGrid->setChecked(config.showGrid());
-        m_toggleSnapToGrid->setChecked(config.snapToGrid());
+        m_d->toggleGrid->setChecked(config.showGrid());
+        m_d->toggleSnapToGrid->setChecked(config.snapToGrid());
     }
 }
 
 void KisGridManager::slotChangeGridVisibilityTriggered(bool value)
 {
-    if (!m_imageView) return;
+    if (!m_d->imageView) return;
 
-    KisGridConfig config = m_imageView->document()->gridConfig();
+    KisGridConfig config = m_d->imageView->document()->gridConfig();
     config.setShowGrid(value);
 
     setGridConfig(config);
     emit sigRequestUpdateGridConfig(config);
 }
 
 void KisGridManager::slotSnapToGridTriggered(bool value)
 {
-    if (!m_imageView) return;
+    if (!m_d->imageView) return;
 
-    KisGridConfig config = m_imageView->document()->gridConfig();
+    KisGridConfig config = m_d->imageView->document()->gridConfig();
     config.setSnapToGrid(value);
 
     setGridConfig(config);
     emit sigRequestUpdateGridConfig(config);
 }
 
diff --git a/libs/ui/canvas/kis_grid_manager.h b/libs/ui/canvas/kis_grid_manager.h
index 51ff7a45d8..84650530f4 100644
--- a/libs/ui/canvas/kis_grid_manager.h
+++ b/libs/ui/canvas/kis_grid_manager.h
@@ -1,76 +1,72 @@
 /*
  * This file is part of Krita
  *
  *  Copyright (c) 2006 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_GRID_MANAGER_H
 #define KIS_GRID_MANAGER_H
 
 #include <QPainter>
 
 #include "kis_types.h"
 #include <kritaui_export.h>
 #include "kis_action_manager.h"
 #include "kis_action.h"
 
 class KisGridDecoration;
 class KisViewManager;
 class KisGridConfig;
 
 
 class KRITAUI_EXPORT KisGridManager : public QObject
 {
     Q_OBJECT
 public:
     KisGridManager(KisViewManager * parent);
     ~KisGridManager() override;
 public:
 
     void setup(KisActionManager * actionManager);
     void setView(QPointer<KisView>imageView);
 
     void setGridConfig(const KisGridConfig &config);
 
 Q_SIGNALS:
     void sigRequestUpdateGridConfig(const KisGridConfig &config);
 
 public Q_SLOTS:
 
     void updateGUI();
 
 private Q_SLOTS:
 
     void slotChangeGridVisibilityTriggered(bool value);
     void slotSnapToGridTriggered(bool value);
 
 private:
     void setGridConfigImpl(const KisGridConfig &config, bool emitModified);
 
 private:
     void setFastConfig(int size);
 
-    KisAction *m_toggleGrid;
-    KisAction* m_toggleSnapToGrid;
-
-    QPointer<KisView> m_imageView;
-    KisGridDecoration* m_gridDecoration;
-
-    bool m_blockModifiedSignal;
+private:
+    struct Private;
+    QScopedPointer<Private> m_d;
 };
 
 #endif
diff --git a/libs/ui/kis_painting_assistant.cc b/libs/ui/kis_painting_assistant.cc
index 2b8767e657..6ab2106630 100644
--- a/libs/ui/kis_painting_assistant.cc
+++ b/libs/ui/kis_painting_assistant.cc
@@ -1,886 +1,896 @@
 /*
  *  Copyright (c) 2008,2011 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2010 Geoffry Song <goffrie@gmail.com>
  *  Copyright (c) 2017 Scott Petrovic <scottpetrovic@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <QXmlStreamReader>
 #include "kis_painting_assistant.h"
 #include "kis_coordinates_converter.h"
 #include "kis_debug.h"
 #include "kis_dom_utils.h"
 #include <kis_canvas2.h>
 #include "kis_tool.h"
 #include "kis_config.h"
 
 #include <KoStore.h>
 
 #include <QGlobalStatic>
 #include <QPen>
 #include <QPainter>
 #include <QPixmapCache>
 #include <QDomElement>
 #include <QDomDocument>
 
 Q_GLOBAL_STATIC(KisPaintingAssistantFactoryRegistry, s_instance)
 
 struct KisPaintingAssistantHandle::Private {
     QList<KisPaintingAssistant*> assistants;
     char handle_type;
 };
 
 KisPaintingAssistantHandle::KisPaintingAssistantHandle(double x, double y) : QPointF(x, y), d(new Private)
 {
 }
 
 KisPaintingAssistantHandle::KisPaintingAssistantHandle(QPointF p) : QPointF(p), d(new Private)
 {
 }
 
 KisPaintingAssistantHandle::KisPaintingAssistantHandle(const KisPaintingAssistantHandle& rhs)
     : QPointF(rhs)
     , KisShared()
     , d(new Private)
 {
     dbgUI << "KisPaintingAssistantHandle ctor";
 }
 
 KisPaintingAssistantHandle& KisPaintingAssistantHandle::operator=(const QPointF &  pt)
 {
     setX(pt.x());
     setY(pt.y());
     return *this;
 }
 
 void KisPaintingAssistantHandle::setType(char type)
 {
     d->handle_type = type;
 }
 
 char KisPaintingAssistantHandle::handleType() const
 {
     return d->handle_type;
 }
 
 KisPaintingAssistantHandle::~KisPaintingAssistantHandle()
 {
     Q_ASSERT(d->assistants.empty());
     delete d;
 }
 
 void KisPaintingAssistantHandle::registerAssistant(KisPaintingAssistant* assistant)
 {
     Q_ASSERT(!d->assistants.contains(assistant));
     d->assistants.append(assistant);
 }
 
 void KisPaintingAssistantHandle::unregisterAssistant(KisPaintingAssistant* assistant)
 {
     d->assistants.removeOne(assistant);
     Q_ASSERT(!d->assistants.contains(assistant));
 }
 
 bool KisPaintingAssistantHandle::containsAssistant(KisPaintingAssistant* assistant) const
 {
     return d->assistants.contains(assistant);
 }
 
 void KisPaintingAssistantHandle::mergeWith(KisPaintingAssistantHandleSP handle)
 {
     if(this->handleType()== HandleType::NORMAL || handle.data()->handleType()== HandleType::SIDE) {
         return;
     }
 
 
     Q_FOREACH (KisPaintingAssistant* assistant, handle->d->assistants) {
         if (!assistant->handles().contains(this)) {
             assistant->replaceHandle(handle, this);
         }
     }
 }
 
 void KisPaintingAssistantHandle::uncache()
 {
     Q_FOREACH (KisPaintingAssistant* assistant, d->assistants) {
         assistant->uncache();
     }
 }
 
 struct KisPaintingAssistant::Private {
     Private();
     explicit Private(const Private &rhs);
     KisPaintingAssistantHandleSP reuseOrCreateHandle(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap, KisPaintingAssistantHandleSP origHandle, KisPaintingAssistant *q);
     QList<KisPaintingAssistantHandleSP> handles, sideHandles;
     KisPaintingAssistantHandleSP topLeft, bottomLeft, topRight, bottomRight, topMiddle, bottomMiddle, rightMiddle, leftMiddle;
 
     // share everything except handles between the clones
     struct SharedData {
         QString id;
         QString name;
         bool isSnappingActive;
         bool outlineVisible;
         KisCanvas2* m_canvas = 0;
 
         QPixmapCache::Key cached;
         QRect cachedRect; // relative to boundingRect().topLeft()
 
         struct TranslationInvariantTransform {
             qreal m11, m12, m21, m22;
             TranslationInvariantTransform() { }
             TranslationInvariantTransform(const QTransform& t) : m11(t.m11()), m12(t.m12()), m21(t.m21()), m22(t.m22()) { }
             bool operator==(const TranslationInvariantTransform& b) {
                 return m11 == b.m11 && m12 == b.m12 && m21 == b.m21 && m22 == b.m22;
             }
         } cachedTransform;
 
         QColor assistantGlobalColorCache = QColor(Qt::red);     // color to paint with if a custom color is not set
 
         bool useCustomColor = false;
         QColor assistantCustomColor = KisConfig(true).defaultAssistantsColor();
     };
 
     QSharedPointer<SharedData> s;
 };
 
 KisPaintingAssistant::Private::Private()
     : s(new SharedData)
 {
 }
 
 KisPaintingAssistant::Private::Private(const Private &rhs)
     : s(rhs.s)
 {
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::Private::reuseOrCreateHandle(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap, KisPaintingAssistantHandleSP origHandle, KisPaintingAssistant *q)
 {
     KisPaintingAssistantHandleSP mappedHandle = handleMap.value(origHandle);
     if (!mappedHandle) {
         if (origHandle) {
             dbgUI << "handle not found in the map, creating a new one...";
             mappedHandle = KisPaintingAssistantHandleSP(new KisPaintingAssistantHandle(*origHandle));
             dbgUI << "done";
             mappedHandle->setType(origHandle->handleType());
             handleMap.insert(origHandle, mappedHandle);
         } else {
             dbgUI << "orig handle is null, not doing anything";
             mappedHandle = KisPaintingAssistantHandleSP();
         }
     }
     if (mappedHandle) {
         mappedHandle->registerAssistant(q);
     }
     return mappedHandle;
 }
 
 bool KisPaintingAssistant::useCustomColor()
 {
     return d->s->useCustomColor;
 }
 
 void KisPaintingAssistant::setUseCustomColor(bool useCustomColor)
 {
     d->s->useCustomColor = useCustomColor;
 }
 
 void KisPaintingAssistant::setAssistantCustomColor(QColor color)
 {
     d->s->assistantCustomColor = color;
 }
 
 QColor KisPaintingAssistant::assistantCustomColor()
 {
     return d->s->assistantCustomColor;
 }
 
 void KisPaintingAssistant::setAssistantGlobalColorCache(const QColor &color)
 {
     d->s->assistantGlobalColorCache = color;
 }
 
 QColor KisPaintingAssistant::effectiveAssistantColor() const
 {
     return d->s->useCustomColor ? d->s->assistantCustomColor : d->s->assistantGlobalColorCache;
 }
 
 KisPaintingAssistant::KisPaintingAssistant(const QString& id, const QString& name) : d(new Private)
 {
     d->s->id = id;
     d->s->name = name;
     d->s->isSnappingActive = true;
     d->s->outlineVisible = true;
 }
 
 KisPaintingAssistant::KisPaintingAssistant(const KisPaintingAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap)
     : d(new Private(*(rhs.d)))
 {
     dbgUI << "creating handles...";
     Q_FOREACH (const KisPaintingAssistantHandleSP origHandle, rhs.d->handles) {
         d->handles << d->reuseOrCreateHandle(handleMap, origHandle, this);
     }
     Q_FOREACH (const KisPaintingAssistantHandleSP origHandle, rhs.d->sideHandles) {
         d->sideHandles << d->reuseOrCreateHandle(handleMap, origHandle, this);
     }
 #define _REUSE_H(name) d->name = d->reuseOrCreateHandle(handleMap, rhs.d->name, this)
     _REUSE_H(topLeft);
     _REUSE_H(bottomLeft);
     _REUSE_H(topRight);
     _REUSE_H(bottomRight);
     _REUSE_H(topMiddle);
     _REUSE_H(bottomMiddle);
     _REUSE_H(rightMiddle);
     _REUSE_H(leftMiddle);
 #undef _REUSE_H
     dbgUI << "done";
 }
 
 bool KisPaintingAssistant::isSnappingActive() const
 {
     return d->s->isSnappingActive;
 }
 
 void KisPaintingAssistant::setSnappingActive(bool set)
 {
     d->s->isSnappingActive = set;
 }
 
 
 void KisPaintingAssistant::drawPath(QPainter& painter, const QPainterPath &path, bool isSnappingOn)
 {
 
     QColor paintingColor = effectiveAssistantColor();
 
     if (!isSnappingOn) {
         paintingColor.setAlpha(0.2 * paintingColor.alpha());
     }
 
     painter.save();
     QPen pen_a(paintingColor, 2);
     pen_a.setCosmetic(true);
     painter.setPen(pen_a);
     painter.drawPath(path);
     painter.restore();
 }
 
 void KisPaintingAssistant::drawPreview(QPainter& painter, const QPainterPath &path)
 {
     painter.save();
     QPen pen_a(effectiveAssistantColor(), 1);
     pen_a.setStyle(Qt::SolidLine);
     pen_a.setCosmetic(true);
     painter.setPen(pen_a);
     painter.drawPath(path);
     painter.restore();
 }
 
 void KisPaintingAssistant::initHandles(QList<KisPaintingAssistantHandleSP> _handles)
 {
     Q_ASSERT(d->handles.isEmpty());
     d->handles = _handles;
     Q_FOREACH (KisPaintingAssistantHandleSP handle, _handles) {
         handle->registerAssistant(this);
     }
 }
 
 KisPaintingAssistant::~KisPaintingAssistant()
 {
     Q_FOREACH (KisPaintingAssistantHandleSP handle, d->handles) {
         handle->unregisterAssistant(this);
     }
     if(!d->sideHandles.isEmpty()) {
         Q_FOREACH (KisPaintingAssistantHandleSP handle, d->sideHandles) {
             handle->unregisterAssistant(this);
         }
     }
     delete d;
 }
 
 const QString& KisPaintingAssistant::id() const
 {
     return d->s->id;
 }
 
 const QString& KisPaintingAssistant::name() const
 {
     return d->s->name;
 }
 
 void KisPaintingAssistant::replaceHandle(KisPaintingAssistantHandleSP _handle, KisPaintingAssistantHandleSP _with)
 {
     Q_ASSERT(d->handles.contains(_handle));
     d->handles.replace(d->handles.indexOf(_handle), _with);
     Q_ASSERT(!d->handles.contains(_handle));
     _handle->unregisterAssistant(this);
     _with->registerAssistant(this);
 }
 
 void KisPaintingAssistant::addHandle(KisPaintingAssistantHandleSP handle, HandleType type)
 {
     Q_ASSERT(!d->handles.contains(handle));
     if (HandleType::SIDE == type) {
         d->sideHandles.append(handle);
     } else {
         d->handles.append(handle);
     }
 
     handle->registerAssistant(this);
     handle.data()->setType(type);
 }
 
 
 void KisPaintingAssistant::drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool useCache, KisCanvas2* canvas, bool assistantVisible, bool previewVisible)
 {
     Q_UNUSED(updateRect);
 
     Q_UNUSED(previewVisible);
 
     findPerspectiveAssistantHandleLocation();
 
     if (!useCache) {
         gc.save();
         drawCache(gc, converter, assistantVisible);
         gc.restore();
         return;
     }
 
     const QRect bound = boundingRect();
     if (bound.isEmpty()) {
         return;
     }
 
     const QTransform transform = converter->documentToWidgetTransform();
     const QRect widgetBound = transform.mapRect(bound);
 
     const QRect paintRect = transform.mapRect(bound).intersected(gc.viewport());
     if (paintRect.isEmpty()) return;
 
     QPixmap cached;
     bool found = QPixmapCache::find(d->s->cached, &cached);
 
     if (!(found &&
           d->s->cachedTransform == transform &&
           d->s->cachedRect.translated(widgetBound.topLeft()).contains(paintRect))) {
 
         const QRect cacheRect = gc.viewport().adjusted(-100, -100, 100, 100).intersected(widgetBound);
         Q_ASSERT(!cacheRect.isEmpty());
 
         if (cached.isNull() || cached.size() != cacheRect.size()) {
             cached = QPixmap(cacheRect.size());
         }
 
         cached.fill(Qt::transparent);
         QPainter painter(&cached);
         painter.setRenderHint(QPainter::Antialiasing);
         painter.setWindow(cacheRect);
         drawCache(painter, converter, assistantVisible);
         painter.end();
         d->s->cachedTransform = transform;
         d->s->cachedRect = cacheRect.translated(-widgetBound.topLeft());
         d->s->cached = QPixmapCache::insert(cached);
     }
 
     gc.drawPixmap(paintRect, cached, paintRect.translated(-widgetBound.topLeft() - d->s->cachedRect.topLeft()));
 
 
     if (canvas) {
         d->s->m_canvas = canvas;
     }
 }
 
 void KisPaintingAssistant::uncache()
 {
     d->s->cached = QPixmapCache::Key();
 }
 
 QRect KisPaintingAssistant::boundingRect() const
 {
     QRectF r;
     Q_FOREACH (KisPaintingAssistantHandleSP h, handles()) {
         r = r.united(QRectF(*h, QSizeF(1,1)));
     }
     return r.adjusted(-2, -2, 2, 2).toAlignedRect();
 }
 
 bool KisPaintingAssistant::isAssistantComplete() const
 {
     return true;
 }
 
 QByteArray KisPaintingAssistant::saveXml(QMap<KisPaintingAssistantHandleSP, int> &handleMap)
 {
     QByteArray data;
     QXmlStreamWriter xml(&data);
     xml.writeStartDocument();
     xml.writeStartElement("assistant");
     xml.writeAttribute("type",d->s->id);
     xml.writeAttribute("active", QString::number(d->s->isSnappingActive));
     xml.writeAttribute("useCustomColor", QString::number(d->s->useCustomColor));
     xml.writeAttribute("customColor",  KisDomUtils::qColorToQString(d->s->assistantCustomColor));
 
 
 
     saveCustomXml(&xml); // if any specific assistants have custom XML data to save to
 
     // write individual handle data
     xml.writeStartElement("handles");
     Q_FOREACH (const KisPaintingAssistantHandleSP handle, d->handles) {
         int id = handleMap.size();
         if (!handleMap.contains(handle)){
             handleMap.insert(handle, id);
         }
         id = handleMap.value(handle);
         xml.writeStartElement("handle");
         xml.writeAttribute("id", QString::number(id));
         xml.writeAttribute("x", QString::number(double(handle->x()), 'f', 3));
         xml.writeAttribute("y", QString::number(double(handle->y()), 'f', 3));
         xml.writeEndElement();
     }
     xml.writeEndElement();
     xml.writeEndElement();
     xml.writeEndDocument();
     return data;
 }
 
 void KisPaintingAssistant::saveCustomXml(QXmlStreamWriter* xml)
 {
     Q_UNUSED(xml);
 }
 
 void KisPaintingAssistant::loadXml(KoStore* store, QMap<int, KisPaintingAssistantHandleSP> &handleMap, QString path)
 {
     int id = 0;
     double x = 0.0, y = 0.0;
     store->open(path);
     QByteArray data = store->read(store->size());
     QXmlStreamReader xml(data);
     while (!xml.atEnd()) {
         switch (xml.readNext()) {
         case QXmlStreamReader::StartElement:
             if (xml.name() == "assistant") {
 
                 QStringRef active = xml.attributes().value("active");
                 setSnappingActive( (active != "0")  );
 
                 // load custom shared assistant properties
                 if ( xml.attributes().hasAttribute("useCustomColor")) {
                     QStringRef useCustomColor = xml.attributes().value("useCustomColor");
 
                     bool usingColor = false;
                     if (useCustomColor.toString() == "1") {
                         usingColor = true;
                     }
 
 
                     setUseCustomColor(usingColor);
                 }
 
                 if ( xml.attributes().hasAttribute("customColor")) {
                     QStringRef customColor = xml.attributes().value("customColor");
                     setAssistantCustomColor( KisDomUtils::qStringToQColor(customColor.toString()) );
 
                 }
 
             }
 
             loadCustomXml(&xml);
 
             if (xml.name() == "handle") {
                 QString strId = xml.attributes().value("id").toString(),
                         strX = xml.attributes().value("x").toString(),
                         strY = xml.attributes().value("y").toString();
                 if (!strId.isEmpty() && !strX.isEmpty() && !strY.isEmpty()) {
                     id = strId.toInt();
                     x = strX.toDouble();
                     y = strY.toDouble();
                     if (!handleMap.contains(id)) {
                         handleMap.insert(id, new KisPaintingAssistantHandle(x, y));
                     }
                 }
                 addHandle(handleMap.value(id), HandleType::NORMAL);
             }
             break;
         default:
             break;
         }
     }
     store->close();
 }
 
 bool KisPaintingAssistant::loadCustomXml(QXmlStreamReader* xml)
 {
     Q_UNUSED(xml);
     return true;
 }
 
 void KisPaintingAssistant::saveXmlList(QDomDocument& doc, QDomElement& assistantsElement,int count)
 {
     if (d->s->id == "ellipse"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "ellipse");
         assistantElement.setAttribute("filename", QString("ellipse%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->s->id == "spline"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "spline");
         assistantElement.setAttribute("filename", QString("spline%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->s->id == "perspective"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "perspective");
         assistantElement.setAttribute("filename", QString("perspective%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->s->id == "vanishing point"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "vanishing point");
         assistantElement.setAttribute("filename", QString("vanishing point%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->s->id == "infinite ruler"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "infinite ruler");
         assistantElement.setAttribute("filename", QString("infinite ruler%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->s->id == "parallel ruler"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "parallel ruler");
         assistantElement.setAttribute("filename", QString("parallel ruler%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->s->id == "concentric ellipse"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "concentric ellipse");
         assistantElement.setAttribute("filename", QString("concentric ellipse%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->s->id == "fisheye-point"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "fisheye-point");
         assistantElement.setAttribute("filename", QString("fisheye-point%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->s->id == "ruler"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "ruler");
         assistantElement.setAttribute("filename", QString("ruler%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
 }
 
 void KisPaintingAssistant::findPerspectiveAssistantHandleLocation() {
     QList<KisPaintingAssistantHandleSP> hHandlesList;
     QList<KisPaintingAssistantHandleSP> vHandlesList;
     uint vHole = 0,hHole = 0;
     KisPaintingAssistantHandleSP oppHandle;
     if (d->handles.size() == 4 && d->s->id == "perspective") {
         //get the handle opposite to the first handle
         oppHandle = oppHandleOne();
         //Sorting handles into two list, X sorted and Y sorted into hHandlesList and vHandlesList respectively.
         Q_FOREACH (const KisPaintingAssistantHandleSP handle,d->handles) {
             hHandlesList.append(handle);
             hHole = hHandlesList.size() - 1;
             vHandlesList.append(handle);
             vHole = vHandlesList.size() - 1;
             /*
              sort handles on the basis of X-coordinate
              */
             while(hHole > 0 && hHandlesList.at(hHole -1).data()->x() > handle.data()->x()) {
                 hHandlesList.swap(hHole-1, hHole);
                 hHole = hHole - 1;
             }
             /*
              sort handles on the basis of Y-coordinate
              */
             while(vHole > 0 && vHandlesList.at(vHole -1).data()->y() > handle.data()->y()) {
                 vHandlesList.swap(vHole-1, vHole);
                 vHole = vHole - 1;
             }
         }
 
         /*
          give the handles their respective positions
          */
         if(vHandlesList.at(0).data()->x() > vHandlesList.at(1).data()->x()) {
             d->topLeft = vHandlesList.at(1);
             d->topRight= vHandlesList.at(0);
         }
         else {
             d->topLeft = vHandlesList.at(0);
             d->topRight = vHandlesList.at(1);
         }
         if(vHandlesList.at(2).data()->x() > vHandlesList.at(3).data()->x()) {
             d->bottomLeft = vHandlesList.at(3);
             d->bottomRight = vHandlesList.at(2);
         }
         else {
             d->bottomLeft= vHandlesList.at(2);
             d->bottomRight = vHandlesList.at(3);
         }
 
         /*
          find if the handles that should be opposite are actually oppositely positioned
          */
         if (( (d->topLeft == d->handles.at(0).data() && d->bottomRight == oppHandle) ||
               (d->topLeft == oppHandle && d->bottomRight == d->handles.at(0).data()) ||
               (d->topRight == d->handles.at(0).data() && d->bottomLeft == oppHandle) ||
               (d->topRight == oppHandle && d->bottomLeft == d->handles.at(0).data()) ) )
         {}
         else {
             if(hHandlesList.at(0).data()->y() > hHandlesList.at(1).data()->y()) {
                 d->topLeft = hHandlesList.at(1);
                 d->bottomLeft= hHandlesList.at(0);
             }
             else {
                 d->topLeft = hHandlesList.at(0);
                 d->bottomLeft = hHandlesList.at(1);
             }
             if(hHandlesList.at(2).data()->y() > hHandlesList.at(3).data()->y()) {
                 d->topRight = hHandlesList.at(3);
                 d->bottomRight = hHandlesList.at(2);
             }
             else {
                 d->topRight= hHandlesList.at(2);
                 d->bottomRight = hHandlesList.at(3);
             }
 
         }
         /*
          Setting the middle handles as needed
          */
         if(!d->bottomMiddle && !d->topMiddle && !d->leftMiddle && !d->rightMiddle) {
             d->bottomMiddle = new KisPaintingAssistantHandle((d->bottomLeft.data()->x() + d->bottomRight.data()->x())*0.5,
                                                              (d->bottomLeft.data()->y() + d->bottomRight.data()->y())*0.5);
             d->topMiddle = new KisPaintingAssistantHandle((d->topLeft.data()->x() + d->topRight.data()->x())*0.5,
                                                           (d->topLeft.data()->y() + d->topRight.data()->y())*0.5);
             d->rightMiddle= new KisPaintingAssistantHandle((d->topRight.data()->x() + d->bottomRight.data()->x())*0.5,
                                                            (d->topRight.data()->y() + d->bottomRight.data()->y())*0.5);
             d->leftMiddle= new KisPaintingAssistantHandle((d->bottomLeft.data()->x() + d->topLeft.data()->x())*0.5,
                                                           (d->bottomLeft.data()->y() + d->topLeft.data()->y())*0.5);
             addHandle(d->rightMiddle.data(), HandleType::SIDE);
             addHandle(d->leftMiddle.data(), HandleType::SIDE);
             addHandle(d->bottomMiddle.data(), HandleType::SIDE);
             addHandle(d->topMiddle.data(), HandleType::SIDE);
         }
         else
         {
             d->bottomMiddle.data()->operator =(QPointF((d->bottomLeft.data()->x() + d->bottomRight.data()->x())*0.5,
                                                        (d->bottomLeft.data()->y() + d->bottomRight.data()->y())*0.5));
             d->topMiddle.data()->operator =(QPointF((d->topLeft.data()->x() + d->topRight.data()->x())*0.5,
                                                     (d->topLeft.data()->y() + d->topRight.data()->y())*0.5));
             d->rightMiddle.data()->operator =(QPointF((d->topRight.data()->x() + d->bottomRight.data()->x())*0.5,
                                                       (d->topRight.data()->y() + d->bottomRight.data()->y())*0.5));
             d->leftMiddle.data()->operator =(QPointF((d->bottomLeft.data()->x() + d->topLeft.data()->x())*0.5,
                                                      (d->bottomLeft.data()->y() + d->topLeft.data()->y())*0.5));
         }
 
     }
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::oppHandleOne()
 {
     QPointF intersection(0,0);
     if((QLineF(d->handles.at(0).data()->toPoint(),d->handles.at(1).data()->toPoint()).intersect(QLineF(d->handles.at(2).data()->toPoint(),d->handles.at(3).data()->toPoint()), &intersection) != QLineF::NoIntersection)
             && (QLineF(d->handles.at(0).data()->toPoint(),d->handles.at(1).data()->toPoint()).intersect(QLineF(d->handles.at(2).data()->toPoint(),d->handles.at(3).data()->toPoint()), &intersection) != QLineF::UnboundedIntersection))
     {
         return d->handles.at(1);
     }
     else if((QLineF(d->handles.at(0).data()->toPoint(),d->handles.at(2).data()->toPoint()).intersect(QLineF(d->handles.at(1).data()->toPoint(),d->handles.at(3).data()->toPoint()), &intersection) != QLineF::NoIntersection)
             && (QLineF(d->handles.at(0).data()->toPoint(),d->handles.at(2).data()->toPoint()).intersect(QLineF(d->handles.at(1).data()->toPoint(),d->handles.at(3).data()->toPoint()), &intersection) != QLineF::UnboundedIntersection))
     {
         return d->handles.at(2);
     }
     else
     {
         return d->handles.at(3);
     }
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::topLeft()
 {
     return d->topLeft;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::topLeft() const
 {
     return d->topLeft;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::bottomLeft()
 {
     return d->bottomLeft;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::bottomLeft() const
 {
     return d->bottomLeft;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::topRight()
 {
     return d->topRight;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::topRight() const
 {
     return d->topRight;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::bottomRight()
 {
     return d->bottomRight;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::bottomRight() const
 {
     return d->bottomRight;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::topMiddle()
 {
     return d->topMiddle;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::topMiddle() const
 {
     return d->topMiddle;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::bottomMiddle()
 {
     return d->bottomMiddle;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::bottomMiddle() const
 {
     return d->bottomMiddle;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::rightMiddle()
 {
     return d->rightMiddle;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::rightMiddle() const
 {
     return d->rightMiddle;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::leftMiddle()
 {
     return d->leftMiddle;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::leftMiddle() const
 {
     return d->leftMiddle;
 }
 
 const QList<KisPaintingAssistantHandleSP>& KisPaintingAssistant::handles() const
 {
     return d->handles;
 }
 
 QList<KisPaintingAssistantHandleSP> KisPaintingAssistant::handles()
 {
     return d->handles;
 }
 
 const QList<KisPaintingAssistantHandleSP>& KisPaintingAssistant::sideHandles() const
 {
     return d->sideHandles;
 }
 
 QList<KisPaintingAssistantHandleSP> KisPaintingAssistant::sideHandles()
 {
     return d->sideHandles;
 }
 
 
 
 bool KisPaintingAssistant::areTwoPointsClose(const QPointF& pointOne, const QPointF& pointTwo)
 {
     int m_handleSize = 16;
 
     QRectF handlerect(pointTwo - QPointF(m_handleSize * 0.5, m_handleSize * 0.5), QSizeF(m_handleSize, m_handleSize));
     return handlerect.contains(pointOne);
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::closestCornerHandleFromPoint(QPointF point)
 {
     if (!d->s->m_canvas) {
         return 0;
     }
 
 
     if (areTwoPointsClose(point, pixelToView(topLeft()->toPoint()))) {
         return topLeft();
     } else if (areTwoPointsClose(point, pixelToView(topRight()->toPoint()))) {
         return topRight();
     } else if (areTwoPointsClose(point, pixelToView(bottomLeft()->toPoint()))) {
         return bottomLeft();
     } else if (areTwoPointsClose(point, pixelToView(bottomRight()->toPoint()))) {
         return bottomRight();
     }
     return 0;
 }
 
 
 QPointF KisPaintingAssistant::pixelToView(const QPoint pixelCoords) const
 {
     QPointF documentCoord = d->s->m_canvas->image()->pixelToDocument(pixelCoords);
     return d->s->m_canvas->viewConverter()->documentToView(documentCoord);
 }
 
 double KisPaintingAssistant::norm2(const QPointF& p)
 {
     return p.x() * p.x() + p.y() * p.y();
 }
 
+QList<KisPaintingAssistantSP> KisPaintingAssistant::cloneAssistantList(const QList<KisPaintingAssistantSP> &list)
+{
+    QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> handleMap;
+    QList<KisPaintingAssistantSP> clonedList;
+    for (auto i = list.begin(); i != list.end(); ++i) {
+        clonedList << (*i)->clone(handleMap);
+    }
+    return clonedList;
+}
+
 
 
 /*
  * KisPaintingAssistantFactory classes
 */
 
 KisPaintingAssistantFactory::KisPaintingAssistantFactory()
 {
 }
 
 KisPaintingAssistantFactory::~KisPaintingAssistantFactory()
 {
 }
 
 KisPaintingAssistantFactoryRegistry::KisPaintingAssistantFactoryRegistry()
 {
 }
 
 KisPaintingAssistantFactoryRegistry::~KisPaintingAssistantFactoryRegistry()
 {
     Q_FOREACH (const QString &id, keys()) {
         delete get(id);
     }
     dbgRegistry << "deleting KisPaintingAssistantFactoryRegistry ";
 }
 
 KisPaintingAssistantFactoryRegistry* KisPaintingAssistantFactoryRegistry::instance()
 {
     return s_instance;
 }
 
diff --git a/libs/ui/kis_painting_assistant.h b/libs/ui/kis_painting_assistant.h
index 6f2150bf93..741194f449 100644
--- a/libs/ui/kis_painting_assistant.h
+++ b/libs/ui/kis_painting_assistant.h
@@ -1,237 +1,242 @@
 /*
  *  Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2017 Scott Petrovic <scottpetrovic@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef _KIS_PAINTING_ASSISTANT_H_
 #define _KIS_PAINTING_ASSISTANT_H_
 
 #include <QString>
 #include <QPointF>
 #include <QRect>
 #include <QFile>
 #include <QObject>
 #include <QColor>
 #include <QXmlStreamWriter>
 #include <QMap>
 
 #include <kritaui_export.h>
 #include <kis_shared.h>
 #include <kis_types.h>
 
 class QPainter;
 class QRect;
 class QRectF;
 class KoStore;
 class KisCoordinatesConverter;
 class KisCanvas2;
 class QDomDocument;
 class QDomElement;
 
 #include <kis_shared_ptr.h>
 #include <KoGenericRegistry.h>
 
 class KisPaintingAssistantHandle;
 typedef KisSharedPtr<KisPaintingAssistantHandle> KisPaintingAssistantHandleSP;
 class KisPaintingAssistant;
 class QPainterPath;
 
 enum HandleType {
     NORMAL,
     SIDE,
     CORNER,
     VANISHING_POINT,
     ANCHOR
 };
 
 
 /**
   * Represent an handle of the assistant, used to edit the parameters
   * of an assistants. Handles can be shared between assistants.
   */
 class KRITAUI_EXPORT KisPaintingAssistantHandle : public QPointF, public KisShared
 {
     friend class KisPaintingAssistant;
 
 public:
     KisPaintingAssistantHandle(double x, double y);
     explicit KisPaintingAssistantHandle(QPointF p);
     KisPaintingAssistantHandle(const KisPaintingAssistantHandle&);
     ~KisPaintingAssistantHandle();
     void mergeWith(KisPaintingAssistantHandleSP);
     void uncache();
     KisPaintingAssistantHandle& operator=(const QPointF&);
     void setType(char type);
     char handleType() const;
 
 private:
     void registerAssistant(KisPaintingAssistant*);
     void unregisterAssistant(KisPaintingAssistant*);
     bool containsAssistant(KisPaintingAssistant*) const;
 
 private:
     struct Private;
     Private* const d;
 };
 
 /**
  * A KisPaintingAssistant is an object that assist the drawing on the canvas.
  * With this class you can implement virtual equivalent to ruler or compas.
  */
 class KRITAUI_EXPORT KisPaintingAssistant
 {
 public:
     KisPaintingAssistant(const QString& id, const QString& name);
     virtual ~KisPaintingAssistant();
     virtual KisPaintingAssistantSP clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const = 0;
     const QString& id() const;
     const QString& name() const;
     bool isSnappingActive() const;
     void setSnappingActive(bool set);
 
 
     /**
      * Adjust the position given in parameter.
      * @param point the coordinates in point in the document reference
      * @param strokeBegin the coordinates of the beginning of the stroke
      */
     virtual QPointF adjustPosition(const QPointF& point, const QPointF& strokeBegin) = 0;
     virtual void endStroke() { }
     virtual QPointF buttonPosition() const = 0;
     virtual int numHandles() const = 0;
 
     void replaceHandle(KisPaintingAssistantHandleSP _handle, KisPaintingAssistantHandleSP _with);
     void addHandle(KisPaintingAssistantHandleSP handle, HandleType type);
 
     QColor effectiveAssistantColor() const;
 
     /// should this assistant use a custom color for the display? global color will be used if this is false
     bool useCustomColor();
     void setUseCustomColor(bool useCustomColor);
 
     /// getter and setter for assistant's custom color
     void setAssistantCustomColor(QColor color);
     QColor assistantCustomColor();
 
     void setAssistantGlobalColorCache(const QColor &color);
 
 
     virtual void drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter *converter, bool cached = true,KisCanvas2 *canvas=0, bool assistantVisible=true, bool previewVisible=true);
     void uncache();
     const QList<KisPaintingAssistantHandleSP>& handles() const;
     QList<KisPaintingAssistantHandleSP> handles();
     const QList<KisPaintingAssistantHandleSP>& sideHandles() const;
     QList<KisPaintingAssistantHandleSP> sideHandles();
 
     QByteArray saveXml( QMap<KisPaintingAssistantHandleSP, int> &handleMap);
     virtual void saveCustomXml(QXmlStreamWriter* xml); //in case specific assistants have custom properties (like vanishing point)
 
     void loadXml(KoStore *store, QMap<int, KisPaintingAssistantHandleSP> &handleMap, QString path);
     virtual bool loadCustomXml(QXmlStreamReader* xml);
 
     void saveXmlList(QDomDocument& doc, QDomElement& ssistantsElement, int count);
     void findPerspectiveAssistantHandleLocation();
     KisPaintingAssistantHandleSP oppHandleOne();
 
     /**
       * Get the topLeft, bottomLeft, topRight and BottomRight corners of the assistant
       * Some assistants like the perspective grid have custom logic built around certain handles
       */
     const KisPaintingAssistantHandleSP topLeft() const;
     KisPaintingAssistantHandleSP topLeft();
     const KisPaintingAssistantHandleSP topRight() const;
     KisPaintingAssistantHandleSP topRight();
     const KisPaintingAssistantHandleSP bottomLeft() const;
     KisPaintingAssistantHandleSP bottomLeft();
     const KisPaintingAssistantHandleSP bottomRight() const;
     KisPaintingAssistantHandleSP bottomRight();
     const KisPaintingAssistantHandleSP topMiddle() const;
     KisPaintingAssistantHandleSP topMiddle();
     const KisPaintingAssistantHandleSP rightMiddle() const;
     KisPaintingAssistantHandleSP rightMiddle();
     const KisPaintingAssistantHandleSP leftMiddle() const;
     KisPaintingAssistantHandleSP leftMiddle();
     const KisPaintingAssistantHandleSP bottomMiddle() const;
     KisPaintingAssistantHandleSP bottomMiddle();
 
 
     // calculates whether a point is near one of the corner points of the assistant
     // returns: a corner point from the perspective assistant if the given node is close
     // only called once in code when calculating the perspective assistant
     KisPaintingAssistantHandleSP closestCornerHandleFromPoint(QPointF point);
 
     // determines if two points are close to each other
     // only used by the nodeNearPoint function (perspective grid assistant).
     bool areTwoPointsClose(const QPointF& pointOne, const QPointF& pointTwo);
 
     /// determines if the assistant has enough handles to be considered created
     /// new assistants get in a "creation" phase where they are currently being made on the canvas
     /// it will return false if we are in the middle of creating the assistant.
     virtual bool isAssistantComplete() const;
 
 public:
     /**
      * This will render the final output. The drawCache does rendering most of the time so be sure to check that
      */
     void drawPath(QPainter& painter, const QPainterPath& path, bool drawActive=true);
     void drawPreview(QPainter& painter, const QPainterPath& path);
     static double norm2(const QPointF& p);
 
 protected:
     explicit KisPaintingAssistant(const KisPaintingAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap);
 
     virtual QRect boundingRect() const;
 
     /// performance layer where the graphics can be drawn from a cache instead of generated every render update
     virtual void drawCache(QPainter& gc, const KisCoordinatesConverter *converter, bool assistantVisible=true) = 0;
 
     void initHandles(QList<KisPaintingAssistantHandleSP> _handles);
     QList<KisPaintingAssistantHandleSP> m_handles;
 
     QPointF pixelToView(const QPoint pixelCoords) const;
+public:
+    /// clones the list of assistants
+    /// the originally shared handles will still be shared
+    /// the cloned assistants do not share any handle with the original assistants
+    static QList<KisPaintingAssistantSP> cloneAssistantList(const QList<KisPaintingAssistantSP> &list);
 
 private:
     struct Private;
     Private* const d;
 
 };
 
 /**
  * Allow to create a painting assistant.
  */
 class KRITAUI_EXPORT KisPaintingAssistantFactory
 {
 public:
     KisPaintingAssistantFactory();
     virtual ~KisPaintingAssistantFactory();
     virtual QString id() const = 0;
     virtual QString name() const = 0;
     virtual KisPaintingAssistant* createPaintingAssistant() const = 0;
 
 };
 
 class KRITAUI_EXPORT KisPaintingAssistantFactoryRegistry : public KoGenericRegistry<KisPaintingAssistantFactory*>
 {
   public:
     KisPaintingAssistantFactoryRegistry();
     ~KisPaintingAssistantFactoryRegistry() override;
 
     static KisPaintingAssistantFactoryRegistry* instance();
 
 };
 
 #endif
diff --git a/plugins/assistants/Assistants/kis_assistant_tool.cc b/plugins/assistants/Assistants/kis_assistant_tool.cc
index 204e1d5144..7cd15bec72 100644
--- a/plugins/assistants/Assistants/kis_assistant_tool.cc
+++ b/plugins/assistants/Assistants/kis_assistant_tool.cc
@@ -1,1073 +1,1061 @@
 /*
  * Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  * Copyright (c) 2010 Geoffry Song <goffrie@gmail.com>
  * Copyright (c) 2017 Scott Petrovic <scottpetrovic@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_assistant_tool.h>
 
 #include <QPainter>
 #include <QXmlStreamReader>
 #include <QXmlStreamWriter>
 #include <QStandardPaths>
 #include <QFile>
 #include <QLineF>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 #include <KColorButton>
 #include "kis_dom_utils.h"
 #include <QMessageBox>
 
 #include <KoIcon.h>
 #include <KoFileDialog.h>
 #include <KoViewConverter.h>
 #include <KoPointerEvent.h>
 #include <KoSnapGuide.h>
 
 #include <canvas/kis_canvas2.h>
 #include <kis_canvas_resource_provider.h>
 #include <kis_cursor.h>
 #include <kis_image.h>
 #include <KisViewManager.h>
 #include <kis_icon.h>
 #include <kis_abstract_perspective_grid.h>
 #include <kis_painting_assistants_decoration.h>
 #include "kis_global.h"
 #include "VanishingPointAssistant.h"
 #include "EditAssistantsCommand.h"
 #include <kis_undo_adapter.h>
 
 #include <math.h>
 
 KisAssistantTool::KisAssistantTool(KoCanvasBase * canvas)
     : KisTool(canvas, KisCursor::arrowCursor()), m_canvas(dynamic_cast<KisCanvas2*>(canvas)),
       m_assistantDrag(0), m_newAssistant(0), m_optionsWidget(0)
 {
     Q_ASSERT(m_canvas);
     setObjectName("tool_assistanttool");
 }
 
 KisAssistantTool::~KisAssistantTool()
 {
 }
 
 void KisAssistantTool::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
 
     KisTool::activate(toolActivation, shapes);
 
     m_canvas->paintingAssistantsDecoration()->activateAssistantsEditor();
     m_handles = m_canvas->paintingAssistantsDecoration()->handles();
 
     m_handleDrag = 0;
     m_internalMode = MODE_CREATION;
     m_assistantHelperYOffset = 10;
 
 
     m_handleSize = 17;
     m_canvas->paintingAssistantsDecoration()->setHandleSize(m_handleSize);
 
 
     if (m_optionsWidget) {
         m_canvas->paintingAssistantsDecoration()->deselectAssistant();
         updateToolOptionsUI();
     }
 
     m_canvas->updateCanvas();
 }
 
 void KisAssistantTool::deactivate()
 {
     m_canvas->paintingAssistantsDecoration()->deactivateAssistantsEditor();
     m_canvas->updateCanvas();
     KisTool::deactivate();
 }
 
 void KisAssistantTool::beginPrimaryAction(KoPointerEvent *event)
 {
     setMode(KisTool::PAINT_MODE);
-    m_origAssistantList = cloneAssistantList(m_canvas->paintingAssistantsDecoration()->assistants());
+    m_origAssistantList = KisPaintingAssistant::cloneAssistantList(m_canvas->paintingAssistantsDecoration()->assistants());
 
     bool newAssistantAllowed = true;
 
     KisPaintingAssistantsDecorationSP canvasDecoration = m_canvas->paintingAssistantsDecoration();
 
     if (m_newAssistant) {
         m_internalMode = MODE_CREATION;
         *m_newAssistant->handles().back() = canvasDecoration->snapToGuide(event, QPointF(), false);
         if (m_newAssistant->handles().size() == m_newAssistant->numHandles()) {
             addAssistant();
         } else {
             m_newAssistant->addHandle(new KisPaintingAssistantHandle(canvasDecoration->snapToGuide(event, QPointF(), false)), HandleType::NORMAL);
         }
         m_canvas->updateCanvas();
         return;
     }
     m_handleDrag = 0;
     double minDist = 81.0;
 
 
     QPointF mousePos = m_canvas->viewConverter()->documentToView(canvasDecoration->snapToGuide(event, QPointF(), false));//m_canvas->viewConverter()->documentToView(event->point);
 
     // syncs the assistant handles to the handles reference we store in this tool
     // they can get out of sync with the way the actions and paintevents occur
     // we probably need to stop storing a reference in m_handles and call the assistants directly
     m_handles = m_canvas->paintingAssistantsDecoration()->handles();
 
 
     Q_FOREACH (KisPaintingAssistantSP assistant, m_canvas->paintingAssistantsDecoration()->assistants()) {
 
 
         // find out which handle on all assistants is closest to the mouse position
         // vanishing points have "side handles", so make sure to include that
         {
             QList<KisPaintingAssistantHandleSP> allAssistantHandles;
             allAssistantHandles.append(assistant->handles());
             allAssistantHandles.append(assistant->sideHandles());
 
             Q_FOREACH (const KisPaintingAssistantHandleSP handle, allAssistantHandles) {
 
                 double dist = KisPaintingAssistant::norm2(mousePos - m_canvas->viewConverter()->documentToView(*handle));
                 if (dist < minDist) {
                     minDist = dist;
                     m_handleDrag = handle;
 
                     assistantSelected(assistant); // whatever handle is the closest contains the selected assistant
                 }
             }
         }
 
 
 
 
         if(m_handleDrag && assistant->id() == "perspective") {
             // Look for the handle which was pressed
 
 
             if (m_handleDrag == assistant->topLeft()) {
                 double dist = KisPaintingAssistant::norm2(mousePos - m_canvas->viewConverter()->documentToView(*m_handleDrag));
                 if (dist < minDist) {
                     minDist = dist;
                 }
                 m_dragStart = QPointF(assistant->topRight().data()->x(),assistant->topRight().data()->y());
                 m_internalMode = MODE_DRAGGING_NODE;
             } else if (m_handleDrag == assistant->topRight()) {
                 double dist = KisPaintingAssistant::norm2(mousePos - m_canvas->viewConverter()->documentToView(*m_handleDrag));
                 if (dist < minDist) {
                     minDist = dist;
                 }
                 m_internalMode = MODE_DRAGGING_NODE;
                 m_dragStart = QPointF(assistant->topLeft().data()->x(),assistant->topLeft().data()->y());
             } else if (m_handleDrag == assistant->bottomLeft()) {
                 double dist = KisPaintingAssistant::norm2(mousePos - m_canvas->viewConverter()->documentToView(*m_handleDrag));
                 if (dist < minDist) {
                     minDist = dist;
                 }
                 m_internalMode = MODE_DRAGGING_NODE;
                 m_dragStart = QPointF(assistant->bottomRight().data()->x(),assistant->bottomRight().data()->y());
             } else if (m_handleDrag == assistant->bottomRight()) {
                 double dist = KisPaintingAssistant::norm2(mousePos - m_canvas->viewConverter()->documentToView(*m_handleDrag));
                 if (dist < minDist) {
                     minDist = dist;
                 }
                 m_internalMode = MODE_DRAGGING_NODE;
                 m_dragStart = QPointF(assistant->bottomLeft().data()->x(),assistant->bottomLeft().data()->y());
             } else if (m_handleDrag == assistant->leftMiddle()) {
                 m_internalMode = MODE_DRAGGING_TRANSLATING_TWONODES;
                 m_dragStart = QPointF((assistant->bottomLeft().data()->x()+assistant->topLeft().data()->x())*0.5,
                                       (assistant->bottomLeft().data()->y()+assistant->topLeft().data()->y())*0.5);
                 m_selectedNode1 = new KisPaintingAssistantHandle(assistant->topLeft().data()->x(),assistant->topLeft().data()->y());
                 m_selectedNode2 = new KisPaintingAssistantHandle(assistant->bottomLeft().data()->x(),assistant->bottomLeft().data()->y());
                 m_newAssistant = toQShared(KisPaintingAssistantFactoryRegistry::instance()->get("perspective")->createPaintingAssistant());
                 m_newAssistant->addHandle(assistant->topLeft(), HandleType::NORMAL );
                 m_newAssistant->addHandle(m_selectedNode1, HandleType::NORMAL);
                 m_newAssistant->addHandle(m_selectedNode2, HandleType::NORMAL);
                 m_newAssistant->addHandle(assistant->bottomLeft(), HandleType::NORMAL);
                 m_dragEnd = event->point;
                 m_handleDrag = 0;
                 m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
                 return;
             } else if (m_handleDrag == assistant->rightMiddle()) {
                 m_dragStart = QPointF((assistant->topRight().data()->x()+assistant->bottomRight().data()->x())*0.5,
                                       (assistant->topRight().data()->y()+assistant->bottomRight().data()->y())*0.5);
                 m_internalMode = MODE_DRAGGING_TRANSLATING_TWONODES;
                 m_selectedNode1 = new KisPaintingAssistantHandle(assistant->topRight().data()->x(),assistant->topRight().data()->y());
                 m_selectedNode2 = new KisPaintingAssistantHandle(assistant->bottomRight().data()->x(),assistant->bottomRight().data()->y());
                 m_newAssistant = toQShared(KisPaintingAssistantFactoryRegistry::instance()->get("perspective")->createPaintingAssistant());
                 m_newAssistant->addHandle(assistant->topRight(), HandleType::NORMAL);
                 m_newAssistant->addHandle(m_selectedNode1, HandleType::NORMAL);
                 m_newAssistant->addHandle(m_selectedNode2, HandleType::NORMAL);
                 m_newAssistant->addHandle(assistant->bottomRight(), HandleType::NORMAL);
                 m_dragEnd = event->point;
                 m_handleDrag = 0;
                 m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
                 return;
             } else if (m_handleDrag == assistant->topMiddle()) {
                 m_dragStart = QPointF((assistant->topLeft().data()->x()+assistant->topRight().data()->x())*0.5,
                                       (assistant->topLeft().data()->y()+assistant->topRight().data()->y())*0.5);
                 m_internalMode = MODE_DRAGGING_TRANSLATING_TWONODES;
                 m_selectedNode1 = new KisPaintingAssistantHandle(assistant->topLeft().data()->x(),assistant->topLeft().data()->y());
                 m_selectedNode2 = new KisPaintingAssistantHandle(assistant->topRight().data()->x(),assistant->topRight().data()->y());
                 m_newAssistant = toQShared(KisPaintingAssistantFactoryRegistry::instance()->get("perspective")->createPaintingAssistant());
                 m_newAssistant->addHandle(m_selectedNode1, HandleType::NORMAL);
                 m_newAssistant->addHandle(m_selectedNode2, HandleType::NORMAL);
                 m_newAssistant->addHandle(assistant->topRight(), HandleType::NORMAL);
                 m_newAssistant->addHandle(assistant->topLeft(), HandleType::NORMAL);
                 m_dragEnd = event->point;
                 m_handleDrag = 0;
                 m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
                 return;
             } else if (m_handleDrag == assistant->bottomMiddle()) {
                 m_dragStart = QPointF((assistant->bottomLeft().data()->x()+assistant->bottomRight().data()->x())*0.5,
                                       (assistant->bottomLeft().data()->y()+assistant->bottomRight().data()->y())*0.5);
                 m_internalMode = MODE_DRAGGING_TRANSLATING_TWONODES;
                 m_selectedNode1 = new KisPaintingAssistantHandle(assistant->bottomLeft().data()->x(),assistant->bottomLeft().data()->y());
                 m_selectedNode2 = new KisPaintingAssistantHandle(assistant->bottomRight().data()->x(),assistant->bottomRight().data()->y());
                 m_newAssistant = toQShared(KisPaintingAssistantFactoryRegistry::instance()->get("perspective")->createPaintingAssistant());
                 m_newAssistant->addHandle(assistant->bottomLeft(), HandleType::NORMAL);
                 m_newAssistant->addHandle(assistant->bottomRight(), HandleType::NORMAL);
                 m_newAssistant->addHandle(m_selectedNode2, HandleType::NORMAL);
                 m_newAssistant->addHandle(m_selectedNode1, HandleType::NORMAL);
                 m_dragEnd = event->point;
                 m_handleDrag = 0;
                 m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
                 return;
             }
             m_snapIsRadial = false;
         }
         else if (m_handleDrag && assistant->handles().size()>1 && (assistant->id() == "ruler" ||
                                                                    assistant->id() == "parallel ruler" ||
                                                                    assistant->id() == "infinite ruler" ||
                                                                    assistant->id() == "spline")){
             if (m_handleDrag == assistant->handles()[0]) {
                 m_dragStart = *assistant->handles()[1];
             } else if (m_handleDrag == assistant->handles()[1]) {
                 m_dragStart = *assistant->handles()[0];
             } else if(assistant->handles().size()==4){
                 if (m_handleDrag == assistant->handles()[2]) {
                     m_dragStart = *assistant->handles()[0];
                 } else if (m_handleDrag == assistant->handles()[3]) {
                     m_dragStart = *assistant->handles()[1];
                 }
             }
             m_snapIsRadial = false;
         } else if (m_handleDrag && assistant->handles().size()>2 && (assistant->id() == "ellipse" ||
                                     assistant->id() == "concentric ellipse" ||
                                     assistant->id() == "fisheye-point")){
             m_snapIsRadial = false;
             if (m_handleDrag == assistant->handles()[0]) {
                 m_dragStart = *assistant->handles()[1];
             } else if (m_handleDrag == assistant->handles()[1]) {
                 m_dragStart = *assistant->handles()[0];
             } else if (m_handleDrag == assistant->handles()[2]) {
                 m_dragStart = assistant->buttonPosition();
                 m_radius = QLineF(m_dragStart, *assistant->handles()[0]);
                 m_snapIsRadial = true;
             }
 
         } else {
             m_dragStart = assistant->buttonPosition();
             m_snapIsRadial = false;
         }
     }
 
     if (m_handleDrag) {
         // TODO: Shift-press should now be handled using the alternate actions
         // if (event->modifiers() & Qt::ShiftModifier) {
         //     m_handleDrag->uncache();
         //     m_handleDrag = m_handleDrag->split()[0];
         //     m_handles = m_canvas->view()->paintingAssistantsDecoration()->handles();
         // }
         m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
         return;
     }
 
     m_assistantDrag.clear();
     Q_FOREACH (KisPaintingAssistantSP assistant, m_canvas->paintingAssistantsDecoration()->assistants()) {
 
         // This code contains the click event behavior.
         QTransform initialTransform = m_canvas->coordinatesConverter()->documentToWidgetTransform();
         QPointF actionsPosition = initialTransform.map(assistant->buttonPosition());
 
 
         // for UI editor widget controls with move, show, and delete -- disregard document transforms like rotating and mirroring.
         // otherwise the UI controls get awkward to use when they are at 45 degree angles or the order of controls gets flipped backwards
         QPointF uiMousePosition = initialTransform.map( canvasDecoration->snapToGuide(event, QPointF(), false));
 
         AssistantEditorData editorShared; // shared position data between assistant tool and decoration
 
         QPointF iconMovePosition(actionsPosition + editorShared.moveIconPosition);
         QPointF iconSnapPosition(actionsPosition + editorShared.snapIconPosition);
         QPointF iconDeletePosition(actionsPosition + editorShared.deleteIconPosition);
 
 
         QRectF deleteRect(iconDeletePosition, QSizeF(editorShared.deleteIconSize, editorShared.deleteIconSize));
         QRectF visibleRect(iconSnapPosition, QSizeF(editorShared.snapIconSize, editorShared.snapIconSize));
         QRectF moveRect(iconMovePosition, QSizeF(editorShared.moveIconSize, editorShared.moveIconSize));
 
         if (moveRect.contains(uiMousePosition)) {
             m_assistantDrag = assistant;
             m_cursorStart = event->point;
             m_currentAdjustment = QPointF();
             m_internalMode = MODE_EDITING;
 
 
             assistantSelected(assistant); // whatever handle is the closest contains the selected assistant
 
             return;
         }
 
         if (deleteRect.contains(uiMousePosition)) {
             removeAssistant(assistant);
             if(m_canvas->paintingAssistantsDecoration()->assistants().isEmpty()) {
                 m_internalMode = MODE_CREATION;
             }
             else
                 m_internalMode = MODE_EDITING;
             m_canvas->updateCanvas();
             return;
         }
         if (visibleRect.contains(uiMousePosition)) {
             newAssistantAllowed = false;
             assistant->setSnappingActive(!assistant->isSnappingActive()); // toggle
             assistant->uncache();//this updates the chache of the assistant, very important.
 
             assistantSelected(assistant); // whatever handle is the closest contains the selected assistant
         }
     }
     if (newAssistantAllowed==true){//don't make a new assistant when I'm just toogling visibility//
         QString key = m_options.availableAssistantsComboBox->model()->index( m_options.availableAssistantsComboBox->currentIndex(), 0 ).data(Qt::UserRole).toString();
         m_newAssistant = toQShared(KisPaintingAssistantFactoryRegistry::instance()->get(key)->createPaintingAssistant());
         m_internalMode = MODE_CREATION;
         m_newAssistant->addHandle(new KisPaintingAssistantHandle(canvasDecoration->snapToGuide(event, QPointF(), false)), HandleType::NORMAL);
         if (m_newAssistant->numHandles() <= 1) {
             addAssistant();
         } else {
             m_newAssistant->addHandle(new KisPaintingAssistantHandle(canvasDecoration->snapToGuide(event, QPointF(), false)), HandleType::NORMAL);
         }
     }
 
     if (m_newAssistant) {
         m_newAssistant->setAssistantGlobalColorCache(m_canvas->paintingAssistantsDecoration()->globalAssistantsColor());
     }
 
     m_canvas->updateCanvas();
 }
 
 void KisAssistantTool::continuePrimaryAction(KoPointerEvent *event)
 {
     KisPaintingAssistantsDecorationSP canvasDecoration = m_canvas->paintingAssistantsDecoration();
 
     if (m_handleDrag) {
         *m_handleDrag = event->point;
         //ported from the gradient tool... we need to think about this more in the future.
         if (event->modifiers() == Qt::ShiftModifier && m_snapIsRadial) {
             QLineF dragRadius = QLineF(m_dragStart, event->point);
             dragRadius.setLength(m_radius.length());
             *m_handleDrag = dragRadius.p2();
         } else if (event->modifiers() == Qt::ShiftModifier ) {
             QPointF move = snapToClosestAxis(event->point - m_dragStart);
             *m_handleDrag = m_dragStart + move;
         } else {
             *m_handleDrag = canvasDecoration->snapToGuide(event, QPointF(), false);
         }
         m_handleDrag->uncache();
 
         m_handleCombine = 0;
         if (!(event->modifiers() & Qt::ShiftModifier)) {
             double minDist = 49.0;
             QPointF mousePos = m_canvas->viewConverter()->documentToView(event->point);
             Q_FOREACH (const KisPaintingAssistantHandleSP handle, m_handles) {
                 if (handle == m_handleDrag)
                     continue;
 
 
                 double dist = KisPaintingAssistant::norm2(mousePos - m_canvas->viewConverter()->documentToView(*handle));
                 if (dist < minDist) {
                     minDist = dist;
                     m_handleCombine = handle;
                 }
             }
         }
         m_canvas->updateCanvas();
     } else if (m_assistantDrag) {
         QPointF newAdjustment = canvasDecoration->snapToGuide(event, QPointF(), false) - m_cursorStart;
         if (event->modifiers() == Qt::ShiftModifier ) {
             newAdjustment = snapToClosestAxis(newAdjustment);
         }
         Q_FOREACH (KisPaintingAssistantHandleSP handle, m_assistantDrag->handles()) {
             *handle += (newAdjustment - m_currentAdjustment);
         }
         if (m_assistantDrag->id()== "vanishing point"){
             Q_FOREACH (KisPaintingAssistantHandleSP handle, m_assistantDrag->sideHandles()) {
                 *handle += (newAdjustment - m_currentAdjustment);
             }
         }
         m_currentAdjustment = newAdjustment;
         m_canvas->updateCanvas();
 
     } else {
         event->ignore();
     }
 
     bool wasHiglightedNode = m_higlightedNode != 0;
     QPointF mousep = m_canvas->viewConverter()->documentToView(event->point);
     QList <KisPaintingAssistantSP> pAssistant= m_canvas->paintingAssistantsDecoration()->assistants();
 
     Q_FOREACH (KisPaintingAssistantSP assistant, pAssistant) {
         if(assistant->id() == "perspective") {
             if ((m_higlightedNode = assistant->closestCornerHandleFromPoint(mousep))) {
                 if (m_higlightedNode == m_selectedNode1 || m_higlightedNode == m_selectedNode2) {
                     m_higlightedNode = 0;
                 } else {
                     m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
                     break;
                 }
             }
         }
 
         //this following bit sets the translations for the vanishing-point handles.
         if(m_handleDrag && assistant->id() == "vanishing point" && assistant->sideHandles().size()==4) {
             //for inner handles, the outer handle gets translated.
             if (m_handleDrag == assistant->sideHandles()[0]) {
                 QLineF perspectiveline = QLineF(*assistant->handles()[0],
                                                 *assistant->sideHandles()[0]);
 
                 qreal length = QLineF(*assistant->sideHandles()[0],
                                       *assistant->sideHandles()[1]).length();
 
                 if (length < 2.0){
                     length = 2.0;
                 }
 
                 length += perspectiveline.length();
                 perspectiveline.setLength(length);
                 *assistant->sideHandles()[1] = perspectiveline.p2();
             }
             else if (m_handleDrag == assistant->sideHandles()[2]){
                 QLineF perspectiveline = QLineF(*assistant->handles()[0], *assistant->sideHandles()[2]);
                 qreal length = QLineF(*assistant->sideHandles()[2], *assistant->sideHandles()[3]).length();
 
                 if (length<2.0){
                     length=2.0;
                 }
 
                 length += perspectiveline.length();
                 perspectiveline.setLength(length);
                 *assistant->sideHandles()[3] = perspectiveline.p2();
             } // for outer handles, only the vanishing point is translated, but only if there's an intersection.
             else if (m_handleDrag == assistant->sideHandles()[1]|| m_handleDrag == assistant->sideHandles()[3]){
                 QPointF vanishingpoint(0,0);
                 QLineF perspectiveline = QLineF(*assistant->sideHandles()[0], *assistant->sideHandles()[1]);
                 QLineF perspectiveline2 = QLineF(*assistant->sideHandles()[2], *assistant->sideHandles()[3]);
 
                 if (QLineF(perspectiveline2).intersect(QLineF(perspectiveline), &vanishingpoint) != QLineF::NoIntersection){
                     *assistant->handles()[0] = vanishingpoint;
                 }
             }// and for the vanishing point itself, only the outer handles get translated.
             else if (m_handleDrag == assistant->handles()[0]){
                 QLineF perspectiveline = QLineF(*assistant->handles()[0], *assistant->sideHandles()[0]);
                 QLineF perspectiveline2 = QLineF(*assistant->handles()[0], *assistant->sideHandles()[2]);
                 qreal length =  QLineF(*assistant->sideHandles()[0], *assistant->sideHandles()[1]).length();
                 qreal length2 = QLineF(*assistant->sideHandles()[2], *assistant->sideHandles()[3]).length();
 
                 if (length < 2.0) {
                     length = 2.0;
                 }
 
                 if (length2 < 2.0) {
                     length2=2.0;
                 }
 
                 length += perspectiveline.length();
                 length2 += perspectiveline2.length();
                 perspectiveline.setLength(length);
                 perspectiveline2.setLength(length2);
                 *assistant->sideHandles()[1] = perspectiveline.p2();
                 *assistant->sideHandles()[3] = perspectiveline2.p2();
             }
 
         }
     }
     if (wasHiglightedNode && !m_higlightedNode) {
         m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
     }
 }
 
 void KisAssistantTool::endPrimaryAction(KoPointerEvent *event)
 {
     setMode(KisTool::HOVER_MODE);
 
     if (m_handleDrag || m_assistantDrag) {
         if (m_handleDrag) {
             if (!(event->modifiers() & Qt::ShiftModifier) && m_handleCombine) {
                 m_handleCombine->mergeWith(m_handleDrag);
                 m_handleCombine->uncache();
                 m_handles = m_canvas->paintingAssistantsDecoration()->handles();
             }
             m_handleDrag = m_handleCombine = 0;
         } else {
             m_assistantDrag.clear();
         }
         dbgUI << "creating undo command...";
-        KUndo2Command *command = new EditAssistantsCommand(m_canvas, m_origAssistantList, cloneAssistantList(m_canvas->paintingAssistantsDecoration()->assistants()));
+        KUndo2Command *command = new EditAssistantsCommand(m_canvas, m_origAssistantList, KisPaintingAssistant::cloneAssistantList(m_canvas->paintingAssistantsDecoration()->assistants()));
         m_canvas->viewManager()->undoAdapter()->addCommand(command);
         dbgUI << "done";
     } else if(m_internalMode == MODE_DRAGGING_TRANSLATING_TWONODES) {
         addAssistant();
         m_internalMode = MODE_CREATION;
     }
     else {
         event->ignore();
     }
 
     m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
 }
 
-QList<KisPaintingAssistantSP> KisAssistantTool::cloneAssistantList(const QList<KisPaintingAssistantSP> &list) const
-{
-    QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> handleMap;
-    QList<KisPaintingAssistantSP> clonedList;
-    dbgUI << "cloning assistants...";
-    for (auto i = list.begin(); i != list.end(); ++i) {
-        clonedList << (*i)->clone(handleMap);
-    }
-    dbgUI << "done";
-    return clonedList;
-}
-
 void KisAssistantTool::addAssistant()
 {
     m_canvas->paintingAssistantsDecoration()->addAssistant(m_newAssistant);
 
     KisAbstractPerspectiveGrid* grid = dynamic_cast<KisAbstractPerspectiveGrid*>(m_newAssistant.data());
     if (grid) {
         m_canvas->viewManager()->canvasResourceProvider()->addPerspectiveGrid(grid);
     }
 
     QList<KisPaintingAssistantSP> assistants = m_canvas->paintingAssistantsDecoration()->assistants();
-    KUndo2Command *addAssistantCmd = new EditAssistantsCommand(m_canvas, m_origAssistantList, cloneAssistantList(assistants), EditAssistantsCommand::ADD, assistants.indexOf(m_newAssistant));
+    KUndo2Command *addAssistantCmd = new EditAssistantsCommand(m_canvas, m_origAssistantList, KisPaintingAssistant::cloneAssistantList(assistants), EditAssistantsCommand::ADD, assistants.indexOf(m_newAssistant));
     m_canvas->viewManager()->undoAdapter()->addCommand(addAssistantCmd);
 
     m_handles = m_canvas->paintingAssistantsDecoration()->handles();
     m_canvas->paintingAssistantsDecoration()->setSelectedAssistant(m_newAssistant);
     updateToolOptionsUI(); // vanishing point assistant will get an extra option
 
     m_newAssistant.clear();
 }
 
 void KisAssistantTool::removeAssistant(KisPaintingAssistantSP assistant)
 {
     QList<KisPaintingAssistantSP> assistants = m_canvas->paintingAssistantsDecoration()->assistants();
 
     KisAbstractPerspectiveGrid* grid = dynamic_cast<KisAbstractPerspectiveGrid*>(assistant.data());
     if (grid) {
         m_canvas->viewManager()->canvasResourceProvider()->removePerspectiveGrid(grid);
     }
     m_canvas->paintingAssistantsDecoration()->removeAssistant(assistant);
 
-    KUndo2Command *removeAssistantCmd = new EditAssistantsCommand(m_canvas, m_origAssistantList, cloneAssistantList(m_canvas->paintingAssistantsDecoration()->assistants()), EditAssistantsCommand::REMOVE, assistants.indexOf(assistant));
+    KUndo2Command *removeAssistantCmd = new EditAssistantsCommand(m_canvas, m_origAssistantList, KisPaintingAssistant::cloneAssistantList(m_canvas->paintingAssistantsDecoration()->assistants()), EditAssistantsCommand::REMOVE, assistants.indexOf(assistant));
     m_canvas->viewManager()->undoAdapter()->addCommand(removeAssistantCmd);
 
     m_handles = m_canvas->paintingAssistantsDecoration()->handles();
     m_canvas->paintingAssistantsDecoration()->deselectAssistant();
     updateToolOptionsUI();
 }
 
 void KisAssistantTool::assistantSelected(KisPaintingAssistantSP assistant)
 {
      m_canvas->paintingAssistantsDecoration()->setSelectedAssistant(assistant);
      updateToolOptionsUI();
 }
 
 void KisAssistantTool::updateToolOptionsUI()
 {
      KisPaintingAssistantSP m_selectedAssistant =  m_canvas->paintingAssistantsDecoration()->selectedAssistant();
 
      bool hasActiveAssistant = m_selectedAssistant ? true : false;
 
      if (m_selectedAssistant) {
          bool isVanishingPointAssistant = m_selectedAssistant->id() == "vanishing point";
          m_options.vanishingPointAngleSpinbox->setVisible(isVanishingPointAssistant);
 
          if (isVanishingPointAssistant) {
              QSharedPointer <VanishingPointAssistant> assis = qSharedPointerCast<VanishingPointAssistant>(m_selectedAssistant);
              m_options.vanishingPointAngleSpinbox->setValue(assis->referenceLineDensity());
          }
 
          // load custom color settings from assistant (this happens when changing assistant
          m_options.useCustomAssistantColor->setChecked(m_selectedAssistant->useCustomColor());
          m_options.customAssistantColorButton->setColor(m_selectedAssistant->assistantCustomColor());
          float opacity = (float)m_selectedAssistant->assistantCustomColor().alpha()/255.0 * 100.0 ;
          m_options.customColorOpacitySlider->setValue(opacity);
      } else {
          m_options.vanishingPointAngleSpinbox->setVisible(false); //
      }
 
      // show/hide elements if an assistant is selected or not
       m_options.assistantsGlobalOpacitySlider->setVisible(hasActiveAssistant);
       m_options.assistantsColor->setVisible(hasActiveAssistant);
       m_options.globalColorLabel->setVisible(hasActiveAssistant);
       m_options.useCustomAssistantColor->setVisible(hasActiveAssistant);
 
       // hide custom color options if use custom color is not selected
       bool showCustomColorSettings = m_options.useCustomAssistantColor->isChecked() && hasActiveAssistant;
       m_options.customColorOpacitySlider->setVisible(showCustomColorSettings);
       m_options.customAssistantColorButton->setVisible(showCustomColorSettings);
 
       // disable global color settings if we are using the custom color
       m_options.assistantsGlobalOpacitySlider->setEnabled(!showCustomColorSettings);
       m_options.assistantsColor->setEnabled(!showCustomColorSettings);
       m_options.globalColorLabel->setEnabled(!showCustomColorSettings);
 
 }
 
 void KisAssistantTool::slotChangeVanishingPointAngle(double value)
 {
     if ( m_canvas->paintingAssistantsDecoration()->assistants().length() == 0) {
         return;
     }
 
     // get the selected assistant and change the angle value
     KisPaintingAssistantSP m_selectedAssistant =  m_canvas->paintingAssistantsDecoration()->selectedAssistant();
     if (m_selectedAssistant) {
         bool isVanishingPointAssistant = m_selectedAssistant->id() == "vanishing point";
 
         if (isVanishingPointAssistant) {
             QSharedPointer <VanishingPointAssistant> assis = qSharedPointerCast<VanishingPointAssistant>(m_selectedAssistant);
             assis->setReferenceLineDensity((float)value);
         }
     }
 
     m_canvas->canvasWidget()->update();
 }
 
 void KisAssistantTool::mouseMoveEvent(KoPointerEvent *event)
 {
     if (m_newAssistant && m_internalMode == MODE_CREATION) {
         *m_newAssistant->handles().back() = event->point;
 
     } else if (m_newAssistant && m_internalMode == MODE_DRAGGING_TRANSLATING_TWONODES) {
         QPointF translate = event->point - m_dragEnd;
         m_dragEnd = event->point;
         m_selectedNode1.data()->operator = (QPointF(m_selectedNode1.data()->x(),m_selectedNode1.data()->y()) + translate);
         m_selectedNode2.data()->operator = (QPointF(m_selectedNode2.data()->x(),m_selectedNode2.data()->y()) + translate);
     }
 
      m_canvas->updateCanvas();
 }
 
 void KisAssistantTool::paint(QPainter& _gc, const KoViewConverter &_converter)
 {
     QRectF canvasSize = QRectF(QPointF(0, 0), QSizeF(m_canvas->image()->size()));
 
     // show special display while a new assistant is in the process of being created
     if (m_newAssistant) {
 
         QColor assistantColor = m_newAssistant->effectiveAssistantColor();
         assistantColor.setAlpha(80);
 
         m_newAssistant->drawAssistant(_gc, canvasSize, m_canvas->coordinatesConverter(), false, m_canvas, true, false);
         Q_FOREACH (const KisPaintingAssistantHandleSP handle, m_newAssistant->handles()) {
             QPainterPath path;
             path.addEllipse(QRectF(_converter.documentToView(*handle) -  QPointF(m_handleSize * 0.5, m_handleSize * 0.5), QSizeF(m_handleSize, m_handleSize)));
 
             _gc.save();
             _gc.setPen(Qt::NoPen);
             _gc.setBrush(assistantColor);
             _gc.drawPath(path);
             _gc.restore();
         }
     }
 
 
     Q_FOREACH (KisPaintingAssistantSP assistant, m_canvas->paintingAssistantsDecoration()->assistants()) {
 
         QColor assistantColor = assistant->effectiveAssistantColor();
         assistantColor.setAlpha(80);
 
         Q_FOREACH (const KisPaintingAssistantHandleSP handle, m_handles) {
             QRectF ellipse(_converter.documentToView(*handle) -  QPointF(m_handleSize * 0.5, m_handleSize * 0.5),
                            QSizeF(m_handleSize, m_handleSize));
 
             // render handles differently if it is the one being dragged.
             if (handle == m_handleDrag || handle == m_handleCombine) {
                 QPen stroke(assistantColor, 4);
                 _gc.save();
                 _gc.setPen(stroke);
                 _gc.setBrush(Qt::NoBrush);
                 _gc.drawEllipse(ellipse);
                 _gc.restore();
             }
 
         }
     }
 }
 
 void KisAssistantTool::removeAllAssistants()
 {
     m_canvas->viewManager()->canvasResourceProvider()->clearPerspectiveGrids();
     m_canvas->paintingAssistantsDecoration()->removeAll();
     m_handles = m_canvas->paintingAssistantsDecoration()->handles();
     m_canvas->updateCanvas();
 
     m_canvas->paintingAssistantsDecoration()->deselectAssistant();
     updateToolOptionsUI();
 }
 
 void KisAssistantTool::loadAssistants()
 {
     KoFileDialog dialog(m_canvas->viewManager()->mainWindow(), KoFileDialog::OpenFile, "OpenAssistant");
     dialog.setCaption(i18n("Select an Assistant"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(QStringList() << "application/x-krita-assistant", "application/x-krita-assistant");
     QString filename = dialog.filename();
     if (filename.isEmpty()) return;
     if (!QFileInfo(filename).exists()) return;
 
     QFile file(filename);
     file.open(QIODevice::ReadOnly);
 
     QByteArray data = file.readAll();
     QXmlStreamReader xml(data);
     QMap<int, KisPaintingAssistantHandleSP> handleMap;
     KisPaintingAssistantSP assistant;
     bool errors = false;
     while (!xml.atEnd()) {
         switch (xml.readNext()) {
         case QXmlStreamReader::StartElement:
             if (xml.name() == "handle") {
                 if (assistant && !xml.attributes().value("ref").isEmpty()) {
                     KisPaintingAssistantHandleSP handle = handleMap.value(xml.attributes().value("ref").toString().toInt());
                     if (handle) {
                        assistant->addHandle(handle, HandleType::NORMAL);
                     } else {
                         errors = true;
                     }
                 } else {
                     QString strId = xml.attributes().value("id").toString(),
                             strX = xml.attributes().value("x").toString(),
                             strY = xml.attributes().value("y").toString();
 
 
 
                     if (!strId.isEmpty() && !strX.isEmpty() && !strY.isEmpty()) {
                         int id = strId.toInt();
                         double x = strX.toDouble(),
                                 y = strY.toDouble();
                         if (!handleMap.contains(id)) {
                             handleMap.insert(id, new KisPaintingAssistantHandle(x, y));
                         } else {
                             errors = true;
                         }
                     } else {
                         errors = true;
                     }
                 }
             } else if (xml.name() == "assistant") {
                 const KisPaintingAssistantFactory* factory = KisPaintingAssistantFactoryRegistry::instance()->get(xml.attributes().value("type").toString());
 
                 if (factory) {
                     if (assistant) {
                         errors = true;
                         assistant.clear();
                     }
                     assistant = toQShared(factory->createPaintingAssistant());
                 } else {
                     errors = true;
                 }
 
 
                // load custom shared assistant properties
                if ( xml.attributes().hasAttribute("useCustomColor")) {
                    QStringRef useCustomColor = xml.attributes().value("useCustomColor");
 
                    bool usingColor = false;
                    if (useCustomColor.toString() == "1") {
                        usingColor = true;
                    }
                    assistant->setUseCustomColor(usingColor);
                }
 
                if ( xml.attributes().hasAttribute("useCustomColor")) {
                    QStringRef customColor = xml.attributes().value("customColor");
                    assistant->setAssistantCustomColor( KisDomUtils::qStringToQColor(customColor.toString()) );
 
                }
            }
 
             if (assistant) {
                 assistant->loadCustomXml(&xml);
             }
 
 
            break;
         case QXmlStreamReader::EndElement:
             if (xml.name() == "assistant") {
                 if (assistant) {
                     if (assistant->handles().size() == assistant->numHandles()) {
                         if (assistant->id() == "vanishing point"){
                         //ideally we'd save and load side-handles as well, but this is all I've got//
                             QPointF pos = *assistant->handles()[0];
                             assistant->addHandle(new KisPaintingAssistantHandle(pos+QPointF(-70,0)), HandleType::SIDE);
                             assistant->addHandle(new KisPaintingAssistantHandle(pos+QPointF(-140,0)), HandleType::SIDE);
                             assistant->addHandle(new KisPaintingAssistantHandle(pos+QPointF(70,0)), HandleType::SIDE);
                             assistant->addHandle(new KisPaintingAssistantHandle(pos+QPointF(140,0)), HandleType::SIDE);
                         }
                         m_canvas->paintingAssistantsDecoration()->addAssistant(assistant);
                         KisAbstractPerspectiveGrid* grid = dynamic_cast<KisAbstractPerspectiveGrid*>(assistant.data());
                         if (grid) {
                             m_canvas->viewManager()->canvasResourceProvider()->addPerspectiveGrid(grid);
                         }
                     } else {
                         errors = true;
                     }
                     assistant.clear();
                 }
             }
 
             break;
         default:
             break;
         }
 
     }
     if (assistant) {
         errors = true;
         assistant.clear();
     }
     if (xml.hasError()) {
         QMessageBox::warning(0, i18nc("@title:window", "Krita"), xml.errorString());
     }
     if (errors) {
         QMessageBox::warning(0, i18nc("@title:window", "Krita"), i18n("Errors were encountered. Not all assistants were successfully loaded."));
     }
     m_handles = m_canvas->paintingAssistantsDecoration()->handles();
     m_canvas->updateCanvas();
 
 }
 
 void KisAssistantTool::saveAssistants()
 {
 
     if (m_handles.isEmpty()) return;
 
     QByteArray data;
     QXmlStreamWriter xml(&data);
     xml.writeStartDocument();
     xml.writeStartElement("paintingassistant");
     xml.writeAttribute("color",
                        KisDomUtils::qColorToQString(
                            m_canvas->paintingAssistantsDecoration()->globalAssistantsColor())); // global color if no custom color used
 
 
     xml.writeStartElement("handles");
     QMap<KisPaintingAssistantHandleSP, int> handleMap;
     Q_FOREACH (const KisPaintingAssistantHandleSP handle, m_handles) {
         int id = handleMap.size();
         handleMap.insert(handle, id);
         xml.writeStartElement("handle");
         //xml.writeAttribute("type", handle->handleType());
         xml.writeAttribute("id", QString::number(id));
         xml.writeAttribute("x", QString::number(double(handle->x()), 'f', 3));
         xml.writeAttribute("y", QString::number(double(handle->y()), 'f', 3));
         xml.writeEndElement();
     }
     xml.writeEndElement();
     xml.writeStartElement("assistants");
 
 
     Q_FOREACH (const KisPaintingAssistantSP assistant, m_canvas->paintingAssistantsDecoration()->assistants()) {
         xml.writeStartElement("assistant");
         xml.writeAttribute("type", assistant->id());
         xml.writeAttribute("useCustomColor", QString::number(assistant->useCustomColor()));
         xml.writeAttribute("customColor",  KisDomUtils::qColorToQString(assistant->assistantCustomColor()));
 
 
 
         // custom assistant properties like angle density on vanishing point
         assistant->saveCustomXml(&xml);
 
         // handle information
         xml.writeStartElement("handles");
         Q_FOREACH (const KisPaintingAssistantHandleSP handle, assistant->handles()) {
             xml.writeStartElement("handle");
             xml.writeAttribute("ref", QString::number(handleMap.value(handle)));
             xml.writeEndElement();
         }
         xml.writeEndElement();
         xml.writeEndElement();
     }
     xml.writeEndElement();
     xml.writeEndElement();
     xml.writeEndDocument();
 
     KoFileDialog dialog(m_canvas->viewManager()->mainWindow(), KoFileDialog::SaveFile, "OpenAssistant");
     dialog.setCaption(i18n("Save Assistant"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(QStringList() << "application/x-krita-assistant", "application/x-krita-assistant");
     QString filename = dialog.filename();
     if (filename.isEmpty()) return;
 
     QFile file(filename);
     file.open(QIODevice::WriteOnly);
     file.write(data);
 }
 
 QWidget *KisAssistantTool::createOptionWidget()
 {
     if (!m_optionsWidget) {
         m_optionsWidget = new QWidget;
         m_options.setupUi(m_optionsWidget);
 
         // See https://bugs.kde.org/show_bug.cgi?id=316896
         QWidget *specialSpacer = new QWidget(m_optionsWidget);
         specialSpacer->setObjectName("SpecialSpacer");
         specialSpacer->setFixedSize(0, 0);
         m_optionsWidget->layout()->addWidget(specialSpacer);
 
         m_options.loadAssistantButton->setIcon(KisIconUtils::loadIcon("document-open"));
         m_options.saveAssistantButton->setIcon(KisIconUtils::loadIcon("document-save"));
         m_options.deleteAllAssistantsButton->setIcon(KisIconUtils::loadIcon("edit-delete"));
 
         QList<KoID> assistants;
         Q_FOREACH (const QString& key, KisPaintingAssistantFactoryRegistry::instance()->keys()) {
             QString name = KisPaintingAssistantFactoryRegistry::instance()->get(key)->name();
             assistants << KoID(key, name);
         }
         std::sort(assistants.begin(), assistants.end(), KoID::compareNames);
         Q_FOREACH(const KoID &id, assistants) {
             m_options.availableAssistantsComboBox->addItem(id.name(), id.id());
         }
 
         connect(m_options.saveAssistantButton, SIGNAL(clicked()), SLOT(saveAssistants()));
         connect(m_options.loadAssistantButton, SIGNAL(clicked()), SLOT(loadAssistants()));
         connect(m_options.deleteAllAssistantsButton, SIGNAL(clicked()), SLOT(removeAllAssistants()));
 
         connect(m_options.assistantsColor, SIGNAL(changed(QColor)), SLOT(slotGlobalAssistantsColorChanged(QColor)));
         connect(m_options.assistantsGlobalOpacitySlider, SIGNAL(valueChanged(int)), SLOT(slotGlobalAssistantOpacityChanged()));
 
 
         connect(m_options.vanishingPointAngleSpinbox, SIGNAL(valueChanged(double)), this, SLOT(slotChangeVanishingPointAngle(double)));
 
         //ENTER_FUNCTION() << ppVar(m_canvas) << ppVar(m_canvas && m_canvas->paintingAssistantsDecoration());
 
         // initialize UI elements with existing data if possible
         if (m_canvas && m_canvas->paintingAssistantsDecoration()) {
             const QColor color = m_canvas->paintingAssistantsDecoration()->globalAssistantsColor();
 
             QColor opaqueColor = color;
             opaqueColor.setAlpha(255);
 
             //ENTER_FUNCTION() << ppVar(opaqueColor);
 
             m_options.assistantsColor->setColor(opaqueColor);
             m_options.customAssistantColorButton->setColor(opaqueColor);
             m_options.assistantsGlobalOpacitySlider->setValue(color.alphaF() * 100.0);
 
         } else {
             m_options.assistantsColor->setColor(QColor(176, 176, 176, 255)); // grey default for all assistants
             m_options.assistantsGlobalOpacitySlider->setValue(100); // 100%
         }
 
         m_options.assistantsGlobalOpacitySlider->setPrefix(i18n("Opacity: "));
         m_options.assistantsGlobalOpacitySlider->setSuffix(" %");
 
 
         // custom color of selected assistant
         m_options.customColorOpacitySlider->setValue(100); // 100%
         m_options.customColorOpacitySlider->setPrefix(i18n("Opacity: "));
         m_options.customColorOpacitySlider->setSuffix(" %");
 
         connect(m_options.useCustomAssistantColor, SIGNAL(clicked(bool)), this, SLOT(slotUpdateCustomColor()));
         connect(m_options.customAssistantColorButton, SIGNAL(changed(QColor)), this, SLOT(slotUpdateCustomColor()));
         connect(m_options.customColorOpacitySlider, SIGNAL(valueChanged(int)), SLOT(slotCustomOpacityChanged()));
 
         m_options.vanishingPointAngleSpinbox->setPrefix(i18n("Density: "));
         m_options.vanishingPointAngleSpinbox->setSuffix(QChar(Qt::Key_degree));
         m_options.vanishingPointAngleSpinbox->setRange(1.0, 180.0);
         m_options.vanishingPointAngleSpinbox->setSingleStep(0.5);
 
 
         m_options.vanishingPointAngleSpinbox->setVisible(false);
 
     }
 
     updateToolOptionsUI();
 
     return m_optionsWidget;
 }
 
 void KisAssistantTool::slotGlobalAssistantsColorChanged(const QColor& setColor)
 {
     // color and alpha are stored separately, so we need to merge the values before sending it on
     int oldAlpha = m_canvas->paintingAssistantsDecoration()->globalAssistantsColor().alpha();
 
     QColor newColor = setColor;
     newColor.setAlpha(oldAlpha);
 
     m_canvas->paintingAssistantsDecoration()->setGlobalAssistantsColor(newColor);
 
     m_canvas->paintingAssistantsDecoration()->uncache();
     m_canvas->canvasWidget()->update();
 }
 
 void KisAssistantTool::slotGlobalAssistantOpacityChanged()
 {
     QColor newColor = m_canvas->paintingAssistantsDecoration()->globalAssistantsColor();
     qreal newOpacity = m_options.assistantsGlobalOpacitySlider->value() * 0.01 * 255.0;
     newColor.setAlpha(int(newOpacity));
     m_canvas->paintingAssistantsDecoration()->setGlobalAssistantsColor(newColor);
 
     m_canvas->paintingAssistantsDecoration()->uncache();
     m_canvas->canvasWidget()->update();
 }
 
 void KisAssistantTool::slotUpdateCustomColor()
 {
     // get the selected assistant and change the angle value
     KisPaintingAssistantSP m_selectedAssistant =  m_canvas->paintingAssistantsDecoration()->selectedAssistant();
     if (m_selectedAssistant) {
         m_selectedAssistant->setUseCustomColor(m_options.useCustomAssistantColor->isChecked());
 
         // changing color doesn't keep alpha, so update that before we send it on
         QColor newColor = m_options.customAssistantColorButton->color();
         newColor.setAlpha(m_selectedAssistant->assistantCustomColor().alpha());
 
         m_selectedAssistant->setAssistantCustomColor(newColor);
         m_selectedAssistant->uncache();
     }
 
     updateToolOptionsUI();
     m_canvas->canvasWidget()->update();
 }
 
 void KisAssistantTool::slotCustomOpacityChanged()
 {
     KisPaintingAssistantSP m_selectedAssistant =  m_canvas->paintingAssistantsDecoration()->selectedAssistant();
     if (m_selectedAssistant) {
         QColor newColor = m_selectedAssistant->assistantCustomColor();
         qreal newOpacity = m_options.customColorOpacitySlider->value() * 0.01 * 255.0;
         newColor.setAlpha(int(newOpacity));
         m_selectedAssistant->setAssistantCustomColor(newColor);
         m_selectedAssistant->uncache();
     }
 
     // this forces the canvas to refresh to see the changes immediately
     m_canvas->paintingAssistantsDecoration()->uncache();
     m_canvas->canvasWidget()->update();
 }
diff --git a/plugins/assistants/Assistants/kis_assistant_tool.h b/plugins/assistants/Assistants/kis_assistant_tool.h
index 26f3e506c8..0ef7512325 100644
--- a/plugins/assistants/Assistants/kis_assistant_tool.h
+++ b/plugins/assistants/Assistants/kis_assistant_tool.h
@@ -1,181 +1,176 @@
 /*
  * Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  * Copyright (c) 2017 Scott Petrovic <scottpetrovic@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 _KIS_ASSISTANT_TOOL_H_
 #define _KIS_ASSISTANT_TOOL_H_
 
 #include <QPointer>
 
 #include <KoToolFactoryBase.h>
 #include <KoIcon.h>
 
 #include <kis_tool.h>
 #include "kis_painting_assistant.h"
 #include <kis_icon.h>
 #include <kis_canvas2.h>
 
 #include "ui_AssistantsToolOptions.h"
 
 /* The assistant tool allows artists to create special guides on the canvas
  * to help them with things like perspective and parallel lines
  * This tool has its own canvas decoration on it that only appears when the tool
  * is active. This decoration allows people to edit assistant points as well as delete assistants
  * Many of the operations here are forwarded on to another class (kis_painting_assistant_decoration)
  * that stores the assistant information as well as the decoration information with lines
  *
  * Drawing in two separate classes creates an issue where the editor controls in this class
  * are covered by the kis_painting_assistant_decoration class. In the future, we probably need to
  * do all the drawing in one class so we have better control of what is in front
  */
 class KisAssistantTool : public KisTool
 {
     Q_OBJECT
     enum PerspectiveAssistantEditionMode {
         MODE_CREATION, // This is the mode when there is not yet a perspective grid
         MODE_EDITING, // This is the mode when the grid has been created, and we are waiting for the user to click on a control box
         MODE_DRAGGING_NODE, // In this mode one node is translated
         MODE_DRAGGING_TRANSLATING_TWONODES // This mode is used when creating a new sub perspective grid
     };
 public:
     KisAssistantTool(KoCanvasBase * canvas);
     ~KisAssistantTool() override;
 
     virtual quint32 priority() {
         return 3;
     }
 
 
     /* this is a very big function that has to figure out if we are adding a new assistant,
      * or editing an existing one when we click on the canvas. There is also a lot of logic
      * in here that is specific to certain assistants and how they should be handled.
      * The editor widget is not a UI file, so the move, delete, preview areas have manual
      * hitbox regions specified to know if a click is doing any of those actions.
      */
     void beginPrimaryAction(KoPointerEvent *event) override;
 
 
     void continuePrimaryAction(KoPointerEvent *event) override;
     void endPrimaryAction(KoPointerEvent *event) override;
     void mouseMoveEvent(KoPointerEvent *event) override;
 
     QWidget *createOptionWidget() override;
 
-    /// clones the list of assistants
-    /// the originally shared handles will still be shared
-    /// the cloned assistants do not share any handle with the original assistants
-    QList<KisPaintingAssistantSP> cloneAssistantList(const QList<KisPaintingAssistantSP> &list) const;
-
 private:
     // adds and removes assistant.
     // this is event is forwarded to the kis_painting_decoration class
     // perspective grids seem to be managed in two places with these calls
     void addAssistant();
     void removeAssistant(KisPaintingAssistantSP assistant);
 
     void assistantSelected(KisPaintingAssistantSP assistant);
 
 public Q_SLOTS:
     void activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes) override;
     void deactivate() override;
 
 
     void slotChangeVanishingPointAngle(double value);
 
 private Q_SLOTS:
     void removeAllAssistants();
     void saveAssistants();
     void loadAssistants();
     void updateToolOptionsUI();
 
     /// send the color and opacity information from the UI to the kis_painting_decoration
     /// which manages the assistants
     void slotGlobalAssistantsColorChanged(const QColor&);
     void slotGlobalAssistantOpacityChanged();
 
     void slotUpdateCustomColor();
     void slotCustomOpacityChanged();
 
 protected:
     /// Draws the editor widget controls with move, activate, and delete
     /// This also creates a lot of assistant specific stuff for vanishing points and perspective grids
     /// Whatever is painted here will be underneath the content painted in the kis_painting_assistant_decoration
     /// The kis_painting_assistant_decoration paints the final assistant, so this is more of just editor controls
     void paint(QPainter& gc, const KoViewConverter &converter) override;
 
 protected:
     /// this class manipulates the kis_painting_assistant_decorations a lot, so this class is a helper
     ///  to get a reference to it and call "updateCanvas" which refreshes the display
     QPointer<KisCanvas2> m_canvas;
 
     /// the handles are retrieved from the kis_painting_decoration originally
     /// They are used here to generate and manipulate editor handles with the tool's primary action
     QList<KisPaintingAssistantHandleSP> m_handles;
     QList<KisPaintingAssistantHandleSP> m_sideHandles;
     KisPaintingAssistantHandleSP m_handleDrag;
     KisPaintingAssistantHandleSP m_handleCombine;
     KisPaintingAssistantSP m_assistantDrag;
 
     /// Used while a new assistant is being created. Most assistants need multiple points to exist
     /// so this helps manage the visual state while this creation process is going on
     KisPaintingAssistantSP m_newAssistant;
 
     QPointF m_cursorStart;
     QPointF m_currentAdjustment;
     Ui::AssistantsToolOptions m_options;
     QWidget* m_optionsWidget;
     QPointF m_dragStart;
     QLineF m_radius;
     bool m_snapIsRadial;
     QPointF m_dragEnd;
     int m_handleSize; // how large the editor handles will appear
 
 
 private:
     void drawEditorWidget(KisPaintingAssistantSP assistant, QPainter& _gc);
 
     PerspectiveAssistantEditionMode m_internalMode;
     KisPaintingAssistantHandleSP m_selectedNode1, m_selectedNode2, m_higlightedNode;
     int m_assistantHelperYOffset; // used by the assistant editor icons for placement on the canvas.
     QList<KisPaintingAssistantSP> m_origAssistantList;
 };
 
 
 class KisAssistantToolFactory : public KoToolFactoryBase
 {
 public:
     KisAssistantToolFactory()
             : KoToolFactoryBase("KisAssistantTool") {
         setToolTip(i18n("Assistant Tool"));
         setSection(TOOL_TYPE_VIEW);
         setIconName(koIconNameCStr("krita_tool_assistant"));
         setPriority(0);
         setActivationShapeId(KRITA_TOOL_ACTIVATION_ID);
     }
 
 
     ~KisAssistantToolFactory() override {}
 
     KoToolBase * createTool(KoCanvasBase * canvas) override {
         return new KisAssistantTool(canvas);
     }
 
 };
 
 
 #endif