diff --git a/libs/ui/canvas/KisMirrorAxisConfig.cpp b/libs/ui/canvas/KisMirrorAxisConfig.cpp
index 16ed0b6fc8..2a316f9ee5 100644
--- a/libs/ui/canvas/KisMirrorAxisConfig.cpp
+++ b/libs/ui/canvas/KisMirrorAxisConfig.cpp
@@ -1,247 +1,250 @@
 /*
  *  Copyright (c) 2019 Anna Medonosova <anna.medonosova@gmail.com>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <kis_dom_utils.h>
 #include <QPointF>
 
 #include "KisMirrorAxisConfig.h"
 
 
 class Q_DECL_HIDDEN KisMirrorAxisConfig::Private
 {
 public:
     Private()
         : mirrorHorizontal(false)
         , mirrorVertical(false)
         , lockHorizontal(false)
         , lockVertical(false)
         , hideVerticalDecoration(false)
         , hideHorizontalDecoration(false)
         , handleSize(32.f)
         , horizontalHandlePosition(64.f)
         , verticalHandlePosition(64.f)
         , axisPosition(QPointF(0.f,0.f))
     {}
 
     bool operator==(const Private& rhs) {
         return mirrorHorizontal == rhs.mirrorHorizontal &&
                 mirrorVertical == rhs.mirrorVertical &&
                 lockHorizontal == rhs.lockHorizontal &&
                 lockVertical == rhs.lockVertical &&
                 hideHorizontalDecoration == rhs.hideHorizontalDecoration &&
                 hideVerticalDecoration == rhs.hideVerticalDecoration &&
                 handleSize == rhs.handleSize &&
                 horizontalHandlePosition == rhs.horizontalHandlePosition &&
                 verticalHandlePosition == rhs.verticalHandlePosition &&
                 axisPosition == rhs.axisPosition;
     }
 
     bool mirrorHorizontal;
     bool mirrorVertical;
     bool lockHorizontal;
     bool lockVertical;
     bool hideVerticalDecoration;
     bool hideHorizontalDecoration;
 
     float handleSize;
     float horizontalHandlePosition;
     float verticalHandlePosition;
 
     QPointF axisPosition;
 };
 
 
 KisMirrorAxisConfig::KisMirrorAxisConfig()
     : QObject()
     , d(new Private())
 {
 
 }
 
 KisMirrorAxisConfig::~KisMirrorAxisConfig()
 {
 
 }
 
 KisMirrorAxisConfig::KisMirrorAxisConfig(const KisMirrorAxisConfig &rhs)
     : QObject()
     , d(new Private(*rhs.d))
 {
 
 }
 
 KisMirrorAxisConfig &KisMirrorAxisConfig::operator=(const KisMirrorAxisConfig &rhs)
 {
     if (&rhs != this) {
         *d = *rhs.d;
     }
 
     return *this;
 }
 
 bool KisMirrorAxisConfig::operator==(const KisMirrorAxisConfig &rhs) const
 {
+    KIS_ASSERT(d);
+    KIS_ASSERT(rhs.d);
+
     return *d == *rhs.d;
 }
 
 bool KisMirrorAxisConfig::mirrorHorizontal()
 {
     return d->mirrorHorizontal;
 }
 
 void KisMirrorAxisConfig::setMirrorHorizontal(bool state)
 {
     d->mirrorHorizontal = state;
 }
 
 bool KisMirrorAxisConfig::mirrorVertical()
 {
     return d->mirrorVertical;
 }
 
 void KisMirrorAxisConfig::setMirrorVertical(bool state)
 {
     d->mirrorVertical = state;
 }
 
 bool KisMirrorAxisConfig::lockHorizontal()
 {
     return d->lockHorizontal;
 }
 
 void KisMirrorAxisConfig::setLockHorizontal(bool state)
 {
     d->lockHorizontal = state;
 }
 
 bool KisMirrorAxisConfig::lockVertical()
 {
     return d->lockVertical;
 }
 
 void KisMirrorAxisConfig::setLockVertical(bool state)
 {
     d->lockVertical = state;
 }
 
 bool KisMirrorAxisConfig::hideVerticalDecoration()
 {
     return d->hideVerticalDecoration;
 }
 
 void KisMirrorAxisConfig::setHideVerticalDecoration(bool state)
 {
     d->hideVerticalDecoration = state;
 }
 
 bool KisMirrorAxisConfig::hideHorizontalDecoration()
 {
     return d->hideHorizontalDecoration;
 }
 
 void KisMirrorAxisConfig::setHideHorizontalDecoration(bool state)
 {
     d->hideHorizontalDecoration = state;
 }
 
 float KisMirrorAxisConfig::handleSize()
 {
     return d->handleSize;
 }
 
 void KisMirrorAxisConfig::setHandleSize(float size)
 {
     d->handleSize = size;
 }
 
 float KisMirrorAxisConfig::horizontalHandlePosition()
 {
     return d->horizontalHandlePosition;
 }
 
 void KisMirrorAxisConfig::setHorizontalHandlePosition(float position)
 {
     d->horizontalHandlePosition = position;
 }
 
 float KisMirrorAxisConfig::verticalHandlePosition()
 {
     return d->verticalHandlePosition;
 }
 
 void KisMirrorAxisConfig::setVerticalHandlePosition(float position)
 {
     d->verticalHandlePosition = position;
 }
 
 QPointF KisMirrorAxisConfig::axisPosition()
 {
     return d->axisPosition;
 }
 
 void KisMirrorAxisConfig::setAxisPosition(QPointF position)
 {
     d->axisPosition = position;
 }
 
 QDomElement KisMirrorAxisConfig::saveToXml(QDomDocument &doc, const QString &tag) const
 {
     QDomElement mirrorAxisElement = doc.createElement(tag);
     KisDomUtils::saveValue(&mirrorAxisElement, "mirrorHorizontal", d->mirrorHorizontal);
     KisDomUtils::saveValue(&mirrorAxisElement, "mirrorVertical", d->mirrorVertical);
     KisDomUtils::saveValue(&mirrorAxisElement, "lockHorizontal", d->lockHorizontal);
     KisDomUtils::saveValue(&mirrorAxisElement, "lockVertical", d->lockVertical);
 
     KisDomUtils::saveValue(&mirrorAxisElement, "hideHorizontalDecoration", d->hideHorizontalDecoration);
     KisDomUtils::saveValue(&mirrorAxisElement, "hideVerticalDecoration", d->hideVerticalDecoration);
 
     KisDomUtils::saveValue(&mirrorAxisElement, "handleSize", d->handleSize);
 
     KisDomUtils::saveValue(&mirrorAxisElement, "horizontalHandlePosition", d->horizontalHandlePosition);
     KisDomUtils::saveValue(&mirrorAxisElement, "verticalHandlePosition", d->verticalHandlePosition);
 
     KisDomUtils::saveValue(&mirrorAxisElement, "axisPosition", d->axisPosition);
 
     return mirrorAxisElement;
 }
 
 bool KisMirrorAxisConfig::loadFromXml(const QDomElement &parent)
 {
     bool result = true;
 
     result &= KisDomUtils::loadValue(parent, "mirrorHorizontal", &d->mirrorHorizontal);
     result &= KisDomUtils::loadValue(parent, "mirrorVertical", &d->mirrorVertical);
     result &= KisDomUtils::loadValue(parent, "lockHorizontal", &d->lockHorizontal);
     result &= KisDomUtils::loadValue(parent, "lockVertical", &d->lockVertical);
 
     result &= KisDomUtils::loadValue(parent, "hideHorizontalDecoration", &d->hideHorizontalDecoration);
     result &= KisDomUtils::loadValue(parent, "hideVerticalDecoration", &d->hideVerticalDecoration);
 
     result &= KisDomUtils::loadValue(parent, "handleSize", &d->handleSize);
 
     result &= KisDomUtils::loadValue(parent, "horizontalHandlePosition", &d->horizontalHandlePosition);
     result &= KisDomUtils::loadValue(parent, "verticalHandlePosition", &d->verticalHandlePosition);
     result &= KisDomUtils::loadValue(parent, "axisPosition", &d->axisPosition);
 
     return result;
 }
 
 bool KisMirrorAxisConfig::isDefault() const
 {
     KisMirrorAxisConfig defaultConfig;
     return *this == defaultConfig;
 }
diff --git a/libs/ui/kis_mirror_manager.cpp b/libs/ui/kis_mirror_manager.cpp
index a5ff783c07..a54c4b8bda 100644
--- a/libs/ui/kis_mirror_manager.cpp
+++ b/libs/ui/kis_mirror_manager.cpp
@@ -1,131 +1,132 @@
 /*
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2014 Sven Langkamp <sven.langkamp@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 "kis_mirror_manager.h"
 #include "KisViewManager.h"
 #include <kis_canvas_controller.h>
 #include <kis_icon.h>
 
 #include <klocalizedstring.h>
 #include <kguiitem.h>
 #include <ktoggleaction.h>
 #include <kactioncollection.h>
 #include <QAction>
 
 #include "kis_canvas2.h"
 #include "kis_mirror_axis.h"
 #include <KisMirrorAxisConfig.h>
 #include <KisDocument.h>
 #include <kis_signals_blocker.h>
 
 class KisMirrorManager::Private
 {
 public:
     Private()
         : mirrorAxisDecoration(nullptr)
     {}
 
     KisMirrorAxis* mirrorAxisDecoration;
 };
 
 KisMirrorManager::KisMirrorManager(KisViewManager* view) : QObject(view)
     , d(new Private())
     , m_imageView(0)
 {
 }
 
 KisMirrorManager::~KisMirrorManager()
 {
 }
 
 void KisMirrorManager::setup(KActionCollection * collection)
 {
     m_mirrorCanvas = new KToggleAction(i18n("Mirror View"), this);
     m_mirrorCanvas->setChecked(false);
     m_mirrorCanvas->setIcon(KisIconUtils::loadIcon("mirror-view"));
 
     collection->addAction("mirror_canvas", m_mirrorCanvas);
     collection->setDefaultShortcut(m_mirrorCanvas, QKeySequence(Qt::Key_M));
 
     updateAction();
 }
 
 void KisMirrorManager::setView(QPointer<KisView> imageView)
 {
     if (m_imageView) {
         m_mirrorCanvas->disconnect();
         m_imageView->document()->disconnect();
+
+        d->mirrorAxisDecoration->disconnect();
+        d->mirrorAxisDecoration = nullptr;
     }
+
     m_imageView = imageView;
+
     if (m_imageView)  {
         connect(m_mirrorCanvas, SIGNAL(toggled(bool)), dynamic_cast<KisCanvasController*>(m_imageView->canvasController()), SLOT(mirrorCanvas(bool)));
         connect(m_imageView->document(), SIGNAL(sigMirrorAxisConfigChanged()), this, SLOT(slotDocumentConfigChanged()), Qt::UniqueConnection);
 
-        if (!hasDecoration()) {
-            d->mirrorAxisDecoration = new KisMirrorAxis(m_imageView->viewManager()->canvasResourceProvider(), m_imageView);
-            connect(d->mirrorAxisDecoration, SIGNAL(sigConfigChanged()), this, SLOT(slotMirrorAxisConfigChanged()), Qt::UniqueConnection);
-            m_imageView->canvasBase()->addDecoration(d->mirrorAxisDecoration);
+        KisMirrorAxis* decoration;
+        if (m_imageView->canvasBase() && m_imageView->canvasBase()->decoration("mirror_axis")) {
+            decoration = dynamic_cast<KisMirrorAxis*>(m_imageView->canvasBase()->decoration("mirror_axis").data());
+        } else {
+            decoration = new KisMirrorAxis(m_imageView->viewManager()->canvasResourceProvider(), m_imageView);
+            connect(decoration, SIGNAL(sigConfigChanged()), this, SLOT(slotMirrorAxisConfigChanged()), Qt::UniqueConnection);
+            m_imageView->canvasBase()->addDecoration(decoration);
         }
 
+        d->mirrorAxisDecoration = decoration;
         setDecorationConfig();
     }
 
     updateAction();
 }
 
 void KisMirrorManager::updateAction()
 {
     if (m_imageView) {
         m_mirrorCanvas->setEnabled(true);
         m_mirrorCanvas->setChecked(m_imageView->canvasIsMirrored());
     }
     else {
         m_mirrorCanvas->setEnabled(false);
         m_mirrorCanvas->setChecked(false);
     }
 }
 
 void KisMirrorManager::slotDocumentConfigChanged()
 {
     setDecorationConfig();
 }
 
 void KisMirrorManager::slotMirrorAxisConfigChanged()
 {
     if (m_imageView && m_imageView->document()) {
         KisSignalsBlocker blocker(m_imageView->document());
         m_imageView->document()->setMirrorAxisConfig(d->mirrorAxisDecoration->mirrorAxisConfig());
     }
 }
 
-KisMirrorAxis* KisMirrorManager::hasDecoration() {
-
-    if (m_imageView && m_imageView->canvasBase() && m_imageView->canvasBase()->decoration("mirror_axis")) {
-        return dynamic_cast<KisMirrorAxis*>(m_imageView->canvasBase()->decoration("mirror_axis").data());
-    }
-    return 0;
-}
-
 void KisMirrorManager::setDecorationConfig()
 {
     if (m_imageView && m_imageView->document()) {
         KisMirrorAxisConfig config = m_imageView->document()->mirrorAxisConfig();
         d->mirrorAxisDecoration->setMirrorAxisConfig(config);
     }
 }
diff --git a/libs/ui/kis_mirror_manager.h b/libs/ui/kis_mirror_manager.h
index 106a3fcf83..e95f8b11e0 100644
--- a/libs/ui/kis_mirror_manager.h
+++ b/libs/ui/kis_mirror_manager.h
@@ -1,61 +1,60 @@
 /*
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2014 Sven Langkamp <sven.langkamp@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_MIRROR_MANAGER_H
 #define KIS_MIRROR_MANAGER_H
 
 #include <QObject>
 #include <QPointer>
 #include <QScopedPointer>
 
 #include "KisView.h"
 
 class KisViewManager;
 class KActionCollection;
 class KisMirrorAxis;
 class KisMirrorAxisConfig;
 
 class KisMirrorManager : public QObject
 {
     Q_OBJECT
 
 public:
     KisMirrorManager(KisViewManager* view);
     ~KisMirrorManager() override;
 
     void setup(KActionCollection* collection);
 
     void setView(QPointer<KisView> imageView);
 
 private Q_SLOTS:
     void updateAction();
     void slotDocumentConfigChanged();
     void slotMirrorAxisConfigChanged();
 
 private:
     class Private;
     const QScopedPointer<Private> d;
 
     QPointer<KisView> m_imageView;
     QAction *m_mirrorCanvas;
-    KisMirrorAxis* hasDecoration();
     void setDecorationConfig();
 };
 
 #endif // KIS__MANAGER_H